gsd-pi 2.80.0-dev.fbe7c8c6f → 2.81.0

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

@@ -547,4 +547,144 @@ describe("complete-milestone", () => {
       cleanup(base);
     }
   });
+
+  test("verification-gate step numbers match the actual numbered verification steps", () => {
+    // Regression for step-number drift: step 1 (duplicate guard) was inserted
+    // in ea5a2cc0 and the rest renumbered, but the gate text was not updated.
+    // Re-derive the verification-step indices from the rendered prompt and
+    // assert the gate / "Important" footer reference the correct numbers.
+    const prompt = loadPromptFromWorktree("complete-milestone", {
+      workingDirectory: "/tmp/test-project",
+      milestoneId: "M001",
+      milestoneTitle: "Step Number Drift",
+      roadmapPath: ".gsd/milestones/M001/M001-ROADMAP.md",
+      inlinedContext: "context",
+      milestoneSummaryPath: ".gsd/milestones/M001/M001-SUMMARY.md",
+      skillActivation: "{{skillActivation block}}",
+      extractLearningsSteps: "{{extract learnings block}}",
+    });
+
+    function findStep(needle: RegExp): number {
+      const lines = prompt.split("\n");
+      for (const line of lines) {
+        const m = /^(\d+)\.\s/.exec(line);
+        if (m && needle.test(line)) return Number(m[1]);
+      }
+      throw new Error(`no numbered step matches ${needle}`);
+    }
+
+    const codeChange = findStep(/Verify code changes/);
+    const successCriteria = findStep(/Verify every \*\*success criterion\*\*/);
+    const defOfDone = findStep(/Verify \*\*definition of done\*\*/);
+    const completeMilestone = findStep(/Persist completion through `gsd_complete_milestone`/);
+    const requirementUpdate = findStep(/gsd_requirement_update/);
+
+    // Gate clause references the verification steps.
+    const gateLine = prompt.split("\n").find(l => l.includes("Verification failure was recorded") || l.includes("verification failure was recorded"));
+    assert.ok(gateLine, "verification gate sentence is present");
+    assert.ok(
+      gateLine!.includes(`steps ${codeChange}, ${successCriteria}, or ${defOfDone}`),
+      `gate must cite verification steps ${codeChange}, ${successCriteria}, ${defOfDone}; got: ${gateLine}`,
+    );
+    // "Do NOT proceed with steps X-Y" — Y must be at least the gsd_complete_milestone step.
+    const proceedMatch = /Do NOT proceed with steps (\d+)[–-](\d+)/.exec(gateLine!);
+    assert.ok(proceedMatch, "gate must include a 'Do NOT proceed with steps X–Y' clause");
+    assert.ok(
+      Number(proceedMatch![1]) > requirementUpdate - 1 && Number(proceedMatch![2]) >= completeMilestone,
+      `'Do NOT proceed' range ${proceedMatch![1]}–${proceedMatch![2]} must cover steps from after the gate through gsd_complete_milestone (${completeMilestone})`,
+    );
+
+    // "Important" footer references the same verification steps.
+    const importantLine = prompt.split("\n").find(l => l.includes("Do NOT skip code-change"));
+    assert.ok(importantLine, "Important footer is present");
+    assert.ok(
+      importantLine!.includes(`steps ${codeChange}-${defOfDone}`) ||
+        importantLine!.includes(`steps ${codeChange}–${defOfDone}`),
+      `Important footer must cite verification range ${codeChange}-${defOfDone}; got: ${importantLine}`,
+    );
+
+    // On-demand Read ordering line cites the gsd_complete_milestone step.
+    const readOrderLine = prompt.split("\n").find(l => l.includes("On-demand Read ordering"));
+    assert.ok(readOrderLine, "On-demand Read ordering line is present");
+    assert.ok(
+      readOrderLine!.includes(`(step ${completeMilestone})`),
+      `On-demand Read ordering must cite step ${completeMilestone}; got: ${readOrderLine}`,
+    );
+  });
+
+  test("sanitizeCompleteMilestoneParams preserves actorName and triggerReason", async () => {
+    const { sanitizeCompleteMilestoneParams } = await import("../bootstrap/sanitize-complete-milestone.ts");
+
+    const sanitized = sanitizeCompleteMilestoneParams({
+      milestoneId: "M001",
+      title: "T",
+      oneLiner: "x",
+      narrative: "n",
+      verificationPassed: true,
+      actorName: "  executor-01  ",
+      triggerReason: " milestone validation passed ",
+    } as any);
+
+    assert.strictEqual(sanitized.actorName, "executor-01");
+    assert.strictEqual(sanitized.triggerReason, "milestone validation passed");
+  });
+
+  test("sanitizeCompleteMilestoneParams omits blank actorName/triggerReason rather than emitting empty strings", async () => {
+    const { sanitizeCompleteMilestoneParams } = await import("../bootstrap/sanitize-complete-milestone.ts");
+
+    const sanitized = sanitizeCompleteMilestoneParams({
+      milestoneId: "M001",
+      title: "T",
+      oneLiner: "x",
+      narrative: "n",
+      verificationPassed: true,
+      // actorName/triggerReason omitted
+    } as any);
+
+    assert.strictEqual(sanitized.actorName, undefined);
+    assert.strictEqual(sanitized.triggerReason, undefined);
+  });
+
+  test("rendered SUMMARY.md uses placeholder text for empty enrichment fields", async () => {
+    const { handleCompleteMilestone } = await import("../tools/complete-milestone.ts");
+    const base = createFixtureBase();
+    const mid = "M001";
+    const dbPath = join(base, ".gsd", "gsd.db");
+    try {
+      openDatabase(dbPath);
+      insertMilestone({ id: mid, title: "Empty Enrichment", status: "active" });
+      insertSlice({ id: "S01", milestoneId: mid, title: "Slice", status: "complete" });
+      insertTask({ id: "T01", sliceId: "S01", milestoneId: mid, title: "Task", status: "complete" });
+
+      const result = await handleCompleteMilestone({
+        milestoneId: mid,
+        title: "Empty Enrichment",
+        oneLiner: "no enrichment",
+        narrative: "did the thing",
+        // enrichment fields intentionally empty (post-sanitizer state)
+        successCriteriaResults: "",
+        definitionOfDoneResults: "",
+        requirementOutcomes: "",
+        keyDecisions: [],
+        keyFiles: [],
+        lessonsLearned: [],
+        followUps: "",
+        deviations: "",
+        verificationPassed: true,
+      }, base);
+
+      assert.ok(!("error" in result), `handler should succeed: ${JSON.stringify(result)}`);
+      const summary = readFileSync((result as { summaryPath: string }).summaryPath, "utf-8");
+      assert.match(summary, /## Success Criteria Results\n\nNot provided\./);
+      assert.match(summary, /## Definition of Done Results\n\nNot provided\./);
+      assert.match(summary, /## Requirement Outcomes\n\nNot provided\./);
+      assert.match(summary, /## Deviations\n\nNone\./);
+      assert.match(summary, /## Follow-ups\n\nNone\./);
+    } finally {
+      try { closeDatabase(); } catch { /* */ }
+      clearPathCache();
+      clearParseCache();
+      cleanup(base);
+    }
+  });
 });

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

@@ -113,8 +113,9 @@ test("#4782 phase 3: buildCompleteSlicePrompt composes roadmap → plan → task
     "task summaries precede slice-summary template",
   );
 
-  // Task body inlined
-  assert.match(prompt, /Task one did the thing/);
+  // Task summary excerpt is inlined; full narrative remains on-demand.
+  assert.match(prompt, /### Task Summary: T01 \(excerpt\)/);
+  assert.doesNotMatch(prompt, /Task one did the thing/);
 });
 
 test("#4782 phase 3: buildCompleteSlicePrompt handles missing task summaries gracefully", async (t) => {

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));