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

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

@@ -5,13 +5,14 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { randomUUID } from "node:crypto";
 
-import { verifyExpectedArtifact, hasImplementationArtifacts, resolveExpectedArtifactPath, diagnoseExpectedArtifact, buildLoopRemediationSteps, writeBlockerPlaceholder } from "../auto-recovery.ts";
+import { verifyExpectedArtifact, hasImplementationArtifacts, resolveExpectedArtifactPath, diagnoseExpectedArtifact, buildLoopRemediationSteps, writeBlockerPlaceholder, refreshRecoveryDbForArtifact } from "../auto-recovery.ts";
 import { resolveMilestoneFile } from "../paths.ts";
-import { openDatabase, closeDatabase, insertMilestone, insertSlice, insertGateRow, insertTask } from "../gsd-db.ts";
+import { openDatabase, closeDatabase, insertMilestone, insertSlice, insertGateRow, insertTask, getMilestoneCommitAttributionShas } from "../gsd-db.ts";
 import { clearParseCache } from "../files.ts";
 import { parseRoadmap } from "../parsers-legacy.ts";
 import { invalidateAllCaches } from "../cache.ts";
 import { deriveState, invalidateStateCache } from "../state.ts";
+import { writeIntegrationBranch } from "../git-service.ts";
 
 const tmpDirs: string[] = [];
 
@@ -174,6 +175,19 @@ test("resolveExpectedArtifactPath returns correct path for all slice-level types
   }
 });
 
+test("refreshRecoveryDbForArtifact treats missing execute-task DB rows as fatal mismatches", () => {
+  makeTmpProject();
+
+  const result = refreshRecoveryDbForArtifact("execute-task", "M001/S01/T01");
+
+  assert.deepEqual(result, {
+    ok: false,
+    fatal: true,
+    reason: "execute-task-artifact-db-missing",
+    message: "Stuck recovery found execute-task M001/S01/T01 artifacts, but no matching DB task row exists after refresh.",
+  });
+});
+
 // ─── diagnoseExpectedArtifact ─────────────────────────────────────────────
 
 test("diagnoseExpectedArtifact returns description for known types", () => {
@@ -735,6 +749,174 @@ test("hasImplementationArtifacts rejects milestone-scoped main history with only
   }
 });
 
