@opengsd/gsd-pi 1.1.1-dev.2034b16 → 1.1.1-dev.2de7ea0

package/src/resources/extensions/gsd/tests/post-unit-retry-on-orchestrator-bridge.test.ts

@@ -8,6 +8,7 @@ import { mock } from "node:test";
 import { postUnitPostVerification, type PostUnitContext } from "../auto-post-unit.ts";
 import { AutoSession } from "../auto/session.ts";
 import { checkPostUnitHooks, resetHookState, resolveHookArtifactPath } from "../post-unit-hooks.ts";
+import { emitJournalEvent } from "../journal.ts";
 import { _clearGsdRootCache } from "../paths.ts";
 import { invalidateAllCaches } from "../cache.ts";
 
@@ -28,6 +29,43 @@ post_unit_hooks:
   writeFileSync(join(basePath, ".gsd", "PREFERENCES.md"), content, "utf-8");
 }
 
+function writeFailingHookPreferences(basePath: string): void {
+  const content = `---
+post_unit_hooks:
+  - name: review-arbiter
+    after:
+      - execute-task
+    prompt: Review {taskId}
+    artifact: REVIEW-DEBATE.md
+    max_cycles: 1
+    enabled: true
+  - name: follow-up-review
+    after:
+      - execute-task
+    prompt: Follow-up review {taskId}
+    enabled: true
+---
+`;
+  writeFileSync(join(basePath, ".gsd", "PREFERENCES.md"), content, "utf-8");
+}
+
+function writeBlockingPreferences(basePath: string): void {
+  const content = `---
+post_unit_hooks:
+  - name: review-arbiter
+    after:
+      - execute-task
+    prompt: Review {taskId}
+    agent: arbiter
+    artifact: REVIEW-DEBATE.md
+    criticality: blocking
+    max_cycles: 2
+    enabled: true
+---
+`;
+  writeFileSync(join(basePath, ".gsd", "PREFERENCES.md"), content, "utf-8");
+}
+
 test("post-unit retry_on marks trigger unit as retry in orchestrator before redispatch", async () => {
   const originalCwd = process.cwd();
   const base = mkdtempSync(join(tmpdir(), "gsd-post-unit-retry-"));
@@ -91,3 +129,144 @@ test("post-unit retry_on marks trigger unit as retry in orchestrator before redi
     rmSync(base, { recursive: true, force: true });
   }
 });
