@opengsd/gsd-pi 1.1.1-dev.616a1a1 → 1.1.1-dev.9bb7453

package/src/resources/extensions/gsd/tests/deep-planning-mode-dispatch.test.ts

@@ -229,6 +229,24 @@ function makeIsolatedBaseWithCleanup(t: TestContext): string {
   return base;
 }
 
+function setGsdHeadless(t: TestContext): void {
+  const previous = process.env.GSD_HEADLESS;
+  process.env.GSD_HEADLESS = "1";
+  t.after(() => {
+    if (previous === undefined) delete process.env.GSD_HEADLESS;
+    else process.env.GSD_HEADLESS = previous;
+  });
+}
+
+function unsetGsdHeadless(t: TestContext): void {
+  const previous = process.env.GSD_HEADLESS;
+  delete process.env.GSD_HEADLESS;
+  t.after(() => {
+    if (previous === undefined) delete process.env.GSD_HEADLESS;
+    else process.env.GSD_HEADLESS = previous;
+  });
+}
+
 function writeValidProject(base: string): void {
   writeFileSync(join(base, ".gsd", "PROJECT.md"), VALID_PROJECT_MD);
 }
@@ -364,16 +382,33 @@ test("Deep mode: discuss-project does NOT dispatch when planning_depth is 'light
 test("Deep mode: discuss-project DOES dispatch when planning_depth is 'deep' and PROJECT.md missing", async (t) => {
   const base = makeIsolatedBaseWithCleanup(t);
 
+  unsetGsdHeadless(t);
+
   const prefs = { planning_depth: "deep" } as GSDPreferences;
   const result = await rule(PROJECT_RULE_NAME).match(makeCtx(base, prefs));
   assert.ok(result && result.action === "dispatch", "deep mode + missing PROJECT.md must dispatch");
   if (result.action === "dispatch") {
     assert.strictEqual(result.unitType, "discuss-project");
     assert.strictEqual(result.unitId, "PROJECT");
+    assert.strictEqual(result.pauseAfterDispatch, true);
     assert.ok(result.prompt.length > 0, "prompt must be non-empty");
   }
 });
 
+test("Deep mode: discuss-project does not pause when GSD_HEADLESS is set", async (t) => {
+  const base = makeIsolatedBaseWithCleanup(t);
+
+  setGsdHeadless(t);
+
+  const prefs = { planning_depth: "deep" } as GSDPreferences;
+  const result = await rule(PROJECT_RULE_NAME).match(makeCtx(base, prefs));
+  assert.ok(result && result.action === "dispatch", "deep mode + missing PROJECT.md must dispatch");
+  if (result.action === "dispatch") {
+    assert.strictEqual(result.unitType, "discuss-project");
+    assert.strictEqual(result.pauseAfterDispatch, false);
+  }
+});
+
 test("Deep mode: discuss-project does NOT dispatch when PROJECT.md already exists and is valid", async (t) => {
   const base = makeIsolatedBaseWithCleanup(t);
 
@@ -432,6 +467,8 @@ test("Deep mode: discuss-requirements does NOT dispatch when PROJECT.md missing
 test("Deep mode: discuss-requirements DOES dispatch when PROJECT.md exists and REQUIREMENTS.md missing", async (t) => {
   const base = makeIsolatedBaseWithCleanup(t);
 
+  unsetGsdHeadless(t);
+
   writeValidProject(base);
   const prefs = { planning_depth: "deep" } as GSDPreferences;
   const result = await rule(REQUIREMENTS_RULE_NAME).match(makeCtx(base, prefs));
@@ -439,6 +476,22 @@ test("Deep mode: discuss-requirements DOES dispatch when PROJECT.md exists and R
   if (result.action === "dispatch") {
     assert.strictEqual(result.unitType, "discuss-requirements");
     assert.strictEqual(result.unitId, "REQUIREMENTS");
+    assert.strictEqual(result.pauseAfterDispatch, true);
+  }
+});
+
+test("Deep mode: discuss-requirements does not pause when GSD_HEADLESS is set", async (t) => {
+  const base = makeIsolatedBaseWithCleanup(t);
+
+  setGsdHeadless(t);
+
+  writeValidProject(base);
+  const prefs = { planning_depth: "deep" } as GSDPreferences;
+  const result = await rule(REQUIREMENTS_RULE_NAME).match(makeCtx(base, prefs));
+  assert.ok(result && result.action === "dispatch", "deep mode + PROJECT.md present + REQUIREMENTS.md missing must dispatch");
+  if (result.action === "dispatch") {
+    assert.strictEqual(result.unitType, "discuss-requirements");
+    assert.strictEqual(result.pauseAfterDispatch, false);
   }
 });
 

package/src/resources/extensions/gsd/tests/derive-state-db.test.ts

@@ -868,6 +868,14 @@ describe('derive-state-db', async () => {
         dbState.blockers.some(b => b.includes('needs-remediation') && b.includes('M001')),
         'remediation-stuck-db: blocker message mentions milestone and verdict',
       );
+      assert.ok(
+        dbState.blockers.some(b => b.includes('/gsd dispatch reassess')),
+        'remediation-stuck-db: blocker message points users to the reassess command',
+      );
+      assert.ok(
+        dbState.blockers.every(b => !b.includes('gsd_reassess_roadmap')),
+        'remediation-stuck-db: blocker message does not expose the internal tool name',
+      );
 
       closeDatabase();
     } finally {

package/src/resources/extensions/gsd/tests/derive-state-helpers.test.ts

@@ -473,13 +473,13 @@ describe('derive-state-helpers', () => {
     }
   });
 
-	  test('getActiveMilestoneId: DB lock path ignores PARKED flag projection', async () => {
-	    const base = createFixtureBase();
-	    const previousLock = process.env.GSD_MILESTONE_LOCK;
-	    const previousWorker = process.env.GSD_PARALLEL_WORKER;
-	    try {
-	      process.env.GSD_MILESTONE_LOCK = 'M001';
-	      process.env.GSD_PARALLEL_WORKER = '1';
+  test('getActiveMilestoneId: DB lock path ignores PARKED flag projection', async () => {
+    const base = createFixtureBase();
+    const previousLock = process.env.GSD_MILESTONE_LOCK;
+    const previousWorker = process.env.GSD_PARALLEL_WORKER;
+    try {
+      process.env.GSD_MILESTONE_LOCK = 'M001';
+      process.env.GSD_PARALLEL_WORKER = '1';
       writeFile(base, 'milestones/M001/M001-PARKED.md', '# Parked on disk');
 
       openDatabase(':memory:');
@@ -487,12 +487,41 @@ describe('derive-state-helpers', () => {
 
       const id = await getActiveMilestoneId(base);
       assert.equal(id, 'M001', 'DB status remains authoritative despite PARKED projection');
-	    } finally {
-	      if (previousLock === undefined) delete process.env.GSD_MILESTONE_LOCK;
-	      else process.env.GSD_MILESTONE_LOCK = previousLock;
-	      if (previousWorker === undefined) delete process.env.GSD_PARALLEL_WORKER;
-	      else process.env.GSD_PARALLEL_WORKER = previousWorker;
-	      closeDatabase();
+    } finally {
+      if (previousLock === undefined) delete process.env.GSD_MILESTONE_LOCK;
+      else process.env.GSD_MILESTONE_LOCK = previousLock;
+      if (previousWorker === undefined) delete process.env.GSD_PARALLEL_WORKER;
+      else process.env.GSD_PARALLEL_WORKER = previousWorker;
+      closeDatabase();
+      cleanup(base);
+    }
+  });
+
+  test('deriveStateFromDb: solo milestone lock scopes state to the requested milestone', async () => {
+    const base = createFixtureBase();
+    const previousLock = process.env.GSD_MILESTONE_LOCK;
+    const previousWorker = process.env.GSD_PARALLEL_WORKER;
+    try {
+      delete process.env.GSD_PARALLEL_WORKER;
+      process.env.GSD_MILESTONE_LOCK = 'M002';
+
+      openDatabase(':memory:');
+      insertMilestone({ id: 'M001', title: 'Earlier', status: 'active' });
+      insertMilestone({ id: 'M002', title: 'Requested', status: 'active' });
+
+      invalidateStateCache();
+      const state = await deriveStateFromDb(base);
+      const id = await getActiveMilestoneId(base);
+
+      assert.equal(state.activeMilestone?.id, 'M002', 'explicit lock chooses requested milestone');
+      assert.deepEqual(state.registry.map((entry) => entry.id), ['M002'], 'registry is scoped to requested milestone');
+      assert.equal(id, 'M002', 'active milestone helper honors solo lock');
+    } finally {
+      if (previousLock === undefined) delete process.env.GSD_MILESTONE_LOCK;
+      else process.env.GSD_MILESTONE_LOCK = previousLock;
+      if (previousWorker === undefined) delete process.env.GSD_PARALLEL_WORKER;
+      else process.env.GSD_PARALLEL_WORKER = previousWorker;
+      closeDatabase();
       cleanup(base);
     }
   });
@@ -526,6 +555,14 @@ describe('derive-state-helpers', () => {
         state.blockers.some(b => b.includes('needs-remediation') && b.includes('M001')),
         'remediation-stuck: blocker message mentions milestone and verdict',
       );
+      assert.ok(
+        state.blockers.some(b => b.includes('/gsd dispatch reassess')),
+        'remediation-stuck: blocker message points users to the reassess command',
+      );
+      assert.ok(
+        state.blockers.every(b => !b.includes('gsd_reassess_roadmap')),
+        'remediation-stuck: blocker message does not expose the internal tool name',
+      );
     } finally {
       closeDatabase();
       cleanup(base);

package/src/resources/extensions/gsd/tests/discuss-milestone-structured-questions.test.ts

@@ -44,14 +44,26 @@ function setGsdHeadless(t: { after: (fn: () => void) => void }): void {
   });
 }
 
+function unsetGsdHeadless(t: { after: (fn: () => void) => void }): void {
+  const previous = process.env.GSD_HEADLESS;
+  delete process.env.GSD_HEADLESS;
+  t.after(() => {
+    if (previous === undefined) delete process.env.GSD_HEADLESS;
+    else process.env.GSD_HEADLESS = previous;
+  });
+}
+
 test("auto-dispatch passes structuredQuestionsAvailable=true into discuss-milestone prompt", async (t) => {
   const tmp = mkdtempSync(join(tmpdir(), "gsd-discuss-milestone-structured-"));
   t.after(() => rmSync(tmp, { recursive: true, force: true }));
 
+  unsetGsdHeadless(t);
+
   const result = await resolveDispatch(makeContext(tmp, "needs-discussion", "true"));
 
   assert.equal(result.action, "dispatch");
   assert.equal(result.unitType, "discuss-milestone");
+  assert.equal(result.pauseAfterDispatch, true);
   assert.match(
     result.prompt,
     /\*\*Structured questions available: true\*\*/,
@@ -62,10 +74,13 @@ test("auto-dispatch preserves structuredQuestionsAvailable=false for discuss-mil
   const tmp = mkdtempSync(join(tmpdir(), "gsd-discuss-milestone-plain-"));
   t.after(() => rmSync(tmp, { recursive: true, force: true }));
 
+  unsetGsdHeadless(t);
+
   const result = await resolveDispatch(makeContext(tmp, "pre-planning", "false"));
 
   assert.equal(result.action, "dispatch");
   assert.equal(result.unitType, "discuss-milestone");
+  assert.equal(result.pauseAfterDispatch, true);
   assert.match(
     result.prompt,
     /\*\*Structured questions available: false\*\*/,
@@ -82,6 +97,7 @@ test("auto-dispatch uses discuss-headless prompt when GSD_HEADLESS is set", asyn
 
   assert.equal(result.action, "dispatch");
   assert.equal(result.unitType, "discuss-milestone");
+  assert.equal(result.pauseAfterDispatch, false);
   assert.match(result.prompt, /This is a \*\*headless\*\* flow/);
   assert.doesNotMatch(result.prompt, /\*\*Structured questions available: true\*\*/);
 });
@@ -96,10 +112,24 @@ test("auto-dispatch uses discuss-headless prompt for needs-discussion when GSD_H
 
   assert.equal(result.action, "dispatch");
   assert.equal(result.unitType, "discuss-milestone");
+  assert.equal(result.pauseAfterDispatch, false);
   assert.match(result.prompt, /This is a \*\*headless\*\* flow/);
   assert.doesNotMatch(result.prompt, /\*\*Structured questions available: true\*\*/);
 });
 
+test("auto-dispatch pauses after execution-entry discuss-milestone recovery", async (t) => {
+  const tmp = mkdtempSync(join(tmpdir(), "gsd-discuss-milestone-executing-"));
+  t.after(() => rmSync(tmp, { recursive: true, force: true }));
+
+  unsetGsdHeadless(t);
+
+  const result = await resolveDispatch(makeContext(tmp, "executing", "true"));
+
+  assert.equal(result.action, "dispatch");
+  assert.equal(result.unitType, "discuss-milestone");
+  assert.equal(result.pauseAfterDispatch, true);
+});
+
 test("auto-dispatch uses discuss-headless prompt for executing when GSD_HEADLESS is set", async (t) => {
   const tmp = mkdtempSync(join(tmpdir(), "gsd-discuss-milestone-headless-"));
   t.after(() => rmSync(tmp, { recursive: true, force: true }));
@@ -110,6 +140,7 @@ test("auto-dispatch uses discuss-headless prompt for executing when GSD_HEADLESS
 
   assert.equal(result.action, "dispatch");
   assert.equal(result.unitType, "discuss-milestone");
+  assert.equal(result.pauseAfterDispatch, false);
   assert.match(result.prompt, /This is a \*\*headless\*\* flow/);
   assert.doesNotMatch(result.prompt, /\*\*Structured questions available: true\*\*/);
 });

package/src/resources/extensions/gsd/tests/dispatch-missing-task-plans.test.ts

@@ -19,6 +19,7 @@ import type { DispatchContext } from "../auto-dispatch.ts";
 import type { AutoSession } from "../auto/session.ts";
 import type { GSDState } from "../types.ts";
 import { enableDebug, disableDebug, getDebugLogPath } from "../debug-logger.ts";
+import { closeDatabase, insertMilestone, isDbAvailable, openDatabase } from "../gsd-db.ts";
 
 function makeState(overrides: Partial<GSDState> = {}): GSDState {
   return {
@@ -123,6 +124,29 @@ test("dispatch: missing task plan triggers plan-slice (not stop) — issue #909"
     `unitId should be M002/S03, got: ${result.action === "dispatch" ? result.unitId : "(stop)"}`);
 });
 
+test("dispatch: closed milestone is not implicitly recovered or reopened", async (t) => {
+  const tmp = mkdtempSync(join(tmpdir(), "gsd-closed-dispatch-"));
+  t.after(() => {
+    if (isDbAvailable()) closeDatabase();
+    rmSync(tmp, { recursive: true, force: true });
+  });
+
+  if (isDbAvailable()) closeDatabase();
+  mkdirSync(join(tmp, ".gsd"), { recursive: true });
+  openDatabase(join(tmp, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M002", title: "Closed Milestone", status: "complete" });
+  scaffoldMilestoneContext(tmp, "M002");
+  scaffoldSlicePlan(tmp, "M002", "S03");
+
+  const result = await resolveDispatch(makeContext(tmp));
+
+  assert.equal(result.action, "stop");
+  assert.ok(result.action === "stop");
+  assert.equal(result.level, "warning");
+  assert.match(result.reason, /Milestone M002 is closed/);
+  assert.match(result.reason, /will not reopen or recover it implicitly/);
+});
+
 test("dispatch: present task plan proceeds to execute-task normally", async (t) => {
   const tmp = mkdtempSync(join(tmpdir(), "gsd-909-ok-"));
   t.after(() => rmSync(tmp, { recursive: true, force: true }));
@@ -141,6 +165,42 @@ test("dispatch: present task plan proceeds to execute-task normally", async (t)
     `unitId should be M002/S03/T01, got: ${result.action === "dispatch" ? result.unitId : "(stop)"}`);
 });
 
+test("dispatch: session milestone mismatch stops before missing-task-plan recovery", async (t) => {
+  const tmp = mkdtempSync(join(tmpdir(), "gsd-session-milestone-mismatch-"));
+  t.after(() => rmSync(tmp, { recursive: true, force: true }));
+
+  const worktreeRoot = join(tmp, ".gsd", "worktrees", "M002");
+  mkdirSync(worktreeRoot, { recursive: true });
+
+  const ctx = makeContextFor(tmp, "M001", "S01", "T01", {
+    basePath: worktreeRoot,
+    originalBasePath: tmp,
+    currentMilestoneId: "M002",
+  });
+  const result = await resolveDispatch(ctx);
+
+  assert.equal(result.action, "stop");
+  assert.ok(result.action === "stop");
+  assert.equal(result.level, "warning");
+  assert.match(result.reason, /context mid "M001" does not match session\.currentMilestoneId "M002"/);
+});
+
+test("dispatch: worktree path mismatch stops before planning a different milestone", async (t) => {
+  const tmp = mkdtempSync(join(tmpdir(), "gsd-worktree-path-milestone-mismatch-"));
+  t.after(() => rmSync(tmp, { recursive: true, force: true }));
+
+  const worktreeRoot = join(tmp, ".gsd", "worktrees", "M002");
+  mkdirSync(worktreeRoot, { recursive: true });
+
+  const ctx = makeContextFor(worktreeRoot, "M001", "S01", "T01");
+  const result = await resolveDispatch(ctx);
+
+  assert.equal(result.action, "stop");
+  assert.ok(result.action === "stop");
+  assert.equal(result.level, "warning");
+  assert.match(result.reason, /context mid "M001" does not match basePath worktree "M002"/);
+});
+
 test("dispatch: executing recovery checks active milestone worktree task plans before re-dispatching plan-slice", async (t) => {
   const tmp = mkdtempSync(join(tmpdir(), "gsd-6192-"));
   t.after(() => rmSync(tmp, { recursive: true, force: true }));

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

@@ -45,3 +45,30 @@ test("doctor fix respects git.manage_gitignore false (#4161)", async (t) => {
   assert.equal(readFileSync(join(dir, ".gitignore"), "utf-8"), "node_modules/\n");
   assert.equal(existsSync(join(dir, ".gsd", "PREFERENCES.md")), true);
 });
+
+test("doctor fix resets run-uat counters at the dispatch cap", async (t) => {
+  const dir = createGitProject();
+  t.after(() => rmSync(dir, { recursive: true, force: true }));
+
+  const runtimeDir = join(dir, ".gsd", "runtime");
+  mkdirSync(runtimeDir, { recursive: true });
+  const counterPath = join(runtimeDir, "uat-count-M002-S01.json");
+  writeFileSync(
+    counterPath,
+    JSON.stringify({ count: 3, updatedAt: "2026-06-02T19:40:23.289Z" }) + "\n",
+    "utf-8",
+  );
+
+  const detect = await runGSDDoctor(dir);
+  const issue = detect.issues.find((candidate) => candidate.code === "uat_retry_exhausted");
+  assert.ok(issue, "doctor reports the exhausted UAT retry counter at the dispatch cap");
+  assert.equal(issue.unitId, "M002/S01");
+  assert.match(issue.message, /3 attempt\(s\)/);
+
+  const fixed = await runGSDDoctor(dir, { fix: true, scope: "M002/S02" });
+  assert.ok(
+    fixed.fixesApplied.some((fix) => fix.includes("reset exhausted run-uat retry counter for M002/S01")),
+    "doctor --fix resets the blocked counter even when the current displayed scope has advanced",
+  );
+  assert.equal(existsSync(counterPath), false);
+});

package/src/resources/extensions/gsd/tests/escalation.test.ts

@@ -106,7 +106,7 @@ test("ADR-011 P2: writeEscalationArtifact persists canonical JSON at tasks/T##-E
   assert.equal(row?.escalation_artifact_path, path);
 });
 
-test("ADR-011 P2: continueWithDefault=true sets awaiting_review (NOT pending) — no pause", (t) => {
+test("ADR-011 P2: continueWithDefault=true sets awaiting_review (NOT pending)", (t) => {
   const base = makeBase();
   t.after(() => cleanup(base));
   seedCompletedTask(base, "T04");
@@ -126,7 +126,7 @@ test("ADR-011 P2: continueWithDefault=true sets awaiting_review (NOT pending)
   assert.equal(row?.escalation_awaiting_review, 1);
 });
 
-test("ADR-011 P2: detectPendingEscalation returns only pause-scoped escalations", (t) => {
+test("ADR-011 P2: detectPendingEscalation pauses on unresolved awaiting_review escalations", (t) => {
   const base = makeBase();
   t.after(() => cleanup(base));
   seedCompletedTask(base, "T01");
@@ -147,7 +147,7 @@ test("ADR-011 P2: detectPendingEscalation returns only pause-scoped escalations"
 
   const tasks = [getTask("M001", "S01", "T01")!, getTask("M001", "S01", "T02")!];
   const id = detectPendingEscalation(tasks, base);
-  assert.equal(id, "T02", "only T02 is pause-worthy; T01 is awaiting_review");
+  assert.equal(id, "T01", "unresolved awaiting_review escalations must pause before later tasks");
 });
 
 test("ADR-011 P2: resolveEscalation(accept) marks artifact + clears flags", (t) => {
@@ -677,26 +677,19 @@ test("ADR-011 P3 #23: concurrent escalations across parallel slices — only the
   assert.equal(detectPendingEscalation([getTask("M001", "S02", "T70")!], base), null);
 });
 
-test("ADR-011 P3 #24: continueWithDefault timeout — late user response injects into the next task dispatched AFTER the response", (t) => {
-  // Timeline this test pins (the "timeout" is implicit — it's just the
-  // elapsed wall-clock where the loop keeps running after T80's
-  // continueWithDefault=true write):
+test("ADR-011 P3 #24: continueWithDefault requires explicit response before override injection", (t) => {
+  // Timeline this test pins:
   //
-  //   1. T80 writes continueWithDefault=true → awaiting_review=1, loop
-  //      continues dispatching T81, T82. Neither claim fires because the
-  //      user has not responded (pins Bug 2 behavior, tested at line 244).
-  //   2. The user responds LATE (after T81/T82 already dispatched).
-  //   3. The very next prompt build (for T83) claims the override exactly
-  //      once. T81/T82 are in the past — they must not retroactively
-  //      receive the injection even though they ran during the window.
+  //   1. T80 writes continueWithDefault=true → awaiting_review=1.
+  //   2. Scheduler detection pauses on T80 instead of treating silence as
+  //      consent. Prompt injection still waits until the user responds.
+  //   3. After the response, the next prompt build claims the override once.
   const base = makeBase();
   t.after(() => cleanup(base));
   seedCompletedTask(base, "T80");
-  seedCompletedTask(base, "T81");
-  seedCompletedTask(base, "T82");
   seedCompletedTask(base, "T83");
 
-  // Phase 1 — T80 escalates with continueWithDefault=true, loop continues.
+  // Phase 1 — T80 escalates with continueWithDefault=true.
   writeEscalationArtifact(base, buildEscalationArtifact({
     taskId: "T80", sliceId: "S01", milestoneId: "M001",
     question: "Which cache strategy?", options: sampleOptions,
@@ -704,21 +697,17 @@ test("ADR-011 P3 #24: continueWithDefault timeout — late user response injects
     continueWithDefault: true,
   }));
 
-  // T80 is awaiting_review (not pending) — scheduler does not pause.
+  // T80 is awaiting_review (not pending), but scheduler detection still
+  // pauses until the user explicitly responds.
   assert.equal(getTask("M001", "S01", "T80")?.escalation_awaiting_review, 1);
   assert.equal(getTask("M001", "S01", "T80")?.escalation_pending, 0);
-  assert.equal(detectPendingEscalation([getTask("M001", "S01", "T80")!], base), null);
+  assert.equal(detectPendingEscalation([getTask("M001", "S01", "T80")!], base), "T80");
 
-  // T81 + T82 dispatch during the response window — neither gets the injection.
+  // Prompt injection must still wait for a response.
   assert.equal(
     claimOverrideForInjection(base, "M001", "S01"),
     null,
-    "T81's prompt build must not claim the unresolved awaiting_review",
-  );
-  assert.equal(
-    claimOverrideForInjection(base, "M001", "S01"),
-    null,
-    "T82's prompt build must also not claim the unresolved awaiting_review",
+    "unresolved awaiting_review must not be claimed as a default response",
   );
 
   // The response window remains open across N tasks — still no override applied.
@@ -728,7 +717,7 @@ test("ADR-011 P3 #24: continueWithDefault timeout — late user response injects
     "applied_at must stay null throughout the response window",
   );
 
-  // Phase 2 — user responds LATE with a different option than the recommendation.
+  // Phase 2 — user responds with a different option than the recommendation.
   const resolveResult = resolveEscalation(
     base, "M001", "S01", "T80", "B", "after reviewing, B is the call",
   );

package/src/resources/extensions/gsd/tests/exec-sandbox.test.ts

@@ -53,6 +53,24 @@ test('runExecSandbox: captures stdout, persists artifacts, returns digest', asyn
   }
 });
 
+test('runExecSandbox: persists optional request metadata', async () => {
+  const base = freshBase();
+  try {
+    const result = await runExecSandbox(
+      {
+        runtime: 'bash',
+        script: 'echo metadata-ok',
+        metadata: { kind: 'uat_exec', intent: 'uat-artifact-check' },
+      },
+      baseOpts(base),
+    );
+    const meta = JSON.parse(readFileSync(result.meta_path, 'utf-8')) as Record<string, unknown>;
+    assert.deepEqual(meta.metadata, { kind: 'uat_exec', intent: 'uat-artifact-check' });
+  } finally {
+    cleanup(base);
+  }
+});
+
 test('runExecSandbox: enforces stdout cap and marks truncation', async () => {
   const base = freshBase();
   try {

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

@@ -0,0 +1,69 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { registerExecTools } from "../bootstrap/exec-tools.ts";
+import { executeUatExec } from "../tools/exec-tool.ts";
+import type { ExecSandboxRequest, ExecSandboxResult } from "../exec-sandbox.ts";
+
+function makeExecResult(request: ExecSandboxRequest): ExecSandboxResult {
+  return {
+    id: "exec-1",
+    runtime: request.runtime,
+    exit_code: 0,
+    signal: null,
+    timed_out: false,
+    duration_ms: 1,
+    stdout_bytes: 12,
+    stderr_bytes: 0,
+    stdout_truncated: false,
+    stderr_truncated: false,
+    stdout_path: ".gsd/exec/exec-1.stdout",
+    stderr_path: ".gsd/exec/exec-1.stderr",
+    meta_path: ".gsd/exec/exec-1.meta.json",
+    digest: "check passed",
+  };
+}
+
+test("executeUatExec accepts evidence-mode aliases for intent", async () => {
+  const requests: ExecSandboxRequest[] = [];
+  const result = await executeUatExec(
+    {
+      milestoneId: "M001",
+      sliceId: "S01",
+      checkId: "UAT-PRE",
+      intent: "artifact",
+      runtime: "bash",
+      script: "printf ok",
+    },
+    {
+      baseDir: "/tmp/gsd-uat-exec-test",
+      preferences: null,
+      run: async (request) => {
+        requests.push(request);
+        return makeExecResult(request);
+      },
+    },
+  );
+
+  assert.equal(result.isError, false);
+  assert.equal(result.details?.operation, "gsd_uat_exec");
+  assert.equal(result.details?.intent, "uat-artifact-check");
+  assert.equal(requests[0]?.metadata?.intent, "uat-artifact-check");
+});
+
+test("registerExecTools exposes gsd_uat_exec intent as recoverable string schema", () => {
+  const tools: Array<{ name: string; parameters: any }> = [];
+  registerExecTools({
+    registerTool: (tool: { name: string; parameters: any }) => {
+      tools.push(tool);
+    },
+  } as any);
+
+  const tool = tools.find((registeredTool) => registeredTool.name === "gsd_uat_exec");
+  assert.ok(tool, "gsd_uat_exec should be registered");
+  const intentSchema = tool.parameters.properties.intent;
+  assert.equal(intentSchema.type, "string");
+  assert.equal("anyOf" in intentSchema, false);
+  assert.match(intentSchema.description, /uat-artifact-check/);
+  assert.match(intentSchema.description, /artifact/);
+});

package/src/resources/extensions/gsd/tests/forensics-issue-routing.test.ts

@@ -41,3 +41,23 @@ test("forensics prompt routes issue creation through bash tool, not github_issue
     "Prompt must instruct use of the bash tool for issue creation",
   );
 });
+
+test("forensics prompt provides paste-once fallback when bash is unavailable", () => {
+  const prompt = readPrompt("forensics");
+
+  assert.match(
+    prompt,
+    /If `bash` is unavailable/i,
+    "Prompt must branch when bash cannot be activated",
+  );
+  assert.match(
+    prompt,
+    /paste-once shell script/i,
+    "Prompt must provide a user-runnable fallback instead of an impossible tool call",
+  );
+  assert.match(
+    prompt,
+    /Searching closed issues for possible duplicates/i,
+    "Fallback script must preserve the duplicate-search step for the user",
+  );
+});

package/src/resources/extensions/gsd/tests/forensics-prompt-rendering.test.ts

@@ -24,13 +24,16 @@ test("forensics prompt renders compact investigation and issue routing guidance"
     forensicData: "stuck-detected event for execute-task/M001/S01/T01",
     gsdSourceDir: process.env.GSD_TEST_WORKSPACE_ROOT ?? process.cwd(),
     dedupSection: "No duplicate issue found.",
+    toolingSection: "## Filing Tool Availability\n\n- `bash`: available\n- `write`: available",
   });
 
   assert.match(prompt, /Investigation Protocol/);
+  assert.match(prompt, /Filing Tool Availability/);
   assert.match(prompt, /gsd_milestone_status/);
   assert.match(prompt, /sqlite3 .gsd\/gsd.db/);
   assert.match(prompt, /gh issue create --repo open-gsd\/gsd-pi/);
   assert.match(prompt, /Do NOT use the `github_issues` tool/);
+  assert.match(prompt, /paste-once shell script/);
   assert.match(prompt, /Redaction Rules/);
   assert.doesNotMatch(prompt, /\{\{[a-zA-Z][a-zA-Z0-9_]*\}\}/);
 });