feat(server): carry the per-job run cap across with the runs

The extension kept fifteen runs per job, trimming as it created each
one. Now that it no longer owns the history that policy has to live
here, or the table grows without bound.

It applies on every write rather than only on creation, which is bounded
and idempotent, so it holds however the run was written. The import path
does not prune, staying purely additive; the next real run trims.

Author: DaniAkash

packages/browseros-agent/apps/server/src/api/routes/scheduled-job-runs.ts

@@ -78,6 +78,10 @@ export function createScheduledJobRunRoutes(
           ...c.req.valid('json'),
           id: c.req.valid('param').runId,
         })
+        // Every write, not just the first: a run is written twice, when it
+        // starts and when it finishes, and pruning is bounded and idempotent.
+        // The import path deliberately does not prune, so it stays additive.
+        await store.prune(run.jobId)
         return c.json({ run })
       },
     )

packages/browseros-agent/apps/server/src/lib/schedules/run-store.ts

@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: AGPL-3.0-or-later
  */
 
-import { desc, eq } from 'drizzle-orm'
+import { desc, eq, inArray } from 'drizzle-orm'
 import { getDb } from '../db'
 import {
   type NewScheduledJobRunRow,
@@ -24,6 +24,14 @@ export type ScheduledJobRunUpsert = Omit<
   createdAt?: number
 }
 
