@opengsd/gsd-pi 1.4.0 → 1.5.0

package/src/resources/extensions/gsd/tests/schedule-wakeup-tool.test.ts

@@ -0,0 +1,167 @@
+// Project/App: gsd-pi
+// File Purpose: Regression tests for ScheduleWakeup tool behavior.
+
+import test, { mock } from "node:test";
+import assert from "node:assert/strict";
+
+import { autoSession } from "../auto-runtime-state.ts";
+import {
+  registerScheduleWakeupTool,
+  _resetInteractiveWakeupsForTest,
+} from "../bootstrap/schedule-wakeup-tool.ts";
+
+test("ScheduleWakeup arms an interactive wakeup when auto-mode is inactive", async () => {
+  autoSession.reset();
+  _resetInteractiveWakeupsForTest();
+  mock.timers.enable({ apis: ["setTimeout"] });
+
+  const sent: Array<{ message: unknown; options: unknown }> = [];
+  let tool: any;
+  const pi = {
+    registerTool(registered: any) {
+      tool = registered;
+    },
+    sendMessage(message: unknown, options: unknown) {
+      sent.push({ message, options });
+    },
+  };
+
+  try {
+    registerScheduleWakeupTool(pi as any);
+    assert.ok(tool, "ScheduleWakeup tool should be registered");
+
+    const result = await tool.execute(
+      "call-1",
+      {
+        delaySeconds: 1,
+        prompt: "Check the external job and report back.",
+        reason: "poll external job",
+      },
+      undefined,
+      undefined,
+      { cwd: process.cwd() },
+    );
+
+    assert.equal(result.isError, undefined);
+    assert.match(result.content[0].text, /Wakeup scheduled for 1s/);
+    assert.equal(sent.length, 0, "wakeup should not dispatch synchronously");
+
+    mock.timers.tick(999);
+    assert.equal(sent.length, 0, "wakeup should wait for the configured delay");
+
+    mock.timers.tick(1);
+    assert.equal(sent.length, 1);
+    assert.deepEqual(sent[0].options, { triggerTurn: true });
+    assert.deepEqual(sent[0].message, {
+      customType: "gsd-schedule-wakeup",
+      content: "Check the external job and report back.",
+      display: true,
+      details: {
+        delaySeconds: 1,
+        reason: "poll external job",
+      },
+    });
+  } finally {
+    mock.timers.reset();
+    _resetInteractiveWakeupsForTest();
+    autoSession.reset();
+  }
+});
+
+test("ScheduleWakeup re-arm cancels the prior interactive timer instead of stacking", async () => {
+  autoSession.reset();
+  _resetInteractiveWakeupsForTest();
+  mock.timers.enable({ apis: ["setTimeout"] });
+
+  const sent: Array<{ message: any; options: unknown }> = [];
+  let tool: any;
+  const pi = {
+    registerTool(registered: any) {
+      tool = registered;
+    },
+    sendMessage(message: unknown, options: unknown) {
+      sent.push({ message, options } as { message: any; options: unknown });
+    },
+  };
+
+  try {
+    registerScheduleWakeupTool(pi as any);
+    assert.ok(tool, "ScheduleWakeup tool should be registered");
+
+    const ctx = { cwd: process.cwd() };
+    await tool.execute(
+      "call-1",
+      { delaySeconds: 5, prompt: "stale prompt", reason: "first arm" },
+      undefined,
+      undefined,
+      ctx,
+    );
+    await tool.execute(
+      "call-2",
+      { delaySeconds: 5, prompt: "fresh prompt", reason: "re-arm" },
+      undefined,
+      undefined,
+      ctx,
+    );
+
+    mock.timers.tick(5000);
+
+    assert.equal(sent.length, 1, "re-arming must not stack overlapping wakeups");
+    assert.equal(sent[0].message.content, "fresh prompt");
+  } finally {
+    mock.timers.reset();
+    _resetInteractiveWakeupsForTest();
+    autoSession.reset();
+  }
+});
+
+test("ScheduleWakeup keeps interactive wakeups isolated per session base path", async () => {
+  autoSession.reset();
+  _resetInteractiveWakeupsForTest();
+  mock.timers.enable({ apis: ["setTimeout"] });
+
+  const sent: Array<{ message: any; options: unknown }> = [];
+  let tool: any;
+  const pi = {
+    registerTool(registered: any) {
+      tool = registered;
+    },
+    sendMessage(message: unknown, options: unknown) {
+      sent.push({ message, options } as { message: any; options: unknown });
+    },
+  };
+
+  try {
+    registerScheduleWakeupTool(pi as any);
+    assert.ok(tool, "ScheduleWakeup tool should be registered");
+
+    // Two concurrent interactive sessions (different cwds) arm wakeups. One
+    // session re-arming must not cancel the other session's pending wakeup.
+    await tool.execute(
+      "call-a",
+      { delaySeconds: 5, prompt: "session A", reason: "poll A" },
+      undefined,
+      undefined,
+      { cwd: "/tmp" },
+    );
+    await tool.execute(
+      "call-b",
+      { delaySeconds: 5, prompt: "session B", reason: "poll B" },
+      undefined,
+      undefined,
+      { cwd: process.cwd() },
+    );
+
+    mock.timers.tick(5000);
+
+    assert.equal(sent.length, 2, "distinct sessions must each keep their wakeup");
+    assert.deepEqual(
+      sent.map((s) => s.message.content).sort(),
+      ["session A", "session B"],
+    );
+  } finally {
+    mock.timers.reset();
+    _resetInteractiveWakeupsForTest();
+    autoSession.reset();
+  }
+});

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