+test("hasImplementationArtifacts finds integration implementation-only commits when milestone branch diff is .gsd-only", () => {
+  const base = makeGitBase();
+  try {
+    mkdirSync(join(base, "src"), { recursive: true });
+    writeFileSync(join(base, "src", "feature.ts"), "export function feature() {}\n");
+    execFileSync("git", ["add", "src/feature.ts"], { cwd: base, stdio: "ignore" });
+    execFileSync("git", ["commit", "-m", "feat: add milestone feature\n\nGSD-Task: S01/T01"], { cwd: base, stdio: "ignore" });
+
+    mkdirSync(join(base, ".gsd"), { recursive: true });
+    openDatabase(join(base, ".gsd", "gsd.db"));
+    insertMilestone({ id: "M001", title: "Milestone One", status: "active" });
+    insertSlice({
+      id: "S01",
+      milestoneId: "M001",
+      title: "Slice One",
+      status: "complete",
+      risk: "low",
+      depends: [],
+    });
+    insertTask({
+      id: "T01",
+      sliceId: "S01",
+      milestoneId: "M001",
+      title: "Task One",
+      status: "complete",
+    });
+
+    execFileSync("git", ["checkout", "-b", "milestone/M001"], { cwd: base, stdio: "ignore" });
+    writeIntegrationBranch(base, "M001", "main");
+    writeFileSync(join(base, ".gsd", "milestones", "M001", "M001-SUMMARY.md"), "# Milestone Summary\nDone.");
+    execFileSync("git", ["add", "."], { cwd: base, stdio: "ignore" });
+    execFileSync("git", ["commit", "-m", "chore: auto-commit after complete-milestone\n\nGSD-Unit: M001"], { cwd: base, stdio: "ignore" });
+
+    const result = hasImplementationArtifacts(base, "M001");
+    assert.equal(
+      result,
+      "present",
+      ".gsd-only milestone closeout diffs should still honor implementation commits already on the integration branch",
+    );
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("hasImplementationArtifacts backfills untagged main implementation commits from completed task file hints", () => {
+  const base = makeGitBase();
+  try {
+    mkdirSync(join(base, ".gsd"), { recursive: true });
+    openDatabase(join(base, ".gsd", "gsd.db"));
+    insertMilestone({ id: "M001", title: "Milestone One", status: "active" });
+    insertSlice({
+      id: "S01",
+      milestoneId: "M001",
+      title: "Slice One",
+      status: "complete",
+      risk: "low",
+      depends: [],
+    });
+    insertTask({
+      id: "T01",
+      sliceId: "S01",
+      milestoneId: "M001",
+      title: "Task One",
+      status: "complete",
+      keyFiles: ["index.html", "style.css", "app.js"],
+      planning: { files: ["index.html", "style.css", "app.js"] },
+    });
+
+    writeFileSync(join(base, "index.html"), "<main></main>\n");
+    writeFileSync(join(base, "style.css"), "main { display: block; }\n");
+    writeFileSync(join(base, "app.js"), "document.body.dataset.ready = 'true';\n");
+    execFileSync("git", ["add", "index.html", "style.css", "app.js"], { cwd: base, stdio: "ignore" });
+    execFileSync("git", ["commit", "-m", "feat: add to-do app with CRUD and localStorage persistence"], { cwd: base, stdio: "ignore" });
+    const commitSha = execFileSync("git", ["rev-parse", "HEAD"], { cwd: base, encoding: "utf-8" }).trim();
+
+    const result = hasImplementationArtifacts(base, "M001");
+    assert.equal(
+      result,
+      "present",
+      "completed task file hints should repair prior untagged implementation commits on main",
+    );
+    assert.deepEqual(getMilestoneCommitAttributionShas("M001"), [commitSha]);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("hasImplementationArtifacts does not backfill untagged commits before milestone creation", () => {
+  const base = makeGitBase();
+  try {
+    writeFileSync(join(base, "app.js"), "document.body.dataset.ready = 'old';\n");
+    execFileSync("git", ["add", "app.js"], { cwd: base, stdio: "ignore" });
+    execFileSync("git", ["commit", "-m", "feat: old app work"], {
+      cwd: base,
+      stdio: "ignore",
+      env: {
+        ...process.env,
+        GIT_AUTHOR_DATE: "2020-01-01T00:00:00Z",
+        GIT_COMMITTER_DATE: "2020-01-01T00:00:00Z",
+      },
+    });
+
+    mkdirSync(join(base, ".gsd"), { recursive: true });
+    openDatabase(join(base, ".gsd", "gsd.db"));
+    insertMilestone({ id: "M001", title: "Milestone One", status: "active" });
+    insertSlice({
+      id: "S01",
+      milestoneId: "M001",
+      title: "Slice One",
+      status: "complete",
+      risk: "low",
+      depends: [],
+    });
+    insertTask({
+      id: "T01",
+      sliceId: "S01",
+      milestoneId: "M001",
+      title: "Task One",
+      status: "complete",
+      keyFiles: ["app.js"],
+      planning: { files: ["app.js"] },
+    });
+
+    const result = hasImplementationArtifacts(base, "M001");
+    assert.equal(result, "absent", "pre-milestone commits must not be attributed to the milestone");
+    assert.deepEqual(getMilestoneCommitAttributionShas("M001"), []);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("hasImplementationArtifacts does not backfill unrelated untagged implementation commits", () => {
+  const base = makeGitBase();
+  try {
+    mkdirSync(join(base, ".gsd"), { recursive: true });
+    openDatabase(join(base, ".gsd", "gsd.db"));
+    insertMilestone({ id: "M001", title: "Milestone One", status: "active" });
+    insertSlice({
+      id: "S01",
+      milestoneId: "M001",
+      title: "Slice One",
+      status: "complete",
+      risk: "low",
+      depends: [],
+    });
+    insertTask({
+      id: "T01",
+      sliceId: "S01",
+      milestoneId: "M001",
+      title: "Task One",
+      status: "complete",
+      keyFiles: ["src/expected.ts"],
+      planning: { files: ["src/expected.ts"] },
+    });
+
+    mkdirSync(join(base, "src"), { recursive: true });
+    writeFileSync(join(base, "src", "unrelated.ts"), "export const unrelated = true;\n");
+    execFileSync("git", ["add", "src/unrelated.ts"], { cwd: base, stdio: "ignore" });
+    execFileSync("git", ["commit", "-m", "feat: unrelated work"], { cwd: base, stdio: "ignore" });
+
+    const result = hasImplementationArtifacts(base, "M001");
+    assert.equal(result, "absent", "backfill must require overlap with completed task file hints");
+    assert.deepEqual(getMilestoneCommitAttributionShas("M001"), []);
+  } finally {
+    cleanup(base);
+  }
+});
+
 test("hasImplementationArtifacts treats empty non-integration branch diff as absent (#4699)", () => {
   const base = makeGitBase();
   try {

package/src/resources/extensions/gsd/tests/auto-remediate-slice-status.test.ts

@@ -4,43 +4,45 @@
  * A SUMMARY.md on disk is a projection/diagnostic. Runtime post-unit checks
  * must not use it to mark the DB slice complete; explicit import/recovery
  * commands own markdown-to-DB behavior.
- *
- * This structural test verifies the complete-slice rogue branch reports the
- * stale projection without calling updateSliceStatus().
  */
 
-import { describe, test } from 'node:test';
-import assert from 'node:assert/strict';
-import { readFileSync } from 'node:fs';
-import { fileURLToPath } from 'node:url';
-import { dirname, join } from 'node:path';
-import { extractSourceRegion } from "./test-helpers.ts";
+import { afterEach, describe, test } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, realpathSync, rmSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { tmpdir } from "node:os";
 
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
+import { detectRogueFileWrites } from "../auto-post-unit.ts";
+import {
+  closeDatabase,
+  getSlice,
+  insertMilestone,
+  insertSlice,
+  isDbAvailable,
+  openDatabase,
+} from "../gsd-db.ts";
 
-const source = readFileSync(join(__dirname, '..', 'auto-post-unit.ts'), 'utf-8');
+afterEach(() => {
+  if (isDbAvailable()) closeDatabase();
+});
 
-describe('DB-authoritative slice rogue detection', () => {
-  test('updateSliceStatus is not imported for post-unit rogue reconciliation', () => {
-    assert.doesNotMatch(source, /import\s*\{[^}]*updateSliceStatus[^}]*\}\s*from\s*["']\.\/gsd-db/,
-      'auto-post-unit must not import updateSliceStatus for disk-to-DB reconciliation');
-  });
+describe("DB-authoritative slice rogue detection", () => {
+  test("complete-slice SUMMARY.md is reported as rogue without marking DB complete", (t) => {
+    const base = realpathSync(mkdtempSync(join(tmpdir(), "gsd-rogue-slice-")));
+    t.after(() => rmSync(base, { recursive: true, force: true }));
 
-  test('complete-slice rogue branch does not mark DB complete from disk', () => {
-    assert.doesNotMatch(source, /updateSliceStatus\(mid,\s*sid,\s*["']complete["']/,
-      'SUMMARY.md on disk must not mark slice complete in DB');
-  });
+    mkdirSync(join(base, ".gsd"), { recursive: true });
+    openDatabase(join(base, ".gsd", "gsd.db"));
+    insertMilestone({ id: "M001", title: "Milestone", status: "active" });
+    insertSlice({ milestoneId: "M001", id: "S01", title: "Slice", status: "pending", sequence: 1 });
 
-  test('explicit rogue diagnostic reports stale slice summary projection', () => {
-    const branch = extractSourceRegion(source, 'unitType === "complete-slice"', 'unitType === "plan-milestone"');
-    assert.match(branch, /rogues\.push\(\{\s*path:\s*summaryPath,\s*unitType,\s*unitId\s*\}\)/,
-      'complete-slice branch should report stale SUMMARY.md as rogue');
-  });
+    const summaryPath = join(base, ".gsd", "milestones", "M001", "slices", "S01", "S01-SUMMARY.md");
+    mkdirSync(dirname(summaryPath), { recursive: true });
+    writeFileSync(summaryPath, "# Summary\n", "utf-8");
+
+    const rogues = detectRogueFileWrites("complete-slice", "M001/S01", base);
 
-  test('post-unit runtime does not call rogue diagnostics automatically', () => {
-    const postUnit = extractSourceRegion(source, 'export async function postUnitPostVerification');
-    assert.doesNotMatch(postUnit, /detectRogueFileWrites\(/,
-      'runtime post-unit path must not scan disk projections for rogue files');
+    assert.deepEqual(rogues, [{ path: summaryPath, unitType: "complete-slice", unitId: "M001/S01" }]);
+    assert.equal(getSlice("M001", "S01")?.status, "pending");
   });
 });

package/src/resources/extensions/gsd/tests/auto-start-bootstrap-await-3420.test.ts

@@ -1,141 +1,45 @@
 /**
  * auto-start-bootstrap-await-3420.test.ts — Regression test for #3420.
  *
- * Bug: In bootstrapAutoSession, when state.phase === "pre-planning" and no
- * context file exists, showSmartEntry is called to dispatch a discuss workflow.
- * showSmartEntry calls dispatchWorkflow which calls pi.sendMessage() — a
- * fire-and-forget call that returns immediately. The LLM discussion runs
- * asynchronously in a separate turn.
- *
- * The bug: after showSmartEntry returns (before the LLM has run), the code
- * immediately calls invalidateAllCaches() + deriveState() + checks postState.
- * Since the discussion hasn't run yet, postState.phase is still "pre-planning"
- * and the context check fails, producing the warning:
- *   "Discussion completed but milestone context is still missing. Run /gsd to try again."
- *
- * The discussion never ran — the warning fires immediately.
- *
- * Fix: bootstrapAutoSession must return false (release lock) after showSmartEntry
- * dispatches the workflow. The checkAutoStartAfterDiscuss callback in guided-flow.ts
- * already handles re-entering auto-mode when the discussion completes.
- *
- * This test verifies the fix by asserting that the pre-planning !hasContext block
- * does NOT contain a postState phase check after showSmartEntry — it must
- * return false immediately to let the async dispatch complete.
+ * The discussion handoff is asynchronous: bootstrap queues a discuss turn and
+ * releases the lock; checkAutoStartAfterDiscuss is responsible for re-entry
+ * once artifacts exist.
  */
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
+import { tmpdir } from "node:os";
 
-const sourcePath = join(import.meta.dirname, "..", "auto-start.ts");
-const source = readFileSync(sourcePath, "utf-8");
-
-test("bootstrapAutoSession: pre-planning no-context path does NOT check postState immediately after showSmartEntry (#3420)", () => {
-  // Find the pre-planning block that handles the case where context is missing.
-  // This block dispatches showSmartEntry which is async (fire-and-forget via pi.sendMessage).
-  // After the dispatch, checking postState.phase immediately is premature — the
-  // LLM discussion hasn't run yet. The block should return false instead.
-  const prePlanningNoContextBlock = source.match(
-    /\/\/ Active milestone exists but has no roadmap\s*\n\s*if\s*\(\s*state\.phase\s*===\s*"pre-planning"\s*\)([\s\S]*?)\/\/ Active milestone has CONTEXT-DRAFT/,
-  );
-  assert.ok(
-    !!prePlanningNoContextBlock,
-    "auto-start.ts must have the pre-planning handler block before needs-discussion",
-  );
+import {
+  checkAutoStartAfterDiscuss,
+  clearPendingAutoStart,
+  setPendingAutoStart,
+} from "../guided-flow.ts";
 
-  const block = prePlanningNoContextBlock![1];
-
-  // The block must call showSmartEntry when !hasContext
-  assert.ok(
-    block.includes("showSmartEntry"),
-    "pre-planning !hasContext block must call showSmartEntry to dispatch the discuss workflow",
-  );
-
-  // FAILING ASSERTION (before fix): after showSmartEntry, the block must NOT
-  // immediately check postState.phase — that check fires before the LLM runs.
-  // Instead, it must return false (release lock) so the async dispatch can complete.
-  // The warning "Discussion completed but milestone context is still missing"
-  // fires prematurely when this postState check exists.
-  assert.ok(
-    !block.includes("Discussion completed but milestone context is still missing"),
-    "pre-planning !hasContext block must NOT check postState.phase immediately after showSmartEntry — " +
-    "the dispatch is async (pi.sendMessage is fire-and-forget) and the discussion hasn't run yet; " +
-    "return false instead so checkAutoStartAfterDiscuss can re-enter auto-mode after discussion completes (#3420)",
-  );
+test.afterEach(() => {
+  clearPendingAutoStart();
 });
 
-test("bootstrapAutoSession: complete/no-milestone path does NOT check postState immediately after showSmartEntry (#3420)", () => {
-  // Find the complete/no-milestone block
-  const completeBlock = source.match(
-    /\/\/ No active work — start a new milestone via discuss flow\s*\n\s*if\s*\(!state\.activeMilestone\s*\|\|\s*state\.phase\s*===\s*"complete"\s*\)([\s\S]*?)\/\/ Active milestone exists but has no roadmap/,
-  );
-  assert.ok(
-    !!completeBlock,
-    "auto-start.ts must have the complete/no-milestone handler block",
-  );
-
-  const block = completeBlock![1];
-
-  // The block must call showSmartEntry
-  assert.ok(
-    block.includes("showSmartEntry"),
-    "complete/no-milestone block must call showSmartEntry",
-  );
-
-  // After showSmartEntry dispatches, checking postState.phase is premature —
-  // the LLM hasn't had a turn yet. The block should return false.
-  // Specifically, the "no milestone context was written" warning fires too early.
-  assert.ok(
-    !block.includes("Discussion completed but no milestone context was written"),
-    "complete/no-milestone block must NOT check postState.phase immediately after showSmartEntry dispatch — " +
-    "return false instead so the async LLM turn can complete (#3420)",
-  );
-});
-
-test("bootstrapAutoSession: showSmartEntry in pre-planning path is followed by releaseLockAndReturn, not postState check (#3420)", () => {
-  // After the fix, the pre-planning !hasContext branch should call showSmartEntry
-  // and then immediately return releaseLockAndReturn() — not check postState.
-  const prePlanningNoContextBlock = source.match(
-    /\/\/ Active milestone exists but has no roadmap\s*\n\s*if\s*\(\s*state\.phase\s*===\s*"pre-planning"\s*\)([\s\S]*?)\/\/ Active milestone has CONTEXT-DRAFT/,
-  );
-  assert.ok(!!prePlanningNoContextBlock, "pre-planning handler block found");
-
-  const block = prePlanningNoContextBlock![1];
-
-  // After the fix, the !hasContext branch ends with releaseLockAndReturn
-  assert.ok(
-    block.includes("releaseLockAndReturn"),
-    "pre-planning !hasContext block must call releaseLockAndReturn() after showSmartEntry dispatch (#3420)",
-  );
-
-  // The showSmartEntry call must appear before releaseLockAndReturn
-  const showSmartEntryIdx = block.indexOf("showSmartEntry");
-  const releaseLockIdx = block.indexOf("releaseLockAndReturn");
-  assert.ok(
-    showSmartEntryIdx > -1 && releaseLockIdx > -1,
-    "both showSmartEntry and releaseLockAndReturn must appear in the block",
-  );
-  assert.ok(
-    showSmartEntryIdx < releaseLockIdx,
-    "showSmartEntry must appear before releaseLockAndReturn in pre-planning !hasContext block",
-  );
-
-  // There must be NO invalidateAllCaches between showSmartEntry and releaseLockAndReturn
-  // (invalidateAllCaches + deriveState after showSmartEntry is the buggy premature check)
-  const afterShowSmartEntry = block.substring(showSmartEntryIdx);
-  const cacheInvalidateIdx = afterShowSmartEntry.indexOf("invalidateAllCaches");
-  const releaseFromShowIdx = afterShowSmartEntry.indexOf("releaseLockAndReturn");
-
-  // If invalidateAllCaches appears, it must appear AFTER releaseLockAndReturn
-  // (which is impossible since releaseLockAndReturn returns) — so invalidateAllCaches
-  // must not appear at all between showSmartEntry and the end of the !hasContext block.
-  if (cacheInvalidateIdx !== -1) {
-    assert.ok(
-      cacheInvalidateIdx > releaseFromShowIdx,
-      "invalidateAllCaches must NOT appear between showSmartEntry and releaseLockAndReturn — " +
-      "this is the premature postState check that causes #3420",
-    );
-  }
+test("checkAutoStartAfterDiscuss waits until discussion artifacts exist before re-entering auto-mode", (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-bootstrap-await-"));
+  const notifications: string[] = [];
+  t.after(() => rmSync(base, { recursive: true, force: true }));
+  mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
+  setPendingAutoStart(base, {
+    basePath: base,
+    milestoneId: "M001",
+    ctx: { ui: { notify: (message: string) => notifications.push(message) } } as any,
+    pi: { sendMessage: () => {} } as any,
+  });
+
+  assert.equal(checkAutoStartAfterDiscuss(), false);
+  assert.deepEqual(notifications, []);
+
+  writeFileSync(join(base, ".gsd", "milestones", "M001", "M001-CONTEXT.md"), "# Context\n", "utf-8");
+  writeFileSync(join(base, ".gsd", "STATE.md"), "# State\n", "utf-8");
+
+  assert.equal(checkAutoStartAfterDiscuss(), true);
+  assert.deepEqual(notifications, ["Milestone M001 ready."]);
 });

package/src/resources/extensions/gsd/tests/auto-start-clean-runtime-db-gated.test.ts

@@ -1,72 +1,38 @@
 // GSD-2 auto-start regression test: cleanStaleRuntimeUnits is DB-gated (#4663)
-//
-// Source-level structural check that the stale-runtime-cleanup predicate in
-// auto-start.ts consults DB status when available instead of treating a
-// SUMMARY-file on disk as proof of milestone completion. Pairs with #4658 /
-// PR #4660 fix in auto-dispatch + auto-recovery.
 
 import { describe, test } from "node:test";
 import assert from "node:assert/strict";
-import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
-import { join, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
+import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { randomUUID } from "node:crypto";
 import { cleanStaleRuntimeUnits } from "../auto-worktree.ts";
-import { extractSourceRegion } from "./test-helpers.ts";
 
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const sourceFile = join(__dirname, "..", "auto-start.ts");
+function makeBase(): string {
+  return join(tmpdir(), `gsd-clean-runtime-${randomUUID()}`);
+}
 
 describe("auto-start cleanStaleRuntimeUnits DB gating (#4663)", () => {
-  const source = readFileSync(sourceFile, "utf-8");
-
-  test("imports isClosedStatus for DB-status check", () => {
-    assert.match(
-      source,
-      /import\s*\{\s*isClosedStatus\s*\}\s*from\s*["']\.\/status-guards/,
-    );
-  });
-
-  test("cleanStaleRuntimeUnits is called after openProjectDbIfPresent", () => {
-    const openDbIdx = source.indexOf("await openProjectDbIfPresent(base)");
-    assert.ok(openDbIdx > -1, "openProjectDbIfPresent should be called in auto-start");
-    const cleanIdx = source.indexOf("cleanStaleRuntimeUnits(", openDbIdx);
-    assert.ok(
-      cleanIdx > -1,
-      "cleanStaleRuntimeUnits must run AFTER openProjectDbIfPresent so predicate can consult DB",
-    );
-  });
+  test("predicate controls whether milestone runtime units are removed", () => {
+    const base = makeBase();
+    const unitsDir = join(base, ".gsd", "runtime", "units");
+    try {
+      mkdirSync(unitsDir, { recursive: true });
+      const unitFile = join(unitsDir, "execute-task-M001-S01-T01.json");
+      writeFileSync(unitFile, "{}\n", "utf-8");
 
-  test("cleanStaleRuntimeUnits predicate consults DB status when available", () => {
-    const cleanIdx = source.indexOf("cleanStaleRuntimeUnits(");
-    assert.ok(cleanIdx > -1);
-    const snippet = extractSourceRegion(source, "cleanStaleRuntimeUnits(");
-    assert.match(
-      snippet,
-      /isDbAvailable\(\)/,
-      "predicate must branch on DB availability",
-    );
-    assert.match(
-      snippet,
-      /isClosedStatus\(/,
-      "predicate must check DB status via isClosedStatus",
-    );
-  });
+      assert.equal(cleanStaleRuntimeUnits(join(base, ".gsd"), () => false), 0);
+      assert.equal(existsSync(unitFile), true);
 
-  test("cleanStaleRuntimeUnits predicate still falls back to SUMMARY-file when DB unavailable", () => {
-    const cleanIdx = source.indexOf("cleanStaleRuntimeUnits(");
-    assert.ok(cleanIdx > -1);
-    const snippet = extractSourceRegion(source, "cleanStaleRuntimeUnits(");
-    assert.match(
-      snippet,
-      /resolveMilestoneFile\(base,\s*mid,\s*["']SUMMARY["']\)/,
-      "legacy FS-fallback branch should still use SUMMARY file presence",
-    );
+      assert.equal(cleanStaleRuntimeUnits(join(base, ".gsd"), (mid) => mid === "M001"), 1);
+      assert.equal(existsSync(unitFile), false);
+    } finally {
+      rmSync(base, { recursive: true, force: true });
+    }
   });
 
   test("cleanStaleRuntimeUnits removes legacy pseudo deep-setup runtime files", () => {
-    const base = join(tmpdir(), `gsd-clean-runtime-${randomUUID()}`);
+    const base = makeBase();
     const gsdRoot = join(base, ".gsd");
     const unitsDir = join(gsdRoot, "runtime", "units");
     try {

package/src/resources/extensions/gsd/tests/auto-start-cold-db-bootstrap.test.ts

@@ -1,37 +1,27 @@
-import { readFileSync } from "node:fs";
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, realpathSync, rmSync } from "node:fs";
 import { join } from "node:path";
+import { tmpdir } from "node:os";
 
-import {createTestContext, extractSourceRegion } from "./test-helpers.ts";
+import { openProjectDbIfPresent } from "../auto-start.ts";
+import { closeDatabase, isDbAvailable, openDatabase } from "../gsd-db.ts";
 
-const { assertTrue, report } = createTestContext();
+test.afterEach(() => {
+  if (isDbAvailable()) closeDatabase();
+});
 
-const srcPath = join(import.meta.dirname, "..", "auto-start.ts");
-const src = readFileSync(srcPath, "utf-8");
+test("#2841: cold DB bootstrap opens an existing project database before state derivation", async (t) => {
+  const base = realpathSync(mkdtempSync(join(tmpdir(), "gsd-cold-db-")));
+  t.after(() => rmSync(base, { recursive: true, force: true }));
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  const dbPath = join(base, ".gsd", "gsd.db");
 
-console.log("\n=== #2841: cold DB opened before initial deriveState ===");
+  assert.equal(openDatabase(dbPath), true);
+  closeDatabase();
+  assert.equal(isDbAvailable(), false);
 
-const helperIdx = src.indexOf("async function openProjectDbIfPresent");
-assertTrue(helperIdx >= 0, "auto-start.ts defines a helper for pre-derive DB open (#2841)");
+  await openProjectDbIfPresent(base);
 
-const helperRegion = helperIdx >= 0 ? extractSourceRegion(src, "async function openProjectDbIfPresent") : "";
-assertTrue(
-  helperRegion.includes("resolveProjectRootDbPath(basePath)"),
-  "pre-derive DB helper resolves the project-root DB path (#2841)",
-);
-assertTrue(
-  helperRegion.includes("openDatabase(gsdDbPath)"),
-  "pre-derive DB helper opens the resolved DB path (#2841)",
-);
-
-const firstDeriveIdx = src.indexOf("let state = await deriveState(base);");
-assertTrue(firstDeriveIdx > 0, "auto-start.ts has the initial deriveState(base) call");
-
-const preDeriveRegion = firstDeriveIdx > 0 ? src.slice(0, firstDeriveIdx) : "";
-const preDeriveOpenIdx = preDeriveRegion.lastIndexOf("await openProjectDbIfPresent(base);");
-
-assertTrue(
-  preDeriveOpenIdx > 0,
-  "bootstrapAutoSession opens the DB before the first deriveState(base) call (#2841)",
-);
-
-report();
+  assert.equal(isDbAvailable(), true);
+});