@opengsd/gsd-pi 1.1.1-dev.74e8dd1 → 1.1.1-dev.9bb7453

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/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/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_]*\}\}/);
 });

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

@@ -0,0 +1,69 @@
+// Project/App: gsd-pi
+// File Purpose: Verifies /gsd forensics scopes issue-filing tools for its queued turn.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import {
+  applyForensicsToolScope,
+  buildForensicsToolingSection,
+  createForensicsToolScope,
+  restoreForensicsToolScope,
+} from "../forensics.ts";
+
+function tool(name: string): { name: string } {
+  return { name };
+}
+
+test("forensics adds registered filing tools for the queued turn and restores the prior tools", () => {
+  const originalTools = ["read"];
+  let activeTools = [...originalTools];
+  const pi = {
+    getActiveTools: () => [...activeTools],
+    getAllTools: () => ["read", "bash", "write"].map(tool),
+    setActiveTools: (tools: string[]) => {
+      activeTools = [...tools];
+    },
+  };
+
+  const scope = createForensicsToolScope(pi as any);
+
+  assert.deepEqual(scope.savedTools, originalTools);
+  assert.deepEqual(scope.activeToolsForTurn, ["read", "bash", "write"]);
+  assert.deepEqual(scope.availableFilingTools, ["bash", "write"]);
+  assert.deepEqual(scope.missingFilingTools, []);
+  assert.equal(scope.toolsChanged, true);
+  assert.deepEqual(activeTools, originalTools, "scope creation must not mutate active tools");
+
+  applyForensicsToolScope(pi as any, scope);
+  assert.deepEqual(activeTools, ["read", "bash", "write"]);
+
+  const toolingSection = buildForensicsToolingSection(scope);
+  assert.match(toolingSection, /`bash`: available/);
+  assert.match(toolingSection, /`write`: available/);
+  assert.match(toolingSection, /GitHub duplicate-check and issue-creation protocols/);
+
+  restoreForensicsToolScope(pi as any, scope);
+  assert.deepEqual(activeTools, originalTools);
+});
+
+test("forensics tooling guidance falls back when bash is not registered", () => {
+  let activeTools = ["read"];
+  const pi = {
+    getActiveTools: () => [...activeTools],
+    getAllTools: () => ["read", "write"].map(tool),
+    setActiveTools: (tools: string[]) => {
+      activeTools = [...tools];
+    },
+  };
+
+  const scope = createForensicsToolScope(pi as any);
+
+  assert.deepEqual(scope.availableFilingTools, ["write"]);
+  assert.deepEqual(scope.missingFilingTools, ["bash"]);
+  assert.deepEqual(scope.activeToolsForTurn, ["read", "write"]);
+
+  const toolingSection = buildForensicsToolingSection(scope);
+  assert.match(toolingSection, /`bash`: unavailable/);
+  assert.match(toolingSection, /paste-once shell script fallback/);
+});

package/src/resources/extensions/gsd/tests/guided-discuss-milestone-prompt-rendering.test.ts

