@opengsd/gsd-pi 1.1.1-dev.3ea310e → 1.1.1-dev.595401e

package/src/resources/extensions/gsd/tests/tui-header-lifecycle.test.ts

@@ -7,12 +7,17 @@
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { mkdirSync, rmSync } from "node:fs";
+import { mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { visibleWidth } from "@gsd/pi-tui";
 
-import { setCompletionProgressWidget, updateProgressWidget } from "../auto-dashboard.ts";
+import {
+  _resetWidgetModeForTests,
+  setCompletionProgressWidget,
+  setWidgetMode,
+  updateProgressWidget,
+} from "../auto-dashboard.ts";
 import type { GSDState } from "../types.ts";
 
 interface CapturedSetHeader {
@@ -143,10 +148,18 @@ test("updateProgressWidget gracefully no-ops when ctx.ui lacks setHeader/setStat
 
 // ── NEXT-mode footer guidance ───────────────────────────────────────────
 
-test("auto-dashboard widget render output includes /gsd next guidance when isStepMode is true", (t) => {
+test("auto-dashboard full widget render output includes /gsd next guidance when isStepMode is true", (t) => {
   const dir = makeTempDir("step-hint");
   mkdirSync(join(dir, ".gsd"), { recursive: true });
-  t.after(() => cleanup(dir));
+  const projectPrefsPath = join(dir, ".gsd", "preferences.md");
+  const globalPrefsPath = join(dir, ".gsd", "global-preferences.md");
+  writeFileSync(projectPrefsPath, "---\nversion: 1\n---\n", "utf-8");
+  _resetWidgetModeForTests();
+  setWidgetMode("full", projectPrefsPath, globalPrefsPath);
+  t.after(() => {
+    _resetWidgetModeForTests();
+    cleanup(dir);
+  });
 
   let widgetFactory: ((tui: unknown, theme: unknown) => any) | undefined;
 
@@ -173,6 +186,7 @@ test("auto-dashboard widget render output includes /gsd next guidance when isSte
     bold: (text: string) => text,
   };
   const component = widgetFactory!(fakeTui, fakeTheme);
+  t.after(() => component.dispose?.());
   const lines = component.render(120);
 
   const hasStepHint = lines.some((line: string) => line.includes("/gsd next to advance one step"));
@@ -181,10 +195,18 @@ test("auto-dashboard widget render output includes /gsd next guidance when isSte
   if (component.dispose) component.dispose();
 });
 
-test("auto-dashboard widget render output omits /gsd next guidance when isStepMode is false", (t) => {
+test("auto-dashboard full widget render output omits /gsd next guidance when isStepMode is false", (t) => {
   const dir = makeTempDir("no-step-hint");
   mkdirSync(join(dir, ".gsd"), { recursive: true });
-  t.after(() => cleanup(dir));
+  const projectPrefsPath = join(dir, ".gsd", "preferences.md");
+  const globalPrefsPath = join(dir, ".gsd", "global-preferences.md");
+  writeFileSync(projectPrefsPath, "---\nversion: 1\n---\n", "utf-8");
+  _resetWidgetModeForTests();
+  setWidgetMode("full", projectPrefsPath, globalPrefsPath);
+  t.after(() => {
+    _resetWidgetModeForTests();
+    cleanup(dir);
+  });
 
   let widgetFactory: ((tui: unknown, theme: unknown) => any) | undefined;
 
@@ -211,6 +233,7 @@ test("auto-dashboard widget render output omits /gsd next guidance when isStepMo
     bold: (text: string) => text,
   };
   const component = widgetFactory!(fakeTui, fakeTheme);
+  t.after(() => component.dispose?.());
   const lines = component.render(120);
 
   const hasStepHint = lines.some((line: string) => line.includes("/gsd next to advance one step"));

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

@@ -344,6 +344,7 @@ test("#5843: run-uat uses verification tools policy so build/test commands can r
   const manifest = UNIT_MANIFESTS["run-uat"];
 
   assert.strictEqual(manifest.tools.mode, "verification");
+  assert.deepEqual(manifest.tools.allowedSubagents, ["mnemo", "scout", "reviewer", "tester"]);
 
   const buildResult = shouldBlockPlanningUnit(
     "bash",
@@ -367,6 +368,20 @@ test("#5843: run-uat uses verification tools policy so build/test commands can r
   );
   assert.strictEqual(sourceWriteResult.block, true);
   assert.match(sourceWriteResult.reason!, /tools-policy "verification"/);
+
+  const subagentResult = shouldBlockPlanningUnit(
+    "subagent",
+    "",
+    process.cwd(),
+    "run-uat",
+    manifest.tools,
+    ["mnemo"],
+  );
+  assert.strictEqual(
+    subagentResult.block,
+    false,
+    `run-uat must allow listed verification subagents: ${subagentResult.reason}`,
+  );
 });
 
 test("planning-dispatch hard block message omits internal tracker references", () => {
@@ -420,6 +435,11 @@ test('Unit Tool Contract exposes subagent dispatch permissions', () => {
     allowedSubagents: ["reviewer", "security", "tester"],
     toolsMode: "planning-dispatch",
   });
+  assert.deepEqual(resolveSubagentPermissionContract("run-uat"), {
+    allowed: true,
+    allowedSubagents: ["mnemo", "scout", "reviewer", "tester"],
+    toolsMode: "verification",
+  });
   assert.deepEqual(resolveSubagentPermissionContract("discuss-milestone"), {
     allowed: false,
     allowedSubagents: [],
@@ -427,21 +447,24 @@ test('Unit Tool Contract exposes subagent dispatch permissions', () => {
   });
 });
 
-test('planning-dispatch manifests declare non-empty allowedSubagents lists', () => {
+test('dispatch-capable manifests declare globally allowed subagents', () => {
   for (const [unitType, manifest] of Object.entries(UNIT_MANIFESTS)) {
-    if (manifest.tools.mode !== "planning-dispatch") continue;
+    const allowedSubagents = "allowedSubagents" in manifest.tools
+      ? manifest.tools.allowedSubagents
+      : undefined;
+    if (!allowedSubagents) continue;
     assert.ok(
-      Array.isArray(manifest.tools.allowedSubagents) && manifest.tools.allowedSubagents.length > 0,
-      `manifest "${unitType}" has planning-dispatch policy but no allowedSubagents — explicit allowlist is required for runtime dispatch gating`,
+      Array.isArray(allowedSubagents) && allowedSubagents.length > 0,
+      `manifest "${unitType}" enables subagent dispatch but has no allowedSubagents — explicit allowlist is required for runtime dispatch gating`,
     );
-    for (const agent of manifest.tools.allowedSubagents) {
+    for (const agent of allowedSubagents) {
       assert.ok(
         typeof agent === "string" && agent.length > 0,
         `manifest "${unitType}" has empty/invalid allowedSubagents entry: ${JSON.stringify(agent)}`,
       );
       assert.ok(
         ALLOWED_PLANNING_DISPATCH_AGENTS.has(agent),
-        `manifest "${unitType}" allows "${agent}", but the runtime planning-dispatch registry will hard-block it`,
+        `manifest "${unitType}" allows "${agent}", but the runtime controlled-dispatch registry will hard-block it`,
       );
     }
   }

package/src/resources/extensions/gsd/tests/validate-milestone-prompt-verification-classes.test.ts

@@ -11,11 +11,14 @@ const prompt = readFileSync(promptPath, "utf-8");
 
 test("validate-milestone reviewer C requires canonical verification class names", () => {
   assert.match(prompt, /\*\*Reviewer C[\s\S]*Verification Classes/i);
-  assert.match(prompt, /exact class names [`']?Contract[`']?, [`']?Integration[`']?, [`']?Operational[`']?, and [`']?UAT[`']?/i);
+  assert.match(prompt, /must be exactly `Contract`, `Integration`, `Operational`, or `UAT`/i);
+  assert.match(prompt, /Preserve every planned non-empty class row/i);
+  assert.match(prompt, /first cell of each row must be exactly `Contract`, `Integration`, `Operational`, or `UAT`/i);
   assert.match(prompt, /If no verification classes were planned, say that explicitly/i);
 });
 
 test("validate-milestone prompt routes verification class analysis into verificationClasses", () => {
-  assert.match(prompt, /pass it in `verificationClasses`/i);
-  assert.match(prompt, /Extract the `Verification Classes` subsection from Reviewer C and pass it verbatim in `verificationClasses`/);
+  assert.match(prompt, /pass a complete canonical table in `verificationClasses`/i);
+  assert.match(prompt, /If Reviewer C omitted a planned class, reconstruct the missing row/i);
+  assert.match(prompt, /Do not call `gsd_validate_milestone` with a partial `verificationClasses` table/i);
 });

package/src/resources/extensions/gsd/tests/validate-milestone-write-order.test.ts

@@ -180,6 +180,35 @@ describe("handleValidateMilestone write ordering (#2725)", () => {
     assert.equal(row, undefined, "assessment row should not be written when verification classes are invalid");
   });
 
+  it("reports all missing planned verification class rows at once", async () => {
+    base = makeTmpBase();
+    const dbPath = join(base, ".gsd", "gsd.db");
+    openDatabase(dbPath);
+    insertMilestone({
+      id: "M001",
+      planning: {
+        verificationContract: "Contract command exits 0",
+        verificationOperational: "Process lifecycle proof",
+        verificationUat: "Browser-observable UAT proof",
+      },
+    });
+    insertSlice({ id: "S01", milestoneId: "M001" });
+
+    const result = await handleValidateMilestone(
+      { ...VALID_PARAMS, verificationClasses: "| Check | Result |\n| --- | --- |\n| Generic verification | PASS |" },
+      base,
+    );
+    assert.ok("error" in result, "expected validation to fail");
+    assert.match(result.error, /canonical rows "Contract", "Operational", "UAT"/);
+    assert.match(result.error, /planned contract, operational, uat verification/);
+
+    const adapter = _getAdapter()!;
+    const row = adapter.prepare(
+      `SELECT status FROM assessments WHERE milestone_id = 'M001' AND scope = 'milestone-validation'`,
+    ).get() as { status: string } | undefined;
+    assert.equal(row, undefined, "assessment row should not be written when verification classes are invalid");
+  });
+
   it("accepts verificationClasses when planned Operational class is present", async () => {
     base = makeTmpBase();
     const dbPath = join(base, ".gsd", "gsd.db");
@@ -406,6 +435,110 @@ describe("handleValidateMilestone write ordering (#2725)", () => {
     assert.equal(result.verdict, "pass");
   });
 
+  it("keeps pass when browser-like criteria are verified by runtime-executable UAT", async () => {
+    base = makeTmpBase();
+    const dbPath = join(base, ".gsd", "gsd.db");
+    openDatabase(dbPath);
+    insertMilestone({
+      id: "M001",
+      planning: {
+        successCriteria: [
+          "Clicking Mark All Complete sets all todos completed",
+          "Reload keeps completed state",
+        ],
+        verificationUat: "Run the Node.js DOM-state script against the static app source.",
+      },
+    });
+    insertSlice({
+      id: "S01",
+      milestoneId: "M001",
+      // Uses localhost so hasBrowserRequiredText returns true and the gate is
+      // actually triggered before the runtime evidence bypasses it.
+      demo: "Visit localhost:3000 to verify DOM state after clicking Mark All Complete.",
+    });
+    const sliceDir = join(base, ".gsd", "milestones", "M001", "slices", "S01");
+    mkdirSync(sliceDir, { recursive: true });
+    writeFileSync(
+      join(sliceDir, "S01-ASSESSMENT.md"),
+      [
+        "---",
+        "sliceId: S01",
+        "uatType: runtime-executable",
+        "verdict: PASS",
+        "attempt: 1",
+        "---",
+        "# UAT Result - S01",
+        "",
+        "## Checks",
+        "",
+        "| Check | Mode | Result | Evidence | Notes |",
+        "|-------|------|--------|----------|-------|",
+        "| DOM-state script | runtime | PASS | gsd_uat_exec:.gsd/evidence/uat/M001/S01/dom-state.json | Runtime assertion verified completed state and reload persistence. |",
+        "",
+      ].join("\n"),
+      "utf-8",
+    );
+
+    const result = await handleValidateMilestone(
+      {
+        ...VALID_PARAMS,
+        verificationClasses:
+          `${VALID_PARAMS.verificationClasses}\n| UAT | Runtime executable UAT verified static-app behavior. |`,
+      },
+      base,
+    );
+
+    assert.ok(!("error" in result), `unexpected error: ${"error" in result ? result.error : ""}`);
+    assert.equal(result.verdict, "pass");
+  });
+
+  it("downgrades to needs-attention when only one of two browser-requiring slices has runtime evidence", async () => {
+    base = makeTmpBase();
+    const dbPath = join(base, ".gsd", "gsd.db");
+    openDatabase(dbPath);
+    insertMilestone({ id: "M001" });
+    insertSlice({
+      id: "S01",
+      milestoneId: "M001",
+      demo: "Visit localhost:3000 to verify DOM state.",
+    });
+    insertSlice({
+      id: "S02",
+      milestoneId: "M001",
+      demo: "Visit localhost:3000 to confirm persistence after reload.",
+    });
+    // S01 has runtime-executable evidence; S02 has none.
+    mkdirSync(join(base, ".gsd", "milestones", "M001", "slices", "S01"), { recursive: true });
+    writeFileSync(
+      join(base, ".gsd", "milestones", "M001", "slices", "S01", "S01-ASSESSMENT.md"),
+      [
+        "---",
+        "sliceId: S01",
+        "uatType: runtime-executable",
+        "verdict: PASS",
+        "---",
+        "| DOM check | runtime | PASS | gsd_uat_exec:.gsd/evidence/uat/M001/S01/dom.json | Verified. |",
+        "",
+      ].join("\n"),
+      "utf-8",
+    );
+
+    const result = await handleValidateMilestone(
+      {
+        ...VALID_PARAMS,
+        verificationClasses: `${VALID_PARAMS.verificationClasses}\n| UAT | S01 runtime verified; S02 still needs evidence. |`,
+      },
+      base,
+    );
+
+    assert.ok(!("error" in result), `unexpected error: ${"error" in result ? result.error : ""}`);
+    assert.equal(
+      result.verdict,
+      "needs-attention",
+      "S01 runtime evidence must not bypass the gate for S02 which has browser requirements but no evidence",
+    );
+  });
+
   it("ignores slice full_uat_md planning text for browser requirement detection", async () => {
     base = makeTmpBase();
     const dbPath = join(base, ".gsd", "gsd.db");

package/src/resources/extensions/gsd/tests/validation-block-guard.test.ts

@@ -54,6 +54,8 @@ test("validation block allows recovery, diagnostics, and unrelated commands", ()
     "status",
     "verdict pass --rationale ok",
     "validate-milestone",
+    "dispatch reassess",
+    "dispatch reassess-roadmap",
     "dispatch validate",
     "dispatch validate-milestone",
     "park M006",
@@ -122,3 +124,22 @@ test("validation block message includes attempted command and recovery options",
   assert.match(message, /\/gsd verdict pass --rationale/);
   assert.match(message, /\/gsd park M006/);
 });
+
+test("validation block message can guide remediation through dispatch reassess", () => {
+  const message = formatValidationBlockedMessage({
+    ...blockedState(),
+    blockers: [
+      [
+        "Milestone M006 is blocked because milestone validation returned needs-remediation, but all slices are complete.",
+        "Fix options:",
+        "1. Run `/gsd dispatch reassess` to add remediation slices, then run `/gsd auto`",
+        "2. If the finding is acceptable, override it: `/gsd verdict pass --rationale \"why this is okay\"`",
+        "3. If this should wait, defer it explicitly: `/gsd park M006`",
+      ].join("\n"),
+    ],
+  }, "auto");
+
+  assert.ok(message);
+  assert.match(message, /\/gsd dispatch reassess/);
+  assert.doesNotMatch(message, /gsd_reassess_roadmap/);
+});

package/src/resources/extensions/gsd/tests/verification-gate.test.ts

@@ -35,6 +35,20 @@ function makeTempDir(prefix: string): string {
   return dir;
 }
 
+function withRtkDisabled<T>(callback: () => T): T {
+  const previous = process.env.GSD_RTK_DISABLED;
+  process.env.GSD_RTK_DISABLED = "1";
+  try {
+    return callback();
+  } finally {
+    if (previous === undefined) {
+      delete process.env.GSD_RTK_DISABLED;
+    } else {
+      process.env.GSD_RTK_DISABLED = previous;
+    }
+  }
+}
+
 // ─── Discovery Tests ─────────────────────────────────────────────────────────
 
 describe("verification-gate: discovery", () => {
@@ -430,6 +444,38 @@ describe("verification-gate: execution", () => {
     assert.ok(result.checks[1].stderr.includes("err"));
   });
 
+  test("grep -c zero-match failure includes absence-check warning", () => {
+    writeFileSync(join(tmp, "sample.txt"), "present\n");
+
+    const result = withRtkDisabled(() => runVerificationGate({
+      cwd: tmp,
+      preferenceCommands: ["grep -c missing sample.txt"],
+    }));
+
+    assert.equal(result.passed, false);
+    assert.equal(result.checks.length, 1);
+    assert.equal(result.checks[0].exitCode, 1);
+    assert.equal(result.checks[0].stdout.trim(), "0");
+    assert.match(result.checks[0].stderr, /grep -c/);
+    assert.match(result.checks[0].stderr, /count=0/);
+    assert.match(result.checks[0].stderr, /! grep -q/);
+  });
+
+  test("grep -c matching count does not warn", () => {
+    writeFileSync(join(tmp, "sample.txt"), "present\n");
+
+    const result = withRtkDisabled(() => runVerificationGate({
+      cwd: tmp,
+      preferenceCommands: ["grep -c present sample.txt"],
+    }));
+
+    assert.equal(result.passed, true);
+    assert.equal(result.checks.length, 1);
+    assert.equal(result.checks[0].exitCode, 0);
+    assert.equal(result.checks[0].stdout.trim(), "1");
+    assert.equal(result.checks[0].stderr, "");
+  });
+
   test("no commands discovered → gate passes with 0 checks", () => {
     const result = runVerificationGate({
       cwd: tmp,
@@ -686,6 +732,11 @@ test("isLikelyCommand: bash negation with known command is accepted", () => {
   assert.equal(isLikelyCommand("! grep needle file.txt"), true);
 });
 
+test("validateVerificationCommand accepts negated quiet absence checks", () => {
+  assert.equal(validateVerificationCommand("! grep -q needle file.txt").ok, true);
+  assert.equal(validateVerificationCommand("! rg -q needle file.txt").ok, true);
+});
+
 test("validateVerificationCommand allows shell pipelines", () => {
   assert.deepEqual(validateVerificationCommand("python3 -m pytest tests/ -q --tb=short").ok, true);
   const result = validateVerificationCommand("python3 -m pytest tests/ -q --tb=short | tail -5");

package/src/resources/extensions/gsd/tests/workflow-mcp-auto-prep.test.ts

@@ -54,7 +54,7 @@ test("prepareWorkflowMcpForProject uses the selected unit model when session pro
 
   assert.equal(result?.status, "created");
   assert.equal(existsSync(join(projectRoot, ".mcp.json")), true);
-  assert.match(notifications.map((entry) => entry.message).join("\n"), /Claude Code MCP prepared/);
+  assert.match(notifications.map((entry) => entry.message).join("\n"), /GSD MCP Server Prepared/);
 });
 
 test("shouldAutoPrepareWorkflowMcp stays disabled for non-Claude active provider even when claude-code is ready", () => {
@@ -178,7 +178,7 @@ test("before_agent_start auto-prepares project workflow MCP for Claude Code CLI"
     GSD_WORKFLOW_MCP_SERVER_NAME,
     GSD_BROWSER_MCP_SERVER_NAME,
   ]);
-  assert.match(notifications.join("\n"), /Claude Code MCP prepared/);
+  assert.match(notifications.join("\n"), /GSD MCP Server Prepared/);
 });
 
 test("before_agent_start returns discovered skill fallback without project .gsd", async (t) => {

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

@@ -30,6 +30,7 @@ import {
   executeSliceComplete,
   executeSliceReopen,
   executeValidateMilestone,
+  executeUatResultSave,
 } from "../tools/workflow-tool-executors.ts";
 
 function makeTmpBase(): string {
@@ -234,6 +235,62 @@ test("executeTaskComplete derives missing verification from evidence", async ()
   }
 });
 
+test("executeTaskComplete surfaces escalation questions and metadata", async () => {
+  const base = makeTmpBase();
+  try {
+    openTestDb(base);
+    writeFileSync(join(base, ".gsd", "PREFERENCES.md"), [
+      "---",
+      "version: 1",
+      "phases:",
+      "  mid_execution_escalation: true",
+      "---",
+    ].join("\n"));
+    const planDir = join(base, ".gsd", "milestones", "M001", "slices", "S01");
+    mkdirSync(planDir, { recursive: true });
+    writeFileSync(join(planDir, "S01-PLAN.md"), "# S01\n\n- [ ] **T01: Demo** `est:5m`\n");
+
+    const result = await inProjectDir(base, () => executeTaskComplete({
+      milestoneId: "M001",
+      sliceId: "S01",
+      taskId: "T01",
+      oneLiner: "Completed task",
+      narrative: "Did the work but found an ambiguity.",
+      verification: "npm test",
+      escalation: {
+        question: "Should the cache use write-through or write-back?",
+        options: [
+          { id: "A", label: "Write-through", tradeoffs: "Simpler reads; slower writes." },
+          { id: "B", label: "Write-back", tradeoffs: "Faster writes; more flush complexity." },
+        ],
+        recommendation: "A",
+        recommendationRationale: "Current usage favors correctness over write latency.",
+        continueWithDefault: true,
+      },
+    }, base));
+
+    assert.equal(result.details.operation, "complete_task");
+    assert.match(
+      String(result.content[0]?.text),
+      /Task completed with escalation decision required: Should the cache use write-through or write-back\?/,
+    );
+    assert.match(String(result.content[0]?.text), /Resolve with: \/gsd escalate resolve T01/);
+    assert.equal((result.details.escalation as { question?: string }).question, "Should the cache use write-through or write-back?");
+
+    const db = _getAdapter();
+    assert.ok(db, "DB should be open");
+    const row = db!.prepare(
+      "SELECT escalation_pending, escalation_awaiting_review, escalation_artifact_path FROM tasks WHERE milestone_id = ? AND slice_id = ? AND id = ?",
+    ).get("M001", "S01", "T01") as Record<string, unknown> | undefined;
+    assert.equal(row?.escalation_pending, 0);
+    assert.equal(row?.escalation_awaiting_review, 1);
+    assert.ok(String(row?.escalation_artifact_path ?? "").endsWith("T01-ESCALATION.json"));
+  } finally {
+    closeDatabase();
+    cleanup(base);
+  }
+});
+
 test("executeTaskComplete returns a tool error when verification cannot be derived", async () => {
   const base = makeTmpBase();
   try {
@@ -504,6 +561,162 @@ test("executePlanSlice marks validation failures with isError", async () => {
   }
 });
 
+test("executeUatResultSave accepts gsd_uat_exec evidence written in a milestone worktree", async () => {
+  const base = makeTmpBase();
+  const worktree = join(base, ".gsd", "worktrees", "M001");
+  const worktreeExecDir = join(worktree, ".gsd", "exec");
+  const browserTimelineDir = join(base, ".artifacts", "browser", "session");
+  const evidenceId = "worktree-uat-evidence";
+  const browserTimelinePath = join(browserTimelineDir, "s02-uat-browser-timeline.json");
+  try {
+    openTestDb(base);
+    seedMilestone("M001", "Milestone One");
+    seedSlice("M001", "S02", "complete");
+    mkdirSync(worktreeExecDir, { recursive: true });
+    mkdirSync(browserTimelineDir, { recursive: true });
+    writeFileSync(browserTimelinePath, JSON.stringify({ summary: "browser timeline evidence" }), "utf-8");
+    writeFileSync(
+      join(worktreeExecDir, `${evidenceId}.meta.json`),
+      JSON.stringify({
+        id: evidenceId,
+        metadata: {
+          kind: "uat_exec",
+          milestoneId: "M001",
+          sliceId: "S02",
+          checkId: "UAT-01",
+          intent: "uat-runtime-check",
+        },
+      }),
+      "utf-8",
+    );
+
+    const result = await inProjectDir(worktree, () => executeUatResultSave({
+      milestoneId: "M001",
+      sliceId: "S02",
+      uatType: "runtime-executable",
+      verdict: "PASS",
+      checks: [{
+        id: "UAT-01",
+        description: "Runtime path C:\\tmp|uat evidence was captured in the active worktree",
+        mode: "runtime",
+        result: "PASS",
+        evidence: [
+          { kind: "gsd_uat_exec", ref: evidenceId },
+          { kind: "browser", ref: browserTimelinePath },
+        ],
+        notes: "Worktree-local gsd_uat_exec metadata should resolve with backslash \\ and pipe |.",
+      }],
+      presentation: {
+        surface: "mcp",
+        presentedTools: [
+          "gsd_uat_exec",
+          "gsd_uat_result_save",
+          "gsd_resume",
+          "gsd_milestone_status",
+          "gsd_journal_query",
+        ],
+        blockedTools: [
+          { name: "gsd_exec", reason: "forbidden during run-uat" },
+          { name: "gsd_summary_save", reason: "forbidden during run-uat" },
+          { name: "gsd_save_gate_result", reason: "forbidden during run-uat" },
+        ],
+      },
+      notes: "UAT passed with worktree-local evidence.",
+    }, worktree));
+
+    assert.equal(result.isError, undefined);
+    assert.equal(result.details.operation, "save_uat_result");
+    assert.equal(result.details.verdict, "PASS");
+    assert.ok(
+      existsSync(join(base, ".gsd", "uat", "M001", "S02", "attempt-1.json")),
+      "attempt JSON should be persisted under the authoritative project .gsd",
+    );
+    const assessment = readFileSync(
+      join(base, ".gsd", "milestones", "M001", "slices", "S02", "S02-ASSESSMENT.md"),
+      "utf-8",
+    );
+    assert.match(assessment, /Runtime path C:\\\\tmp\\\|uat evidence/);
+    assert.match(assessment, /backslash \\\\ and pipe \\\|/);
+  } finally {
+    closeDatabase();
+    cleanup(base);
+  }
+});
+
+test("executeUatResultSave rejects artifact-driven PASS with human follow-up checks", async () => {
+  const base = makeTmpBase();
+  const worktree = join(base, ".gsd", "worktrees", "M001");
+  const evidenceId = "uat-artifact-nonautomatable";
+  const worktreeExecDir = join(worktree, ".gsd", "exec");
+  try {
+    openTestDb(base);
+    seedMilestone("M001", "Milestone One");
+    seedSlice("M001", "S01", "complete");
+    mkdirSync(worktreeExecDir, { recursive: true });
+    writeFileSync(
+      join(worktreeExecDir, `${evidenceId}.meta.json`),
+      JSON.stringify({
+        id: evidenceId,
+        metadata: {
+          kind: "uat_exec",
+          milestoneId: "M001",
+          sliceId: "S01",
+          checkId: "UAT-01",
+          intent: "uat-artifact-check",
+        },
+      }),
+      "utf-8",
+    );
+
+    const result = await inProjectDir(worktree, () => executeUatResultSave({
+      milestoneId: "M001",
+      sliceId: "S01",
+      uatType: "artifact-driven",
+      verdict: "PASS",
+      checks: [
+        {
+          id: "UAT-01",
+          description: "Static contract passes",
+          mode: "artifact",
+          result: "PASS",
+          evidence: [{ kind: "gsd_uat_exec", ref: evidenceId }],
+          notes: "Artifact check passed.",
+        },
+        {
+          id: "UAT-02",
+          description: "Browser polish is deferred to the next slice",
+          mode: "human-follow-up",
+          result: "NEEDS-HUMAN",
+          notes: "Out of scope for this artifact-driven UAT.",
+          nonAutomatable: true,
+        },
+      ],
+      presentation: {
+        surface: "mcp",
+        presentedTools: [
+          "gsd_uat_exec",
+          "gsd_uat_result_save",
+          "gsd_resume",
+          "gsd_milestone_status",
+          "gsd_journal_query",
+        ],
+        blockedTools: [
+          { name: "gsd_exec", reason: "forbidden during run-uat" },
+          { name: "gsd_summary_save", reason: "forbidden during run-uat" },
+          { name: "gsd_save_gate_result", reason: "forbidden during run-uat" },
+        ],
+      },
+      notes: "UAT passed; non-automatable browser polish is deferred.",
+    }, worktree));
+
+    assert.equal(result.isError, true);
+    assert.match(String(result.content[0]?.text), /artifact-driven UAT cannot PASS with human-only checks/);
+  } finally {
+    closeDatabase();
+    cleanup(base);
+  }
+});
+
 test("executeSliceComplete coerces string enrichment entries and writes summary/UAT artifacts", async () => {
   const base = makeTmpBase();
   try {