gsd-pi 2.80.0-dev.96f4d89d5 → 2.80.0-dev.a947d025c

package/src/resources/extensions/gsd/tests/smart-entry-draft.test.ts

@@ -1,124 +1,33 @@
-import { mkdtempSync, mkdirSync, rmSync, writeFileSync, readFileSync } from "node:fs";
+// GSD-2 — Guided smart entry draft-state behavior tests.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 
 import { deriveState } from "../state.js";
 import { resolveMilestoneFile } from "../paths.js";
-import { extractSourceRegion } from "./test-helpers.ts";
-
-let passed = 0;
-let failed = 0;
 
-function assert(condition: boolean, message: string): void {
-  if (condition) {
-    passed++;
-  } else {
-    failed++;
-    console.error(`  FAIL: ${message}`);
-  }
+function writeDraftOnlyMilestone(base: string): void {
+  const milestoneDir = join(base, ".gsd", "milestones", "M001");
+  mkdirSync(milestoneDir, { recursive: true });
+  writeFileSync(
+    join(milestoneDir, "M001-CONTEXT-DRAFT.md"),
+    "# M001: Test Milestone\n\n**Status:** Draft\n\nSeed material.\n",
+  );
 }
 
-// ─── Fixture: milestone with only CONTEXT-DRAFT.md ──────────────────────
-
-const tmpBase = mkdtempSync(join(tmpdir(), "gsd-smart-entry-draft-test-"));
-const gsd = join(tmpBase, ".gsd");
-
-mkdirSync(join(gsd, "milestones", "M001"), { recursive: true });
-
-const draftContent = `# M001: Test Milestone — Context\n\n**Status:** Draft\n\nSeed material from a prior discussion.\n`;
-writeFileSync(
-  join(gsd, "milestones", "M001", "M001-CONTEXT-DRAFT.md"),
-  draftContent,
-);
-
-// ─── Test: deriveState returns 'needs-discussion' for draft-only milestone ───
-
-const state = await deriveState(tmpBase);
-
-assert(
-  state.phase === "needs-discussion",
-  `phase should be 'needs-discussion' for draft-only milestone, got: "${state.phase}"`,
-);
-
-assert(
-  state.activeMilestone?.id === "M001",
-  `active milestone should be M001, got: "${state.activeMilestone?.id}"`,
-);
-
-// ─── Test: resolveMilestoneFile resolves CONTEXT-DRAFT ─────────────────────
-
-const draftFile = resolveMilestoneFile(tmpBase, "M001", "CONTEXT-DRAFT");
-
-assert(
-  draftFile !== null && draftFile !== undefined,
-  `resolveMilestoneFile should resolve CONTEXT-DRAFT, got: ${draftFile}`,
-);
-
-assert(
-  draftFile!.endsWith("M001-CONTEXT-DRAFT.md"),
-  `resolved path should end with M001-CONTEXT-DRAFT.md, got: "${draftFile}"`,
-);
-
-// ─── Test: CONTEXT.md is NOT resolved (only draft exists) ──────────────────
-
-const contextFile = resolveMilestoneFile(tmpBase, "M001", "CONTEXT");
-
-assert(
-  contextFile === null || contextFile === undefined,
-  `resolveMilestoneFile should NOT resolve CONTEXT when only CONTEXT-DRAFT exists, got: "${contextFile}"`,
-);
-
-// ─── Static: guided-flow.ts has 'needs-discussion' branch ─────────────────
-
-const guidedFlowSource = readFileSync(
-  join(import.meta.dirname, "..", "guided-flow.ts"),
-  "utf-8",
-);
-
-assert(
-  guidedFlowSource.includes('state.phase === "needs-discussion"'),
-  "guided-flow.ts should have 'needs-discussion' phase check in showSmartEntry",
-);
-
-// Check the branch has draft-aware menu options
-const branchIdx = guidedFlowSource.indexOf('state.phase === "needs-discussion"');
-const branchChunk = extractSourceRegion(guidedFlowSource, 'state.phase === "needs-discussion"');
-
-assert(
-  branchChunk.includes("discuss_draft"),
-  "needs-discussion branch should have 'discuss_draft' option",
-);
-
-assert(
-  branchChunk.includes("discuss_fresh"),
-  "needs-discussion branch should have 'discuss_fresh' option",
-);
-
-assert(
-  branchChunk.includes("skip_milestone"),
-  "needs-discussion branch should have 'skip_milestone' option",
-);
-
-assert(
-  branchChunk.includes("CONTEXT-DRAFT"),
-  "needs-discussion branch should load CONTEXT-DRAFT via resolveMilestoneFile",
-);
-
-assert(
-  branchChunk.includes("Draft Seed") || branchChunk.includes("draftContent"),
-  "discuss_draft path should include draft content as seed in the dispatched prompt",
-);
-
-assert(
-  branchChunk.includes("return"),
-  "needs-discussion branch should return early (not fall through to generic no-roadmap menu)",
-);
-
-// ─── Cleanup ──────────────────────────────────────────────────────────────
-
-rmSync(tmpBase, { recursive: true, force: true });
-
-// ─── Results ──────────────────────────────────────────────────────────────
-
-console.log(`\nsmart-entry-draft: ${passed} passed, ${failed} failed`);
-if (failed > 0) process.exit(1);
+test("deriveState returns needs-discussion for draft-only milestone", async () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-smart-entry-draft-"));
+  try {
+    writeDraftOnlyMilestone(base);
+    const state = await deriveState(base);
+    assert.equal(state.phase, "needs-discussion");
+    assert.equal(state.activeMilestone?.id, "M001");
+    assert.match(resolveMilestoneFile(base, "M001", "CONTEXT-DRAFT") ?? "", /M001-CONTEXT-DRAFT\.md$/);
+    assert.equal(resolveMilestoneFile(base, "M001", "CONTEXT"), null);
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});

package/src/resources/extensions/gsd/tests/sqlite-unavailable-gate.test.ts

@@ -1,65 +1,29 @@
-/**
- * sqlite-unavailable-gate.test.ts — #2419
- *
- * When the SQLite provider fails to open, bootstrapAutoSession must
- * refuse to start auto-mode. Otherwise gsd_task_complete returns
- * "db_unavailable", artifact retry re-dispatches the same task, and
- * the session loops forever.
- *
- * This test verifies the gate by reading auto-start.ts source and
- * confirming the pattern: after the DB lifecycle block, if the DB
- * file exists on disk but isDbAvailable() still returns false after
- * the open attempt, bootstrap must abort with an error notification.
- */
+// GSD-2 — SQLite unavailable bootstrap gate regression tests.
 
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
-import { createTestContext } from "./test-helpers.ts";
+import test from "node:test";
+import assert from "node:assert/strict";
 
-const { assertTrue, report } = createTestContext();
+import { _shouldAbortBootstrapForUnavailableDbForTest } from "../auto-start.ts";
 
-const srcPath = join(import.meta.dirname, "..", "auto-start.ts");
-const src = readFileSync(srcPath, "utf-8");
+test("bootstrap abort gate trips when DB exists but SQLite remains unavailable", () => {
+  const dbPath = "/repo/.gsd/gsd.db";
+  const exists = (path: string) => path === dbPath;
 
-console.log("\n=== #2419: SQLite unavailable gate in auto-start.ts ===");
-
-// The DB lifecycle section tries to open the DB. After those try/catch
-// blocks, there must be a HARD GATE: if the DB file exists on disk but
-// isDbAvailable() is still false (open failed), bootstrap must abort
-// by calling releaseLockAndReturn() with an error notification.
-
-const dbLifecycleIdx = src.indexOf("DB lifecycle");
-assertTrue(dbLifecycleIdx > 0, "auto-start.ts has a DB lifecycle section");
-
-const afterDbLifecycle = src.slice(dbLifecycleIdx);
-
-// The DB lifecycle section may contain multiple isDbAvailable() checks now that
-// cold-start bootstrap can pre-open the DB earlier in the file. What matters
-// for #2419 is the explicit abort gate after the DB open attempts.
-assertTrue(
-  afterDbLifecycle.includes("!isDbAvailable()"),
-  "DB lifecycle section still checks for unavailable DB state (#2419)",
-);
-
-const gateMatch = afterDbLifecycle.match(
-  /if\s*\(existsSync\(gsdDbPath\)\s*&&\s*!isDbAvailable\(\)\)\s*\{[\s\S]*?releaseLockAndReturn\(\);[\s\S]*?\}/,
-);
+  assert.equal(
+    _shouldAbortBootstrapForUnavailableDbForTest(dbPath, false, exists),
+    true,
+  );
+});
 
-assertTrue(
-  !!gateMatch,
-  "auto-start.ts has a hard abort gate when gsd.db exists but SQLite is still unavailable (#2419)",
-);
+test("bootstrap abort gate stays open when DB is available or absent", () => {
+  const dbPath = "/repo/.gsd/gsd.db";
 
-if (gateMatch) {
-  const gateRegion = gateMatch[0];
-  assertTrue(
-    gateRegion.includes("releaseLockAndReturn"),
-    "The DB availability gate calls releaseLockAndReturn() to abort bootstrap (#2419)",
+  assert.equal(
+    _shouldAbortBootstrapForUnavailableDbForTest(dbPath, true, () => true),
+    false,
   );
-  assertTrue(
-    /database|sqlite|db.*unavailable/i.test(gateRegion),
-    "The DB availability gate includes a user-facing error message about the database (#2419)",
+  assert.equal(
+    _shouldAbortBootstrapForUnavailableDbForTest(dbPath, false, () => false),
+    false,
   );
-}
-
-report();
+});

package/src/resources/extensions/gsd/tests/stale-dirlistcache-4648.test.ts

@@ -1,38 +1,15 @@
 /**
- * GSD-2 / agent-end-recovery — regression tests for #4648
- *
- * Covers the stale `dirListCache` bug where `maybeHandleReadyPhraseWithoutFiles`
- * (and `checkAutoStartAfterDiscuss`) falsely reported milestone artifacts as
- * missing, because the directory-listing cache in `paths.ts` was populated
- * before the LLM wrote the files during the same turn.
- *
- * The fix invalidates the cache at the top of `handleAgentEnd`, before any
- * artifact-existence check runs.
+ * GSD-2 / agent-end-recovery — regression tests for #4648.
  */
 
 import { describe, test } from "node:test";
 import assert from "node:assert/strict";
-import {
-  mkdtempSync,
-  mkdirSync,
-  rmSync,
-  writeFileSync,
-  readFileSync,
-} from "node:fs";
-import { join, dirname } from "node:path";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
 import { tmpdir } from "node:os";
-import { fileURLToPath } from "node:url";
 
-import { resolveMilestoneFile } from "../paths.ts";
-import { clearPathCache } from "../paths.ts";
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const AGENT_END_RECOVERY_PATH = join(
-  __dirname,
-  "..",
-  "bootstrap",
-  "agent-end-recovery.ts",
-);
+import { handleAgentEnd } from "../bootstrap/agent-end-recovery.ts";
+import { resolveMilestoneFile, clearPathCache } from "../paths.ts";
 
 function mkBase(): string {
   const base = mkdtempSync(join(tmpdir(), "gsd-4648-"));
@@ -40,73 +17,49 @@ function mkBase(): string {
   return base;
 }
 
-describe("#4648 stale dirListCache — behavioral", () => {
+describe("#4648 stale dirListCache", () => {
   test("resolveMilestoneFile returns stale null until clearPathCache runs", () => {
     const base = mkBase();
     try {
       clearPathCache();
+      assert.equal(resolveMilestoneFile(base, "M001", "CONTEXT"), null);
 
-      // Prime the cache: directory exists but is empty at this point.
-      assert.equal(
-        resolveMilestoneFile(base, "M001", "CONTEXT"),
-        null,
-        "empty dir → null",
-      );
-
-      // Simulate the LLM writing CONTEXT.md during the turn.
       writeFileSync(
         join(base, ".gsd", "milestones", "M001", "M001-CONTEXT.md"),
         "# M001 Context\n",
       );
 
-      // Without a cache flush the resolver still reports null — this is the bug.
-      assert.equal(
-        resolveMilestoneFile(base, "M001", "CONTEXT"),
-        null,
-        "stale cache returns null even though the file exists on disk",
-      );
-
-      // The fix: clearPathCache() — after which the resolver finds the file.
+      assert.equal(resolveMilestoneFile(base, "M001", "CONTEXT"), null);
       clearPathCache();
-      const resolved = resolveMilestoneFile(base, "M001", "CONTEXT");
-      assert.ok(
-        resolved && /M001-CONTEXT\.md$/.test(resolved),
-        `after clearPathCache, resolver finds the file (got: ${resolved})`,
-      );
+      assert.match(resolveMilestoneFile(base, "M001", "CONTEXT") ?? "", /M001-CONTEXT\.md$/);
     } finally {
       clearPathCache();
       rmSync(base, { recursive: true, force: true });
     }
   });
-});
-
-describe("#4648 agent-end-recovery wiring", () => {
-  test("handleAgentEnd invalidates the path cache before the discuss guards", () => {
-    const source = readFileSync(AGENT_END_RECOVERY_PATH, "utf-8");
 
-    assert.ok(
-      /import\s*\{\s*clearPathCache\s*\}\s*from\s*"\.\.\/paths\.js"/.test(source),
-      "agent-end-recovery.ts must import clearPathCache from ../paths.js",
-    );
+  test("handleAgentEnd invalidates the path cache before recovery guards read artifacts", async () => {
+    const base = mkBase();
+    const previousCwd = process.cwd();
+    try {
+      process.chdir(base);
+      clearPathCache();
+      assert.equal(resolveMilestoneFile(base, "M001", "CONTEXT"), null);
 
-    const fnStart = source.indexOf("export async function handleAgentEnd");
-    assert.ok(fnStart > -1, "handleAgentEnd must exist");
+      writeFileSync(
+        join(base, ".gsd", "milestones", "M001", "M001-CONTEXT.md"),
+        "# M001 Context\n",
+      );
 
-    const checkIdx = source.indexOf("checkAutoStartAfterDiscuss(", fnStart);
-    const clearIdx = source.indexOf("clearPathCache(", fnStart);
-    const readyIdx = source.indexOf(
-      "maybeHandleReadyPhraseWithoutFiles(",
-      fnStart,
-    );
+      await handleAgentEnd({} as any, { messages: [] }, {
+        ui: { notify: () => {} },
+      } as any);
 
-    assert.ok(clearIdx > -1, "handleAgentEnd must call clearPathCache");
-    assert.ok(
-      clearIdx < checkIdx,
-      "clearPathCache must run before checkAutoStartAfterDiscuss so the guard sees fresh disk state",
-    );
-    assert.ok(
-      clearIdx < readyIdx,
-      "clearPathCache must run before maybeHandleReadyPhraseWithoutFiles",
-    );
+      assert.match(resolveMilestoneFile(base, "M001", "CONTEXT") ?? "", /M001-CONTEXT\.md$/);
+    } finally {
+      process.chdir(previousCwd);
+      clearPathCache();
+      rmSync(base, { recursive: true, force: true });
+    }
   });
 });

package/src/resources/extensions/gsd/tests/stale-lockfile-recovery.test.ts

@@ -1,36 +1,45 @@
 /**
- * stale-lockfile-recovery.test.ts — #3668
- *
- * Verify that session-lock.ts contains pre-flight stale lock cleanup logic
- * that removes orphaned lock directories when the owning PID is dead,
- * preventing the 30-min stale window from blocking /gsd after crashes.
+ * stale-lockfile-recovery.test.ts — #3668.
  */
 
-import { describe, test } from "node:test";
+import { describe, test, afterEach } from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { join, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
+import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
 
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const sourceFile = join(__dirname, "..", "session-lock.ts");
+import { acquireSessionLock, releaseSessionLock } from "../session-lock.ts";
 
-describe("stale lockfile auto-recovery (#3668)", () => {
-  const source = readFileSync(sourceFile, "utf-8");
+let tempBase: string | null = null;
 
-  test("checks for orphan lock with isPidAlive", () => {
-    assert.match(source, /isPidAlive\(existingData\.pid\)/);
-  });
+afterEach(() => {
+  if (tempBase) {
+    releaseSessionLock(tempBase);
+    rmSync(tempBase, { recursive: true, force: true });
+  }
+  tempBase = null;
+});
 
-  test("removes stale lock directory with rmSync", () => {
-    assert.match(source, /rmSync\(lockDir,\s*\{\s*recursive:\s*true/);
-  });
+describe("stale lockfile auto-recovery (#3668)", () => {
+  test("acquireSessionLock removes an orphan proper-lockfile directory before acquiring", () => {
+    tempBase = mkdtempSync(join(tmpdir(), "gsd-stale-lock-"));
+    const gsdDir = join(tempBase, ".gsd");
+    mkdirSync(join(gsdDir, "auto.lock.lock"), { recursive: true });
+    writeFileSync(
+      join(gsdDir, "auto.lock"),
+      JSON.stringify({
+        pid: 999_999_999,
+        startedAt: new Date().toISOString(),
+        unitType: "execute-task",
+        unitId: "M001/S01/T01",
+        unitStartedAt: new Date().toISOString(),
+      }),
+      "utf-8",
+    );
 
-  test("references issue #3218 in pre-flight cleanup comment", () => {
-    assert.match(source, /#3218.*Pre-flight stale lock cleanup/);
-  });
+    const result = acquireSessionLock(tempBase);
 
-  test("provides actionable rm -rf workaround in error message", () => {
-    assert.match(source, /rm\s+-rf/);
+    assert.equal(result.acquired, true);
+    assert.equal(existsSync(join(gsdDir, "auto.lock.lock")), true, "new active lock directory is present");
   });
 });

package/src/resources/extensions/gsd/tests/stale-slice-rows.test.ts

@@ -1,40 +1,49 @@
 /**
- * stale-slice-rows.test.ts
- *
- * Verify that state.ts no longer treats slice SUMMARY.md projections as
- * authority for DB slice status. Slice rows must be updated through DB-backed
- * completion/import APIs.
+ * Verify that state derivation treats DB slice rows as authoritative over
+ * stale markdown projections.
  */
 
-import { describe, test } from "node:test";
+import { describe, test, afterEach } from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { join, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
 
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const sourceFile = join(__dirname, "..", "state.ts");
+import { deriveState, invalidateStateCache } from "../state.ts";
+import { closeDatabase, insertMilestone, insertSlice, openDatabase } from "../gsd-db.ts";
 
-describe("stale slice row DB-authoritative boundary", () => {
-  const source = readFileSync(sourceFile, "utf-8");
-
-  test("does not import updateSliceStatus into state derivation", () => {
-    assert.doesNotMatch(source, /import\s*\{[^}]*updateSliceStatus[^}]*\}\s*from/);
-  });
-
-  test("does not scan DB slice rows for disk SUMMARY reconciliation", () => {
-    assert.doesNotMatch(source, /dbSlice/);
-  });
+let tempBase: string | null = null;
 
-  test("does not resolve slice SUMMARY to mutate DB state", () => {
-    assert.doesNotMatch(source, /resolveSliceFile\(basePath,\s*mid,\s*dbSlice\.id,\s*["']SUMMARY["']\)/);
-  });
-
-  test("does not call updateSliceStatus from state derivation", () => {
-    assert.doesNotMatch(source, /updateSliceStatus\(/);
-  });
+afterEach(() => {
+  closeDatabase();
+  invalidateStateCache();
+  if (tempBase) rmSync(tempBase, { recursive: true, force: true });
+  tempBase = null;
+});
 
-  test("documents markdown projections as non-authoritative", () => {
-    assert.match(source, /Markdown files are projections only/);
+describe("stale slice row DB-authoritative boundary", () => {
+  test("a stale SUMMARY.md projection does not make a DB-pending slice complete", async () => {
+    tempBase = mkdtempSync(join(tmpdir(), "gsd-stale-slice-"));
+    const sliceDir = join(tempBase, ".gsd", "milestones", "M001", "slices", "S01");
+    mkdirSync(sliceDir, { recursive: true });
+    writeFileSync(join(sliceDir, "S01-SUMMARY.md"), "# S01 Summary\n", "utf-8");
+
+    openDatabase(join(tempBase, ".gsd", "gsd.db"));
+    insertMilestone({ id: "M001", title: "DB authority", status: "active", depends_on: [] });
+    insertSlice({
+      id: "S01",
+      milestoneId: "M001",
+      title: "Still pending",
+      status: "pending",
+      risk: "low",
+      depends: [],
+      demo: "",
+      sequence: 1,
+    });
+
+    const state = await deriveState(tempBase);
+
+    assert.equal(state.activeSlice?.id, "S01");
+    assert.equal(state.phase, "planning");
   });
 });

package/src/resources/extensions/gsd/tests/stalled-tool-recovery.test.ts

@@ -15,10 +15,11 @@
  * (the fix) and verifies it does not crash.
  */
 
-import { mkdtempSync, mkdirSync, rmSync } from "node:fs";
+import { mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { recoverTimedOutUnit, type RecoveryContext } from "../auto-timeout-recovery.ts";
+import { closeDatabase, insertMilestone, insertSlice, insertTask, openDatabase } from "../gsd-db.ts";
 import { test } from 'node:test';
 import assert from 'node:assert/strict';
 
@@ -39,6 +40,14 @@ function makeMockPi() {
   } as any;
 }
 
+function makeRecordingPi() {
+  const messages: unknown[] = [];
+  return {
+    messages,
+    sendMessage: (message: unknown) => { messages.push(message); },
+  } as any;
+}
+
 // ═══ #1855: empty RecoveryContext (basePath undefined) crashes ════════════════
 
 {
@@ -63,6 +72,45 @@ function makeMockPi() {
   assert.ok(crashed, "should crash when basePath is undefined (reproduces #1855)");
 }
 
+// ═══ DB-complete execute-task recovery advances without steering ═════════════
+
+{
+  console.log("\n=== execute-task timeout recovery trusts closed DB status ===");
+  const base = mkdtempSync(join(tmpdir(), "gsd-timeout-db-complete-"));
+  mkdirSync(join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks"), { recursive: true });
+
+  try {
+    openDatabase(join(base, ".gsd", "gsd.db"));
+    insertMilestone({ id: "M001", title: "Milestone", status: "active" });
+    insertSlice({ id: "S01", milestoneId: "M001", title: "Slice", status: "in_progress" });
+    insertTask({ id: "T01", milestoneId: "M001", sliceId: "S01", title: "Task", status: "complete" });
+    writeFileSync(
+      join(base, ".gsd", "milestones", "M001", "slices", "S01", "S01-PLAN.md"),
+      "# S01\n\n## Tasks\n\n- [ ] **T01: Task** `est:10m`\n",
+      "utf-8",
+    );
+    writeFileSync(join(base, ".gsd", "STATE.md"), "## Next Action\nExecute T01 for S01: Task\n", "utf-8");
+
+    const ctx = makeMockCtx();
+    const pi = makeRecordingPi();
+    const result = await recoverTimedOutUnit(ctx, pi, "execute-task", "M001/S01/T01", "idle", {
+      basePath: base,
+      verbose: false,
+      currentUnitStartedAt: Date.now(),
+      unitRecoveryCount: new Map(),
+    });
+
+    assert.equal(result, "recovered", "db-complete task should recover immediately");
+    assert.equal(pi.messages.length, 0, "db-complete task should not send steering recovery");
+    const runtime = JSON.parse(readFileSync(join(base, ".gsd", "runtime", "units", "execute-task-M001-S01-T01.json"), "utf-8"));
+    assert.equal(runtime.phase, "finalized", "db-complete task should be finalized");
+    assert.equal(runtime.recovery.dbComplete, true, "runtime recovery should record DB completion");
+  } finally {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  }
+}
+
 // ═══ #1855: valid RecoveryContext does not crash ═════════════════════════════
 
 {