@@ -3,10 +3,11 @@
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync, rmSync } from "node:fs";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { VISION_ASK_VARIANTS } from "../vision-ask.ts";
+import { buildDiscussMilestonePrompt } from "../auto-prompts.ts";
 
 test("guided milestone prompt renders compact interview and context guidance", async (t) => {
   const previousGsdHome = process.env.GSD_HOME;
@@ -47,3 +48,41 @@ test("guided milestone prompt renders compact interview and context guidance", a
   assert.match(prompt, /milestone_id: M001/);
   assert.doesNotMatch(prompt, /\{\{[a-zA-Z][a-zA-Z0-9_]*\}\}/);
 });
+
+test("guided milestone prompt builder preloads milestone planning context", async () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-guided-milestone-context-"));
+  try {
+    const milestonesRoot = join(base, ".gsd", "milestones");
+    const priorDir = join(milestonesRoot, "M001");
+    const currentDir = join(milestonesRoot, "M002");
+    const futureDir = join(milestonesRoot, "M003");
+    mkdirSync(priorDir, { recursive: true });
+    mkdirSync(currentDir, { recursive: true });
+    mkdirSync(futureDir, { recursive: true });
+
+    writeFileSync(join(base, ".gsd", "DECISIONS.md"), "# Decisions\n\nDECISION-SIGNAL", "utf-8");
+    writeFileSync(join(priorDir, "M001-SUMMARY.md"), "# M001 Summary\n\nPRIOR-SUMMARY-SIGNAL", "utf-8");
+    writeFileSync(join(currentDir, "M002-ROADMAP.md"), "# M002 Roadmap\n\nROADMAP-SIGNAL", "utf-8");
+    writeFileSync(join(currentDir, "M002-CONTEXT.md"), "# M002 Context\n\nCONTEXT-SIGNAL", "utf-8");
+    writeFileSync(join(currentDir, "M002-RESEARCH.md"), "# M002 Research\n\nRESEARCH-SIGNAL", "utf-8");
+    writeFileSync(join(futureDir, "M003-SUMMARY.md"), "# M003 Summary\n\nFUTURE-SUMMARY-SIGNAL", "utf-8");
+
+    const prompt = await buildDiscussMilestonePrompt("M002", "Checkout Polish", base, "true");
+
+    assert.match(prompt, /## Inlined Context \(preloaded — do not re-read these files\)/);
+    assert.match(prompt, /### Milestone Roadmap/);
+    assert.match(prompt, /ROADMAP-SIGNAL/);
+    assert.match(prompt, /### Milestone Context/);
+    assert.match(prompt, /CONTEXT-SIGNAL/);
+    assert.match(prompt, /### Milestone Research/);
+    assert.match(prompt, /RESEARCH-SIGNAL/);
+    assert.match(prompt, /### Decisions Register/);
+    assert.match(prompt, /DECISION-SIGNAL/);
+    assert.match(prompt, /### M001 Prior Milestone Summary/);
+    assert.match(prompt, /PRIOR-SUMMARY-SIGNAL/);
+    assert.doesNotMatch(prompt, /FUTURE-SUMMARY-SIGNAL/);
+    assert.match(prompt, /### Output Template: Context/);
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});

package/src/resources/extensions/gsd/tests/guided-dispatch-root.test.ts

@@ -104,3 +104,89 @@ test("guided dispatch passes the explicit project root through model and compati
     rmSync(otherRoot, { recursive: true, force: true });
   }
 });
+
+test("guided dispatch accepts workflow MCP tools absent from parent active tool surface", async () => {
+  const explicitRoot = mkdtempSync(join(tmpdir(), "gsd-guided-mcp-surface-"));
+  const workflowPath = join(explicitRoot, "GSD-WORKFLOW.md");
+  const originalWorkflowPath = process.env.GSD_WORKFLOW_PATH;
+  const originalMcpCommand = process.env.GSD_WORKFLOW_MCP_COMMAND;
+  const notifications: string[] = [];
+  let sent = false;
+
+  const ctx = {
+    model: { provider: "claude-code", baseUrl: "local://claude-code" },
+    modelRegistry: {
+      getProviderAuthMode: () => "externalCli",
+    },
+    ui: {
+      notify: (message: string) => {
+        notifications.push(message);
+      },
+    },
+  };
+
+  let activeTools = [
+    "ScheduleWakeup",
+    "ToolSearch",
+    "ask_user_questions",
+    "bash",
+    "read",
+    "write",
+  ];
+
+  const pi = {
+    getActiveTools: () => [...activeTools],
+    setActiveTools: (tools: string[]) => {
+      activeTools = [...tools];
+    },
+    sendMessage: () => {
+      sent = true;
+    },
+  };
+
+  try {
+    writeFileSync(workflowPath, "# Workflow\n", "utf-8");
+    process.env.GSD_WORKFLOW_PATH = workflowPath;
+    process.env.GSD_WORKFLOW_MCP_COMMAND = "node";
+
+    await _dispatchWorkflowForTest(
+      pi as any,
+      "Discuss the milestone.",
+      "gsd-discuss",
+      ctx as any,
+      "discuss-milestone",
+      {
+        basePath: explicitRoot,
+        deps: {
+          loadPreferences: () => ({ preferences: {} }) as any,
+          selectModel: (async () => ({
+            routing: null,
+            appliedModel: {
+              provider: "claude-code",
+              id: "claude-opus-4-8",
+              baseUrl: "local://claude-code",
+            },
+          })) as any,
+        },
+      },
+    );
+
+    assert.equal(sent, true);
+    assert.equal(
+      notifications.some((message) => message.includes("cannot run guided flow")),
+      false,
+    );
+  } finally {
+    if (originalWorkflowPath === undefined) {
+      delete process.env.GSD_WORKFLOW_PATH;
+    } else {
+      process.env.GSD_WORKFLOW_PATH = originalWorkflowPath;
+    }
+    if (originalMcpCommand === undefined) {
+      delete process.env.GSD_WORKFLOW_MCP_COMMAND;
+    } else {
+      process.env.GSD_WORKFLOW_MCP_COMMAND = originalMcpCommand;
+    }
+    rmSync(explicitRoot, { recursive: true, force: true });
+  }
+});

package/src/resources/extensions/gsd/tests/guided-flow.test.ts

@@ -8,14 +8,17 @@ const __dirname = dirname(fileURLToPath(import.meta.url));
 
 test("guided milestone discussion callsites pass workingDirectory to loadPrompt", () => {
   const source = readFileSync(join(__dirname, "..", "guided-flow.ts"), "utf-8");
-  const calls = [...source.matchAll(/loadPrompt\("guided-discuss-milestone",\s*\{([\s\S]*?)\}\)/g)];
 
-  assert.equal(calls.length, 8, "all guided-flow guided-discuss-milestone callsites should be covered");
-  for (const call of calls) {
-    assert.match(
-      call[1] ?? "",
-      /\bworkingDirectory:\s*basePath\b/,
-      "guided-discuss-milestone prompts need workingDirectory so template validation does not crash",
-    );
-  }
+  // All guided-discuss-milestone dispatches now go through buildDiscussMilestonePrompt,
+  // which centralises the loadPrompt call and always passes workingDirectory.
+  // Verify no callsite bypasses the builder by calling loadPrompt directly.
+  const directCalls = [...source.matchAll(/loadPrompt\("guided-discuss-milestone"/g)];
+  assert.equal(
+    directCalls.length,
+    0,
+    'guided-flow.ts must not call loadPrompt("guided-discuss-milestone") directly — use buildDiscussMilestonePrompt',
+  );
+
+  const calls = [...source.matchAll(/\bawait buildDiscussMilestonePrompt\(/g)];
+  assert.equal(calls.length, 9, "all guided-flow guided-discuss-milestone callsites should be covered");
 });

package/src/resources/extensions/gsd/tests/integration/auto-recovery.test.ts

@@ -119,8 +119,8 @@ test("resolveExpectedArtifactPath returns correct path for all slice-level types
 // ─── run-uat artifact path contract (#2873) ──────────────────────────────
 
 test("resolveExpectedArtifactPath for run-uat returns ASSESSMENT path, not UAT (#2873)", (t) => {
-  // The run-uat prompt instructs the agent to call gsd_summary_save with
-  // artifact_type: "ASSESSMENT", which writes S##-ASSESSMENT.md. The artifact
+  // The run-uat prompt instructs the agent to call gsd_uat_result_save, which
+  // writes S##-ASSESSMENT.md through the workflow persistence path. The artifact
   // verification path must match — otherwise verification fails and auto-mode
   // retries the unit in an infinite loop.
   const base = makeTmpBase();
@@ -147,12 +147,12 @@ test("diagnoseExpectedArtifact for run-uat references ASSESSMENT (#2873)", (t) =
 });
 
 test("verifyExpectedArtifact passes for run-uat when ASSESSMENT file exists (#2873)", (t) => {
-  // Regression test: run-uat writes S##-ASSESSMENT.md via gsd_summary_save,
+  // Regression test: run-uat writes S##-ASSESSMENT.md via gsd_uat_result_save,
   // but verification looked for S##-UAT.md, causing false stuck retries.
   const base = makeTmpBase();
   t.after(() => cleanup(base));
 
-  // Write the ASSESSMENT file (what gsd_summary_save actually produces)
+  // Write the ASSESSMENT file (what gsd_uat_result_save actually produces)
   const assessPath = join(base, ".gsd", "milestones", "M001", "slices", "S01", "S01-ASSESSMENT.md");
   writeFileSync(assessPath, "---\nverdict: PASS\n---\n# UAT Assessment\n");
 

package/src/resources/extensions/gsd/tests/integration/run-uat.test.ts

@@ -72,6 +72,38 @@ function makeBrowserObservableUatContent(mode = 'artifact-driven'): string {
   ].join('\n');
 }
 
+function makeDeferredBrowserUatContent(): string {
+  return [
+    '# UAT File',
+    '',
+    '## UAT Type',
+    '',
+    '- UAT mode: artifact-driven',
+    '- Why this mode is sufficient: Node interaction tests exercise the real app.js render/event/localStorage loop through a DOM harness. Live browser, keyboard, responsive, and visual-polish UAT remain intentionally deferred to S02.',
+    '',
+    '## Smoke Test',
+    '',
+    'Run `node --test tests/s01-static-interactions.test.js` and confirm all tests pass.',
+    '',
+    '## Test Cases',
+    '',
+    '1. Click the todo row edit control in the DOM harness.',
+    '2. Save changed text and reload/recreate the app from persisted localStorage.',
+    '3. Expected: the stored record shape remains unchanged.',
+    '',
+    '## Not Proven By This UAT',
+    '',
+    '- Final visual polish of edit controls.',
+    '- Keyboard usability through a real browser.',
+    '- Browser console and local network cleanliness.',
+    '',
+    '## Notes for Tester',
+    '',
+    'S02 should capture browser evidence for the full loop rather than changing this persisted model.',
+    '',
+  ].join('\n');
+}
+
 describe('run-uat', () => {
 test('(a) artifact-driven', () => {
   assert.deepStrictEqual(
@@ -232,8 +264,8 @@ test('(k) run-uat prompt template', () => {
     `prompt contains detected dynamic uatType value "${uatType}" after substitution`,
   );
   assert.ok(
-    promptResult?.includes(`uatType: ${uatType}`) ?? false,
-    `prompt contains dynamic uatType frontmatter value "${uatType}" after substitution`,
+    promptResult?.includes(`uatType: "${uatType}"`) ?? false,
+    `prompt contains dynamic uatType field "${uatType}" after substitution`,
   );
   assert.ok(
     !/\{\{[^}]+\}\}/.test(promptResult ?? ''),
@@ -249,7 +281,7 @@ test('(k) run-uat prompt template', () => {
   );
 });
 
-test('(k2) run-uat prompt references gsd_summary_save, not direct write', () => {
+test('(k2) run-uat prompt references gsd_uat_result_save, not direct write', () => {
   const promptResult = loadPromptFromWorktree('run-uat', {
     workingDirectory: '/tmp/test-project',
     milestoneId: 'M001',
@@ -261,17 +293,25 @@ test('(k2) run-uat prompt references gsd_summary_save, not direct write', () =>
   });
 
   assert.ok(
-    promptResult.includes('gsd_summary_save'),
-    'run-uat prompt should reference gsd_summary_save tool',
+    promptResult.includes('gsd_uat_result_save'),
+    'run-uat prompt should reference gsd_uat_result_save tool',
+  );
+  assert.ok(
+    promptResult.includes('presentedTools') && promptResult.includes('blockedTools'),
+    'run-uat prompt should specify the tool presentation contract',
   );
   assert.ok(
-    promptResult.includes('artifact_type: "ASSESSMENT"'),
-    'run-uat prompt should specify ASSESSMENT artifact type',
+    !promptResult.includes('Call `gsd_summary_save`'),
+    'run-uat prompt should not instruct direct summary-save UAT persistence',
   );
   assert.ok(
     !promptResult.includes('MUST write'),
     'run-uat prompt should not instruct direct file write in footer',
   );
+  assert.ok(
+    !promptResult.includes('Call `gsd_summary_save` with `artifact_type: "ASSESSMENT"`'),
+    'run-uat prompt should not instruct the legacy summary-save UAT path',
+  );
 });
 
 test('(l) dispatch preconditions via resolveSliceFile', () => {
@@ -482,8 +522,8 @@ test('(n) stale replay guard', async () => {
 });
 
 test('(q) verdict in ASSESSMENT file skips UAT dispatch (file-based path)', async () => {
-    // Regression test for #2644: run-uat prompt writes the verdict to
-    // S{sid}-ASSESSMENT.md (via gsd_summary_save artifact_type:"ASSESSMENT"),
+    // Regression test for #2644: run-uat writes the verdict to
+    // S{sid}-ASSESSMENT.md through the structured UAT save path,
     // but checkNeedsRunUat only checked S{sid}-UAT.md — causing a stuck loop.
     const base = createFixtureBase();
     try {
@@ -679,11 +719,27 @@ test('(u) run-uat prompt promotes artifact-driven browser specs to browser-execu
       const prompt = await buildRunUatPrompt('M001', 'S01', uatRel, uatContent, base);
 
       assert.match(prompt, /\*\*Detected UAT mode:\*\*\s*`browser-executable`/);
-      assert.match(prompt, /uatType: browser-executable/);
+      assert.match(prompt, /uatType: "browser-executable"/);
       assert.match(prompt, /use gsd-browser tools/i);
     } finally {
       cleanup(base);
     }
 });
 
+test('(v) run-uat prompt keeps deferred browser work artifact-driven', async () => {
+    const base = createFixtureBase();
+    try {
+      const uatRel = '.gsd/milestones/M001/slices/S01/S01-UAT.md';
+      const uatContent = makeDeferredBrowserUatContent();
+      writeSliceFile(base, 'M001', 'S01', 'UAT', uatContent);
+
+      const prompt = await buildRunUatPrompt('M001', 'S01', uatRel, uatContent, base);
+
+      assert.match(prompt, /\*\*Detected UAT mode:\*\*\s*`artifact-driven`/);
+      assert.match(prompt, /uatType: "artifact-driven"/);
+      assert.doesNotMatch(prompt, /uatType: "browser-executable"/);
+    } finally {
+      cleanup(base);
+    }
+});
 });