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

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

@@ -9,46 +9,42 @@
 
 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';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
-const completeTaskSrc = readFileSync(
-  join(__dirname, '..', 'tools', 'complete-task.ts'),
-  'utf-8',
-);
-const roadmapSlicesSrc = readFileSync(
-  join(__dirname, '..', 'roadmap-slices.ts'),
-  'utf-8',
-);
+import { normalizeListParam } from "../tools/complete-task.ts";
+import { parseRoadmapSlices } from "../roadmap-slices.ts";
 
 describe('complete-task normalizeListParam (#3692)', () => {
-  test('normalizeListParam function is defined', () => {
-    assert.match(completeTaskSrc, /function normalizeListParam\(/,
-      'normalizeListParam function should be defined in complete-task.ts');
+  test('normalizes newline-delimited key file strings', () => {
+    assert.deepEqual(
+      normalizeListParam("- src/app.ts\n* tests/app.test.ts\n  docs/notes.md"),
+      ["src/app.ts", "tests/app.test.ts", "docs/notes.md"],
+    );
   });
 
-  test('normalizeListParam is applied to keyFiles', () => {
-    assert.match(completeTaskSrc, /normalizeListParam\(params\.keyFiles\)/,
-      'normalizeListParam should be applied to keyFiles');
-  });
-
-  test('normalizeListParam is applied to keyDecisions', () => {
-    assert.match(completeTaskSrc, /normalizeListParam\(params\.keyDecisions\)/,
-      'normalizeListParam should be applied to keyDecisions');
+  test('normalizes arrays and empty values', () => {
+    assert.deepEqual(normalizeListParam(["api", 42]), ["api", "42"]);
+    assert.deepEqual(normalizeListParam("   "), []);
+    assert.deepEqual(normalizeListParam(undefined), []);
   });
 });
 
 describe('roadmap-slices depColumnIndex detection (#3692)', () => {
-  test('depColumnIndex is detected from header row', () => {
-    assert.match(roadmapSlicesSrc, /depColumnIndex/,
-      'depColumnIndex variable should exist in roadmap-slices.ts');
-    assert.match(roadmapSlicesSrc, /headerCells/,
-      'headerCells should be parsed from the header row');
-    assert.match(roadmapSlicesSrc, /depends|deps|depend/i,
-      'header detection should match depends/deps/depend');
+  test('parses dependencies from the dependency table column only', () => {
+    const slices = parseRoadmapSlices([
+      "## Slices",
+      "| ID | Title | Risk | Depends | Status |",
+      "| -- | ----- | ---- | ------- | ------ |",
+      "| S01 | Foundation | low | none | Done |",
+      "| S02 | Title mentions S01 but no dependency | medium | none | Pending |",
+      "| S03 | Integration | high | S01, S02 | Pending |",
+    ].join("\n"));
+
+    assert.deepEqual(
+      slices.map((slice) => ({ id: slice.id, depends: slice.depends })),
+      [
+        { id: "S01", depends: [] },
+        { id: "S02", depends: [] },
+        { id: "S03", depends: ["S01", "S02"] },
+      ],
+    );
   });
 });

package/src/resources/extensions/gsd/tests/completed-units-metrics-sync.test.ts

@@ -1,124 +1,61 @@
 /**
  * completed-units-metrics-sync.test.ts — Regression tests for #2313.
- *
- * 1. completed-units.json should be archived (not wiped) on milestone transition
- * 2. metrics.json should be in the worktree → project root sync file list
  */
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync, mkdtempSync, mkdirSync, writeFileSync, existsSync, cpSync } from "node:fs";
+import { readFileSync, mkdtempSync, mkdirSync, writeFileSync, existsSync, cpSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
-
-// ─── Bug 1: completed-units.json should be archived, not wiped ─────────────
-
-const phasesSrcPath = join(import.meta.dirname, "..", "auto", "phases.ts");
-const phasesSrc = readFileSync(phasesSrcPath, "utf-8");
-
-test("#2313: completed-units.json should not be blindly wiped to [] on milestone transition", () => {
-  // The milestone transition block should NOT write an empty array to completed-units.json
-  // without first archiving the existing data. Look for the archive/rename pattern.
-  const transitionIdx = phasesSrc.indexOf("Milestone transition");
-  assert.ok(transitionIdx !== -1, "Milestone transition section exists");
-
-  // Find the completed-units handling block
-  const completedUnitsIdx = phasesSrc.indexOf("completed-units", transitionIdx);
-  assert.ok(completedUnitsIdx !== -1, "completed-units handling exists in transition");
-
-  // Get a window around the completed-units handling (1200 chars to
-  // accommodate CRLF line endings on Windows which inflate byte offsets).
-  const windowStart = Math.max(0, completedUnitsIdx - 300);
-  const windowEnd = Math.min(phasesSrc.length, completedUnitsIdx + 900);
-  const window = phasesSrc.slice(windowStart, windowEnd).toLowerCase();
-
-  // Should archive/rename the old file before resetting
-  const hasArchive = window.includes("archive") ||
-    window.includes("rename") ||
-    window.includes("cpsync") ||
-    window.includes("safecopy") ||
-    window.includes("completed-units-");
-
-  assert.ok(
-    hasArchive,
-    "completed-units.json should be archived before reset during milestone transition",
-  );
-});
-
-// ─── Bug 2: metrics.json should be in the sync file lists ──────────────────
-
-test("#2313: syncStateToProjectRoot should sync metrics.json", () => {
-  const syncSrcPath = join(import.meta.dirname, "..", "auto-worktree.ts");
-  const syncSrc = readFileSync(syncSrcPath, "utf-8");
-
-  // syncStateToProjectRoot should copy metrics.json from worktree to project root
-  assert.ok(
-    syncSrc.includes("metrics.json"),
-    "auto-worktree.ts should reference metrics.json for sync",
-  );
-});
-
-test("syncStateToProjectRoot should back-sync completed-units.json", () => {
-  const syncSrcPath = join(import.meta.dirname, "..", "auto-worktree.ts");
-  const syncSrc = readFileSync(syncSrcPath, "utf-8");
-  const fnIdx = syncSrc.indexOf("export function syncStateToProjectRoot(");
-  assert.ok(fnIdx !== -1, "syncStateToProjectRoot exists");
-  const fnBlock = syncSrc.slice(fnIdx, syncSrc.indexOf("// ─── Resource Staleness", fnIdx));
-
-  assert.ok(
-    fnBlock.includes('"completed-units.json"'),
-    "syncStateToProjectRoot should copy completed-units.json back to the project root",
-  );
-});
-
-test("#2313: syncWorktreeStateBack should include metrics.json in ROOT_DIAGNOSTIC_FILES", () => {
-  const autoWorktreeSrcPath = join(import.meta.dirname, "..", "auto-worktree.ts");
-  const autoWorktreeSrc = readFileSync(autoWorktreeSrcPath, "utf-8");
-
-  // Find the ROOT_DIAGNOSTIC_FILES constant used for worktree copy-back.
-  const constIdx = autoWorktreeSrc.indexOf("ROOT_DIAGNOSTIC_FILES");
-  assert.ok(constIdx !== -1, "ROOT_DIAGNOSTIC_FILES constant exists");
-
-  // Get the array content
-  const arrayStart = autoWorktreeSrc.indexOf("[", constIdx);
-  const arrayEnd = autoWorktreeSrc.indexOf("]", arrayStart);
-  const rootFilesBlock = autoWorktreeSrc.slice(arrayStart, arrayEnd);
-
-  assert.ok(
-    rootFilesBlock.includes("metrics.json"),
-    "metrics.json should be in ROOT_DIAGNOSTIC_FILES list",
-  );
+import { syncStateToProjectRoot } from "../auto-worktree.ts";
+
+test("#2313: syncStateToProjectRoot copies metrics and completed-units to the project root", () => {
+  const root = mkdtempSync(join(tmpdir(), "gsd-sync-metrics-"));
+  const projectRoot = join(root, "project");
+  const worktree = join(root, "worktree");
+  mkdirSync(join(projectRoot, ".gsd"), { recursive: true });
+  mkdirSync(join(worktree, ".gsd"), { recursive: true });
+  writeFileSync(join(worktree, ".gsd", "metrics.json"), JSON.stringify({ tokens: 42 }));
+  writeFileSync(join(worktree, ".gsd", "completed-units.json"), JSON.stringify([{ id: "T01" }]));
+
+  try {
+    syncStateToProjectRoot(worktree, projectRoot, "M001");
+
+    assert.deepEqual(
+      JSON.parse(readFileSync(join(projectRoot, ".gsd", "metrics.json"), "utf-8")),
+      { tokens: 42 },
+    );
+    assert.deepEqual(
+      JSON.parse(readFileSync(join(projectRoot, ".gsd", "completed-units.json"), "utf-8")),
+      [{ id: "T01" }],
+    );
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
 });
 
-// ─── Functional test: completed-units archive ────────────────────────────────
-
 test("#2313: functional — completed-units archive creates milestone-specific file", () => {
   const tmpBase = mkdtempSync(join(tmpdir(), "gsd-completed-units-"));
   const gsdDir = join(tmpBase, ".gsd");
   mkdirSync(gsdDir, { recursive: true });
 
-  // Simulate existing completed-units.json with data
-  const existing = [
-    { type: "task", id: "T01" },
-    { type: "slice", id: "S01" },
-  ];
-  const completedKeysPath = join(gsdDir, "completed-units.json");
-  writeFileSync(completedKeysPath, JSON.stringify(existing, null, 2));
-
-  // Simulate the archive behavior: copy to milestone-specific file
-  const milestoneId = "M001";
-  const archivePath = join(gsdDir, `completed-units-${milestoneId}.json`);
-  cpSync(completedKeysPath, archivePath);
-
-  // Reset the main file
-  writeFileSync(completedKeysPath, JSON.stringify([], null, 2));
-
-  // Verify archive exists with original data
-  assert.ok(existsSync(archivePath), "archive file should exist");
-  const archived = JSON.parse(readFileSync(archivePath, "utf-8"));
-  assert.deepEqual(archived, existing, "archived data should match original");
-
-  // Verify main file is reset
-  const current = JSON.parse(readFileSync(completedKeysPath, "utf-8"));
-  assert.deepEqual(current, [], "current completed-units should be empty after transition");
+  try {
+    const existing = [
+      { type: "task", id: "T01" },
+      { type: "slice", id: "S01" },
+    ];
+    const completedKeysPath = join(gsdDir, "completed-units.json");
+    writeFileSync(completedKeysPath, JSON.stringify(existing, null, 2));
+
+    const milestoneId = "M001";
+    const archivePath = join(gsdDir, `completed-units-${milestoneId}.json`);
+    cpSync(completedKeysPath, archivePath);
+    writeFileSync(completedKeysPath, JSON.stringify([], null, 2));
+
+    assert.ok(existsSync(archivePath), "archive file should exist");
+    assert.deepEqual(JSON.parse(readFileSync(archivePath, "utf-8")), existing);
+    assert.deepEqual(JSON.parse(readFileSync(completedKeysPath, "utf-8")), []);
+  } finally {
+    rmSync(tmpBase, { recursive: true, force: true });
+  }
 });

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

@@ -4,7 +4,7 @@
  * No I/O, no extension context, no global state.
  */
 
-import { describe, it } from "node:test";
+import { describe, it, beforeEach } from "node:test";
 import assert from "node:assert/strict";
 
 import {
@@ -16,8 +16,17 @@ import {
   computeBudgets,
   truncateAtSectionBoundary,
   resolveExecutorContextWindow,
+  _resetEmpiricalCacheForTest,
 } from "../context-budget.js";
 
+// Reset the per-provider empirical chars-per-token cache before each test.
+// The hardcoded char-ratio assertions below assume the static fallback path
+// (3.5 / 4.0 chars/token) is used. Without this guard, a prior test that
+// warms tiktoken would populate the cache and silently break these tests.
+beforeEach(() => {
+  _resetEmpiricalCacheForTest();
+});
+
 import type { TokenProvider } from "../token-counter.js";
 
 // ─── Test helpers ─────────────────────────────────────────────────────────────

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

@@ -1,3 +1,5 @@
+// GSD-2 + context-store.test.ts — Regression coverage for DB-backed context query helpers.
+
 import { describe, test, afterEach } from "node:test";
 import assert from "node:assert/strict";
 import {
@@ -362,7 +364,11 @@ describe("context-store: sub-5ms query timing", () => {
 
     assert.strictEqual(decisions.length, 50, `got ${decisions.length} decisions (expected 50)`);
     assert.strictEqual(requirements.length, 50, `got ${requirements.length} requirements (expected 50)`);
-    assert.ok(elapsed < 5, `query latency ${elapsed.toFixed(2)}ms should be < 5ms`);
+    const maxLatencyMs = process.env.NODE_V8_COVERAGE ? 15 : 5;
+    assert.ok(
+      elapsed < maxLatencyMs,
+      `query latency ${elapsed.toFixed(2)}ms should be < ${maxLatencyMs}ms`,
+    );
   });
 });
 

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

@@ -13,11 +13,8 @@ import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync } from 'node:f
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
 import { randomUUID } from 'node:crypto';
-import { fileURLToPath } from 'node:url';
-import { dirname } from 'node:path';
 
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
+import { installEpipeGuard } from "../bootstrap/register-extension.ts";
 
 function makeTmpBase(): string {
   const base = join(tmpdir(), `gsd-test-${randomUUID()}`);
@@ -25,13 +22,6 @@ function makeTmpBase(): string {
   return base;
 }
 
-// ─── register-extension source assertions ────────────────────────────────────
-
-const registerExtSrc = readFileSync(
-  join(__dirname, '..', 'bootstrap', 'register-extension.ts'),
-  'utf-8',
-);
-
 describe('register-extension crash handler secondary fixes (#3348)', () => {
   test('writeCrashLog is exported and writes a file to the crash directory', async () => {
     // Dynamic import so GSD_HOME can be pointed at a temp dir without polluting ~/.gsd
@@ -60,30 +50,44 @@ describe('register-extension crash handler secondary fixes (#3348)', () => {
   });
 
   test('_gsdRejectionGuard is registered for unhandledRejection', () => {
-    assert.match(
-      registerExtSrc,
-      /_gsdRejectionGuard/,
-      '_gsdRejectionGuard handler should be defined',
-    );
-    assert.match(
-      registerExtSrc,
-      /unhandledRejection/,
-      'installEpipeGuard should register an unhandledRejection handler',
+    installEpipeGuard();
+    const listener = process.listeners("unhandledRejection").find((candidate) =>
+      candidate.name === "_gsdRejectionGuard"
     );
+    assert.ok(listener, 'installEpipeGuard should register an unhandledRejection handler');
   });
 
-  test('_gsdEpipeGuard calls process.exit(1) for unrecoverable errors, not log-and-continue', () => {
-    // The original #3696 fix replaced "throw err" with a log-and-continue.
-    // The secondary fix replaces that with writeCrashLog + process.exit(1).
-    assert.ok(
-      !registerExtSrc.includes('process.stderr.write(`[gsd] uncaught extension error (non-fatal)'),
-      '_gsdEpipeGuard should NOT log errors as non-fatal and continue',
-    );
-    assert.match(
-      registerExtSrc,
-      /process\.exit\(1\)/,
-      '_gsdEpipeGuard should call process.exit(1) for unrecoverable errors',
+  test('_gsdEpipeGuard writes a crash log and exits for unrecoverable errors', () => {
+    installEpipeGuard();
+    const listener = process.listeners("uncaughtException").find((candidate) =>
+      candidate.name === "_gsdEpipeGuard"
     );
+    assert.ok(listener, '_gsdEpipeGuard should be registered');
+
+    const tmpHome = join(tmpdir(), `gsd-crash-exit-test-${randomUUID()}`);
+    const origHome = process.env.GSD_HOME;
+    const originalExit = process.exit;
+    let exitCode: number | string | null | undefined;
+    (process as any).exit = (code?: number | string | null | undefined): never => {
+      exitCode = code;
+      throw new Error("process.exit intercepted");
+    };
+    process.env.GSD_HOME = tmpHome;
+    try {
+      assert.throws(
+        () => listener(new Error("unrecoverable crash guard test"), "uncaughtException"),
+        /process\.exit intercepted/,
+      );
+      assert.equal(exitCode, 1);
+      const crashDir = join(tmpHome, "crash");
+      const logs = readdirSync(crashDir).filter((f) => f.endsWith(".log"));
+      assert.equal(logs.length, 1);
+      assert.match(readFileSync(join(crashDir, logs[0]), "utf-8"), /unrecoverable crash guard test/);
+    } finally {
+      (process as any).exit = originalExit;
+      process.env.GSD_HOME = origHome;
+      rmSync(tmpHome, { recursive: true, force: true });
+    }
   });
 
   test('writeCrashLog never throws even when directory is unwritable', async () => {
@@ -232,4 +236,59 @@ describe('emitCrashRecoveredUnitEnd (#3348)', () => {
       rmSync(base, { recursive: true, force: true });
     }
   });
+
+  test('emitOpenUnitEndForUnit closes the latest open start with error context', async () => {
+    const base = makeTmpBase();
+    try {
+      const { emitJournalEvent, queryJournal } = await import('../journal.ts');
+      const { emitOpenUnitEndForUnit } = await import('../crash-recovery.ts');
+
+      const firstFlowId = randomUUID();
+      const secondFlowId = randomUUID();
+      emitJournalEvent(base, {
+        ts: new Date().toISOString(),
+        flowId: firstFlowId,
+        seq: 1,
+        eventType: 'unit-start',
+        data: { unitType: 'execute-task', unitId: 'M008/S04/T02' },
+      });
+      emitJournalEvent(base, {
+        ts: new Date().toISOString(),
+        flowId: firstFlowId,
+        seq: 2,
+        eventType: 'unit-end',
+        data: { unitType: 'execute-task', unitId: 'M008/S04/T02', status: 'completed' },
+        causedBy: { flowId: firstFlowId, seq: 1 },
+      });
+      emitJournalEvent(base, {
+        ts: new Date().toISOString(),
+        flowId: secondFlowId,
+        seq: 3,
+        eventType: 'unit-start',
+        data: { unitType: 'execute-task', unitId: 'M008/S04/T02' },
+      });
+
+      const emitted = emitOpenUnitEndForUnit(
+        base,
+        'execute-task',
+        'M008/S04/T02',
+        'cancelled',
+        { message: 'runUnitPhase exploded', category: 'unit-exception', isTransient: false },
+      );
+
+      assert.equal(emitted, true, 'open unit should be closed');
+      const ends = queryJournal(base).filter((e) => e.eventType === 'unit-end');
+      assert.equal(ends.length, 2, 'should preserve existing end and add one new end');
+      const newEnd = ends.find((e) => e.causedBy?.flowId === secondFlowId);
+      assert.ok(newEnd, 'new end should close the latest open start');
+      assert.equal(newEnd!.data?.status, 'cancelled');
+      assert.deepEqual(newEnd!.data?.errorContext, {
+        message: 'runUnitPhase exploded',
+        category: 'unit-exception',
+        isTransient: false,
+      });
+    } finally {
+      rmSync(base, { recursive: true, force: true });
+    }
+  });
 });

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

@@ -30,6 +30,7 @@ import {
   isLockProcessAlive,
 } from "../crash-recovery.ts";
 import { normalizeRealPath } from "../paths.ts";
+import { writeUnitRuntimeRecord } from "../unit-runtime.ts";
 
 function makeBase(): string {
   const base = mkdtempSync(join(tmpdir(), "gsd-crash-recovery-"));
@@ -102,6 +103,27 @@ test("readCrashLock synthesizes LockData from a stale dead worker (no dispatches
   assert.ok(lock!.startedAt, "startedAt populated from workers.started_at");
 });
 
+test("readCrashLock falls back to latest in-flight runtime record when dispatch claim is missing", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  const projectRoot = normalizeRealPath(base);
+  const workerId = registerAutoWorker({ projectRootRealpath: projectRoot });
+  writeUnitRuntimeRecord(base, "execute-task", "M008/S04/T02", 1778069087937, {
+    phase: "dispatched",
+    lastProgressAt: 1778069087937,
+    lastProgressKind: "dispatch",
+  });
+  setWorkerPid(workerId, 99999);
+  expireWorker(workerId);
+
+  const lock = readCrashLock(base);
+  assert.ok(lock, "stale worker surfaced as a crash lock");
+  assert.equal(lock!.unitType, "execute-task");
+  assert.equal(lock!.unitId, "M008/S04/T02");
+  assert.equal(lock!.unitStartedAt, new Date(1778069087937).toISOString());
+});
+
 test("readCrashLock includes the most recent dispatch as unitType/unitId", (t) => {
   const base = makeBase();
   t.after(() => cleanup(base));

package/src/resources/extensions/gsd/tests/custom-engine-loop-integration.test.ts

@@ -192,7 +192,11 @@ function makeMockDeps(overrides?: Partial<LoopDeps>): LoopDeps & { callLog: stri
     resolveMilestoneFile: () => null,
     reconcileMergeState: () => "clean",
     preflightCleanRoot: () => ({ stashPushed: false, summary: "" }),
-    postflightPopStash: () => {},
+    postflightPopStash: () => ({
+      restored: true,
+      needsManualRecovery: false,
+      message: "restored",
+    }),
     getLedger: () => null,
     getProjectTotals: () => ({ cost: 0 }),
     formatCost: (c: number) => `$${c.toFixed(2)}`,

package/src/resources/extensions/gsd/tests/cwd-fallback-hardening.test.ts

@@ -0,0 +1,138 @@
+// Project/App: GSD-2
+// File Purpose: Behavior tests for deleted-cwd fallback handling.
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { registerDbTools } from "../bootstrap/db-tools.ts";
+import { registerDynamicTools, ensureDbOpen, safeWorkspaceCwd } from "../bootstrap/dynamic-tools.ts";
+import { registerExecTools } from "../bootstrap/exec-tools.ts";
+import { registerJournalTools } from "../bootstrap/journal-tools.ts";
+import { registerMemoryTools } from "../bootstrap/memory-tools.ts";
+import { registerQueryTools } from "../bootstrap/query-tools.ts";
+
+async function withDeletedCwd(fn: (projectRoot: string) => Promise<void> | void): Promise<void> {
+  const previousCwd = process.cwd();
+  const previousProjectRoot = process.env.GSD_PROJECT_ROOT;
+  const projectRoot = mkdtempSync(join(tmpdir(), "gsd-safe-cwd-project-"));
+  const removedCwd = mkdtempSync(join(tmpdir(), "gsd-removed-cwd-"));
+
+  process.env.GSD_PROJECT_ROOT = projectRoot;
+  process.chdir(removedCwd);
+  rmSync(removedCwd, { recursive: true, force: true });
+
+  try {
+    assert.throws(() => process.cwd(), /ENOENT/);
+    await fn(projectRoot);
+  } finally {
+    process.chdir(previousCwd);
+    if (previousProjectRoot === undefined) delete process.env.GSD_PROJECT_ROOT;
+    else process.env.GSD_PROJECT_ROOT = previousProjectRoot;
+    rmSync(projectRoot, { recursive: true, force: true });
+  }
+}
+
+function collectTools(register: (pi: any) => void): any[] {
+  const tools: any[] = [];
+  register({
+    registerTool(tool: any) {
+      tools.push(tool);
+    },
+  });
+  return tools;
+}
+
+test("safeWorkspaceCwd falls back to captured project root when cwd was removed", async () => {
+  await withDeletedCwd((projectRoot) => {
+    assert.equal(safeWorkspaceCwd(), projectRoot);
+  });
+});
+
+test("ensureDbOpen default path does not throw when cwd was removed", async () => {
+  await withDeletedCwd(async () => {
+    assert.equal(await ensureDbOpen(), false);
+  });
+});
+
+test("dynamic tools register when cwd was removed", async () => {
+  await withDeletedCwd(() => {
+    const tools = collectTools(registerDynamicTools);
+    assert.equal(tools.length, 4);
+  });
+});
+
+test("db-backed tool fallbacks return normal unavailable-db errors when cwd was removed", async () => {
+  await withDeletedCwd(async () => {
+    const tools = collectTools(registerDbTools);
+    const decisionSave = tools.find((tool) => tool.name === "gsd_decision_save");
+
+    const result = await decisionSave.execute(
+      "call-1",
+      {
+        scope: "test",
+        decision: "Handle deleted cwd",
+        choice: "Use captured project root",
+        rationale: "The worktree cwd may disappear during cleanup.",
+      },
+      undefined,
+      undefined,
+      undefined,
+    );
+
+    assert.equal(result.details.error, "db_unavailable");
+  });
+});
+
+test("memory and query tools do not throw when cwd was removed", async () => {
+  await withDeletedCwd(async () => {
+    const memoryTools = collectTools(registerMemoryTools);
+    const queryTools = collectTools(registerQueryTools);
+
+    await assert.doesNotReject(() =>
+      memoryTools.find((tool) => tool.name === "memory_query").execute(
+        "call-1",
+        { query: "cwd fallback" },
+        undefined,
+        undefined,
+        undefined,
+      ),
+    );
+    await assert.doesNotReject(() =>
+      queryTools.find((tool) => tool.name === "gsd_milestone_status").execute(
+        "call-2",
+        { milestoneId: "M001" },
+        undefined,
+        undefined,
+        undefined,
+      ),
+    );
+  });
+});
+
+test("journal and exec tools do not throw when cwd was removed", async () => {
+  await withDeletedCwd(async () => {
+    const journalTools = collectTools(registerJournalTools);
+    const execTools = collectTools(registerExecTools);
+
+    await assert.doesNotReject(() =>
+      journalTools.find((tool) => tool.name === "gsd_journal_query").execute(
+        "call-1",
+        { limit: 1 },
+        undefined,
+        undefined,
+        undefined,
+      ),
+    );
+    await assert.doesNotReject(() =>
+      execTools.find((tool) => tool.name === "gsd_resume").execute(
+        "call-2",
+        {},
+        undefined,
+        undefined,
+        undefined,
+      ),
+    );
+  });
+});