@opengsd/gsd-pi 1.3.0 → 1.4.0

package/src/resources/extensions/gsd/tests/complete-task-rollback-evidence.test.ts

@@ -1,6 +1,6 @@
 import { describe, it, afterEach } from "node:test";
 import assert from "node:assert/strict";
-import { mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { mkdirSync, readFileSync, rmSync, writeFileSync, promises as fsPromises } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { randomUUID } from "node:crypto";
@@ -41,7 +41,7 @@ const VALID_PARAMS = {
   ],
 };
 
-describe("complete-task projection failures keep DB completion committed", () => {
+describe("complete-task projection failures roll back DB completion", () => {
   let base: string;
 
   afterEach(() => {
@@ -75,7 +75,44 @@ describe("complete-task projection failures keep DB completion committed", () =>
     assert.equal(rows.length, 2, "should have 2 evidence rows after success");
   });
 
-  it("keeps task completion and verification_evidence when disk projection write fails", async () => {
+  it("reopens the workflow DB when it disappears between SUMMARY.md write and plan render", async (t) => {
+    base = makeTmpBase();
+    openDatabase(join(base, ".gsd", "gsd.db"));
+    insertMilestone({ id: "M001" });
+    insertSlice({ id: "S01", milestoneId: "M001" });
+
+    const planPath = join(base, ".gsd", "milestones", "M001", "slices", "S01", "S01-PLAN.md");
+    writeFileSync(
+      planPath,
+      "# S01 Plan\n\n## Tasks\n\n- [ ] **T01: Test task**\n",
+    );
+
+    const originalRename = fsPromises.rename.bind(fsPromises);
+    let closedAfterSummaryWrite = false;
+    t.mock.method(fsPromises, "rename", async (...args: Parameters<typeof fsPromises.rename>) => {
+      await originalRename(...args);
+      const target = String(args[1]);
+      if (!closedAfterSummaryWrite && target.endsWith("T01-SUMMARY.md")) {
+        closedAfterSummaryWrite = true;
+        closeDatabase();
+      }
+    });
+
+    const result = await handleCompleteTask(VALID_PARAMS, base);
+    assert.ok(closedAfterSummaryWrite, "test fixture should close DB after SUMMARY.md atomic rename");
+    assert.ok(!("error" in result), `unexpected error: ${"error" in result ? result.error : ""}`);
+
+    const content = readFileSync(planPath, "utf-8");
+    assert.match(content, /\[x\][^\n]*\*\*T01\*\*/, "PLAN.md checkbox should be rendered after DB reopen");
+
+    const adapter = _getAdapter()!;
+    const task = adapter.prepare(
+      `SELECT status FROM tasks WHERE milestone_id = 'M001' AND slice_id = 'S01' AND id = 'T01'`,
+    ).get() as { status: string } | undefined;
+    assert.equal(task?.status, "complete", "task should remain complete after successful projection");
+  });
+
+  it("rolls back DB completion and clears verification_evidence when disk projection write fails", async () => {
     base = makeTmpBase();
     openDatabase(join(base, ".gsd", "gsd.db"));
     insertMilestone({ id: "M001" });
@@ -87,19 +124,22 @@ describe("complete-task projection failures keep DB completion committed", () =>
     writeFileSync(tasksDir, "not-a-directory");
 
     const result = await handleCompleteTask(VALID_PARAMS, base);
-    assert.ok(!("error" in result), `unexpected error: ${"error" in result ? result.error : ""}`);
-    assert.equal(result.stale, true, "result should report stale projection");
+    assert.ok("error" in result, "expected rollback error when projection write fails");
+    assert.ok(
+      (result as { error: string }).error.includes("rolled completion back to pending"),
+      `error should mention rollback; got: ${"error" in result ? result.error : ""}`,
+    );
 
     const adapter = _getAdapter()!;
     const task = adapter.prepare(
       `SELECT status FROM tasks WHERE milestone_id = 'M001' AND slice_id = 'S01' AND id = 'T01'`,
     ).get() as { status: string } | undefined;
-    assert.ok(task, "task row should still exist");
-    assert.equal(task!.status, "complete", "task status should remain complete");
+    assert.ok(task, "task row should still exist after rollback");
+    assert.equal(task!.status, "pending", "task status should be rolled back to pending");
 
     const evidenceRows = adapter.prepare(
       `SELECT * FROM verification_evidence WHERE task_id = 'T01' AND slice_id = 'S01' AND milestone_id = 'M001'`,
     ).all();
-    assert.equal(evidenceRows.length, 2, "verification_evidence should remain committed");
+    assert.equal(evidenceRows.length, 0, "verification_evidence should be deleted after rollback");
   });
 });

package/src/resources/extensions/gsd/tests/complete-task.test.ts

@@ -60,10 +60,10 @@ function cleanupDir(dirPath: string): void {
  */
 function createTempProject(): { basePath: string; planPath: string } {
   const basePath = fs.mkdtempSync(path.join(os.tmpdir(), 'gsd-handler-'));
-  const tasksDir = path.join(basePath, '.gsd', 'milestones', 'M001', 'slices', 'S01', 'tasks');
+  const tasksDir = path.join(basePath, '.gsd', 'phases', '01-test');
   fs.mkdirSync(tasksDir, { recursive: true });
 
-  const planPath = path.join(basePath, '.gsd', 'milestones', 'M001', 'slices', 'S01', 'S01-PLAN.md');
+  const planPath = path.join(basePath, '.gsd', 'phases', '01-test', '01-01-PLAN.md');
   fs.writeFileSync(planPath, `# S01: Test Slice
 
 ## Tasks
@@ -359,9 +359,9 @@ console.log('\n=== complete-task: handler happy path ===');
 
     // (d) Verify plan checkbox changed to [x]
     const planContent = fs.readFileSync(planPath, 'utf-8');
-    assertMatch(planContent, /\[x\]\s+\*\*T01:/, 'T01 should be checked in plan');
+    assertMatch(planContent, /\[x\]\s+\*\*T01\*\*/, 'T01 should be checked in plan');
     // T02 should still be unchecked
-    assertMatch(planContent, /\[ \]\s+\*\*T02:/, 'T02 should still be unchecked in plan');
+    assertMatch(planContent, /\[ \]\s+\*\*T02\*\*/, 'T02 should still be unchecked in plan');
 
     // (e) Verify full_summary_md stored in DB for D004 recovery
     const taskAfter = getTask('M001', 'S01', 'T01');
@@ -380,6 +380,81 @@ console.log('\n=== complete-task: handler happy path ===');
   cleanup(dbPath);
 }
 
+// ═══════════════════════════════════════════════════════════════════════════
+// complete-task: Projection failure rolls DB completion back
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n=== complete-task: projection failure rolls DB completion back ===');
+{
+  const dbPath = tempDbPath();
+  openDatabase(dbPath);
+
+  const { basePath, planPath } = createTempProject();
+
+  insertMilestone({ id: 'M001', title: 'Test Milestone' });
+  insertSlice({ id: 'S01', milestoneId: 'M001', title: 'Test Slice' });
+
+  fs.unlinkSync(planPath);
+  fs.mkdirSync(planPath, { recursive: true });
+
+  const result = await handleCompleteTask(makeValidParams(), basePath);
+
+  assertTrue('error' in result, 'projection failure should return an error');
+  if ('error' in result) {
+    assertMatch(result.error, /projection write failed/, 'error should mention projection write failure');
+  }
+
+  const task = getTask('M001', 'S01', 'T01');
+  assertTrue(task !== null, 'task row should remain for retry');
+  assertEq(task!.status, 'pending', 'task status should be rolled back to pending');
+  assertEq(task!.completed_at, null, 'rolled back task should not keep completed_at');
+
+  const adapter = _getAdapter()!;
+  const evRows = adapter.prepare(
+    "SELECT * FROM verification_evidence WHERE task_id = 'T01' AND slice_id = 'S01' AND milestone_id = 'M001'"
+  ).all();
+  assertEq(evRows.length, 0, 'verification evidence should be deleted when projection rollback runs');
+
+  const summaryPath = path.join(path.dirname(planPath), 'T01-SUMMARY.md');
+  assertTrue(!fs.existsSync(summaryPath), 'SUMMARY.md should be removed so disk state stays pending');
+
+  cleanupDir(basePath);
+  cleanup(dbPath);
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// complete-task: Handler does not re-render completed sibling summaries
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n=== complete-task: handler leaves completed sibling summaries untouched ===');
+{
+  const dbPath = tempDbPath();
+  openDatabase(dbPath);
+
+  const { basePath, planPath } = createTempProject();
+
+  insertMilestone({ id: 'M001', title: 'Test Milestone' });
+  insertSlice({ id: 'S01', milestoneId: 'M001', title: 'Test Slice', risk: 'high', depends: [], demo: 'basic functionality works', sequence: 1 });
+  insertTask({ id: 'T00', sliceId: 'S01', milestoneId: 'M001', status: 'complete', title: 'Already complete task', oneLiner: 'Previously completed' });
+  insertTask({ id: 'T02', sliceId: 'S01', milestoneId: 'M001', status: 'pending', title: 'Second task' });
+
+  const siblingSummaryPath = path.join(path.dirname(planPath), 'T00-SUMMARY.md');
+  const siblingSummaryContent = 'existing sibling summary marker\n';
+  fs.writeFileSync(siblingSummaryPath, siblingSummaryContent);
+
+  const result = await handleCompleteTask(makeValidParams(), basePath);
+
+  assertTrue(!('error' in result), 'handler should succeed without error');
+  assertEq(
+    fs.readFileSync(siblingSummaryPath, 'utf-8'),
+    siblingSummaryContent,
+    'complete-task should not re-render summaries for already-completed sibling tasks',
+  );
+
+  cleanupDir(basePath);
+  cleanup(dbPath);
+}
+
 // ═══════════════════════════════════════════════════════════════════════════
 // complete-task: hard-blocker escalation with mid-execution escalation disabled
 // ═══════════════════════════════════════════════════════════════════════════
@@ -584,7 +659,7 @@ console.log('\n=== complete-task: handler with missing plan file ===');
 
   // Create a temp dir WITHOUT a plan file
   const basePath = fs.mkdtempSync(path.join(os.tmpdir(), 'gsd-no-plan-'));
-  const tasksDir = path.join(basePath, '.gsd', 'milestones', 'M001', 'slices', 'S01', 'tasks');
+  const tasksDir = path.join(basePath, '.gsd', 'phases', '01-test');
   fs.mkdirSync(tasksDir, { recursive: true });
 
   // Seed milestone + slice so state machine guards pass
@@ -598,9 +673,9 @@ console.log('\n=== complete-task: handler with missing plan file ===');
   assertTrue(!('error' in result), 'handler should succeed without plan file');
   if (!('error' in result)) {
     assertTrue(fs.existsSync(result.summaryPath), 'summary should be written even without plan file');
-    const planPath = path.join(basePath, '.gsd', 'milestones', 'M001', 'slices', 'S01', 'S01-PLAN.md');
+    const planPath = path.join(basePath, '.gsd', 'phases', '01-test', '01-01-PLAN.md');
     assertTrue(fs.existsSync(planPath), 'missing plan projection should be regenerated from DB');
-    assertTrue(fs.readFileSync(planPath, 'utf-8').includes('[x] **T01:'), 'regenerated plan should reflect DB task completion');
+    assertTrue(fs.readFileSync(planPath, 'utf-8').includes('[x] **T01**'), 'regenerated plan should reflect DB task completion');
   }
 
   cleanupDir(basePath);

package/src/resources/extensions/gsd/tests/consent-question.test.ts

@@ -83,6 +83,8 @@ const POLICY_TABLE: Row[] = [
   { name: "gate × missing response → waiting", question: gateQ, details: {}, expected: "waiting" },
   { name: "gate × notes-only → waiting (notes never satisfy a gate)", question: gateQ, details: { response: { answers: { [gateQ.id]: { notes: "looks fine" } } } }, expected: "waiting" },
   { name: "gate × cancelled → cancelled", question: gateQ, details: { cancelled: true, response: null }, expected: "cancelled" },
+  { name: "gate × timed_out → timeout (#852)", question: gateQ, details: { cancelled: true, timed_out: true, response: null }, expected: "timeout" },
+  { name: "gate × timed_out + interrupted → timeout (timeout wins, #852)", question: gateQ, details: { cancelled: true, timed_out: true, interrupted: true, response: null }, expected: "timeout" },
   // consent
   { name: "consent × valid selected → answered", question: consentQ, details: { response: { answers: { [consentQ.id]: { selected: "Option B" } } } }, expected: "answered" },
   { name: "consent × empty selected → waiting (#528)", question: consentQ, details: { response: { answers: { [consentQ.id]: { selected: "" } } } }, expected: "waiting" },
@@ -90,6 +92,7 @@ const POLICY_TABLE: Row[] = [
   { name: "consent × missing response → waiting", question: consentQ, details: {}, expected: "waiting" },
   { name: "consent × notes-only → answered (a real user utterance)", question: consentQ, details: { response: { answers: { [consentQ.id]: { notes: "neither — keep it simple" } } } }, expected: "answered" },
   { name: "consent × cancelled → cancelled", question: consentQ, details: { cancelled: true, response: null }, expected: "cancelled" },
+  { name: "consent × timed_out → timeout (#852)", question: consentQ, details: { cancelled: true, timed_out: true, response: null }, expected: "timeout" },
 ];
 
 for (const row of POLICY_TABLE) {
@@ -124,6 +127,48 @@ test("evaluateAskUserQuestionsRound: most blocking outcome wins", () => {
   assert.equal(evaluateAskUserQuestionsRound([], {}), "answered");
 });
 
+// ── #852: host elicitation timeout → "timeout" round outcome ────────────────
+
+test("#852: timed_out round → timeout (does NOT become waiting/answered)", () => {
+  // A timeout must not be laundered into "waiting" (which tells the model to
+  // re-ask — that just hits the same timeout again) or "answered".
+  assert.equal(
+    evaluateAskUserQuestionsRound([consentQ], { cancelled: true, timed_out: true, response: null }),
+    "timeout",
+  );
+  assert.equal(
+    evaluateAskUserQuestionsRound([gateQ], { cancelled: true, timed_out: true, response: null }),
+    "timeout",
+  );
+});
+
+test("#852: timeout wins over answered in a mixed round (most blocking)", () => {
+  // One answered question + one timed_out question → the whole round is timeout.
+  const details = {
+    timed_out: true,
+    cancelled: true,
+    response: null,
+  };
+  assert.equal(
+    evaluateAskUserQuestionsRound(
+      [consentQ, { id: "other", options: CONSENT_OPTIONS }],
+      // The timed_out flag is round-level, so even if one question "answered"
+      // the timeout on the round dominates.
+      details,
+    ),
+    "timeout",
+  );
+});
+
+test("#852: cancelled still beats timeout when both flags absent on the round", () => {
+  // Round-level cancelled without timed_out stays cancelled (deliberate user
+  // dismissal is a stronger signal than a host timeout).
+  assert.equal(
+    evaluateAskUserQuestionsRound([consentQ], { cancelled: true, response: null }),
+    "cancelled",
+  );
+});
+
 // ── Regression: #528 empty selected on a consent question never answers ─────
 
 test("#528: empty selected on a NON-gate question is waiting, not answered", () => {

package/src/resources/extensions/gsd/tests/dashboard-overlay.test.ts

@@ -4,10 +4,15 @@
 
 import test from "node:test";
 import assert from "node:assert/strict";
+import { chmodSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { delimiter, join } from "node:path";
+import { tmpdir } from "node:os";
+import { performance } from "node:perf_hooks";
 
 import { GSDDashboardOverlay } from "../dashboard-overlay.ts";
 import type { UnitMetrics } from "../metrics.ts";
 import { assertFullOuterBorder } from "./tui-border-assertions.ts";
+import { autoSession, getAutoRuntimeSnapshot } from "../auto-runtime-state.ts";
 
 const fakeTheme = {
   fg: (_color: string, text: string) => text,
@@ -48,6 +53,91 @@ test("GSDDashboardOverlay reuses metrics aggregations until the unit count chang
   assert.equal(increasedCountMetrics.totals.cost, 1.25);
 });
 
+test("GSDDashboardOverlay non-identity refresh avoids reparsing preferences", async (t) => {
+  const basePath = join(
+    tmpdir(),
+    `gsd-dashboard-overlay-refresh-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+  );
+  mkdirSync(join(basePath, ".gsd"), { recursive: true });
+
+  autoSession.reset();
+  autoSession.active = true;
+  autoSession.basePath = basePath;
+  autoSession.autoStartTime = Date.now() - 1000;
+  autoSession.setCurrentUnit({
+    type: "execute-task",
+    id: "M001/S001/T001",
+    startedAt: Date.now() - 500,
+  });
+
+  const overlay = new GSDDashboardOverlay({ requestRender() {} }, fakeTheme as any, () => {});
+  t.after(() => {
+    overlay.dispose();
+    autoSession.reset();
+    rmSync(basePath, { recursive: true, force: true });
+  });
+
+  (overlay as any).loadedDashboardIdentity = (overlay as any).computeDashboardIdentity(getAutoRuntimeSnapshot());
+  mkdirSync(join(basePath, ".gsd", "PREFERENCES.md"));
+
+  await assert.doesNotReject(
+    () => (overlay as any).refreshDashboard(false),
+    "unchanged overlay identity should not call getAutoDashboardData or read preferences",
+  );
+});
+
+test("GSDDashboardOverlay render and scroll do not run environment doctor subprocesses", (t) => {
+  const basePath = join(
+    tmpdir(),
+    `gsd-dashboard-overlay-env-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+  );
+  const shimDir = join(
+    tmpdir(),
+    `gsd-dashboard-overlay-shim-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+  );
+  mkdirSync(basePath, { recursive: true });
+  mkdirSync(shimDir, { recursive: true });
+  writeFileSync(join(basePath, "package.json"), JSON.stringify({ engines: { node: ">=22.0.0" } }));
+
+  const posixNodeShim = join(shimDir, "node");
+  writeFileSync(posixNodeShim, "#!/bin/sh\nsleep 1\nexit 1\n");
+  chmodSync(posixNodeShim, 0o755);
+  writeFileSync(join(shimDir, "node.cmd"), "@echo off\r\nping -n 2 127.0.0.1 > nul\r\nexit /b 1\r\n");
+
+  const originalPath = process.env.PATH;
+  const overlay = new GSDDashboardOverlay({ requestRender() {} }, fakeTheme as any, () => {});
+  overlay.dispose();
+
+  t.after(() => {
+    if (originalPath === undefined) {
+      delete process.env.PATH;
+    } else {
+      process.env.PATH = originalPath;
+    }
+    rmSync(basePath, { recursive: true, force: true });
+    rmSync(shimDir, { recursive: true, force: true });
+  });
+
+  (overlay as any).loading = false;
+  (overlay as any).milestoneData = null;
+  (overlay as any).dashData = {
+    ...(overlay as any).dashData,
+    basePath,
+  };
+
+  process.env.PATH = `${shimDir}${delimiter}${originalPath ?? ""}`;
+  const start = performance.now();
+  overlay.render(100);
+  overlay.handleInput("j");
+  overlay.render(100);
+  const elapsed = performance.now() - start;
+
+  assert.ok(
+    elapsed < 500,
+    `rendering and scrolling should not wait for environment subprocesses, took ${Math.round(elapsed)}ms`,
+  );
+});
+
 function makeUnit(id: string, cost: number): UnitMetrics {
   return {
     type: "execute-task",

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

@@ -58,7 +58,7 @@ function activeRequirement(id: string): Requirement {
   };
 }
 
-test("DB authority: PROJECT.md and QUEUE-ORDER projections do not choose runtime milestone", async (t) => {
+test("DB authority: PROJECT.md projection does not create runtime milestones from QUEUE-ORDER", async (t) => {
   const base = makeBase();
   t.after(() => cleanup(base));
 

package/src/resources/extensions/gsd/tests/db-memory-fts-schema.test.ts

@@ -3,11 +3,16 @@
 
 import { describe, test } from "node:test";
 import assert from "node:assert/strict";
+import { createRequire } from "node:module";
 import {
+  MEMORIES_FTS_REBUILT_KEY,
   isMemoriesFtsAvailableSchema,
+  rebuildMemoriesFtsSchemaOnce,
   tryCreateMemoriesFtsSchema,
 } from "../db-memory-fts-schema.ts";
-import type { DbAdapter, DbStatement } from "../db-adapter.ts";
+import { createDbAdapter, type DbAdapter, type DbStatement } from "../db-adapter.ts";
+
+const _require = createRequire(import.meta.url);
 
 class FakeStatement implements DbStatement {
   private readonly row: Record<string, unknown> | undefined;
@@ -32,6 +37,7 @@ class FakeStatement implements DbStatement {
 class FakeAdapter implements DbAdapter {
   readonly execCalls: string[] = [];
   hasFts = false;
+  hasRebuildMarker = false;
   failExec = false;
 
   exec(sql: string): void {
@@ -39,13 +45,26 @@ class FakeAdapter implements DbAdapter {
     if (this.failExec) throw new Error("fts unavailable");
   }
 
-  prepare(): DbStatement {
-    return new FakeStatement(this.hasFts ? { name: "memories_fts" } : undefined);
+  prepare(sql: string): DbStatement {
+    if (sql.includes("sqlite_master")) {
+      return new FakeStatement(this.hasFts ? { name: "memories_fts" } : undefined);
+    }
+    if (sql.includes("runtime_kv")) {
+      return new FakeStatement(this.hasRebuildMarker ? { present: 1 } : undefined);
+    }
+    return new FakeStatement(undefined);
   }
 
   close(): void {}
 }
 
+function openMemoryAdapter(): { db: DbAdapter; close: () => void } {
+  const sqlite = _require("node:sqlite") as { DatabaseSync: new (path: string) => unknown };
+  const raw = new sqlite.DatabaseSync(":memory:");
+  const db = createDbAdapter(raw);
+  return { db, close: () => db.close() };
+}
+
 describe("db-memory-fts-schema", () => {
   test("creates memories_fts and insert/delete/update triggers", () => {
     const db = new FakeAdapter();
@@ -83,4 +102,40 @@ describe("db-memory-fts-schema", () => {
     db.hasFts = true;
     assert.equal(isMemoriesFtsAvailableSchema(db), true);
   });
+
+  test("rebuilds the external-content index once and records a marker", () => {
+    const { db, close } = openMemoryAdapter();
+    try {
+      db.exec("CREATE TABLE memories (seq INTEGER PRIMARY KEY AUTOINCREMENT, content TEXT NOT NULL)");
+      db.exec("INSERT INTO memories (content) VALUES ('pre FTS auth memory must be searchable')");
+
+      const ok = tryCreateMemoriesFtsSchema(db);
+      if (!ok) return;
+
+      const before = db.prepare("SELECT rowid FROM memories_fts WHERE memories_fts MATCH 'auth'").all();
+      assert.equal(before.length, 0, "external-content FTS starts empty for existing rows");
+
+      rebuildMemoriesFtsSchemaOnce(db);
+
+      const after = db.prepare("SELECT rowid FROM memories_fts WHERE memories_fts MATCH 'auth'").all();
+      assert.deepEqual(after.map((row) => row["rowid"]), [1]);
+      const marker = db.prepare(
+        "SELECT value_json FROM runtime_kv WHERE scope = 'global' AND scope_id = '' AND key = :key",
+      ).get({ ":key": MEMORIES_FTS_REBUILT_KEY });
+      assert.ok(marker, "rebuild marker should be stored");
+    } finally {
+      close();
+    }
+  });
+
+  test("skips rebuild when marker already exists", () => {
+    const db = new FakeAdapter();
+    db.hasFts = true;
+    db.hasRebuildMarker = true;
+
+    rebuildMemoriesFtsSchemaOnce(db);
+
+    assert.ok(db.execCalls.some((sql) => sql.includes("CREATE TABLE IF NOT EXISTS runtime_kv")));
+    assert.ok(!db.execCalls.some((sql) => sql.includes("VALUES('rebuild')")));
+  });
 });

package/src/resources/extensions/gsd/tests/decisions-projection-from-memories.test.ts

@@ -142,6 +142,57 @@ test("backfill is idempotent — re-running over migrated rows is a no-op", () =
   }
 });
 
+test("backfill skips a decision whose memory insert throws and continues later rows", () => {
+  const base = makeTmpBase();
+  try {
+    seedRawDecision({
+      id: "D001",
+      when_context: "M001",
+      scope: "M001",
+      decision: "before poison",
+      choice: "A",
+      rationale: "first row",
+    });
+    seedRawDecision({
+      id: "D002",
+      when_context: "M001",
+      scope: "M001",
+      decision: "poison",
+      choice: "B",
+      rationale: "this insert throws",
+    });
+    seedRawDecision({
+      id: "D003",
+      when_context: "M001",
+      scope: "M001",
+      decision: "after poison",
+      choice: "C",
+      rationale: "tail row",
+    });
+
+    const adapter = _getAdapter();
+    assert.ok(adapter);
+    adapter.exec(`
+      CREATE TRIGGER fail_d002_memory_insert
+      BEFORE INSERT ON memories
+      WHEN json_extract(NEW.structured_fields, '$.sourceDecisionId') = 'D002'
+      BEGIN
+        SELECT RAISE(ABORT, 'poison decision D002');
+      END
+    `);
+
+    const written = backfillDecisionsToMemories();
+    assert.equal(written, 2, "one poisoned row should not abort the batch");
+    assert.deepEqual(
+      getAllDecisionsFromMemories().map((d) => d.id),
+      ["D001", "D003"],
+      "rows after the poisoned decision should still be migrated",
+    );
+  } finally {
+    cleanup(base);
+  }
+});
+
 // ─── Drift auto-heal ───────────────────────────────────────────────────────
 
 test("backfill auto-heals when a source decision's superseded_by changes after migration", () => {

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

@@ -1,6 +1,8 @@
 import { describe, test } from 'node:test';
 import assert from 'node:assert/strict';
-import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import fs from 'node:fs';
+import { mkdtempSync, mkdirSync, realpathSync, rmSync, writeFileSync } from 'node:fs';
+import { syncBuiltinESMExports } from 'node:module';
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
 
@@ -254,6 +256,29 @@ describe('derive-state-db', async () => {
     }
   });
 
+  test('derive-state-db: opens existing project DB before querying milestones', async (t) => {
+    const base = createFixtureBase();
+    t.after(() => {
+      closeDatabase();
+      cleanup(base);
+    });
+
+    const dbPath = join(base, '.gsd', 'gsd.db');
+    assert.equal(openDatabase(dbPath), true);
+    insertMilestone({ id: 'M001', title: 'Cold DB Milestone', status: 'active' });
+    insertSlice({ id: 'S01', milestoneId: 'M001', title: 'Ready Slice', status: 'active', risk: 'low', depends: [] });
+    insertTask({ id: 'T01', sliceId: 'S01', milestoneId: 'M001', title: 'Ready Task', status: 'pending' });
+    closeDatabase();
+    assert.equal(isDbAvailable(), false);
+
+    const state = await deriveStateFromDb(base);
+
+    assert.equal(state.activeMilestone?.id, 'M001');
+    assert.equal(state.activeSlice?.id, 'S01');
+    assert.equal(state.activeTask?.id, 'T01');
+    assert.notEqual(state.nextAction, 'No milestones found. Run /gsd to create one.');
+  });
+
   // ─── Test 4: Partial DB content does not fill gaps from disk ──────────
   test('derive-state-db: partial DB does not fill requirements from disk', async () => {
     const base = createFixtureBase();
@@ -1239,6 +1264,43 @@ describe('derive-state-db', async () => {
     }
   });
 
+  test('derive-state-db: missing context resolves milestone directory once', async () => {
+    const base = createFixtureBase();
+    const phaseDir = join(realpathSync.native(base), '.gsd', 'phases', '01-m001');
+    let phaseDirExistsChecks = 0;
+    const mutableFs = fs as { existsSync: typeof fs.existsSync };
+    const originalExistsSync = fs.existsSync;
+    mutableFs.existsSync = ((path) => {
+      if (String(path) === phaseDir) phaseDirExistsChecks += 1;
+      return originalExistsSync(path);
+    }) as typeof fs.existsSync;
+    syncBuiltinESMExports();
+
+    try {
+      mkdirSync(phaseDir, { recursive: true });
+
+      openDatabase(':memory:');
+      insertMilestone({ id: 'M001', title: 'First', status: 'queued' });
+
+      invalidateStateCache();
+      const dbState = await deriveStateFromDb(base);
+
+      assert.equal(dbState.activeMilestone?.id, 'M001', 'single-resolve: queued milestone becomes active');
+      assert.equal(
+        phaseDirExistsChecks,
+        3,
+        'single-resolve: one directory resolve plus two artifact probes re-check the milestone directory via resolveFile',
+      );
+
+      closeDatabase();
+    } finally {
+      mutableFs.existsSync = originalExistsSync;
+      syncBuiltinESMExports();
+      closeDatabase();
+      cleanup(base);
+    }
+  });
+
   // ─── Regression: disk-only milestones synced into DB (#2416) ─────────
   test('derive-state-db: disk-only milestone auto-synced into DB (#2416)', async () => {
     const base = createFixtureBase();