@opengsd/gsd-pi 1.1.1-dev.b2556262 → 1.2.0-dev.0b870afa

package/src/resources/extensions/gsd/tests/register-hooks-depth-verification.test.ts

@@ -1,6 +1,6 @@
 import test from "node:test";
 import assert from "node:assert/strict";
-import { existsSync, mkdirSync, readFileSync, rmSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 
@@ -13,11 +13,20 @@ import { closeDatabase, getMilestone } from "../gsd-db.ts";
 import { deriveState, invalidateStateCache } from "../state.ts";
 import {
   getPendingGate,
+  loadWriteGateSnapshot,
+  markApprovalGateVerified,
+  markDepthVerified,
   resetWriteGateState,
+  setPendingGate,
   shouldBlockContextArtifactSave,
 } from "../bootstrap/write-gate.ts";
 import { classifyCommand } from "../safety/destructive-guard.ts";
 import { toRoundResultResponse } from "../../remote-questions/manager.ts";
+import {
+  markInteractiveElicitationStart,
+  markInteractiveElicitationEnd,
+  clearInFlightTools,
+} from "../auto-tool-tracking.ts";
 
 function makeTempDir(prefix: string): string {
   const dir = join(
@@ -708,3 +717,335 @@ test("register-hooks gates MCP ask_user_questions cancellation before requiremen
   assert.equal(requirementBlock?.block, true, "requirement save must be blocked while gate is pending");
   assert.match(requirementBlock?.reason ?? "", /has not been confirmed/);
 });
+
+// ─── Foreground self-cancel regression (#cc-elicitation-self-cancel) ───
+// Product-visible symptom: under claude-code-cli + gsd-MCP, ask_user_questions
+// is routed as an SDK elicitation (the human boundary). The message_update hook
+// would arm the approval-gate pause and emit the "waiting for your approval -
+// pausing" notice, tearing down that elicitation and looping a re-ask. The fix
+// makes message_update bail while an interactive elicitation is in flight, while
+// still pausing for prose-only approvals (native-TUI provider, where the marker
+// is always false). This drives the real registered hook end-to-end.
+test("register-hooks message_update does NOT pause while an interactive elicitation is the human boundary, but still pauses otherwise", async (t) => {
+  const dir = makeTempDir("elicitation-pause-guard");
+  const originalCwd = process.cwd();
+  process.chdir(dir);
+  resetWriteGateState(dir);
+  clearPendingAutoStart(dir);
+  clearInFlightTools();
+
+  t.after(() => {
+    try {
+      resetWriteGateState(dir);
+      clearPendingAutoStart(dir);
+      clearInFlightTools();
+    } finally {
+      process.chdir(originalCwd);
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  const handlers = new Map<string, Array<(event: any, ctx?: any) => Promise<any> | any>>();
+  const pi = {
+    on(event: string, handler: (event: any, ctx?: any) => Promise<any> | any) {
+      const existing = handlers.get(event) ?? [];
+      existing.push(handler);
+      handlers.set(event, existing);
+    },
+  } as any;
+
+  const notices: Array<{ text: string; level: string }> = [];
+  const ctx = {
+    cwd: dir,
+    ui: { notify: (text: string, level: string) => notices.push({ text, level }) },
+  } as any;
+
+  registerHooks(pi, []);
+
+  // A discuss-milestone is the active unit, so the approval text would normally
+  // arm the pause/notice path.
+  setPendingAutoStart(dir, {
+    basePath: dir,
+    milestoneId: "M001",
+    ctx,
+    pi: { sendMessage: () => undefined } as any,
+  });
+
+  // The model's plain-text approval question — identical in both phases.
+  const approvalMessage = {
+    role: "assistant",
+    content: [
+      { type: "text", text: "Here is the milestone plan.\n\nDid I capture the project correctly?" },
+    ],
+  };
+
+  const fireMessageUpdate = async () => {
+    for (const handler of handlers.get("message_update") ?? []) {
+      await handler({ message: approvalMessage }, ctx);
+    }
+  };
+
+  // Phase 1 — FIX: an interactive elicitation is in flight (claude-code-cli
+  // foreground). The pause/notice MUST be suppressed.
+  markInteractiveElicitationStart();
+  await fireMessageUpdate();
+  assert.equal(
+    notices.some((n) => /waiting for your approval - pausing/.test(n.text)),
+    false,
+    "must NOT emit the approval-pause notice while the elicitation is the human boundary",
+  );
+  markInteractiveElicitationEnd();
+
+  // Phase 2 — control: no elicitation in flight (native-TUI provider or a
+  // prose-only approval). The same message MUST still pause.
+  notices.length = 0;
+  await fireMessageUpdate();
+  assert.equal(
+    notices.some((n) => /discuss-milestone M001 is waiting for your approval - pausing/.test(n.text)),
+    true,
+    "prose-only approval with no elicitation in flight must still arm the pause notice",
+  );
+});
+
+test("register-hooks agent_end does not re-arm deferred gate after workflow MCP verified write-gate on disk", async (t) => {
+  const dir = makeTempDir("mcp-disk-sync");
+  const originalCwd = process.cwd();
+  const originalEnv = process.env.GSD_PERSIST_WRITE_GATE_STATE;
+  process.chdir(dir);
+  resetWriteGateState(dir);
+  clearPendingAutoStart(dir);
+  process.env.GSD_PERSIST_WRITE_GATE_STATE = "1";
+
+  const gateId = "depth_verification_M005_confirm";
+  const statePath = join(dir, ".gsd", "runtime", "write-gate-state.json");
+
+  t.after(() => {
+    try {
+      resetWriteGateState(dir);
+      clearPendingAutoStart(dir);
+    } finally {
+      if (originalEnv === undefined) {
+        delete process.env.GSD_PERSIST_WRITE_GATE_STATE;
+      } else {
+        process.env.GSD_PERSIST_WRITE_GATE_STATE = originalEnv;
+      }
+      process.chdir(originalCwd);
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  const handlers = new Map<string, Array<(event: any, ctx?: any) => Promise<any> | any>>();
+  const pi = {
+    on(event: string, handler: (event: any, ctx?: any) => Promise<any> | any) {
+      const existing = handlers.get(event) ?? [];
+      existing.push(handler);
+      handlers.set(event, existing);
+    },
+  } as any;
+
+  const ctx = {
+    cwd: dir,
+    ui: { notify: () => undefined },
+  } as any;
+
+  registerHooks(pi, []);
+
+  setPendingAutoStart(dir, {
+    basePath: dir,
+    milestoneId: "M005",
+    ctx,
+    pi: { sendMessage: () => undefined } as any,
+  });
+
+  const approvalMessage = {
+    role: "assistant",
+    content: [
+      { type: "text", text: "Did I capture the depth right?" },
+    ],
+  };
+
+  for (const handler of handlers.get("message_update") ?? []) {
+    await handler({ message: approvalMessage }, ctx);
+  }
+
+  setPendingGate(gateId, dir);
+  mkdirSync(join(dir, ".gsd", "runtime"), { recursive: true });
+  writeFileSync(statePath, JSON.stringify({
+    verifiedDepthMilestones: ["M005"],
+    verifiedApprovalGates: [gateId],
+    activeQueuePhase: false,
+    pendingGateId: null,
+  }, null, 2), "utf-8");
+
+  for (const handler of handlers.get("agent_end") ?? []) {
+    await handler({ messages: [] }, ctx);
+  }
+
+  assert.equal(getPendingGate(dir), null, "agent_end must not re-arm a gate the MCP subprocess already verified");
+  assert.equal(
+    shouldBlockContextArtifactSave("CONTEXT", "M005", null, dir).block,
+    false,
+    "verified milestone context writes must stay unlocked after agent_end",
+  );
+  assert.deepEqual(loadWriteGateSnapshot(dir), {
+    verifiedDepthMilestones: ["M005"],
+    verifiedApprovalGates: [gateId],
+    activeQueuePhase: false,
+    pendingGateId: null,
+  });
+});
+
+// ── External-engine post-hoc gate replay (write-gate two-process sync) ──────
+// On claude-code-cli, pi ingests the SDK turn's tool blocks after the workflow
+// MCP child already executed them. The depth gate can therefore arrive at
+// tool_execution_start AFTER the child verified it and allowed the CONTEXT
+// save; re-arming then wipes the verification and permanently blocks the
+// discuss→auto handoff.
+
+function makeHookHarness(): {
+  handlers: Map<string, Array<(event: any, ctx?: any) => Promise<any> | any>>;
+  pi: any;
+} {
+  const handlers = new Map<string, Array<(event: any, ctx?: any) => Promise<any> | any>>();
+  const pi = {
+    on(event: string, handler: (event: any, ctx?: any) => Promise<any> | any) {
+      const existing = handlers.get(event) ?? [];
+      existing.push(handler);
+      handlers.set(event, existing);
+    },
+  } as any;
+  return { handlers, pi };
+}
+
+test("tool_execution_start does not re-arm a depth gate the MCP child already verified", async (t) => {
+  const dir = makeTempDir("posthoc-no-rearm");
+  resetWriteGateState(dir);
+  t.after(() => {
+    resetWriteGateState(dir);
+    rmSync(dir, { recursive: true, force: true });
+  });
+
+  const { handlers, pi } = makeHookHarness();
+  registerHooks(pi, []);
+  const ctx = { cwd: dir, ui: { notify: () => undefined } } as any;
+
+  // The child verified the gate and allowed the CONTEXT save before the host
+  // ever saw the tool block.
+  markApprovalGateVerified("depth_verification_M002_confirm", dir);
+  markDepthVerified("M002", dir);
+
+  for (const handler of handlers.get("tool_execution_start") ?? []) {
+    await handler({
+      toolCallId: "t-depth",
+      toolName: "mcp__gsd-workflow__ask_user_questions",
+      args: { questions: [{ id: "depth_verification_M002_confirm" }] },
+    }, ctx);
+  }
+
+  assert.equal(getPendingGate(dir), null, "post-hoc replay must not re-arm a verified gate");
+  const snapshot = loadWriteGateSnapshot(dir);
+  assert.ok(
+    snapshot.verifiedDepthMilestones.includes("M002"),
+    "re-arm wipes verifiedDepthMilestones — the verification must survive the replay",
+  );
+  assert.equal(
+    shouldBlockContextArtifactSave("CONTEXT", "M002", null, dir).block,
+    false,
+    "context saves must stay unlocked after the replayed tool_execution_start",
+  );
+});
+
+test("tool_execution_start still arms an unverified depth gate", async (t) => {
+  const dir = makeTempDir("live-arm");
+  resetWriteGateState(dir);
+  t.after(() => {
+    resetWriteGateState(dir);
+    rmSync(dir, { recursive: true, force: true });
+  });
+
+  const { handlers, pi } = makeHookHarness();
+  registerHooks(pi, []);
+  const ctx = { cwd: dir, ui: { notify: () => undefined } } as any;
+
+  for (const handler of handlers.get("tool_execution_start") ?? []) {
+    await handler({
+      toolCallId: "t-depth",
+      toolName: "ask_user_questions",
+      args: { questions: [{ id: "depth_verification_M002_confirm" }] },
+    }, ctx);
+  }
+
+  assert.equal(getPendingGate(dir), "depth_verification_M002_confirm");
+});
+
+test("tool_result verifies the gate from result.structuredContent when event.details is missing", async (t) => {
+  const dir = makeTempDir("structured-fallback");
+  resetWriteGateState(dir);
+  t.after(() => {
+    resetWriteGateState(dir);
+    rmSync(dir, { recursive: true, force: true });
+  });
+
+  const { handlers, pi } = makeHookHarness();
+  registerHooks(pi, []);
+  const ctx = { cwd: dir, ui: { notify: () => undefined } } as any;
+
+  setPendingGate("depth_verification_M002_confirm", dir);
+
+  const questions = [{
+    id: "depth_verification_M002_confirm",
+    options: [
+      { label: "Yes, you got it (Recommended)" },
+      { label: "Not quite — let me clarify" },
+    ],
+  }];
+  for (const handler of handlers.get("tool_result") ?? []) {
+    await handler({
+      toolCallId: "t-depth",
+      toolName: "mcp__gsd-workflow__ask_user_questions",
+      input: { questions },
+      // External MCP relay: no pi-native details, structured payload on result.
+      result: {
+        content: [{ type: "text", text: "answered" }],
+        structuredContent: {
+          questions,
+          response: {
+            answers: {
+              depth_verification_M002_confirm: { selected: "Yes, you got it (Recommended)", notes: "" },
+            },
+          },
+          cancelled: false,
+        },
+      },
+    }, ctx);
+  }
+
+  assert.equal(getPendingGate(dir), null, "structured fallback must clear the pending gate");
+  assert.ok(loadWriteGateSnapshot(dir).verifiedDepthMilestones.includes("M002"));
+});
+
+test("tool_result without details or structured content leaves the gate pending without crashing", async (t) => {
+  const dir = makeTempDir("no-details");
+  resetWriteGateState(dir);
+  t.after(() => {
+    resetWriteGateState(dir);
+    rmSync(dir, { recursive: true, force: true });
+  });
+
+  const { handlers, pi } = makeHookHarness();
+  registerHooks(pi, []);
+  const ctx = { cwd: dir, ui: { notify: () => undefined } } as any;
+
+  setPendingGate("depth_verification_M002_confirm", dir);
+
+  for (const handler of handlers.get("tool_result") ?? []) {
+    await handler({
+      toolCallId: "t-depth",
+      toolName: "ask_user_questions",
+      input: { questions: [{ id: "depth_verification_M002_confirm" }] },
+      result: { content: [{ type: "text", text: "answered" }] },
+    }, ctx);
+  }
+
+  assert.equal(getPendingGate(dir), "depth_verification_M002_confirm");
+});

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

@@ -130,3 +130,68 @@ test("buildResearchMilestonePrompt keeps broad project docs on-demand", async (t
   assert.match(prompt, /`\.gsd\/REQUIREMENTS\.md`/);
   assert.match(prompt, /`\.gsd\/DECISIONS\.md`/);
 });
+
+// ─── ADR-029: preload-authoritative research grounding ────────────────
+
+test("ADR-029: research-milestone inlines project classification + codebase snapshot", async (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  invalidateAllCaches();
+
+  seed(base, "M001");
+  writeFileSync(join(base, ".gsd", "milestones", "M001", "M001-CONTEXT.md"), "# M001 Context\n");
+  // Give the codebase scan something real to sample.
+  writeFileSync(join(base, "index.html"), "<!doctype html><html><body><h1>hi</h1></body></html>\n");
+  writeFileSync(join(base, "script.js"), "const x = 1;\nasync function go() { await x; }\n");
+
+  const prompt = await buildResearchMilestonePrompt("M001", "Research Test", base);
+
+  // Project-size signal (same block plan-milestone gets).
+  assert.match(prompt, /### Project Classification/);
+  assert.match(prompt, /Workflow sizing:/);
+  // Bounded codebase snapshot grounds research in current code reality.
+  assert.match(prompt, /### Codebase Snapshot \(current code reality\)/);
+  assert.match(prompt, /do NOT re-survey the tree/);
+});
+
+test("ADR-029: codebase snapshot is suppressed when discuss_preparation is false", async (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  invalidateAllCaches();
+
+  seed(base, "M001");
+  writeFileSync(join(base, ".gsd", "milestones", "M001", "M001-CONTEXT.md"), "# M001 Context\n");
+  writeFileSync(join(base, ".gsd", "PREFERENCES.md"), "---\ndiscuss_preparation: false\n---\n");
+  invalidateAllCaches();
+
+  const prompt = await buildResearchMilestonePrompt("M001", "Research Test", base);
+
+  // Snapshot opt-out honored; classification (unconditional) still present.
+  assert.doesNotMatch(prompt, /### Codebase Snapshot/);
+  assert.match(prompt, /### Project Classification/);
+});
+
+test("ADR-029: prior partial RESEARCH is inlined as a resume block; absent otherwise", async (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  invalidateAllCaches();
+
+  seed(base, "M001");
+  writeFileSync(join(base, ".gsd", "milestones", "M001", "M001-CONTEXT.md"), "# M001 Context\n");
+
+  // No prior research yet → no resume block. (Match the rendered block heading,
+  // not the bare phrase — step 8 of the template references the phrase by name.)
+  const before = await buildResearchMilestonePrompt("M001", "Research Test", base);
+  assert.doesNotMatch(before, /### Resume — Prior Partial Research \(continue, do not redo\)/);
+
+  // A partial RESEARCH draft from a prior (interrupted) attempt.
+  writeFileSync(
+    join(base, ".gsd", "milestones", "M001", "M001-RESEARCH.md"),
+    "# Research\n\n## Findings\n\nPartial finding: the app is a static site.\n",
+  );
+  invalidateAllCaches();
+
+  const after = await buildResearchMilestonePrompt("M001", "Research Test", base);
+  assert.match(after, /Resume — Prior Partial Research \(continue, do not redo\)/);
+  assert.match(after, /Partial finding: the app is a static site/);
+});

package/src/resources/extensions/gsd/tests/roadmap-parse-regression.test.ts

@@ -396,4 +396,44 @@ test('T. #1736: Checkbox format unchanged', () => {
     assert.deepStrictEqual(slices[1].done, false, '#1736 checkbox compat: S02 not done');
 });
 
+// ═══════════════════════════════════════════════════════════════════════
+// U. Regression #566: double-bracket depends serialization recovery
+// ═══════════════════════════════════════════════════════════════════════
+test('U. #566: double-bracket depends:[[S01]] recovers to ["S01"]', () => {
+    // Simulates a roadmap written by markdown-renderer when the DB had
+    // depends=["[S01]"] — produces `depends:[[S01]]` on disk.
+    const content = [
+      '# M020: Corrupted Depends',
+      '',
+      '## Slices',
+      '',
+      '- [ ] **S01: Foundation** `risk:low` `depends:[]`',
+      '- [ ] **S02: Build** `risk:medium` `depends:[[S01]]`',
+      '- [ ] **S03: Ship** `risk:high` `depends:[[S01, S02]]`',
+      '',
+    ].join('\n');
+
+    const slices = parseRoadmapSlices(content);
+    assert.deepStrictEqual(slices.length, 3, '#566 double-bracket: 3 slices');
+    assert.deepStrictEqual(slices[1].depends, ['S01'], '#566: S02 depends recovered to ["S01"]');
+    assert.deepStrictEqual(slices[2].depends, ['S01', 'S02'], '#566: S03 depends recovered to ["S01","S02"]');
+});
+
+test('U. #566: bracket-wrapped single element depends:[[S01]] recovers to ["S01"]', () => {
+    // Simulates the exact DB corruption seen in the forensic evidence: depends=["[S01]"]
+    const content = [
+      '# M020: Single Bracket Corruption',
+      '',
+      '## Slices',
+      '',
+      '- [ ] **S01: First** `risk:low` `depends:[]`',
+      '- [ ] **S02: Second** `risk:medium` `depends:[[S01]]`',
+      '',
+    ].join('\n');
+
+    const slices = parseRoadmapSlices(content);
+    assert.deepStrictEqual(slices[1].depends.length, 1, '#566 single: S02 has exactly 1 dep');
+    assert.deepStrictEqual(slices[1].depends[0], 'S01', '#566 single: dep is "S01" not "[S01]"');
+});
+
 });

package/src/resources/extensions/gsd/tests/roadmap-slices.test.ts

@@ -200,6 +200,74 @@ test("parseRoadmapSlices: checkbox slices with pipe characters do not switch to
   assert.deepEqual(slices[2]?.depends, ["S01", "S02"]);
 });
 
+test("parseRoadmapSlices: demo markdown table does not switch checkbox roadmap to table mode (#721)", () => {
+  const checkboxWithDemoTable = [
+    "# M004: Demo Table Repro",
+    "",
+    "## Slices",
+    "",
+    "- [x] **S01: First** `risk:low` `depends:[]`",
+    "  > After this: cli can render examples:",
+    "| Example | Meaning |",
+    "| --- | --- |",
+    "| S01 | Not a roadmap row |",
+    "- [ ] **S02: Second** `risk:medium` `depends:[S01]`",
+    "  > After this: cat file | sort returns stable output.",
+    "",
+  ].join("\n");
+
+  const slices = parseRoadmapSlices(checkboxWithDemoTable);
+  assert.equal(slices.length, 2);
+  assert.equal(slices[0]?.id, "S01");
+  assert.equal(slices[0]?.title, "First");
+  assert.equal(slices[0]?.done, true);
+  assert.equal(slices[1]?.id, "S02");
+  assert.deepEqual(slices[1]?.depends, ["S01"]);
+});
+
+test("parseRoadmapSlices: table preceded by intro prose still parsed as table (#722)", () => {
+  const tableWithIntro = [
+    "# M005: Intro Before Table",
+    "",
+    "## Slices",
+    "",
+    "This milestone is broken into the following slices:",
+    "",
+    "| Slice | Title | Risk | Status |",
+    "| --- | --- | --- | --- |",
+    "| S01 | Foundation | Low | [x] Done |",
+    "| S02 | Core | High | [ ] Pending |",
+    "",
+  ].join("\n");
+
+  const slices = parseRoadmapSlices(tableWithIntro);
+  assert.equal(slices.length, 2);
+  assert.equal(slices[0]?.id, "S01");
+  assert.equal(slices[0]?.done, true);
+  assert.equal(slices[1]?.id, "S02");
+  assert.equal(slices[1]?.done, false);
+});
+
+test("parseRoadmapSlices: table without markdown separator row still parsed as table (#722)", () => {
+  const tableWithoutSeparator = [
+    "# M006: No Separator",
+    "",
+    "## Slices",
+    "",
+    "| Slice | Title | Risk | Status |",
+    "| S01 | Foundation | Low | [x] Done |",
+    "| S02 | Core | High | [ ] Pending |",
+    "",
+  ].join("\n");
+
+  const slices = parseRoadmapSlices(tableWithoutSeparator);
+  assert.equal(slices.length, 2);
+  assert.equal(slices[0]?.id, "S01");
+  assert.equal(slices[0]?.done, true);
+  assert.equal(slices[1]?.id, "S02");
+  assert.equal(slices[1]?.done, false);
+});
+
 // --- Prose slice header completion marker tests (#1803) ---
 
 test("parseRoadmapSlices: prose headers with ✓ marker detected as done", () => {

package/src/resources/extensions/gsd/tests/runtime-invariant-modules.test.ts

@@ -6,7 +6,11 @@ import assert from "node:assert/strict";
 
 import { classifyFailure } from "../recovery-classification.js";
 import { reconcileBeforeDispatch } from "../state-reconciliation.js";
-import { compileUnitToolContract } from "../tool-contract.js";
+import {
+  compileUnitContextContract,
+  compileUnitToolContract,
+  getUnitWorkflowDispatchReadinessError,
+} from "../tool-contract.js";
 import { shouldBlockAutoUnitToolCall } from "../auto-unit-tool-scope.js";
 import type { GSDState } from "../types.js";
 
@@ -68,6 +72,16 @@ test("Tool Contract compiles known Unit prompt and tool policy", () => {
   assert.equal(result.ok && result.contract.toolsPolicy.mode, "all");
   assert.ok(result.ok && result.contract.validationRules.includes("closeout-tool-present"));
   assert.ok(result.ok && result.contract.validationRules.includes("source-observation-contract-present"));
+  assert.deepEqual(result.ok && result.contract.promptContext.artifacts.inline, [
+    "task-plan",
+    "slice-plan",
+    "prior-task-summaries",
+    "templates",
+  ]);
+  assert.deepEqual(result.ok && result.contract.promptContext.artifacts.onDemand, ["slice-research"]);
+  assert.ok(result.ok && result.contract.promptObligations.includes("context-inline:task-plan,slice-plan,prior-task-summaries,templates"));
+  assert.ok(result.ok && result.contract.promptObligations.includes("context-on-demand:slice-research"));
+  assert.ok(result.ok && result.contract.promptObligations.includes("source-observations:whole-file-active-unit"));
   assert.deepEqual(result.ok && result.contract.sourceObservations, {
     mode: "whole-file-active-unit",
     seedFields: ["task.files", "task.inputs"],
@@ -77,6 +91,34 @@ test("Tool Contract compiles known Unit prompt and tool policy", () => {
   });
 });
 
+test("Tool Contract derives dispatch readiness from Unit workflow tools", () => {
+  const error = getUnitWorkflowDispatchReadinessError({
+    provider: "claude-code",
+    unitType: "plan-slice",
+    projectRoot: "/tmp/project",
+    env: { GSD_WORKFLOW_MCP_COMMAND: "node" },
+    surface: "auto-mode",
+    authMode: "externalCli",
+    baseUrl: "local://claude-code",
+  });
+
+  assert.equal(error, null);
+});
+
+test("Unit Context Contract exposes prompt context without workflow tool surface", () => {
+  const result = compileUnitContextContract("execute-task");
+
+  assert.equal(result.ok, true);
+  assert.equal(result.ok && result.contract.unitType, "execute-task");
+  assert.equal(result.ok && result.contract.contextMode, "execution");
+  assert.equal(result.ok && result.contract.toolsPolicy.mode, "all");
+  assert.deepEqual(result.ok && result.contract.artifacts.excerpt, []);
+  assert.deepEqual(result.ok && result.contract.artifacts.computed, []);
+  assert.deepEqual(result.ok && result.contract.artifacts.prepend, []);
+  assert.equal(result.ok && result.contract.maxSystemPromptChars, 1_500_000);
+  assert.equal(result.ok && result.contract.sourceObservations.mode, "whole-file-active-unit");
+});
+
 test("Tool Contract records high-risk cross-phase tool boundaries without single-owning every tool", () => {
   const completeSlice = compileUnitToolContract("complete-slice");
   const runUat = compileUnitToolContract("run-uat");
@@ -140,6 +182,7 @@ test("Recovery Classification covers ADR-015 failure families", () => {
   const cases = [
     ["invalid tool schema enum", "tool-schema", "stop"],
     ["Tool Contract failure: complete-slice cannot use gsd_uat_result_save", "tool-contract", "stop"],
+    ["No such tool available: mcp__gsd-workflow__gsd_uat_exec", "tool-unavailable", "retry"],
     ["deterministic policy rejection", "deterministic-policy", "stop"],
     ["cannot legally advance because required UAT Assessment artifact is missing", "lifecycle-progression", "stop"],
     ["stale worker lease", "stale-worker", "stop"],

package/src/resources/extensions/gsd/tests/safety-harness-false-positives.test.ts

@@ -266,3 +266,41 @@ test("safety-harness: planned changed file avoids unexpected-file warning", (t)
   assert.deepEqual(audit!.unexpectedFiles, [], "planned index.html must not be unexpected");
   assert.deepEqual(audit!.missingFiles, [], "planned index.html must not be missing");
 });
+
+// ─── External engine evidence (claude-code-cli pre-executed tools) ──────────
+// External engines skip beforeToolCall/tool_call, so register-hooks.ts records
+// evidence at tool_execution_start instead. These tests lock the collector
+// semantics that wiring relies on: idempotent recording by toolCallId, and
+// capitalized external tool names (Bash/Write/Edit) being recognized.
+
+test("safety-harness: recordToolCall is idempotent by toolCallId", () => {
+  resetEvidence();
+
+  // Native tools fire tool_execution_start AND tool_call — both record.
+  recordToolCall("tc-dup-1", "bash", { command: "npm test" });
+  recordToolCall("tc-dup-1", "bash", { command: "npm test" });
+
+  assert.equal(getEvidence().length, 1, "same toolCallId must not duplicate");
+});
+
+test("safety-harness: external capitalized Bash call records and resolves evidence", () => {
+  resetEvidence();
+
+  // tool_execution_start with Claude Code's native tool name
+  recordToolCall("ext-bash-1", "Bash", { command: "node /tmp/t01-verify.mjs" });
+  const entries = getEvidence().filter((e): e is BashEvidence => e.kind === "bash");
+  assert.equal(entries.length, 1, "capitalized Bash must be recognized as execution tool");
+  assert.equal(entries[0]!.command, "node /tmp/t01-verify.mjs");
+
+  // tool_execution_end fills the result
+  recordToolResult("ext-bash-1", "Bash", { content: [{ type: "text", text: "13 checks passed" }] }, false);
+  assert.equal(entries[0]!.exitCode, 0, "non-error external result resolves to exitCode 0");
+});
+
+test("safety-harness: external Write call records file evidence", () => {
+  resetEvidence();
+
+  recordToolCall("ext-write-1", "Write", { file_path: "/tmp/app/index.html" });
+  const writes = getEvidence().filter((e) => e.kind === "write");
+  assert.equal(writes.length, 1, "capitalized Write must record file evidence");
+});