@@ -18,6 +18,7 @@
 import { mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
+import { verifyExpectedArtifact } from "../auto-recovery.ts";
 import { recoverTimedOutUnit, type RecoveryContext } from "../auto-timeout-recovery.ts";
 import { closeDatabase, insertMilestone, insertSlice, insertTask, openDatabase } from "../gsd-db.ts";
 import { test } from 'node:test';
@@ -167,6 +168,54 @@ function makeRecordingCtx() {
   }
 }
 
+// ═══ plan-slice verification accepts completed task summaries ═══════════════
+
+{
+  console.log("\n=== plan-slice verification accepts completed task summaries ===");
+  const base = mkdtempSync(join(tmpdir(), "gsd-plan-slice-complete-summary-"));
+  const sliceDir = join(base, ".gsd", "milestones", "M001", "slices", "S05");
+  const tasksDir = join(sliceDir, "tasks");
+  mkdirSync(tasksDir, { recursive: true });
+
+  try {
+    openDatabase(join(base, ".gsd", "gsd.db"));
+    insertMilestone({ id: "M001", title: "Milestone", status: "active" });
+    insertSlice({ id: "S05", milestoneId: "M001", title: "Slice", status: "in_progress" });
+    insertTask({ id: "T01", milestoneId: "M001", sliceId: "S05", title: "Done 1", status: "complete" });
+    insertTask({ id: "T02", milestoneId: "M001", sliceId: "S05", title: "Done 2", status: "complete" });
+    insertTask({ id: "T03", milestoneId: "M001", sliceId: "S05", title: "Pending 1", status: "pending" });
+    insertTask({ id: "T04", milestoneId: "M001", sliceId: "S05", title: "Pending 2", status: "pending" });
+    writeFileSync(
+      join(sliceDir, "S05-PLAN.md"),
+      [
+        "# S05: Slice",
+        "",
+        "## Tasks",
+        "",
+        "- [x] **T01: Done 1** `est:10m`",
+        "- [x] **T02: Done 2** `est:10m`",
+        "- [ ] **T03: Pending 1** `est:10m`",
+        "- [ ] **T04: Pending 2** `est:10m`",
+        "",
+      ].join("\n"),
+      "utf-8",
+    );
+    writeFileSync(join(tasksDir, "T01-SUMMARY.md"), "# T01 Summary\n", "utf-8");
+    writeFileSync(join(tasksDir, "T02-SUMMARY.md"), "# T02 Summary\n", "utf-8");
+    writeFileSync(join(tasksDir, "T03-PLAN.md"), "# T03 Plan\n", "utf-8");
+    writeFileSync(join(tasksDir, "T04-PLAN.md"), "# T04 Plan\n", "utf-8");
+
+    assert.equal(
+      verifyExpectedArtifact("plan-slice", "M001/S05", base),
+      true,
+      "completed DB tasks should be accounted for by SUMMARY files",
+    );
+  } finally {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  }
+}
+
 // ═══ #1855: valid RecoveryContext does not crash ═════════════════════════════
 
 {

package/src/resources/extensions/gsd/tests/state-corruption-2945.test.ts

@@ -312,7 +312,7 @@ describe("#2945 Bug 3: mergeAndExit must teardown worktree after successful merg
       } as unknown as AutoSession;
 
       const deps = {
-        mergeMilestoneToMain: () => ({ pushed: false, codeFilesChanged: true }),
+        mergeMilestone: () => ({ pushed: false, codeFilesChanged: true }),
         worktreeProjection: new WorktreeStateProjection(),
         gitServiceFactory: () => ({}) as unknown as ReturnType<
           import("../worktree-lifecycle.js").WorktreeLifecycleDeps["gitServiceFactory"]

package/src/resources/extensions/gsd/tests/status-per-repo.test.ts

@@ -0,0 +1,94 @@
+/**
+ * status-per-repo.test.ts — `/gsd status` per-repository git-health block (#818).
+ *
+ * Covers the parent-workspace addition to formatTextStatus:
+ *   - parent mode with child repos → "Repositories:" section listing each
+ *   - dirty vs clean markers
+ *   - single-repo (project-mode) project → no Repositories section
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { execFileSync } from "node:child_process";
+
+import { formatTextStatus } from "../commands/handlers/core.ts";
+import type { GSDState } from "../types.ts";
+
+function gitInit(cwd: string): void {
+  execFileSync("git", ["init"], { cwd, stdio: "ignore" });
+}
+
+function makeBaseState(): GSDState {
+  return {
+    activeMilestone: null,
+    activeSlice: null,
+    activeTask: null,
+    phase: "planning",
+    recentDecisions: [],
+    blockers: [],
+    nextAction: "None",
+    registry: [],
+  };
+}
+
+function writeParentPrefs(base: string, repos: Record<string, { path: string; role?: string }>): void {
+  const repoLines = Object.entries(repos)
+    .map(([id, cfg]) => `    ${id}:\n      path: ${cfg.path}${cfg.role ? `\n      role: ${cfg.role}` : ""}`)
+    .join("\n");
+  writeFileSync(
+    join(base, ".gsd", "PREFERENCES.md"),
+    `---\nversion: 1\nworkspace:\n  mode: parent\n  repositories:\n${repoLines}\n---\n`,
+    "utf-8",
+  );
+}
+
+test("formatTextStatus shows a Repositories section for a clean parent workspace", () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-status-repo-clean-"));
+  try {
+    mkdirSync(join(base, ".gsd"), { recursive: true });
+    gitInit(base);
+    mkdirSync(join(base, "frontend"), { recursive: true });
+    gitInit(join(base, "frontend"));
+    writeParentPrefs(base, { frontend: { path: "frontend", role: "web UI" } });
+
+    const out = formatTextStatus(makeBaseState(), base);
+    assert.match(out, /Repositories:/);
+    assert.match(out, /✓ frontend — web UI \(clean\)/);
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("formatTextStatus marks a dirty child repo with ✗", () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-status-repo-dirty-"));
+  try {
+    mkdirSync(join(base, ".gsd"), { recursive: true });
+    gitInit(base);
+    mkdirSync(join(base, "backend"), { recursive: true });
+    gitInit(join(base, "backend"));
+    writeParentPrefs(base, { backend: { path: "backend" } });
+    // Make the backend repo dirty.
+    writeFileSync(join(base, "backend", "README.md"), "# dirty\n", "utf-8");
+
+    const out = formatTextStatus(makeBaseState(), base);
+    assert.match(out, /✗ backend \(uncommitted changes\)/);
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("formatTextStatus omits the Repositories section for single-repo projects", () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-status-repo-single-"));
+  try {
+    mkdirSync(join(base, ".gsd"), { recursive: true });
+    gitInit(base);
+    // No workspace config → project mode (default).
+    const out = formatTextStatus(makeBaseState(), base);
+    assert.doesNotMatch(out, /Repositories:/);
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});

package/src/resources/extensions/gsd/tests/token-tool-gating.test.ts

@@ -552,6 +552,41 @@ test("discuss-milestone dispatch keeps required headless milestone tools after t
   assert.ok(!activeTools.includes("gsd_complete_milestone"));
 });
 
+test("#1157: validate-milestone dispatch surface removes generic write and bash tools", () => {
+  const result = buildMinimalAutoGsdToolSet([
+    "ask_user_questions",
+    "bash",
+    "bg_shell",
+    "edit",
+    "find",
+    "glob",
+    "grep",
+    "ls",
+    "read",
+    "subagent",
+    "write",
+    "gsd_exec",
+    "gsd_exec_search",
+    "gsd_resume",
+    "gsd_milestone_status",
+    "gsd_validate_milestone",
+    "gsd_reassess_roadmap",
+  ], "validate-milestone");
+
+  assert.ok(result.includes("read"));
+  assert.ok(result.includes("find"));
+  assert.ok(result.includes("subagent"));
+  assert.ok(result.includes("gsd_validate_milestone"));
+  assert.ok(result.includes("gsd_milestone_status"));
+  assert.ok(result.includes("gsd_exec"));
+  assert.ok(result.includes("gsd_reassess_roadmap"));
+  assert.ok(!result.includes("bash"));
+  assert.ok(!result.includes("bg_shell"));
+  assert.ok(!result.includes("write"));
+  assert.ok(!result.includes("edit"));
+  assert.ok(!result.includes("ask_user_questions"));
+});
+
 test("scopeGsdWorkflowToolsForDispatch applies and restores per-unit skill visibility", () => {
   const calls: Array<{ kind: "tools" | "skills"; value: string[] | undefined }> = [];
   let activeTools = [

package/src/resources/extensions/gsd/tests/tool-call-loop-guard.test.ts

@@ -385,3 +385,66 @@ console.log('\n── Loop guard: block reasons tell model to respond in text
 }
 
 // ═══════════════════════════════════════════════════════════════════════════
+// Distinct-arg browser-automation calls are a legitimate UAT, not a loop (#1120)
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n── Loop guard: distinct-arg browser automation calls are not capped by per-tool count (#1120) ──');
+
+{
+  // A browser-backed UAT legitimately calls one browser verb many times with
+  // DIFFERENT arguments (read a validation message, count staged edits, inspect
+  // a control card, …). Guard 1's identical-signature streak never trips because
+  // the args vary; Guard 2's arg-independent per-tool cap must NOT block it.
+  for (const toolName of ['browser_evaluate', 'browser_act', 'browser_find']) {
+    resetToolCallLoopGuard();
+    for (let i = 1; i <= 12; i++) {
+      const result = checkToolCallLoop(toolName, { script: `step ${i}` });
+      assert.ok(result.block === false, `distinct ${toolName} call ${i} should be allowed`);
+    }
+  }
+
+  // MCP-prefixed browser tools canonicalize to `browser_*` and are exempt too.
+  resetToolCallLoopGuard();
+  for (let i = 1; i <= 12; i++) {
+    const result = checkToolCallLoop('mcp__agent-browser__browser_evaluate', { script: `step ${i}` });
+    assert.ok(result.block === false, `distinct MCP-prefixed browser_evaluate call ${i} should be allowed`);
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Identical-arg browser loops are STILL caught by Guard 1 (#1120)
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n── Loop guard: identical-arg browser loops are still caught by Guard 1 (#1120) ──');
+
+{
+  resetToolCallLoopGuard();
+  for (let i = 1; i <= 4; i++) {
+    const result = checkToolCallLoop('browser_evaluate', { script: 'document.title' });
+    assert.ok(result.block === false, `identical browser_evaluate call ${i} should be allowed`);
+  }
+  const blocked = checkToolCallLoop('browser_evaluate', { script: 'document.title' });
+  assert.ok(blocked.block === true, '5th identical browser_evaluate call should be blocked by Guard 1');
+  assert.ok(blocked.reason?.includes('identical args'), 'identical browser loops should be caught by Guard 1, not Guard 2');
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// The browser exemption must NOT widen to other non-exempt tools (#1120)
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n── Loop guard: browser exemption does not widen to other tools (#1120) ──');
+
+{
+  // Negative invariant: an arbitrary non-exempt, non-browser tool called past
+  // the default cap with varied args must still be blocked by Guard 2.
+  resetToolCallLoopGuard();
+  for (let i = 1; i <= 6; i++) {
+    const result = checkToolCallLoop('some_workflow_tool', { arg: `v${i}` });
+    assert.ok(result.block === false, `non-exempt tool call ${i} should be allowed`);
+  }
+  const blocked = checkToolCallLoop('some_workflow_tool', { arg: 'v7' });
+  assert.ok(blocked.block === true, '7th varied-arg non-exempt call must still trip Guard 2');
+  assert.ok(blocked.reason?.includes('repeated tool'), 'non-exempt overflow should be caught by Guard 2');
+}
+
+// ═══════════════════════════════════════════════════════════════════════════

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

@@ -268,7 +268,7 @@ test("#4934: every manifest declares a tools policy", () => {
 });
 
 test("#4934: tools.mode is one of the declared policies", () => {
-  const validModes = new Set(["all", "read-only", "planning", "planning-dispatch", "docs", "verification"]);
+  const validModes = new Set(["all", "read-only", "planning", "planning-dispatch", "docs", "verification", "workflow-only"]);
   for (const [unitType, manifest] of Object.entries(UNIT_MANIFESTS)) {
     const mode = (manifest as { tools: { mode: string } }).tools.mode;
     assert.ok(
@@ -327,23 +327,71 @@ test("#5453: complete-milestone uses all tools so bash verification is not plann
   }
 });
 
-test("#5731: validate-milestone and complete-slice use all tools so closeout verification is not planning-dispatch blocked", () => {
-  for (const unitType of ["validate-milestone", "complete-slice"] as const) {
-    const manifest = UNIT_MANIFESTS[unitType];
-    assert.strictEqual(manifest.tools.mode, "all");
-    const result = shouldBlockPlanningUnit(
-      "bash",
-      "go test -short -count=1 ./...",
-      process.cwd(),
-      unitType,
-      manifest.tools,
-    );
-    assert.strictEqual(
-      result.block,
-      false,
-      `${unitType} must allow verification bash commands: ${result.reason}`,
-    );
-  }
+test("#5731: complete-slice uses all tools so closeout verification is not planning-dispatch blocked", () => {
+  const manifest = UNIT_MANIFESTS["complete-slice"];
+  assert.strictEqual(manifest.tools.mode, "all");
+  const result = shouldBlockPlanningUnit(
+    "bash",
+    "go test -short -count=1 ./...",
+    process.cwd(),
+    "complete-slice",
+    manifest.tools,
+  );
+  assert.strictEqual(
+    result.block,
+    false,
+    `complete-slice must allow verification bash commands: ${result.reason}`,
+  );
+});
+
+test("#1157: validate-milestone uses workflow-only tools and blocks manual artifact writes", () => {
+  const manifest = UNIT_MANIFESTS["validate-milestone"];
+  assert.strictEqual(manifest.tools.mode, "workflow-only");
+  assert.deepEqual(resolveSubagentPermissionContract("validate-milestone"), {
+    allowed: true,
+    allowedSubagents: ["reviewer", "security", "tester"],
+    toolsMode: "workflow-only",
+  });
+
+  const validationWrite = shouldBlockPlanningUnit(
+    "write",
+    ".gsd/milestones/M001/M001-VALIDATION.md",
+    process.cwd(),
+    "validate-milestone",
+    manifest.tools,
+  );
+  assert.strictEqual(validationWrite.block, true);
+  assert.match(validationWrite.reason!, /workflow-only/);
+  assert.match(validationWrite.reason!, /direct artifact writes are disabled/);
+
+  const bash = shouldBlockPlanningUnit(
+    "bash",
+    "npm test",
+    process.cwd(),
+    "validate-milestone",
+    manifest.tools,
+  );
+  assert.strictEqual(bash.block, true);
+  assert.match(bash.reason!, /bash is not permitted/);
+
+  const validateTool = shouldBlockPlanningUnit(
+    "gsd_validate_milestone",
+    "",
+    process.cwd(),
+    "validate-milestone",
+    manifest.tools,
+  );
+  assert.strictEqual(validateTool.block, false);
+
+  const reviewer = shouldBlockPlanningUnit(
+    "subagent",
+    "",
+    process.cwd(),
+    "validate-milestone",
+    manifest.tools,
+    ["reviewer"],
+  );
+  assert.strictEqual(reviewer.block, false, reviewer.reason);
 });
 
 test("#5843: run-uat uses verification tools policy so build/test commands can run", () => {

package/src/resources/extensions/gsd/tests/unit-registry.test.ts

@@ -7,6 +7,8 @@
 
 import test from "node:test";
 import assert from "node:assert/strict";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
 
 import {
   KNOWN_UNIT_TYPES,
@@ -15,6 +17,7 @@ import {
   SECTION_CLOSE_GATE_UNIT_TYPES,
   getUnitDescriptor,
   getUnitPhaseChain,
+  getUnitPromptTemplate,
 } from "../unit-registry.ts";
 import {
   AUTO_UNIT_SCOPED_TOOLS,
@@ -96,6 +99,37 @@ const EXPECTED_PHASE_CHAINS: Record<string, string[] | undefined> = {
   "no-such-unit": undefined,
 };
 
+const EXPECTED_DIRECT_PROMPT_TEMPLATES: Record<string, string> = {
+  "research-milestone": "research-milestone",
+  "plan-milestone": "plan-milestone",
+  "validate-milestone": "validate-milestone",
+  "complete-milestone": "complete-milestone",
+  "research-slice": "research-slice",
+  "plan-slice": "plan-slice",
+  "refine-slice": "refine-slice",
+  "replan-slice": "replan-slice",
+  "complete-slice": "complete-slice",
+  "reassess-roadmap": "reassess-roadmap",
+  "execute-task": "execute-task",
+  "reactive-execute": "reactive-execute",
+  "run-uat": "run-uat",
+  "gate-evaluate": "gate-evaluate",
+  "rewrite-docs": "rewrite-docs",
+  "workflow-preferences": "guided-workflow-preferences",
+  "discuss-project": "guided-discuss-project",
+  "discuss-requirements": "guided-discuss-requirements",
+  "research-decision": "guided-research-decision",
+  "research-project": "guided-research-project",
+};
+
+const EXPECTED_UNDECLARED_PROMPT_TEMPLATE_TYPES = [
+  "discuss-milestone",
+  "discuss-slice",
+  "execute-task-simple",
+  "triage-captures",
+  "quick-task",
+];
+
 // ─── Derived-view parity ──────────────────────────────────────────────────
 
 test("KNOWN_UNIT_TYPES derives exactly the pre-registry list, in order", () => {
@@ -134,6 +168,28 @@ test("phaseChainForUnit matches the pre-registry switch for every known input",
   }
 });
 
+test("direct prompt-template associations live on the Unit Registry", () => {
+  for (const [unitType, promptTemplate] of Object.entries(EXPECTED_DIRECT_PROMPT_TEMPLATES)) {
+    assert.equal(
+      getUnitPromptTemplate(unitType),
+      promptTemplate,
+      `prompt template for ${unitType}`,
+    );
+    assert.ok(
+      existsSync(join(process.cwd(), "src/resources/extensions/gsd/prompts", `${promptTemplate}.md`)),
+      `prompt template file must exist for ${unitType}: ${promptTemplate}`,
+    );
+  }
+
+  for (const unitType of EXPECTED_UNDECLARED_PROMPT_TEMPLATE_TYPES) {
+    assert.equal(
+      getUnitPromptTemplate(unitType),
+      undefined,
+      `${unitType} prompt association is conditional or not verified yet`,
+    );
+  }
+});
+
 test("AUTO_UNIT_SCOPED_TOOLS mirrors each contract's allowed tools", () => {
   for (const [unitType, contract] of Object.entries(UNIT_TOOL_CONTRACTS)) {
     assert.deepEqual(AUTO_UNIT_SCOPED_TOOLS[unitType], contract.allowedGsdTools);

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

@@ -6,7 +6,9 @@ import {
   formatExecuteTaskRecoveryStatus,
   inspectExecuteTaskDurability,
   isInFlightRuntimePhase,
+  readUnitHarnessAbort,
   readUnitRuntimeRecord,
+  recordUnitHarnessAbort,
   writeUnitRuntimeRecord,
 } from "../unit-runtime.ts";
 import { closeDatabase, insertMilestone, insertSlice, insertTask, openDatabase } from "../gsd-db.ts";
@@ -41,6 +43,34 @@ console.log("\n=== runtime record write/read/update ===");
   assert.deepStrictEqual(loaded!.phase, "wrapup-warning-sent", "updated phase readable");
 }
 
+console.log("\n=== runtime harness abort preservation and explicit clear ===");
+{
+  const startedAt = 3000;
+  recordUnitHarnessAbort(base, "gate-evaluate", "M100/S02/gates+Q3", startedAt, {
+    kind: "tool-error",
+    reason: "Tool execution failed before the unit could complete its gate evaluation.",
+    toolName: "browser_click",
+  });
+
+  const preserved = writeUnitRuntimeRecord(base, "gate-evaluate", "M100/S02/gates+Q3", startedAt, {
+    phase: "wrapup-warning-sent",
+  });
+  assert.equal(preserved.harnessAbort?.kind, "tool-error", "ordinary same-run updates preserve harness abort");
+
+  const cleared = writeUnitRuntimeRecord(base, "gate-evaluate", "M100/S02/gates+Q3", startedAt, {
+    phase: "recovered",
+    harnessAbort: undefined,
+  });
+  assert.equal(cleared.harnessAbort, undefined, "explicit clear removes stale harness abort");
+  assert.equal(
+    readUnitHarnessAbort(base, "gate-evaluate", "M100/S02/gates+Q3", startedAt),
+    null,
+    "cleared harness abort no longer blocks result saves",
+  );
+
+  clearUnitRuntimeRecord(base, "gate-evaluate", "M100/S02/gates+Q3");
+}
+
 console.log("\n=== execute-task durability inspection ===");
 {
   let status = await inspectExecuteTaskDurability(base, "M100/S02/T09");