gsd-pi 2.67.0-dev.1cd1e0f → 2.67.0-dev.2367d7e

package/src/resources/extensions/gsd/tests/cold-resume-db-reopen.test.ts

@@ -18,22 +18,33 @@ const { assertTrue, report } = createTestContext();
 
 const autoSrc = readFileSync(join(import.meta.dirname, "..", "auto.ts"), "utf-8");
 
-console.log("\n=== #2940: resume path opens DB before rebuildState/deriveState ===");
+console.log("\n=== resume path refreshes resources and opens DB before rebuildState/deriveState ===");
 
 // The resume block is the `if (s.paused) { ... }` section that calls rebuildState/deriveState.
 // Locate the resume section by finding `s.paused = false;` followed by `rebuildState`.
 const resumeSectionStart = autoSrc.indexOf("if (s.paused) {", autoSrc.indexOf("// If resuming from paused state"));
 assertTrue(resumeSectionStart > 0, "auto.ts has the paused-session resume block");
 
-const resumeSection = autoSrc.slice(resumeSectionStart, resumeSectionStart + 3000);
+const resumeSectionEnd = autoSrc.indexOf("await autoLoop(", resumeSectionStart);
+assertTrue(resumeSectionEnd > resumeSectionStart, "resume block reaches autoLoop");
 
-// The resume path must open the DB before rebuildState/deriveState
+const resumeSection = autoSrc.slice(resumeSectionStart, resumeSectionEnd);
+
+// The resume path must refresh managed resources and open the DB before
+// rebuildState/deriveState so resumed auto-mode uses current extension code.
 const rebuildIdx = resumeSection.indexOf("rebuildState(");
 assertTrue(rebuildIdx > 0, "resume block calls rebuildState");
 
 const deriveIdx = resumeSection.indexOf("deriveState(");
 assertTrue(deriveIdx > 0, "resume block calls deriveState");
 
