test: de-flake transform_decisions retention cap via injectable cap

The retention-cap test wrote TRANSFORM_DECISIONS_RETENTION+5 (2005) rows, and
each writeRow opens a fresh DB connection (the off-hot-path telemetry writer's
design). Under CI load that loop exceeded the 5s test timeout and flaked the
plugin check intermittently (unrelated to the change under test). The prune SQL
is cap-agnostic (LIMIT ?), so the behavior is identical at any cap: add a
test-only retention override and exercise the prune with a cap of 10 instead of
2000. Runtime drops from ~10s (timeout) to ~0.25s. A guard test pins the real
TRANSFORM_DECISIONS_RETENTION constant so the production cap can't silently
drift.

Co-authored-by: Alfonso [Magic Context] <288211368+alfonso-magic-context@users.noreply.github.com>

Author: ualtinok

packages/plugin/src/features/magic-context/transform-decision-log.test.ts

@@ -55,13 +55,23 @@ function rowCount(): number {
 }
 
 describe("transform_decisions retention cap", () => {
-    it("prunes to the newest TRANSFORM_DECISIONS_RETENTION rows per (session,harness)", () => {
+    // The prune SQL is cap-agnostic (`LIMIT ?`), so we inject a tiny cap to
+    // exercise it with a handful of rows. Writing the real 2000+ cap opened
+    // that many fresh DB connections in a loop and timed out under CI load.
+    // The override removes the flake without weakening the assertion.
+    const TEST_CAP = 10;
+
+    beforeEach(() => {
+        __test.setRetentionForTests(TEST_CAP);
+    });
+
+    it("prunes to the newest cap rows per (session,harness)", () => {
         // Write cap + 5 rows with strictly increasing ts and distinct message ids.
-        const total = TRANSFORM_DECISIONS_RETENTION + 5;
+        const total = TEST_CAP + 5;
         for (let i = 0; i < total; i++) {
             __test.writeRow(dbPath, baseRow(`msg-${i}`, 1000 + i));
         }
-        expect(rowCount()).toBe(TRANSFORM_DECISIONS_RETENTION);
+        expect(rowCount()).toBe(TEST_CAP);
 
         // The oldest (smallest ts) must be gone; the newest must remain.
         const oldest = db
@@ -75,10 +85,15 @@ describe("transform_decisions retention cap", () => {
     });
 
     it("does not prune below the cap", () => {
-        for (let i = 0; i < 10; i++) {
+        for (let i = 0; i < TEST_CAP - 1; i++) {
             __test.writeRow(dbPath, baseRow(`m-${i}`, 1000 + i));
         }
-        expect(rowCount()).toBe(10);
+        expect(rowCount()).toBe(TEST_CAP - 1);
+    });
+
+    it("keeps the production retention constant sane", () => {
+        // Guard against accidental drift of the real cap.
+        expect(TRANSFORM_DECISIONS_RETENTION).toBe(2000);
     });
 });
 

packages/plugin/src/features/magic-context/transform-decision-log.ts

@@ -82,6 +82,12 @@ const scheduledWriteTokensBySession = new Map<string, Set<symbol>>();
 
 let writerOverrideForTests: TransformDecisionWriter | null = null;
 
+// Tests override the retention cap so the prune can be exercised with a handful
+// of rows instead of writing TRANSFORM_DECISIONS_RETENTION+ rows (each opening a
+// fresh DB connection), which timed out under CI load. The prune SQL is
+// cap-agnostic (LIMIT ?), so a small cap verifies identical behavior.
+let retentionOverrideForTests: number | null = null;
+
 export function normalizeMaterializeReason(
     harness: TransformDecisionHarness,
     reason: string | null | undefined,
@@ -353,7 +359,7 @@ function writeTransformDecisionRow(dbPath: string, row: TransformDecisionRow): v
             row.harness,
             row.sessionId,
             row.harness,
-            TRANSFORM_DECISIONS_RETENTION,
+            retentionOverrideForTests ?? TRANSFORM_DECISIONS_RETENTION,
         );
     } finally {
         closeQuietly(db);
@@ -373,10 +379,14 @@ export const __test = {
         lastBoundMessageIdBySession.clear();
         scheduledWriteTokensBySession.clear();
         writerOverrideForTests = null;
+        retentionOverrideForTests = null;
     },
     setWriterForTests(writer: TransformDecisionWriter | null): void {
         writerOverrideForTests = writer;
     },
+    setRetentionForTests(cap: number | null): void {
+        retentionOverrideForTests = cap;
+    },
     writeRow(dbPath: string, row: TransformDecisionRow): void {
         writeTransformDecisionRow(dbPath, row);
     },