+
+test("failed post-unit hook pauses auto-mode even when its artifact exists", async () => {
+  const originalCwd = process.cwd();
+  const base = mkdtempSync(join(tmpdir(), "gsd-post-unit-hook-failed-"));
+  const taskDir = join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks");
+  mkdirSync(taskDir, { recursive: true });
+
+  try {
+    process.chdir(base);
+    _clearGsdRootCache();
+    invalidateAllCaches();
+    resetHookState();
+    writeFailingHookPreferences(base);
+
+    const hookDispatch = checkPostUnitHooks("execute-task", "M001/S01/T01", base);
+    assert.equal(hookDispatch?.hookName, "review-arbiter");
+
+    const artifactPath = resolveHookArtifactPath(base, "M001/S01/T01", "REVIEW-DEBATE.md");
+    writeFileSync(artifactPath, "partial review", "utf-8");
+    emitJournalEvent(base, {
+      ts: "2026-06-03T12:00:00.000Z",
+      flowId: "flow-hook-failed",
+      seq: 3,
+      eventType: "unit-end",
+      data: {
+        unitType: "hook/review-arbiter",
+        unitId: "M001/S01/T01",
+        status: "cancelled",
+        artifactVerified: false,
+      },
+    });
+
+    const pauseAuto = mock.fn(async () => {});
+    const notifications: string[] = [];
+    const s = new AutoSession();
+    s.basePath = base;
+    s.active = true;
+    s.currentUnit = { type: "hook/review-arbiter", id: "M001/S01/T01", startedAt: Date.now() };
+
+    const pctx: PostUnitContext = {
+      s,
+      ctx: {
+        ui: {
+          notify: (message: string) => { notifications.push(message); },
+          setStatus: () => {},
+          setWidget: () => {},
+          setFooter: () => {},
+        },
+        model: { id: "test-model" },
+      } as any,
+      pi: { sendMessage: async () => {}, setModel: async () => true } as any,
+      buildSnapshotOpts: () => ({}),
+      lockBase: () => base,
+      stopAuto: async () => {},
+      pauseAuto,
+      updateProgressWidget: () => {},
+    };
+
+    const result = await postUnitPostVerification(pctx);
+    assert.equal(result, "stopped");
+    assert.equal(pauseAuto.mock.callCount(), 1);
+    assert.ok(
+      notifications.some(message => message.includes("Post-unit hook review-arbiter failed")),
+      "pause notification should explain the failed hook",
+    );
+  } finally {
+    process.chdir(originalCwd);
+    resetHookState();
+    invalidateAllCaches();
+    _clearGsdRootCache();
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("post-unit blocking gate pauses auto-mode on needs-attention verdict", async () => {
+  const originalCwd = process.cwd();
+  const base = mkdtempSync(join(tmpdir(), "gsd-post-unit-gate-"));
+  const taskDir = join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks");
+  mkdirSync(taskDir, { recursive: true });
+
+  try {
+    process.chdir(base);
+    _clearGsdRootCache();
+    invalidateAllCaches();
+    resetHookState();
+    writeBlockingPreferences(base);
+
+    const hookDispatch = checkPostUnitHooks("execute-task", "M001/S01/T01", base);
+    assert.ok(hookDispatch, "hook should dispatch for execute-task");
+
+    const artifactPath = resolveHookArtifactPath(base, "M001/S01/T01", "REVIEW-DEBATE.md");
+    writeFileSync(artifactPath, "---\nverdict: needs-attention\n---\n\nManual review required.\n", "utf-8");
+
+    const pauseAuto = mock.fn(async () => {});
+    const s = new AutoSession();
+    s.basePath = base;
+    s.active = true;
+    s.currentUnit = { type: "hook/review-arbiter", id: "M001/S01/T01", startedAt: Date.now() };
+    s.orchestration = {
+      start: async () => ({ kind: "started" }),
+      advance: async () => ({ kind: "stopped", reason: "unused" }),
+      completeActiveUnit: async () => {},
+      retryActiveUnit: async () => {},
+      resume: async () => ({ kind: "resumed" }),
+      stop: async (reason: string) => ({ kind: "stopped", reason }),
+      getStatus: () => ({ phase: "running", transitionCount: 0 }),
+    };
+
+    const notifications: string[] = [];
+    const pctx: PostUnitContext = {
+      s,
+      ctx: {
+        ui: {
+          notify: (message: string) => { notifications.push(message); },
+          setStatus: () => {},
+          setWidget: () => {},
+          setFooter: () => {},
+        },
+        model: { id: "test-model" },
+      } as any,
+      pi: { sendMessage: async () => {}, setModel: async () => true } as any,
+      buildSnapshotOpts: () => ({}),
+      lockBase: () => base,
+      stopAuto: async () => {},
+      pauseAuto,
+      updateProgressWidget: () => {},
+    };
+
+    const result = await postUnitPostVerification(pctx);
+    assert.equal(result, "stopped");
+    assert.equal(pauseAuto.mock.callCount(), 1);
+    assert.match(notifications.join("\n"), /Post-unit gate "review-arbiter" blocked execute-task M001\/S01\/T01/);
+    assert.match(notifications.join("\n"), /\/gsd status/);
+  } finally {
+    process.chdir(originalCwd);
+    resetHookState();
+    invalidateAllCaches();
+    _clearGsdRootCache();
+    rmSync(base, { recursive: true, force: true });
+  }
+});

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

@@ -561,6 +561,35 @@ test("post-unit hook max_cycles clamping via validatePreferences", () => {
   assert.equal(p4.post_unit_hooks![0].max_cycles, 3, "valid value passes through");
 });
 
+test("post-unit hook criticality and on_block validation", () => {
+  const base = { name: "h", after: ["execute-task"], prompt: "do something", artifact: "REVIEW.md" };
+
+  const { preferences, errors } = validatePreferences({
+    post_unit_hooks: [{
+      ...base,
+      criticality: "blocking",
+      on_block: { action: "retry-unit", artifact: "NEEDS-REWORK.md" },
+    }],
+  } as any);
+  assert.equal(errors.length, 0);
+  assert.equal(preferences.post_unit_hooks![0].criticality, "blocking");
+  assert.deepEqual(preferences.post_unit_hooks![0].on_block, {
+    action: "retry-unit",
+    artifact: "NEEDS-REWORK.md",
+  });
+
+  const missingArtifact = validatePreferences({
+    post_unit_hooks: [{ name: "blocking", after: ["execute-task"], prompt: "do something", criticality: "blocking" }],
+  } as any);
+  assert.match(missingArtifact.errors.join("\n"), /criticality blocking requires artifact/);
+  assert.equal(missingArtifact.preferences.post_unit_hooks, undefined);
+
+  const invalidAction = validatePreferences({
+    post_unit_hooks: [{ ...base, on_block: { action: "teleport" } }],
+  } as any);
+  assert.match(invalidAction.errors.join("\n"), /invalid on_block action/);
+});
+
 test("pre-dispatch hook action validation via validatePreferences", () => {
   const base = { name: "h", before: ["execute-task"] };
 

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

@@ -2,6 +2,7 @@ import test from "node:test";
 import assert from "node:assert/strict";
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
+import { RUN_UAT_WORKFLOW_TOOL_NAMES } from "../tool-presentation-plan.ts";
 
 const promptsDir = join(process.cwd(), "src/resources/extensions/gsd/prompts");
 const templatesDir = join(process.cwd(), "src/resources/extensions/gsd/templates");
@@ -25,11 +26,15 @@ test("reactive-execute prompt keeps task summaries with subagents and avoids bat
 test("run-uat prompt branches on dynamic UAT mode and supports runtime evidence", () => {
   const prompt = readPrompt("run-uat");
   assert.match(prompt, /\*\*Detected UAT mode:\*\*\s*`\{\{uatType\}\}`/);
-  assert.match(prompt, /uatType:\s*\{\{uatType\}\}/);
+  assert.match(prompt, /uatType:\s*"\{\{uatType\}\}"/);
+  assert.match(prompt, /gsd_uat_result_save/);
+  assert.match(prompt, /presentedTools/);
+  assert.match(prompt, /blockedTools/);
   assert.match(prompt, /live-runtime/);
   assert.match(prompt, /browser\/runtime\/network/i);
   assert.match(prompt, /NEEDS-HUMAN/);
   assert.doesNotMatch(prompt, /uatType:\s*artifact-driven/);
+  assert.doesNotMatch(prompt, /Call `gsd_summary_save`/);
 });
 
 test("run-uat prompt lists canonical gsd_uat_exec intent values", () => {
@@ -42,6 +47,22 @@ test("run-uat prompt lists canonical gsd_uat_exec intent values", () => {
   assert.match(prompt, /do not use `artifact`, `runtime`, or `human-follow-up` as `intent`/i);
 });
 
+test("run-uat prompt gives the complete UAT result-save presentation contract", () => {
+  const prompt = readPrompt("run-uat");
+  assert.match(prompt, /Call `gsd_uat_result_save` once after all checks are complete/);
+  assert.doesNotMatch(prompt, /Call `gsd_summary_save` with `artifact_type: "ASSESSMENT"`/);
+
+  for (const toolName of RUN_UAT_WORKFLOW_TOOL_NAMES) {
+    assert.ok(prompt.includes(`"${toolName}"`), `prompt should include required presented tool ${toolName}`);
+  }
+
+  for (const toolName of ["gsd_exec", "gsd_summary_save", "gsd_save_gate_result"] as const) {
+    assert.ok(prompt.includes(`name: "${toolName}"`), `prompt should include blocked tool ${toolName}`);
+  }
+
+  assert.ok(prompt.includes("forbidden during run-uat"), "prompt should explain blocked run-uat tools");
+});
+
 test("workflow-start prompt defaults to autonomy instead of per-phase confirmation", () => {
   const prompt = readPrompt("workflow-start");
   assert.match(prompt, /Keep moving by default/i);

package/src/resources/extensions/gsd/tests/prompt-loader-extension-dir.test.ts

@@ -22,6 +22,20 @@ test("resolveExtensionDirFromCandidates prefers user-local dir when both trees a
   assert.equal(resolved, agentDir);
 });
 
+test("resolveExtensionDirFromCandidates prefers source checkout dir when both trees are valid", () => {
+  const moduleDir = "/repo/src/resources/extensions/gsd";
+  const agentDir = "/home/user/.gsd/agent/extensions/gsd";
+  const paths = new Set<string>([
+    join(moduleDir, "prompts"),
+    join(moduleDir, "templates", "task-summary.md"),
+    join(agentDir, "prompts"),
+    join(agentDir, "templates", "task-summary.md"),
+  ]);
+
+  const resolved = resolveExtensionDirFromCandidates(moduleDir, agentDir, makeExists(paths));
+  assert.equal(resolved, moduleDir);
+});
+
 test("resolveExtensionDirFromCandidates rejects module dir missing task-summary template", () => {
   const moduleDir = "/npm/global/gsd";
   const agentDir = "/home/user/.gsd/agent/extensions/gsd";

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

@@ -8,6 +8,7 @@ import { test, describe, beforeEach } from "node:test";
 import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
+import { emitJournalEvent } from "../journal.ts";
 import {
   RuleRegistry,
   getRegistry,
@@ -16,6 +17,7 @@ import {
   resetRegistry,
   convertDispatchRules,
   getOrCreateRegistry,
+  resolveHookArtifactPath,
 } from "../rule-registry.ts";
 import type { UnifiedRule } from "../rule-types.ts";
 import type { DispatchAction, DispatchContext } from "../auto-dispatch.ts";
@@ -443,6 +445,79 @@ describe("RuleRegistry", () => {
     }
   });
 
+  test("failed hook completion with an artifact does not dequeue the next hook", () => {
+    const originalGsdHome = process.env.GSD_HOME;
+    const projectRoot = mkdtempSync(join(tmpdir(), "gsd-hook-failed-"));
+    const tempGsdHome = mkdtempSync(join(tmpdir(), "gsd-hook-home-"));
+    const unitId = "M001/S01/T01";
+
+    try {
+      mkdirSync(join(projectRoot, ".gsd", "milestones", "M001", "slices", "S01", "tasks"), { recursive: true });
+      writeFileSync(
+        join(projectRoot, ".gsd", "PREFERENCES.md"),
+        [
+          "---",
+          "version: 1",
+          "post_unit_hooks:",
+          "  - name: review-arbiter",
+          "    after: [execute-task]",
+          "    prompt: Review {taskId}",
+          "    artifact: REVIEW.md",
+          "    max_cycles: 1",
+          "  - name: follow-up-review",
+          "    after: [execute-task]",
+          "    prompt: Follow-up review {taskId}",
+          "---",
+        ].join("\n"),
+        "utf-8",
+      );
+      process.env.GSD_HOME = tempGsdHome;
+
+      const registry = new RuleRegistry([]);
+      const firstHook = registry.evaluatePostUnit("execute-task", unitId, projectRoot);
+      assert.equal(firstHook?.hookName, "review-arbiter");
+
+      writeFileSync(
+        resolveHookArtifactPath(projectRoot, unitId, "REVIEW.md"),
+        "partial review output",
+        "utf-8",
+      );
+      emitJournalEvent(projectRoot, {
+        ts: "2026-06-03T12:00:00.000Z",
+        flowId: "flow-hook-failed",
+        seq: 3,
+        eventType: "unit-end",
+        data: {
+          unitType: "hook/review-arbiter",
+          unitId,
+          status: "cancelled",
+          artifactVerified: false,
+          errorContext: {
+            message: "Provider error: Stream ended without finish_reason",
+            category: "provider",
+          },
+        },
+      });
+
+      const nextHook = registry.evaluatePostUnit("hook/review-arbiter", unitId, projectRoot);
+      assert.equal(nextHook, null, "failed hook must not allow follow-up hook dispatch");
+      const failure = registry.consumeHookFailure();
+      assert.equal(failure?.hookName, "review-arbiter");
+      assert.match(failure?.reason ?? "", /status cancelled/);
+
+      const resumedRegistry = new RuleRegistry([]);
+      resumedRegistry.restoreState(projectRoot);
+      const resumedHook = resumedRegistry.evaluatePostUnit("execute-task", unitId, projectRoot);
+      assert.equal(resumedHook, null, "resumed hook evaluation must not skip failed hook artifact");
+      assert.equal(resumedRegistry.consumeHookFailure()?.hookName, "review-arbiter");
+    } finally {
+      if (originalGsdHome === undefined) delete process.env.GSD_HOME;
+      else process.env.GSD_HOME = originalGsdHome;
+      rmSync(projectRoot, { recursive: true, force: true });
+      rmSync(tempGsdHome, { recursive: true, force: true });
+    }
+  });
+
   // ── matchedRule provenance (S02 journal support) ───────────────────
 
   test("evaluateDispatch result includes matchedRule on dispatch match", async () => {

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/workflow-tool-executors.test.ts

@@ -643,6 +643,80 @@ test("executeUatResultSave accepts gsd_uat_exec evidence written in a milestone
   }
 });
 
+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 {