@opengsd/gsd-pi 1.2.0-dev.fb12b103 → 1.2.0-dev.fbdca60b

package/src/resources/extensions/gsd/tests/db-migration-backup.test.ts

@@ -3,16 +3,22 @@
 
 import { describe, test } from "node:test";
 import assert from "node:assert/strict";
-import { backupDatabaseBeforeMigration } from "../db-migration-backup.ts";
+import { MigrationBackupError, backupDatabaseBeforeMigration } from "../db-migration-backup.ts";
 import type { DbAdapter, DbStatement } from "../db-adapter.ts";
 
 class FakeStatement implements DbStatement {
+  private readonly row: Record<string, unknown> | undefined;
+
+  constructor(row: Record<string, unknown> | undefined = undefined) {
+    this.row = row;
+  }
+
   run(): unknown {
     return undefined;
   }
 
   get(): Record<string, unknown> | undefined {
-    return undefined;
+    return this.row;
   }
 
   all(): Record<string, unknown>[] {
@@ -22,15 +28,19 @@ class FakeStatement implements DbStatement {
 
 class FakeAdapter implements DbAdapter {
   readonly execCalls: string[] = [];
+  readonly prepareCalls: string[] = [];
   failCheckpoint = false;
+  checkpointRow: Record<string, unknown> = { busy: 0, log: 0, checkpointed: 0 };
 
   exec(sql: string): void {
     this.execCalls.push(sql);
     if (this.failCheckpoint) throw new Error("checkpoint failed");
   }
 
-  prepare(): DbStatement {
-    return new FakeStatement();
+  prepare(sql: string): DbStatement {
+    this.prepareCalls.push(sql);
+    if (this.failCheckpoint) throw new Error("checkpoint failed");
+    return new FakeStatement(this.checkpointRow);
   }
 
   close(): void {}
@@ -73,32 +83,71 @@ describe("db-migration-backup", () => {
       logWarning: () => assert.fail("should not warn"),
     });
 
-    assert.deepEqual(db.execCalls, ["PRAGMA wal_checkpoint(TRUNCATE)"]);
+    assert.deepEqual(db.prepareCalls, ["PRAGMA wal_checkpoint(TRUNCATE)"]);
     assert.deepEqual(copies, [["/tmp/gsd.db", "/tmp/gsd.db.backup-v12"]]);
   });
 
-  test("continues copying when checkpoint fails and warns when copy fails", () => {
+  test("throws and skips copying when checkpoint fails", () => {
     const db = new FakeAdapter();
     db.failCheckpoint = true;
     const copies: Array<[string, string]> = [];
     const warnings: string[] = [];
 
-    backupDatabaseBeforeMigration(db, "/tmp/gsd.db", 12, {
-      existsSync: (path) => path === "/tmp/gsd.db",
-      copyFileSync: (src, dest) => copies.push([src, dest]),
-      logWarning: (_scope, message) => warnings.push(message),
-    });
+    assert.throws(
+      () =>
+        backupDatabaseBeforeMigration(db, "/tmp/gsd.db", 12, {
+          existsSync: (path) => path === "/tmp/gsd.db",
+          copyFileSync: (src, dest) => copies.push([src, dest]),
+          logWarning: (_scope, message) => warnings.push(message),
+        }),
+      /checkpoint failed/,
+    );
+
+    assert.deepEqual(db.prepareCalls, ["PRAGMA wal_checkpoint(TRUNCATE)"]);
+    assert.deepEqual(copies, []);
+    assert.equal(warnings.length, 1);
+    assert.match(warnings[0], /Pre-migration backup failed: checkpoint failed/);
+  });
 
-    assert.deepEqual(copies, [["/tmp/gsd.db", "/tmp/gsd.db.backup-v12"]]);
+  test("throws and skips copying when checkpoint result is incomplete", () => {
+    const db = new FakeAdapter();
+    db.checkpointRow = { busy: 1, log: 4, checkpointed: 3 };
+    const copies: Array<[string, string]> = [];
+    const warnings: string[] = [];
 
-    backupDatabaseBeforeMigration(db, "/tmp/fail.db", 13, {
-      existsSync: (path) => path === "/tmp/fail.db",
-      copyFileSync: () => {
-        throw new Error("read only");
-      },
-      logWarning: (_scope, message) => warnings.push(message),
-    });
+    assert.throws(
+      () =>
+        backupDatabaseBeforeMigration(db, "/tmp/gsd.db", 12, {
+          existsSync: (path) => path === "/tmp/gsd.db",
+          copyFileSync: (src, dest) => copies.push([src, dest]),
+          logWarning: (_scope, message) => warnings.push(message),
+        }),
+      MigrationBackupError,
+    );
+
+    assert.deepEqual(db.prepareCalls, ["PRAGMA wal_checkpoint(TRUNCATE)"]);
+    assert.deepEqual(copies, []);
+    assert.equal(warnings.length, 1);
+    assert.match(warnings[0], /Pre-migration backup failed: WAL checkpoint incomplete/);
+  });
+
+  test("throws and warns when copy fails", () => {
+    const db = new FakeAdapter();
+    const warnings: string[] = [];
 
+    assert.throws(
+      () =>
+        backupDatabaseBeforeMigration(db, "/tmp/fail.db", 13, {
+          existsSync: (path) => path === "/tmp/fail.db",
+          copyFileSync: () => {
+            throw new Error("read only");
+          },
+          logWarning: (_scope, message) => warnings.push(message),
+        }),
+      /read only/,
+    );
+
+    assert.deepEqual(db.prepareCalls, ["PRAGMA wal_checkpoint(TRUNCATE)"]);
     assert.equal(warnings.length, 1);
     assert.match(warnings[0], /Pre-migration backup failed: read only/);
   });

package/src/resources/extensions/gsd/tests/db-transaction.test.ts

@@ -17,6 +17,10 @@ class FakeTransactionControls implements DbTransactionControls {
     this.record("BEGIN DEFERRED");
   }
 
+  beginImmediate(): void {
+    this.record("BEGIN IMMEDIATE");
+  }
+
   commit(): void {
     this.record("COMMIT");
   }
@@ -107,4 +111,59 @@ describe("db-transaction", () => {
     assert.equal(rollbackErrors.length, 1);
     assert.match(rollbackErrors[0].message, /failed ROLLBACK/);
   });
+
+  test("commits successful immediate transactions", () => {
+    const runner = createDbTransactionRunner();
+    const controls = new FakeTransactionControls();
+
+    const result = runner.immediateTransaction(controls, () => {
+      assert.equal(runner.isInTransaction(), true);
+      return "ok";
+    });
+
+    assert.equal(result, "ok");
+    assert.equal(runner.isInTransaction(), false);
+    assert.deepEqual(controls.calls, ["BEGIN IMMEDIATE", "COMMIT"]);
+  });
+
+  test("rolls back failed immediate transactions and clears depth", () => {
+    const runner = createDbTransactionRunner();
+    const controls = new FakeTransactionControls();
+
+    assert.throws(
+      () => runner.immediateTransaction(controls, () => {
+        throw new Error("boom");
+      }),
+      /boom/,
+    );
+
+    assert.equal(runner.isInTransaction(), false);
+    assert.deepEqual(controls.calls, ["BEGIN IMMEDIATE", "ROLLBACK"]);
+  });
+
+  test("nested immediate transactions inside write transactions do not issue nested BEGIN", () => {
+    const runner = createDbTransactionRunner();
+    const controls = new FakeTransactionControls();
+
+    runner.transaction(controls, () => {
+      runner.immediateTransaction(controls, () => {
+        assert.equal(runner.isInTransaction(), true);
+      });
+    });
+
+    assert.deepEqual(controls.calls, ["BEGIN", "COMMIT"]);
+  });
+
+  test("nested write transactions inside immediate transactions do not issue nested BEGIN", () => {
+    const runner = createDbTransactionRunner();
+    const controls = new FakeTransactionControls();
+
+    runner.immediateTransaction(controls, () => {
+      runner.transaction(controls, () => {
+        assert.equal(runner.isInTransaction(), true);
+      });
+    });
+
+    assert.deepEqual(controls.calls, ["BEGIN IMMEDIATE", "COMMIT"]);
+  });
 });

package/src/resources/extensions/gsd/tests/db-writer.test.ts

@@ -920,9 +920,9 @@ describe('db-writer', () => {
       decision,
     });
 
-    test('detects deferral in scope with M###/S## pattern in choice', () => {
+    test('detects deferral in scope when the scope names the slice', () => {
       const result = extractDeferredSliceRef(
-        fields('deferral of low-priority work', 'Move M001/S03 to backlog', ''),
+        fields('deferral of slice M001/S03', 'Move low-priority work to backlog', ''),
       );
       assert.deepStrictEqual(result, { milestoneId: 'M001', sliceId: 'S03' });
     });
@@ -950,14 +950,14 @@ describe('db-writer', () => {
 
     test('recognises "deferring" variant', () => {
       const result = extractDeferredSliceRef(
-        fields('deferring this slice', 'M005/S02 can wait', ''),
+        fields('slice prioritization', 'deferring M005/S02 until later', ''),
       );
       assert.deepStrictEqual(result, { milestoneId: 'M005', sliceId: 'S02' });
     });
 
     test('recognises "defers" variant', () => {
       const result = extractDeferredSliceRef(
-        fields('team defers slice', 'M100/S10 not urgent', ''),
+        fields('slice prioritization', 'team defers slice M100/S10', ''),
       );
       assert.deepStrictEqual(result, { milestoneId: 'M100', sliceId: 'S10' });
     });
@@ -969,6 +969,17 @@ describe('db-writer', () => {
       assert.deepStrictEqual(result, { milestoneId: 'M003', sliceId: 'S01' });
     });
 
+    test('does not treat a planning scope reference as a deferred slice', () => {
+      const result = extractDeferredSliceRef(
+        fields(
+          'planning',
+          'Plan S01 as the happy-path money loop only; Defer full duplicate/replay idempotency + polling reconciliation backstop (R006).',
+          'M003/S01 scope boundary for the BTC money loop (which requirements land in the first slice vs deferred follow-on slices).',
+        ),
+      );
+      assert.strictEqual(result, null);
+    });
+
     test('returns null when no deferral keyword is present', () => {
       const result = extractDeferredSliceRef(
         fields('approved work', 'M001/S01 is ready', 'proceed with M001/S01'),

package/src/resources/extensions/gsd/tests/deep-project-auto-loop.test.ts

@@ -6,7 +6,8 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { randomUUID } from "node:crypto";
 
-import { runDispatch, runPreDispatch } from "../auto/phases.ts";
+import { runDispatch } from "../auto/dispatch.ts";
+import { runPreDispatch } from "../auto/pre-dispatch.ts";
 import { AutoSession } from "../auto/session.ts";
 import { resolveUnitSupervisionTimeouts } from "../auto-timers.ts";
 import { bootstrapAutoSession } from "../auto-start.ts";
@@ -15,7 +16,7 @@ import { resolveDispatch, setResearchProjectPromptBuilderForTest } from "../auto
 import { resolveExpectedArtifactPath, verifyExpectedArtifact, writeBlockerPlaceholder } from "../auto-recovery.ts";
 import { finalizeProjectResearchTimeout } from "../project-research-policy.ts";
 import { resetRegistry } from "../rule-registry.ts";
-import { approvalGateIdForUnit, isAwaitingUserInput, isExplicitApprovalResponse, shouldPauseForUserApprovalQuestion } from "../user-input-boundary.ts";
+import { approvalGateIdForUnit, isAwaitingUserInput, isExplicitApprovalResponse, shouldPauseForQuestion } from "../consent-question.ts";
 import {
   clearPendingAutoStart,
   checkDeepProjectSetupAfterTurn,
@@ -1402,7 +1403,7 @@ test("deep project setup: user-quoted remote question failure does not pause aut
   ];
 
   assert.equal(isAwaitingUserInput(messages), false);
-  assert.equal(shouldPauseForUserApprovalQuestion("discuss-project", messages), false);
+  assert.equal(shouldPauseForQuestion("discuss-project", messages), false);
 });
 
 test("deep project setup: plain-text approval wait is treated as waiting for user input", () => {
@@ -1426,7 +1427,7 @@ test("deep project setup: opening interview question does not trigger approval a
   ];
 
   assert.equal(isAwaitingUserInput(messages), true);
-  assert.equal(shouldPauseForUserApprovalQuestion("discuss-project", messages), false);
+  assert.equal(shouldPauseForQuestion("discuss-project", messages), false);
 });
 
 test("deep project setup: grounding interview question with requirements context does not trigger approval abort", () => {
@@ -1441,7 +1442,7 @@ test("deep project setup: grounding interview question with requirements context
   ];
 
   assert.equal(isAwaitingUserInput(messages), true);
-  assert.equal(shouldPauseForUserApprovalQuestion("discuss-project", messages), false);
+  assert.equal(shouldPauseForQuestion("discuss-project", messages), false);
 });
 
 test("deep project setup: persistence and anti-goals interview prompt does not trigger approval abort", () => {
@@ -1460,7 +1461,7 @@ test("deep project setup: persistence and anti-goals interview prompt does not t
   ];
 
   assert.equal(isAwaitingUserInput(messages), true);
-  assert.equal(shouldPauseForUserApprovalQuestion("discuss-project", messages), false);
+  assert.equal(shouldPauseForQuestion("discuss-project", messages), false);
 });
 
 test("deep project setup: discovery questions before writing PROJECT do not trigger approval abort", () => {
@@ -1479,7 +1480,7 @@ test("deep project setup: discovery questions before writing PROJECT do not trig
   ];
 
   assert.equal(isAwaitingUserInput(messages), true);
-  assert.equal(shouldPauseForUserApprovalQuestion("discuss-project", messages), false);
+  assert.equal(shouldPauseForQuestion("discuss-project", messages), false);
 });
 
 test("deep project setup: discovery question mentioning write intent does not trigger approval abort", () => {
@@ -1491,7 +1492,7 @@ test("deep project setup: discovery question mentioning write intent does not tr
   ];
 
   assert.equal(isAwaitingUserInput(messages), true);
-  assert.equal(shouldPauseForUserApprovalQuestion("discuss-project", messages), false);
+  assert.equal(shouldPauseForQuestion("discuss-project", messages), false);
 });
 
 test("deep project setup: scope discovery question mentioning add does not trigger approval abort", () => {
@@ -1503,7 +1504,7 @@ test("deep project setup: scope discovery question mentioning add does not trigg
   ];
 
   assert.equal(isAwaitingUserInput(messages), true);
-  assert.equal(shouldPauseForUserApprovalQuestion("discuss-project", messages), false);
+  assert.equal(shouldPauseForQuestion("discuss-project", messages), false);
 });
 
 test("deep project setup: requirements preview question from screenshot is treated as waiting", () => {
@@ -1523,12 +1524,12 @@ test("deep project setup: requirements preview question from screenshot is treat
   ];
 
   assert.equal(isAwaitingUserInput(messages), true);
-  assert.equal(shouldPauseForUserApprovalQuestion("discuss-requirements", messages), true);
+  assert.equal(shouldPauseForQuestion("discuss-requirements", messages), true);
 });
 
 test("deep project setup: research decision question triggers approval boundary pause", () => {
   assert.equal(
-    shouldPauseForUserApprovalQuestion("research-decision", [
+    shouldPauseForQuestion("research-decision", [
       {
         role: "assistant",
         content: "Run domain research now? (y/n)",

package/src/resources/extensions/gsd/tests/derive-state-helpers.test.ts

@@ -21,6 +21,7 @@ import {
   insertSlice,
   insertTask,
   setMilestoneQueueOrder,
+  transaction,
   updateTaskStatus,
 } from '../gsd-db.ts';
 
@@ -473,6 +474,31 @@ describe('derive-state-helpers', () => {
     }
   });
 
+  test('setMilestoneQueueOrder can be composed inside a transaction', async () => {
+    const base = createFixtureBase();
+    try {
+      writeFile(base, 'milestones/M001/M001-CONTEXT.md', '# M001\n\nContext.');
+      writeFile(base, 'milestones/M002/M002-CONTEXT.md', '# M002\n\nContext.');
+
+      openDatabase(':memory:');
+      insertMilestone({ id: 'M001', title: 'First', status: 'active' });
+      insertMilestone({ id: 'M002', title: 'Second', status: 'active' });
+
+      transaction(() => {
+        setMilestoneQueueOrder(['M002', 'M001']);
+      });
+
+      invalidateStateCache();
+      const state = await deriveStateFromDb(base);
+
+      assert.equal(state.activeMilestone?.id, 'M002', 'queue-order: nested transaction chooses M002');
+      assert.deepEqual(state.registry.map(entry => entry.id), ['M002', 'M001']);
+    } finally {
+      closeDatabase();
+      cleanup(base);
+    }
+  });
+
   test('getActiveMilestoneId: DB lock path ignores PARKED flag projection', async () => {
     const base = createFixtureBase();
     const previousLock = process.env.GSD_MILESTONE_LOCK;
@@ -569,6 +595,42 @@ describe('derive-state-helpers', () => {
     }
   });
 
+  // ─── Batch slice query: multi-milestone slices loaded in one query ─────
+  test('buildRegistryAndFindActive: batched slice query preserves ordering across milestones', async () => {
+    const base = createFixtureBase();
+    try {
+      // M001 is complete so the loop advances past it.
+      writeFile(base, 'milestones/M001/M001-ROADMAP.md', ROADMAP_CONTENT);
+      writeFile(base, 'milestones/M001/M001-SUMMARY.md', '# M001 Summary\n\nDone.');
+      // M002 is a queued shell milestone with no context and no slices — should be deferred.
+      mkdirSync(join(base, '.gsd', 'milestones', 'M002'), { recursive: true });
+      // M003 is the real active milestone with slices in non-trivial sequence order.
+      writeFile(base, 'milestones/M003/M003-CONTEXT.md', '# M003: Real\n\nReal milestone.');
+
+      openDatabase(':memory:');
+      insertMilestone({ id: 'M001', title: 'Complete', status: 'complete' });
+      insertMilestone({ id: 'M002', title: 'Shell', status: 'queued' });
+      insertMilestone({ id: 'M003', title: 'Real', status: 'active' });
+      // Slices intentionally inserted with out-of-order sequences to prove ordering.
+      insertSlice({ id: 'S01', milestoneId: 'M001', title: 'M1 Second', status: 'complete', risk: 'low', depends: [], sequence: 2 });
+      insertSlice({ id: 'S02', milestoneId: 'M001', title: 'M1 First', status: 'complete', risk: 'low', depends: [], sequence: 1 });
+      insertSlice({ id: 'S03', milestoneId: 'M003', title: 'M3 Second', status: 'active', risk: 'low', depends: [], sequence: 5 });
+      insertSlice({ id: 'S04', milestoneId: 'M003', title: 'M3 First', status: 'active', risk: 'low', depends: [], sequence: 3 });
+
+      invalidateStateCache();
+      const state = await deriveStateFromDb(base);
+
+      assert.equal(state.activeMilestone?.id, 'M003', 'batched: M003 is active after complete M001 and shell M002');
+      assert.equal(state.activeSlice?.id, 'S04', 'batched: first slice by sequence is active');
+      assert.equal(state.registry.find(e => e.id === 'M001')?.status, 'complete', 'batched: M001 complete');
+      assert.equal(state.registry.find(e => e.id === 'M002')?.status, 'pending', 'batched: shell M002 deferred to pending');
+      assert.equal(state.registry.find(e => e.id === 'M003')?.status, 'active', 'batched: M003 active');
+    } finally {
+      closeDatabase();
+      cleanup(base);
+    }
+  });
+
   // ─── Deferred queued shell: shell milestone deferred, real one promoted ──
   test('buildRegistryAndFindActive: queued shell deferred, later real milestone becomes active (#3470)', async () => {
     const base = createFixtureBase();

package/src/resources/extensions/gsd/tests/discuss-routing-fixes.test.ts

@@ -39,7 +39,11 @@ function makeDiscussPi() {
     tmp,
     pi: {
       getActiveTools: () => ["gsd_summary_save", "bash"],
+      emitAdjustToolSet: async () => undefined,
+      emitBeforeModelSelect: async () => undefined,
+      setModel: async () => true,
       setActiveTools: () => {},
+      setThinkingLevel: () => {},
       sendMessage: (message: { content?: unknown }) => {
         sent.push(message);
       },
@@ -53,6 +57,7 @@ function makeDiscussPi() {
 }
 
 function makeDiscussCtx(notifications: Array<{ message: string; level?: string }> = []) {
+  const model = { provider: "anthropic", id: "claude-sonnet-4-6", api: "anthropic-messages" };
   return {
     hasUI: true,
     sessionManager: {
@@ -65,8 +70,13 @@ function makeDiscussCtx(notifications: Array<{ message: string; level?: string }
       setStatus: () => {},
     },
     waitForIdle: async () => {},
-    model: undefined,
-    modelRegistry: { getProviderAuthMode: () => undefined },
+    model,
+    modelRegistry: {
+      getAvailable: () => [model],
+      getAll: () => [model],
+      getProviderAuthMode: () => "apiKey",
+      isProviderRequestReady: () => true,
+    },
   };
 }