+const preDeriveSection = resumeSection.slice(0, rebuildIdx);
+
+assertTrue(
+  preDeriveSection.includes("initResources("),
+  "resume path must refresh managed resources before rebuildState/deriveState (#3761)",
+);
+
 // There must be a DB open call before the first rebuildState call
 const dbOpenPatterns = [
   "openProjectDbIfPresent(",
@@ -41,7 +52,6 @@ const dbOpenPatterns = [
   "ensureDbOpen(",
 ];
 
-const preDeriveSection = resumeSection.slice(0, rebuildIdx);
 const hasDbOpen = dbOpenPatterns.some(pat => preDeriveSection.includes(pat));
 assertTrue(
   hasDbOpen,

package/src/resources/extensions/gsd/tests/copy-planning-artifacts-samepath.test.ts

@@ -0,0 +1,21 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+test("copyPlanningArtifacts skips when source and destination .gsd resolve to the same path", () => {
+  const srcPath = join(import.meta.dirname, "..", "auto-worktree.ts");
+  const src = readFileSync(srcPath, "utf-8");
+
+  const fnIdx = src.indexOf("function copyPlanningArtifacts");
+  assert.ok(fnIdx !== -1, "copyPlanningArtifacts function exists");
+
+  const fnBody = src.slice(fnIdx, fnIdx + 2400);
+
+  const guardIdx = fnBody.indexOf("if (isSamePath(srcGsd, dstGsd)) return;");
+  const copyIdx = fnBody.indexOf("safeCopyRecursive(join(srcGsd, \"milestones\")");
+
+  assert.ok(guardIdx !== -1, "copyPlanningArtifacts should guard same-path .gsd copies");
+  assert.ok(copyIdx !== -1, "copyPlanningArtifacts should still copy milestones when paths differ");
+  assert.ok(guardIdx < copyIdx, "same-path guard should run before any copy attempt");
+});

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

@@ -74,3 +74,104 @@ test("model command resolves and persists exact provider-qualified selection", a
   assert.deepEqual(applied, selectedModel);
   assert.match(notices[0]!.message, /openai\/gpt-5\.4/);
 });
+
+test("interactive model picker chooses provider first, then model", async () => {
+  const selectedModel = { provider: "openai", id: "gpt-5.4" };
+  let applied: typeof selectedModel | null = null;
+  const selects: Array<{ title: string; options: string[] }> = [];
+  const notices: Array<{ message: string; type?: string }> = [];
+
+  const ctx = {
+    hasUI: true,
+    model: { provider: "anthropic", id: "claude-sonnet-4-6" },
+    modelRegistry: {
+      getAvailable: () => [
+        { provider: "openai", id: "gpt-5.4" },
+        { provider: "anthropic", id: "claude-opus-4-6" },
+        { provider: "openai", id: "gpt-5.3-mini" },
+        { provider: "anthropic", id: "claude-sonnet-4-6" },
+      ],
+    },
+    ui: {
+      select: async (title: string, options: string[]) => {
+        selects.push({ title, options });
+        return selects.length === 1 ? "openai (2 models)" : "gpt-5.4";
+      },
+      notify: (message: string, type?: string) => {
+        notices.push({ message, type });
+      },
+    },
+  } as any;
+
+  const pi = {
+    setModel: async (model: typeof selectedModel) => {
+      applied = model;
+      return true;
+    },
+  } as any;
+
+  const handled = await handleCoreCommand("model", ctx, pi);
+  assert.equal(handled, true);
+  assert.deepEqual(selects, [
+    {
+      title: "Select session model: — choose provider:",
+      options: ["anthropic (2 models)", "openai (2 models)", "(cancel)"],
+    },
+    {
+      title: "Select session model: — openai:",
+      options: ["gpt-5.3-mini", "gpt-5.4", "(cancel)"],
+    },
+  ]);
+  assert.deepEqual(applied, selectedModel);
+  assert.match(notices[0]!.message, /openai\/gpt-5\.4/);
+});
+
+test("ambiguous typed model selection chooses provider first, then model", async () => {
+  const selectedModel = { provider: "github-copilot", id: "gpt-5" };
+  let applied: typeof selectedModel | null = null;
+  const selects: Array<{ title: string; options: string[] }> = [];
+  const notices: Array<{ message: string; type?: string }> = [];
+
+  const ctx = {
+    hasUI: true,
+    model: { provider: "anthropic", id: "claude-sonnet-4-6" },
+    modelRegistry: {
+      getAvailable: () => [
+        { provider: "openai", id: "gpt-5" },
+        { provider: "github-copilot", id: "gpt-5" },
+        { provider: "openai", id: "gpt-5-mini" },
+      ],
+    },
+    ui: {
+      select: async (title: string, options: string[]) => {
+        selects.push({ title, options });
+        return selects.length === 1 ? "github-copilot (1 model)" : "gpt-5";
+      },
+      notify: (message: string, type?: string) => {
+        notices.push({ message, type });
+      },
+    },
+  } as any;
+
+  const pi = {
+    setModel: async (model: typeof selectedModel) => {
+      applied = model;
+      return true;
+    },
+  } as any;
+
+  const handled = await handleCoreCommand("model gpt", ctx, pi);
+  assert.equal(handled, true);
+  assert.deepEqual(selects, [
+    {
+      title: "Multiple models match \"gpt\" — choose provider:",
+      options: ["github-copilot (1 model)", "openai (2 models)", "(cancel)"],
+    },
+    {
+      title: "Multiple models match \"gpt\" — github-copilot:",
+      options: ["gpt-5", "(cancel)"],
+    },
+  ]);
+  assert.deepEqual(applied, selectedModel);
+  assert.match(notices[0]!.message, /github-copilot\/gpt-5/);
+});

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

@@ -1,6 +1,6 @@
 import test from "node:test";
 import assert from "node:assert/strict";
-import { mkdirSync, existsSync, readFileSync, rmSync } from "node:fs";
+import { mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { randomUUID } from "node:crypto";
@@ -13,6 +13,14 @@ import {
   formatCrashInfo,
   type LockData,
 } from "../crash-recovery.ts";
+import {
+  assessInterruptedSession,
+  hasResumableDerivedState,
+  isBootstrapCrashLock,
+  readPausedSessionMetadata,
+} from "../interrupted-session.ts";
+import { gsdRoot } from "../paths.ts";
+import type { GSDState } from "../types.ts";
 
 function makeTmpBase(): string {
   const base = join(tmpdir(), `gsd-test-${randomUUID()}`);
@@ -24,6 +32,376 @@ function cleanup(base: string): void {
   try { rmSync(base, { recursive: true, force: true }); } catch { /* */ }
 }
 
+function writeTestLock(
+  base: string,
+  unitType: string,
+  unitId: string,
+  sessionFile?: string,
+): void {
+  writeFileSync(
+    join(gsdRoot(base), "auto.lock"),
+    JSON.stringify({
+      pid: 999999999,
+      startedAt: new Date().toISOString(),
+      unitType,
+      unitId,
+      unitStartedAt: new Date().toISOString(),
+      sessionFile,
+    }, null, 2),
+    "utf-8",
+  );
+}
+
+function writeRoadmap(base: string, checked = false): void {
+  const milestoneDir = join(base, ".gsd", "milestones", "M001");
+  mkdirSync(join(milestoneDir, "slices", "S01", "tasks"), { recursive: true });
+  writeFileSync(
+    join(milestoneDir, "M001-ROADMAP.md"),
+    [
+      "# M001: Test Milestone",
+      "",
+      "## Vision",
+      "",
+      "Test milestone.",
+      "",
+      "## Success Criteria",
+      "",
+      "- It works.",
+      "",
+      "## Slices",
+      "",
+      `- [${checked ? "x" : " "}] **S01: Test slice** \`risk:low\``,
+      "  After this: Demo",
+      "",
+      "## Boundary Map",
+      "",
+      "- S01 → terminal",
+      "  - Produces: done",
+      "  - Consumes: nothing",
+    ].join("\n"),
+    "utf-8",
+  );
+}
+
+function writeCompleteSliceArtifacts(base: string): void {
+  const sliceDir = join(base, ".gsd", "milestones", "M001", "slices", "S01");
+  mkdirSync(sliceDir, { recursive: true });
+  writeFileSync(join(sliceDir, "S01-SUMMARY.md"), "# Summary\nDone.\n", "utf-8");
+  writeFileSync(join(sliceDir, "S01-UAT.md"), "# UAT\nPassed.\n", "utf-8");
+}
+
+function writeCompleteMilestoneSummary(base: string): void {
+  const milestoneDir = join(base, ".gsd", "milestones", "M001");
+  mkdirSync(milestoneDir, { recursive: true });
+  writeFileSync(join(milestoneDir, "M001-SUMMARY.md"), "# Milestone Summary\nDone.\n", "utf-8");
+}
+
+function writePausedSession(
+  base: string,
+  milestoneId = "M001",
+  stepMode = false,
+  worktreePath?: string,
+  unitType?: string,
+  unitId?: string,
+): void {
+  const runtimeDir = join(base, ".gsd", "runtime");
+  mkdirSync(runtimeDir, { recursive: true });
+  writeFileSync(
+    join(runtimeDir, "paused-session.json"),
+    JSON.stringify({ milestoneId, originalBasePath: base, stepMode, worktreePath, unitType, unitId }, null, 2),
+    "utf-8",
+  );
+}
+
+function writeActivityLog(base: string, entries: Record<string, unknown>[]): void {
+  const activityDir = join(base, ".gsd", "activity");
+  mkdirSync(activityDir, { recursive: true });
+  writeFileSync(
+    join(activityDir, "001-execute-task-M001-S01-T01.jsonl"),
+    entries.map((entry) => JSON.stringify(entry)).join("\n") + "\n",
+    "utf-8",
+  );
+}
+
+function makeState(phase: GSDState["phase"], activeMilestone = true): GSDState {
+  return {
+    activeMilestone: activeMilestone ? { id: "M001", title: "Test" } : null,
+    activeSlice: null,
+    activeTask: null,
+    phase,
+    recentDecisions: [],
+    blockers: [],
+    nextAction: "",
+    registry: [],
+  };
+}
+
+// ─── interrupted-session helpers ───────────────────────────────────────────
+
+test("hasResumableDerivedState treats only unfinished active work as resumable", () => {
+  assert.equal(hasResumableDerivedState(makeState("executing")), true);
+  assert.equal(hasResumableDerivedState(makeState("complete")), false);
+  assert.equal(hasResumableDerivedState(makeState("pre-planning", false)), false);
+});
+
+test("isBootstrapCrashLock detects starting/bootstrap special case", () => {
+  const bootstrap: LockData = {
+    pid: 999999999,
+    startedAt: new Date().toISOString(),
+    unitType: "starting",
+    unitId: "bootstrap",
+    unitStartedAt: new Date().toISOString(),
+  };
+  assert.equal(isBootstrapCrashLock(bootstrap), true);
+  assert.equal(isBootstrapCrashLock({ ...bootstrap, unitType: "execute-task" }), false);
+});
+
+test("readPausedSessionMetadata reads paused-session metadata when present", () => {
+  const base = makeTmpBase();
+  try {
+    writePausedSession(base, "M009");
+    const meta = readPausedSessionMetadata(base);
+    assert.equal(meta?.milestoneId, "M009");
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("readPausedSessionMetadata preserves unitType and unitId through round-trip", () => {
+  const base = makeTmpBase();
+  try {
+    writePausedSession(base, "M001", false, undefined, "execute-task", "M001/S01/T02");
+    const meta = readPausedSessionMetadata(base);
+    assert.equal(meta?.unitType, "execute-task");
+    assert.equal(meta?.unitId, "M001/S01/T02");
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("readPausedSessionMetadata handles legacy metadata without unitType/unitId", () => {
+  const base = makeTmpBase();
+  try {
+    // Write metadata without unitType/unitId (simulates older version)
+    const runtimeDir = join(base, ".gsd", "runtime");
+    mkdirSync(runtimeDir, { recursive: true });
+    writeFileSync(
+      join(runtimeDir, "paused-session.json"),
+      JSON.stringify({ milestoneId: "M001", originalBasePath: base }),
+      "utf-8",
+    );
+    const meta = readPausedSessionMetadata(base);
+    assert.equal(meta?.milestoneId, "M001");
+    assert.equal(meta?.unitType, undefined);
+    assert.equal(meta?.unitId, undefined);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("assessInterruptedSession returns none when no lock and no paused session exist", async () => {
+  const base = makeTmpBase();
+  try {
+    const assessment = await assessInterruptedSession(base);
+    assert.equal(assessment.classification, "none");
+    assert.equal(assessment.lock, null);
+    assert.equal(assessment.pausedSession, null);
+    assert.equal(assessment.state, null);
+    assert.equal(assessment.recovery, null);
+    assert.equal(assessment.recoveryPrompt, null);
+    assert.equal(assessment.recoveryToolCallCount, 0);
+    assert.equal(assessment.artifactSatisfied, false);
+    assert.equal(assessment.hasResumableDiskState, false);
+    assert.equal(assessment.isBootstrapCrash, false);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("assessInterruptedSession classifies stale complete repo as stale and suppresses recovery", async () => {
+  const base = makeTmpBase();
+  try {
+    writeRoadmap(base, true);
+    writeCompleteSliceArtifacts(base);
+    writeCompleteMilestoneSummary(base);
+    writeTestLock(base, "execute-task", "M001/S01/T01");
+
+    const assessment = await assessInterruptedSession(base);
+    assert.equal(assessment.classification, "stale");
+    assert.equal(assessment.hasResumableDiskState, false);
+    assert.equal(assessment.recoveryPrompt, null);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("assessInterruptedSession suppresses prompt when expected artifact already exists and no resumable state remains", async () => {
+  const base = makeTmpBase();
+  try {
+    writeRoadmap(base, true);
+    writeCompleteSliceArtifacts(base);
+    writeCompleteMilestoneSummary(base);
+    writeTestLock(base, "complete-slice", "M001/S01");
+
+    const assessment = await assessInterruptedSession(base);
+    assert.equal(assessment.classification, "stale");
+    assert.equal(assessment.artifactSatisfied, true);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("assessInterruptedSession keeps paused-session resume recoverable when disk state is unfinished", async () => {
+  const base = makeTmpBase();
+  try {
+    writeRoadmap(base, false);
+    writePausedSession(base);
+    writeTestLock(base, "execute-task", "M001/S01/T01");
+
+    const assessment = await assessInterruptedSession(base);
+    assert.equal(assessment.classification, "recoverable");
+    assert.equal(assessment.pausedSession?.milestoneId, "M001");
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("assessInterruptedSession marks stale paused-session metadata as stale when no work remains", async () => {
+  const base = makeTmpBase();
+  try {
+    writeRoadmap(base, true);
+    writeCompleteSliceArtifacts(base);
+    writeCompleteMilestoneSummary(base);
+    writePausedSession(base, "M999");
+
+    const assessment = await assessInterruptedSession(base);
+    assert.equal(assessment.classification, "stale");
+    assert.equal(assessment.hasResumableDiskState, false);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("assessInterruptedSession classifies paused session without lock as recoverable when disk state is resumable", async () => {
+  const base = makeTmpBase();
+  try {
+    writeRoadmap(base, false);
+    writePausedSession(base, "M001", true);
+
+    const assessment = await assessInterruptedSession(base);
+    assert.equal(assessment.classification, "recoverable");
+    assert.equal(assessment.lock, null);
+    assert.equal(assessment.pausedSession?.milestoneId, "M001");
+    assert.equal(assessment.hasResumableDiskState, true);
+    assert.equal(assessment.isBootstrapCrash, false);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("assessInterruptedSession falls back to basePath when worktreePath no longer exists", async () => {
+  const base = makeTmpBase();
+  try {
+    writeRoadmap(base, false);
+    // Reference a worktree that doesn't exist on disk
+    writePausedSession(base, "M001", false, "/nonexistent/worktree");
+
+    const assessment = await assessInterruptedSession(base);
+    // Should use basePath (which has an unfinished roadmap) instead of the missing worktree
+    assert.equal(assessment.classification, "recoverable");
+    assert.equal(assessment.hasResumableDiskState, true);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("assessInterruptedSession prefers paused worktree state when worktreePath is recorded", async () => {
+  const base = makeTmpBase();
+  const worktree = join(base, "worktree-copy");
+  try {
+    writeRoadmap(base, false);
+    writeRoadmap(worktree, true);
+    writeCompleteSliceArtifacts(worktree);
+    writeCompleteMilestoneSummary(worktree);
+    writePausedSession(base, "M001", false, worktree);
+
+    const assessment = await assessInterruptedSession(base);
+    assert.equal(assessment.classification, "stale");
+    assert.equal(assessment.hasResumableDiskState, false);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("assessInterruptedSession keeps unfinished derived state recoverable without trace", async () => {
+  const base = makeTmpBase();
+  try {
+    writeRoadmap(base, false);
+    writeTestLock(base, "plan-slice", "M001/S01");
+
+    const assessment = await assessInterruptedSession(base);
+    assert.equal(assessment.classification, "recoverable");
+    assert.equal(assessment.hasResumableDiskState, true);
+    assert.equal(assessment.recoveryPrompt, null);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("assessInterruptedSession preserves crash trace when activity log has tool calls", async () => {
+  const base = makeTmpBase();
+  try {
+    writeRoadmap(base, false);
+    writeTestLock(base, "execute-task", "M001/S01/T01");
+    writeActivityLog(base, [
+      {
+        type: "message",
+        message: {
+          role: "assistant",
+          content: [
+            {
+              type: "toolCall",
+              id: "1",
+              name: "bash",
+              arguments: { command: "npm test" },
+            },
+          ],
+        },
+      },
+      {
+        type: "message",
+        message: {
+          role: "toolResult",
+          toolCallId: "1",
+          toolName: "bash",
+          isError: false,
+          content: [{ type: "text", text: "ok" }],
+        },
+      },
+    ]);
+
+    const assessment = await assessInterruptedSession(base);
+    assert.equal(assessment.classification, "recoverable");
+    assert.ok(assessment.recoveryToolCallCount > 0);
+    assert.ok(assessment.recoveryPrompt?.includes("Recovery Briefing"));
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("assessInterruptedSession treats bootstrap crash as stale without paused metadata", async () => {
+  const base = makeTmpBase();
+  try {
+    writeTestLock(base, "starting", "bootstrap");
+
+    const assessment = await assessInterruptedSession(base);
+    assert.equal(assessment.classification, "stale");
+    assert.equal(assessment.isBootstrapCrash, true);
+  } finally {
+    cleanup(base);
+  }
+});
+
 // ─── writeLock / readCrashLock ────────────────────────────────────────────
 
 test("writeLock creates lock file and readCrashLock reads it", (t) => {
@@ -84,7 +462,7 @@ test("#2470: isLockProcessAlive returns true for own PID (we hold the lock)", ()
 
 test("isLockProcessAlive returns false for dead PID", () => {
   const lock: LockData = {
-    pid: 999999999, // almost certainly not running
+    pid: 999999999,
     startedAt: new Date().toISOString(),
     unitType: "execute-task",
     unitId: "M001/S01/T01",

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

@@ -77,6 +77,36 @@ describe('ensure-db-open', () => {
     }
   });
 
+  test('ensureDbOpen: explicit basePath opens target project without cwd override', async () => {
+    const tmpDir = makeTmpDir();
+    const gsdDir = path.join(tmpDir, '.gsd');
+    fs.mkdirSync(gsdDir, { recursive: true });
+    fs.writeFileSync(path.join(gsdDir, 'DECISIONS.md'), `# Decisions
+
+| # | When | Scope | Decision | Choice | Rationale | Revisable |
+|---|------|-------|----------|--------|-----------|-----------|
+| D777 | M001 | architecture | Use explicit basePath | BasePath | Avoid cwd coupling | Yes |
+`);
+
+    try {
+      closeDatabase();
+    } catch { /* ok */ }
+
+    const originalCwd = process.cwd();
+    try {
+      const { ensureDbOpen } = await import('../bootstrap/dynamic-tools.ts');
+      const result = await ensureDbOpen(tmpDir);
+
+      assert.ok(result === true, 'ensureDbOpen should honor explicit basePath');
+      assert.equal(process.cwd(), originalCwd, 'ensureDbOpen should not mutate process.cwd');
+      assert.ok(isDbAvailable(), 'DB should be available after explicit open');
+      assert.ok(getDecisionById('D777') !== null, 'explicit basePath DB should be opened');
+    } finally {
+      closeDatabase();
+      cleanupDir(tmpDir);
+    }
+  });
+
   // ═══════════════════════════════════════════════════════════════════════════
   // ensureDbOpen returns false when no .gsd/ exists
   // ═══════════════════════════════════════════════════════════════════════════
@@ -159,6 +189,42 @@ describe('ensure-db-open', () => {
     }
   });
 
+  test('ensureDbOpen: switches open database when basePath changes', async () => {
+    const firstDir = makeTmpDir();
+    const secondDir = makeTmpDir();
+    fs.mkdirSync(path.join(firstDir, '.gsd'), { recursive: true });
+    fs.mkdirSync(path.join(secondDir, '.gsd'), { recursive: true });
+    fs.writeFileSync(path.join(firstDir, '.gsd', 'DECISIONS.md'), `# Decisions
+
+| # | When | Scope | Decision | Choice | Rationale | Revisable |
+|---|------|-------|----------|--------|-----------|-----------|
+| D101 | M001 | architecture | First DB | First | First rationale | Yes |
+`);
+    fs.writeFileSync(path.join(secondDir, '.gsd', 'DECISIONS.md'), `# Decisions
+
+| # | When | Scope | Decision | Choice | Rationale | Revisable |
+|---|------|-------|----------|--------|-----------|-----------|
+| D202 | M001 | architecture | Second DB | Second | Second rationale | Yes |
+`);
+
+    try {
+      closeDatabase();
+    } catch { /* ok */ }
+
+    try {
+      const { ensureDbOpen } = await import('../bootstrap/dynamic-tools.ts');
+      assert.equal(await ensureDbOpen(firstDir), true);
+      assert.ok(getDecisionById('D101') !== null, 'first DB should be active');
+      assert.equal(await ensureDbOpen(secondDir), true);
+      assert.ok(getDecisionById('D202') !== null, 'second DB should be active after switch');
+      assert.equal(getDecisionById('D101'), null, 'first DB should no longer be active after switch');
+    } finally {
+      closeDatabase();
+      cleanupDir(firstDir);
+      cleanupDir(secondDir);
+    }
+  });
+
   // ═══════════════════════════════════════════════════════════════════════════
 
 });

package/src/resources/extensions/gsd/tests/forensics-context-persist.test.ts

@@ -126,4 +126,34 @@ describe("forensics context persistence (#2941)", () => {
     // Should not throw
     clearForensicsMarker(join(tmpBase, "nonexistent"));
   });
+
+  it("buildForensicsContextInjection keeps marker for low-entropy resume prompts", async () => {
+    const { buildForensicsContextInjection } = await import("../bootstrap/system-context.ts");
+
+    const markerPath = join(tmpBase, ".gsd", "runtime", "active-forensics.json");
+    writeFileSync(markerPath, JSON.stringify({
+      reportPath: "/some/report.md",
+      promptContent: "forensics prompt",
+      createdAt: new Date().toISOString(),
+    }), "utf-8");
+
+    const result = buildForensicsContextInjection(tmpBase, "continue");
+    assert.equal(result, "forensics prompt");
+    assert.ok(existsSync(markerPath), "resume-like follow-up should keep marker intact");
+  });
+
+  it("buildForensicsContextInjection clears marker on unrelated user prompts", async () => {
+    const { buildForensicsContextInjection } = await import("../bootstrap/system-context.ts");
+
+    const markerPath = join(tmpBase, ".gsd", "runtime", "active-forensics.json");
+    writeFileSync(markerPath, JSON.stringify({
+      reportPath: "/some/report.md",
+      promptContent: "forensics prompt",
+      createdAt: new Date().toISOString(),
+    }), "utf-8");
+
+    const result = buildForensicsContextInjection(tmpBase, "please summarize the README");
+    assert.equal(result, null);
+    assert.ok(!existsSync(markerPath), "unrelated follow-up should clear the stale marker");
+  });
 });