fix(dashboard-agent): cover the chat delete cascade and warn on the batch cap

Ports the hard-delete cascade test back from the webapp suite, logs when a
retention pass ends on a full batch, and drops the unused exports.

Author: kathiekiwi

internal-packages/dashboard-agent/GUIDEBOOK.md

@@ -380,14 +380,14 @@ A sweep (`dashboardAgentWatchSweep.server.ts`) is the backstop:
 - a row still active **2 minutes** past `expiresAt` is finalized;
 - a resolved row whose wake is still owed **5 minutes** later is redelivered —
   the sweep can't tell whether the user was already told, so delivery is
-  id-deduped rather than conditional;
-- terminal rows are kept **7 days**; the outcome also lives in the transcript.
+  id-deduped rather than conditional.
 
 The agent project runs two scheduled tasks of its own: `dashboard-agent-investigation-sweep`
 every 5 minutes settles cards left `in_progress` past **30 minutes**
 (`investigation-sweep.ts`), and `dashboard-agent-maintenance` at 03:00 daily is
 retention (`maintenance.ts`) — judged turns and soft-deleted chats past **30
-days**, terminal watches and their submission ledger past **7 days**. Retention
+days**, terminal watches and their submission ledger past **7 days** — a purged
+watch outcome still lives in the transcript. Retention
 does nothing at all without `DASHBOARD_AGENT_DATABASE_URL`: it never falls back
 to another database.
 

internal-packages/dashboard-agent/src/maintenance.test.ts

@@ -74,6 +74,64 @@ async function seedSubmission(chatId: string, requestId: string, ageDays: number
   );
 }
 
+/** One row in every chatId-keyed table, so a delete that misses one leaves a leak. */
+async function seedChatWithChildren(db: DashboardAgentDb, id: string) {
+  await createChat(db, { id, organizationId: ORG, userId: USER });
+  await raw(
+    `insert into trigger_dashboard_agent.chat_messages (chat_id, message_id, position, role, message)
+     values ($1, $1 || '-m', 1, 'user', '{}'::jsonb)`,
+    [id]
+  );
+  await raw(
+    `insert into trigger_dashboard_agent.chat_sessions (chat_id, public_access_token) values ($1, 'pat')`,
+    [id]
+  );
+  await raw(
+    `insert into trigger_dashboard_agent.chat_turn_evals (chat_id, turn, organization_id, user_id)
+     values ($1, 0, $2, $3)`,
+    [id, ORG, USER]
+  );
+  await raw(
+    `insert into trigger_dashboard_agent.investigations (id, chat_id, project_ref, environment_ref, state)
+     values ($1 || '-inv', $1, 'proj', 'env', '{"outcome":"in_progress"}'::jsonb)`,
+    [id]
+  );
+  await raw(
+    `insert into trigger_dashboard_agent.watches
+       (id, chat_id, identity, spec, organization_id, project_id, environment_id, user_id, expires_at)
+     values ($1 || '-w', $1, 'ident', '{}'::jsonb, $2, 'proj', 'env', $3, now() + interval '1 day')`,
+    [id, ORG, USER]
+  );
+  await raw(
+    `insert into trigger_dashboard_agent.watch_submissions
+       (chat_id, client_request_id, organization_id, user_id, project_id, environment_id, draft_hash, draft)
+     values ($1, 'req', $2, $3, 'proj', 'env', 'hash', '{}'::jsonb)`,
+    [id, ORG, USER]
+  );
+}
+
+const CHILD_TABLES = [
+  "chat_messages",
+  "chat_sessions",
+  "chat_turn_evals",
+  "investigations",
+  "watches",
+  "watch_submissions",
+];
+
+async function rowCounts(id: string): Promise<Record<string, number>> {
+  const counts: Record<string, number> = {};
+  for (const table of ["chats", ...CHILD_TABLES]) {
+    const column = table === "chats" ? "id" : "chat_id";
+    const rows = await raw(
+      `select count(*)::int as n from trigger_dashboard_agent.${table} where ${column} = $1`,
+      [id]
+    );
+    counts[table] = Number((rows as unknown as { n: number }[])[0]!.n);
+  }
+  return counts;
+}
+
 async function count(table: string): Promise<number> {
   const rows = await raw(`select count(*)::int as n from trigger_dashboard_agent.${table}`);
   return Number((rows as unknown as { n: number }[])[0]!.n);
@@ -136,6 +194,32 @@ describe("the dashboard agent retention pass", () => {
     60_000
   );
 
+  postgresTest(
+    "a purged chat takes every chatId-keyed child row with it",
+    async ({ postgresContainer }) => {
+      const db = await boot(postgresContainer.getConnectionUri());
+
+      await seedChatWithChildren(db, "chat_cascade_old");
+      await seedChatWithChildren(db, "chat_cascade_new");
+      await raw(
+        `update trigger_dashboard_agent.chats set deleted_at = now() - interval '40 days' where id = 'chat_cascade_old'`
+      );
+      await raw(
+        `update trigger_dashboard_agent.chats set deleted_at = now() - interval '1 day' where id = 'chat_cascade_new'`
+      );
+
+      expect(await runDashboardAgentRetention(db)).toMatchObject({ chats: 1 });
+
+      const purged = await rowCounts("chat_cascade_old");
+      const kept = await rowCounts("chat_cascade_new");
+      for (const table of ["chats", ...CHILD_TABLES]) {
+        expect(purged[table], `${table} should be empty for the purged chat`).toBe(0);
+        expect(kept[table], `${table} kept for the in-window chat`).toBe(1);
+      }
+    },
+    60_000
+  );
+
   postgresTest(
     "an active watch is never purged, however old it is",
     async ({ postgresContainer }) => {

internal-packages/dashboard-agent/src/maintenance.ts

@@ -26,16 +26,16 @@ export const TURN_EVAL_RETENTION_MS = 30 * 24 * 60 * 60 * 1000;
  * enough that an accidental delete can still be investigated; organization deletion soft-
  * deletes the org's chats, so those are removed the same way once the window passes.
  */
-export const CHAT_SOFT_DELETE_RETENTION_MS = 30 * 24 * 60 * 60 * 1000;
+const CHAT_SOFT_DELETE_RETENTION_MS = 30 * 24 * 60 * 60 * 1000;
 
 /** How long a terminal watch and its submission ledger are kept. */
-export const WATCH_RETENTION_MS = 7 * 24 * 60 * 60 * 1000;
+const WATCH_RETENTION_MS = 7 * 24 * 60 * 60 * 1000;
 
 /** Per-statement cap. */
-export const RETENTION_BATCH_LIMIT = 500;
+const RETENTION_BATCH_LIMIT = 500;
 
 /** Cap on the statements one pass may run, so a huge backlog can't run forever. */
-export const MAX_RETENTION_BATCHES = 20;
+const MAX_RETENTION_BATCHES = 20;
 
 export type RetentionResult = {
   turnEvals: number;
@@ -89,6 +89,9 @@ export async function runDashboardAgentRetention(
         const deleted = await purge({ before, limit });
         total += deleted;
         if (deleted < limit) break;
+        if (batch === maxBatches - 1) {
+          logger.warn(`dashboard-agent retention hit the batch cap: ${name}`, { total, before });
+        }
       }
     } catch (error) {
       failed.push(name);