+/**
+ * Runs kept per job. The extension applied this cap when it owned the history,
+ * trimming as it created each run; keeping the number here means it holds
+ * however the run was written rather than only on the path that happened to
+ * enforce it.
+ */
+export const MAX_RUNS_PER_JOB = 15
+
 export interface ScheduledJobRunStore {
   list(): Promise<ScheduledJobRunRow[]>
   get(id: string): Promise<ScheduledJobRunRow | null>
@@ -34,6 +42,8 @@ export interface ScheduledJobRunStore {
    * exists. Used by the one-time import for the reason on the provider store. */
   insertIfAbsent(row: ScheduledJobRunUpsert): Promise<ScheduledJobRunRow | null>
   remove(id: string): Promise<boolean>
+  /** Drops all but the newest `keep` runs of a job. Returns how many went. */
+  prune(jobId: string, keep?: number): Promise<number>
 }
 
 async function list(): Promise<ScheduledJobRunRow[]> {
@@ -78,6 +88,26 @@ async function insertIfAbsent(
   return saved ?? null
 }
 
+async function prune(
+  jobId: string,
+  keep: number = MAX_RUNS_PER_JOB,
+): Promise<number> {
+  const rows = await getDb()
+    .select({ id: scheduledJobRuns.id })
+    .from(scheduledJobRuns)
+    .where(eq(scheduledJobRuns.jobId, jobId))
+    .orderBy(desc(scheduledJobRuns.startedAt))
+    .all()
+
+  const stale = rows.slice(keep).map((row) => row.id)
+  if (stale.length === 0) return 0
+
+  await getDb()
+    .delete(scheduledJobRuns)
+    .where(inArray(scheduledJobRuns.id, stale))
+  return stale.length
+}
+
 async function remove(id: string): Promise<boolean> {
   const deleted = await getDb()
     .delete(scheduledJobRuns)
@@ -92,4 +122,5 @@ export const dbScheduledJobRunStore: ScheduledJobRunStore = {
   upsert,
   insertIfAbsent,
   remove,
+  prune,
 }

packages/browseros-agent/apps/server/tests/api/routes/scheduled-job-runs.test.ts

@@ -48,6 +48,14 @@ function memoryStore(initial: ScheduledJobRunRow[] = []) {
       return store.upsert(input)
     },
     remove: async (id) => rows.delete(id),
+    prune: async (jobId, keep = 15) => {
+      const ofJob = [...rows.values()]
+        .filter((r) => r.jobId === jobId)
+        .sort((a, b) => b.startedAt - a.startedAt)
+      const stale = ofJob.slice(keep)
+      for (const run of stale) rows.delete(run.id)
+      return stale.length
+    },
   }
   return { store, rows }
 }
@@ -103,6 +111,25 @@ describe('scheduled job run routes', () => {
     expect(rows.get(RUN_ID)?.toolCalls).toEqual(toolCalls)
   })
 
+  // The cap moved here from the extension, so a write has to apply it or the
+  // history grows without bound now that nothing else trims it.
+  it('trims a job past the run cap on write', async () => {
+    const existing = Array.from({ length: 15 }, (_, i) =>
+      row({ id: `run-${i}`, startedAt: 1000 + i }),
+    )
+    const { store, rows } = memoryStore(existing)
+
+    await put(
+      createScheduledJobRunRoutes({ store }),
+      { ...body, startedAt: 9999 },
+      'run-new',
+    )
+
+    expect(rows.size).toBe(15)
+    expect(rows.has('run-0')).toBe(false)
+    expect(rows.has('run-new')).toBe(true)
+  })
+
   it('rejects a status the schema does not know', async () => {
     const routes = createScheduledJobRunRoutes(memoryStore())
     const response = await put(routes, { ...body, status: 'cancelled' })

packages/browseros-agent/apps/server/tests/lib/schedules/run-store.test.ts

@@ -4,7 +4,10 @@ import { rm } from 'node:fs/promises'
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
 import { closeDb, initializeDb } from '../../../src/lib/db'
-import { dbScheduledJobRunStore } from '../../../src/lib/schedules/run-store'
+import {
+  dbScheduledJobRunStore,
+  MAX_RUNS_PER_JOB,
+} from '../../../src/lib/schedules/run-store'
 import { dbScheduledJobStore } from '../../../src/lib/schedules/schedule-store'
 
 const JOB_ID = 'job-1'
@@ -119,4 +122,49 @@ describe('dbScheduledJobRunStore', () => {
       'old',
     ])
   })
+
+  // The extension applied this cap while it owned the history, so keeping it
+  // is preserving behaviour rather than adding a policy.
+  test('prune keeps the newest runs of a job and drops the rest', async () => {
+    await useTempDbWithJob()
+    for (let i = 0; i < MAX_RUNS_PER_JOB + 5; i += 1) {
+      await dbScheduledJobRunStore.upsert(
+        baseRun({ id: `run-${i}`, startedAt: 1000 + i }),
+      )
+    }
+
+    const dropped = await dbScheduledJobRunStore.prune(JOB_ID)
+
+    expect(dropped).toBe(5)
+    const remaining = await dbScheduledJobRunStore.list()
+    expect(remaining).toHaveLength(MAX_RUNS_PER_JOB)
+    expect(remaining[0].startedAt).toBe(1000 + MAX_RUNS_PER_JOB + 4)
+  })
+
+  test('prune leaves a job under the cap alone', async () => {
+    await useTempDbWithJob()
+    await dbScheduledJobRunStore.upsert(baseRun())
+
+    expect(await dbScheduledJobRunStore.prune(JOB_ID)).toBe(0)
+    expect(await dbScheduledJobRunStore.list()).toHaveLength(1)
+  })
+
+  test('prune only touches the job it was given', async () => {
+    await useTempDbWithJob()
+    await dbScheduledJobStore.upsert({ ...baseJob(), id: 'job-2' })
+    await dbScheduledJobRunStore.upsert(
+      baseRun({ id: 'other', jobId: 'job-2' }),
+    )
+    for (let i = 0; i < MAX_RUNS_PER_JOB + 2; i += 1) {
+      await dbScheduledJobRunStore.upsert(
+        baseRun({ id: `run-${i}`, startedAt: 1000 + i }),
+      )
+    }
+
+    await dbScheduledJobRunStore.prune(JOB_ID)
+
+    const ids = (await dbScheduledJobRunStore.list()).map((r) => r.id)
+    expect(ids).toContain('other')
+    expect(ids).toHaveLength(MAX_RUNS_PER_JOB + 1)
+  })
 })