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

package/src/resources/extensions/gsd/tests/merge-closeout-consistency-gate.test.ts

@@ -0,0 +1,63 @@
+// Project/App: gsd-pi
+// File Purpose: Regression tests for DB-backed closeout consistency before merge.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { existsSync, mkdtempSync, mkdirSync, realpathSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { execFileSync } from "node:child_process";
+
+import { mergeMilestoneToMain } from "../auto-worktree.ts";
+import { closeDatabase, insertMilestone, openDatabase } from "../gsd-db.ts";
+
+function git(args: string[], cwd: string): string {
+  return execFileSync("git", args, {
+    cwd,
+    stdio: ["ignore", "pipe", "pipe"],
+    encoding: "utf-8",
+  }).trim();
+}
+
+function createRepo(): string {
+  const dir = realpathSync(mkdtempSync(join(tmpdir(), "merge-closeout-gate-")));
+  git(["init"], dir);
+  git(["config", "user.email", "test@test.com"], dir);
+  git(["config", "user.name", "Test"], dir);
+  mkdirSync(join(dir, ".gsd"), { recursive: true });
+  writeFileSync(join(dir, "README.md"), "# test\n");
+  git(["add", "."], dir);
+  git(["commit", "-m", "init"], dir);
+  git(["branch", "-M", "main"], dir);
+
+  git(["checkout", "-b", "milestone/M001"], dir);
+  writeFileSync(join(dir, "feature.ts"), "export const feature = true;\n");
+  git(["add", "feature.ts"], dir);
+  git(["commit", "-m", "feat: milestone work"], dir);
+  git(["checkout", "main"], dir);
+  return dir;
+}
+
+test("mergeMilestoneToMain blocks when project DB closeout is still open", () => {
+  const savedCwd = process.cwd();
+  const repo = createRepo();
+  try {
+    assert.equal(openDatabase(join(repo, ".gsd", "gsd.db")), true);
+    insertMilestone({ id: "M001", title: "Milestone One", status: "active" });
+
+    const mainHeadBefore = git(["rev-parse", "main"], repo);
+    process.chdir(repo);
+
+    assert.throws(
+      () => mergeMilestoneToMain(repo, "M001", "# M001\n- [x] **S01: Done**\n"),
+      /closeout-consistency-blocked/,
+    );
+
+    assert.equal(git(["rev-parse", "main"], repo), mainHeadBefore);
+    assert.equal(git(["branch", "--show-current"], repo), "main");
+  } finally {
+    closeDatabase();
+    process.chdir(savedCwd);
+    if (existsSync(repo)) rmSync(repo, { recursive: true, force: true });
+  }
+});

package/src/resources/extensions/gsd/tests/merge-db-cycle.test.ts

@@ -15,7 +15,7 @@ import { delimiter, join } from "node:path";
 import { execFileSync } from "node:child_process";
 
 import { mergeMilestoneToMain } from "../auto-worktree.ts";
-import { closeDatabase, openDatabase } from "../gsd-db.ts";
+import { closeDatabase, insertAssessment, insertMilestone, insertSlice, openDatabase } from "../gsd-db.ts";
 import { GIT_NO_PROMPT_ENV } from "../git-constants.js";
 import { _clearGsdRootCache } from "../paths.ts";
 import { _resetServiceCache } from "../worktree.ts";
@@ -145,6 +145,15 @@ test("mergeMilestoneToMain keeps the Windows DB cycle closed through squash merg
 
     withPlatform("win32", () => {
       assert.equal(openDatabase(join(repo, ".gsd", "gsd.db")), true);
+      insertMilestone({ id: "M001", title: "Windows DB cycle", status: "complete" });
+      insertSlice({ id: "S01", milestoneId: "M001", title: "Done Slice", status: "complete" });
+      insertAssessment({
+        path: "milestones/M001/M001-VALIDATION.md",
+        milestoneId: "M001",
+        status: "pass",
+        scope: "milestone-validation",
+        fullContent: "verdict: pass",
+      });
       assert.equal(existsSync(join(repo, ".gsd", "gsd.db-shm")), true);
 
       process.env.PATH = `${bin}${delimiter}${originalPath}`;

package/src/resources/extensions/gsd/tests/milestone-closeout.test.ts

@@ -6,7 +6,7 @@ import assert from "node:assert/strict";
 import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
-import { openDatabase, insertMilestone, closeDatabase } from "../gsd-db.js";
+import { openDatabase, insertAssessment, insertMilestone, insertSlice, closeDatabase } from "../gsd-db.js";
 import {
   isMilestoneCloseoutSettled,
   evaluateCompleteMilestoneDispatch,
@@ -39,6 +39,14 @@ test("isMilestoneCloseoutSettled requires DB closed and summary artifact", async
   mkdirSync(join(base, ".gsd"), { recursive: true });
   openDatabase(join(base, ".gsd", "gsd.db"));
   insertMilestone({ id: "M001", title: "Done", status: "complete" });
+  insertSlice({ id: "S01", milestoneId: "M001", title: "Done Slice", status: "complete" });
+  insertAssessment({
+    path: "milestones/M001/M001-VALIDATION.md",
+    milestoneId: "M001",
+    status: "pass",
+    scope: "milestone-validation",
+    fullContent: "verdict: pass",
+  });
   const milestoneDir = join(base, ".gsd", "milestones", "M001");
   mkdirSync(milestoneDir, { recursive: true });
   writeFileSync(join(milestoneDir, "M001-SUMMARY.md"), "# Milestone Summary\n");

package/src/resources/extensions/gsd/tests/planner-handoff.test.ts

@@ -0,0 +1,100 @@
+import { test, describe } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { GSD_COMMAND_DESCRIPTION, getGsdArgumentCompletions, TOP_LEVEL_SUBCOMMANDS } from "../commands/catalog.ts";
+import { handleCoreCommand } from "../commands/handlers/core.ts";
+import { DISPATCH_RULES } from "../auto-dispatch.ts";
+import {
+  buildGsdPlannerSpawnPlan,
+  formatGsdPlannerCommand,
+  hasPlannerHandoffBeenOffered,
+  markPlannerHandoffOffered,
+  PLANNER_HANDOFF_RULE_NAME,
+} from "../planner-handoff.ts";
+
+describe("planner handoff command catalog", () => {
+  test("/gsd planner is hidden from description and completions", () => {
+    assert.doesNotMatch(GSD_COMMAND_DESCRIPTION, /\|planner(?:\||$)/);
+    assert.equal(
+      TOP_LEVEL_SUBCOMMANDS.some((command) => command.cmd === "planner"),
+      false,
+      "planner should not appear in top-level commands",
+    );
+
+    const completions = getGsdArgumentCompletions("pla");
+
+    assert.equal(
+      completions.some((completion) => completion.value === "planner"),
+      false,
+      "planner should not appear in top-level completions",
+    );
+
+    assert.deepEqual(
+      getGsdArgumentCompletions("planner --"),
+      [],
+      "planner should not expose nested completions",
+    );
+  });
+});
+
+describe("planner handoff command handler", () => {
+  test("/gsd planner falls through to the unknown-command path", async () => {
+    const notifications: Array<{ message: string; level?: string }> = [];
+    const ctx = {
+      ui: {
+        notify(message: string, level?: string) {
+          notifications.push({ message, level });
+        },
+      },
+    };
+
+    const handled = await handleCoreCommand("planner M001 --dry-run --inspect", ctx as any);
+
+    assert.equal(handled, false);
+    assert.deepEqual(notifications, []);
+  });
+});
+
+describe("planner handoff launcher", () => {
+  test("builds gsd-planner command with project and milestone context", () => {
+    const plan = buildGsdPlannerSpawnPlan({
+      basePath: "/tmp/project with spaces",
+      milestoneId: "M001",
+      extraArgs: ["--inspect"],
+    });
+
+    assert.deepEqual(plan, {
+      command: "gsd-planner",
+      args: ["--project", "/tmp/project with spaces", "--milestone", "M001", "--inspect"],
+      cwd: "/tmp/project with spaces",
+    });
+    assert.equal(
+      formatGsdPlannerCommand(plan),
+      'gsd-planner --project "/tmp/project with spaces" --milestone M001 --inspect',
+    );
+  });
+
+  test("records one-shot handoff markers per milestone", () => {
+    const basePath = mkdtempSync(join(tmpdir(), "gsd-planner-marker-"));
+    try {
+      assert.equal(hasPlannerHandoffBeenOffered(basePath, "M001"), false);
+      markPlannerHandoffOffered(basePath, "M001");
+      assert.equal(hasPlannerHandoffBeenOffered(basePath, "M001"), true);
+      assert.equal(hasPlannerHandoffBeenOffered(basePath, "M002"), false);
+    } finally {
+      rmSync(basePath, { recursive: true, force: true });
+    }
+  });
+});
+
+describe("planner handoff dispatch rule", () => {
+  test("rule is not registered while /gsd planner is disabled", () => {
+    assert.equal(
+      DISPATCH_RULES.some((rule) => rule.name === PLANNER_HANDOFF_RULE_NAME),
+      false,
+    );
+  });
+});

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

@@ -2,7 +2,21 @@ 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";
+import {
+  RUN_UAT_BROWSER_TOOL_NAMES,
+  buildRunUatResultPresentation,
+  buildRunUatPresentationForType,
+  RUN_UAT_READ_ONLY_TOOL_NAMES,
+  RUN_UAT_TOOL_PRESENTATION_PLAN_ID,
+  RUN_UAT_WORKFLOW_TOOL_NAMES,
+} from "../tool-presentation-plan.ts";
+import {
+  buildMinimalAutoGsdToolSet,
+  MINIMAL_AUTO_BASE_TOOL_NAMES,
+  MINIMAL_GSD_TOOL_NAMES,
+} from "../bootstrap/register-hooks.ts";
+import { shouldBlockAutoUnitToolCall } from "../auto-unit-tool-scope.ts";
+import { UNIT_TOOL_CONTRACTS } from "../unit-tool-contracts.ts";
 
 const promptsDir = join(process.cwd(), "src/resources/extensions/gsd/prompts");
 const templatesDir = join(process.cwd(), "src/resources/extensions/gsd/templates");
@@ -15,6 +29,84 @@ function readTemplate(name: string): string {
   return readFileSync(join(templatesDir, `${name}.md`), "utf-8");
 }
 
+function escapeRegExp(value: string): string {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+const registeredPhaseToolNames = [
+  ...new Set([
+    ...MINIMAL_AUTO_BASE_TOOL_NAMES,
+    ...MINIMAL_GSD_TOOL_NAMES,
+    ...Object.values(UNIT_TOOL_CONTRACTS).flatMap((contract) => contract.allowedGsdTools),
+  ]),
+];
+
+const PHASE_PROMPT_TOOL_CALLS: Record<string, readonly string[]> = {
+  "research-milestone": ["gsd_summary_save"],
+  "plan-milestone": [
+    "gsd_milestone_status",
+    "gsd_plan_milestone",
+    "gsd_plan_slice",
+    "gsd_decision_save",
+  ],
+  "research-slice": ["gsd_summary_save"],
+  "plan-slice": ["gsd_reassess_roadmap", "gsd_plan_slice", "gsd_decision_save"],
+  "refine-slice": ["gsd_plan_slice", "gsd_decision_save"],
+  "replan-slice": ["gsd_replan_slice"],
+  "execute-task": ["gsd_task_complete"],
+  "reactive-execute": ["gsd_summary_save"],
+  "complete-slice": [
+    "gsd_exec",
+    "gsd_task_reopen",
+    "gsd_replan_slice",
+    "gsd_requirement_update",
+    "capture_thought",
+    "gsd_slice_complete",
+    "gsd_summary_save",
+  ],
+  "reassess-roadmap": ["gsd_milestone_status", "gsd_reassess_roadmap"],
+  "validate-milestone": ["gsd_milestone_status", "gsd_validate_milestone", "gsd_reassess_roadmap"],
+  "run-uat": ["gsd_uat_exec", "gsd_uat_result_save"],
+  "gate-evaluate": ["gsd_save_gate_result"],
+  "complete-milestone": [
+    "gsd_milestone_status",
+    "gsd_requirement_update",
+    "gsd_summary_save",
+    "capture_thought",
+    "gsd_complete_milestone",
+  ],
+};
+
+test("auto phase prompt tool calls are available in scoped tool surfaces", () => {
+  for (const [unitType, promptTools] of Object.entries(PHASE_PROMPT_TOOL_CALLS)) {
+    const prompt = readPrompt(unitType);
+    const activeTools = buildMinimalAutoGsdToolSet(
+      registeredPhaseToolNames,
+      unitType,
+      registeredPhaseToolNames,
+    );
+
+    for (const toolName of promptTools) {
+      assert.match(
+        prompt,
+        new RegExp(`\\b${escapeRegExp(toolName)}\\b`),
+        `${unitType} prompt should mention ${toolName}`,
+      );
+      assert.ok(
+        activeTools.includes(toolName),
+        `${unitType} prompt mentions ${toolName}, but scoped tools are ${activeTools.join(", ")}`,
+      );
+
+      const scopeResult = shouldBlockAutoUnitToolCall(unitType, toolName);
+      assert.equal(
+        scopeResult.block,
+        false,
+        `${unitType} phase gate blocked ${toolName}: ${scopeResult.reason ?? "unknown reason"}`,
+      );
+    }
+  }
+});
+
 test("reactive-execute prompt keeps task summaries with subagents and avoids batch commits", () => {
   const prompt = readPrompt("reactive-execute");
   assert.match(prompt, /subagent-written summary as authoritative/i);
@@ -29,7 +121,7 @@ test("run-uat prompt branches on dynamic UAT mode and supports runtime evidence"
   assert.match(prompt, /uatType:\s*"\{\{uatType\}\}"/);
   assert.match(prompt, /gsd_uat_result_save/);
   assert.match(prompt, /presentedTools/);
-  assert.match(prompt, /blockedTools/);
+  assert.match(prompt, /\{\{canonicalPresentation\}\}/);
   assert.match(prompt, /live-runtime/);
   assert.match(prompt, /browser\/runtime\/network/i);
   assert.match(prompt, /NEEDS-HUMAN/);
@@ -51,16 +143,66 @@ 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"`/);
+  assert.match(prompt, /\{\{canonicalPresentation\}\}/);
+  assert.match(prompt, /\{\{toolPresentationPlanId\}\}/);
 
+  const presentation = buildRunUatResultPresentation();
+  assert.equal(presentation.toolPresentationPlanId, RUN_UAT_TOOL_PRESENTATION_PLAN_ID);
   for (const toolName of RUN_UAT_WORKFLOW_TOOL_NAMES) {
-    assert.ok(prompt.includes(`"${toolName}"`), `prompt should include required presented tool ${toolName}`);
+    assert.ok(presentation.presentedTools.includes(toolName), `presentation should include required tool ${toolName}`);
+  }
+  for (const toolName of RUN_UAT_READ_ONLY_TOOL_NAMES) {
+    assert.ok(presentation.presentedTools.includes(toolName), `presentation should include read-only 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(
+      presentation.blockedTools.some((entry) => entry.name === toolName),
+      `presentation should include blocked tool ${toolName}`,
+    );
+  }
+
+  assert.ok(
+    presentation.blockedTools.every((entry) => entry.reason === "forbidden during run-uat"),
+    "presentation should explain blocked run-uat tools",
+  );
+});
+
+test("browser-executable UAT presentation uses direct browser tools", () => {
+  const presentation = buildRunUatPresentationForType("browser-executable");
+
+  assert.equal(presentation.surface, "hybrid");
+  for (const toolName of RUN_UAT_BROWSER_TOOL_NAMES) {
+    assert.ok(presentation.presentedTools.includes(toolName), `presentation should include browser tool ${toolName}`);
+  }
+  assert.ok(!presentation.presentedTools.some((toolName) => toolName.startsWith("mcp__gsd-browser__")));
+});
+
+test("live-runtime and mixed UAT presentations also surface browser tools", () => {
+  // Regression (M001/S03): the run-uat prompt tells live-runtime and mixed to
+  // drive a browser, so the runner must actually receive the browser tools and
+  // a hybrid surface — otherwise live checks silently downgrade to NEEDS-HUMAN.
+  for (const uatType of ["live-runtime", "mixed", "human-experience"] as const) {
+    const presentation = buildRunUatPresentationForType(uatType);
+    assert.equal(presentation.surface, "hybrid", `${uatType} should use the hybrid surface`);
+    for (const toolName of RUN_UAT_BROWSER_TOOL_NAMES) {
+      assert.ok(
+        presentation.presentedTools.includes(toolName),
+        `${uatType} presentation should include browser tool ${toolName}`,
+      );
+    }
   }
+});
 
-  assert.ok(prompt.includes("forbidden during run-uat"), "prompt should explain blocked run-uat tools");
+test("artifact-driven and runtime-executable UAT presentations stay browser-free", () => {
+  for (const uatType of ["artifact-driven", "runtime-executable"] as const) {
+    const presentation = buildRunUatPresentationForType(uatType);
+    assert.equal(presentation.surface, "mcp", `${uatType} should use the mcp surface`);
+    assert.ok(
+      !RUN_UAT_BROWSER_TOOL_NAMES.some((toolName) => presentation.presentedTools.includes(toolName)),
+      `${uatType} presentation should not include browser tools`,
+    );
+  }
 });
 
 test("workflow-start prompt defaults to autonomy instead of per-phase confirmation", () => {

package/src/resources/extensions/gsd/tests/provider-switch-observer.test.ts

@@ -210,6 +210,61 @@ test("end-to-end: audit event is emitted when an auto trace is active", async ()
   }
 });
 
+test("same-API transform with changes does not fire the observer (no real provider switch)", async () => {
+  const { basePath, cleanup } = withTempBasePath();
+  try {
+    initNotificationStore(basePath);
+    installProviderSwitchObserver();
+
+    // Target api === source api. The conversation ends on an unresolved tool
+    // call, so a synthetic tool result IS backfilled (a non-empty report) — but
+    // this is a within-provider normalization, not a cross-provider switch.
+    // `sourceApi` is omitted (the common case), so fromApi defaults to the
+    // target api and equals toApi. The observer must stay silent.
+    const sameApiModel = {
+      id: "gpt-5",
+      name: "GPT-5",
+      api: "openai-responses",
+      provider: "openai",
+      baseUrl: "",
+      reasoning: false,
+      input: ["text"],
+      cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+      contextWindow: 128000,
+      maxTokens: 8192,
+    } as Parameters<typeof transformMessagesWithReport>[1];
+
+    const messages = [
+      {
+        role: "assistant" as const,
+        content: [
+          { type: "toolCall" as const, id: "call_orphan_1", name: "bash", arguments: {} },
+        ],
+        api: "openai-responses",
+        provider: "openai",
+        model: "gpt-5",
+        usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, totalTokens: 0, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 } },
+        stopReason: "stop" as const,
+        timestamp: Date.now(),
+      },
+    ];
+
+    transformMessagesWithReport(
+      messages as Parameters<typeof transformMessagesWithReport>[0],
+      sameApiModel,
+    );
+
+    assert.equal(getProviderSwitchStats().totalSwitches, 0, "same→same transform must not count as a provider switch");
+    assert.equal(
+      readNotifications(basePath).filter((n) => n.message.includes("Provider switch")).length,
+      0,
+      "same→same transform must not emit a provider-switch notification",
+    );
+  } finally {
+    cleanup();
+  }
+});
+
 test("empty report does not bump counter or emit a notification", async () => {
   const { basePath, cleanup } = withTempBasePath();
   try {

package/src/resources/extensions/gsd/tests/register-hooks-depth-verification.test.ts

@@ -70,6 +70,50 @@ test("register-hooks hard-blocks destructive bash commands outside auto-mode", a
   assert.match(block?.reason ?? "", /IaC apply\/destroy/);
 });
 
+test("register-hooks keeps depth-gate reason model-facing and adds displayReason", async (t) => {
+  const dir = makeTempDir("display-reason");
+  const originalCwd = process.cwd();
+  process.chdir(dir);
+  resetWriteGateState(dir);
+
+  t.after(() => {
+    try {
+      resetWriteGateState(dir);
+    } finally {
+      process.chdir(originalCwd);
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  const handlers = new Map<string, Array<(event: any, ctx?: any) => Promise<any> | any>>();
+  const pi = {
+    on(event: string, handler: (event: any, ctx?: any) => Promise<any> | any) {
+      const existing = handlers.get(event) ?? [];
+      existing.push(handler);
+      handlers.set(event, existing);
+    },
+  } as any;
+
+  registerHooks(pi, []);
+
+  let block: any;
+  for (const handler of handlers.get("tool_call") ?? []) {
+    const result = await handler({
+      toolName: "write",
+      input: {
+        path: join(dir, ".gsd", "milestones", "M001", "M001-CONTEXT.md"),
+        content: "# M001 Context\n",
+      },
+    });
+    if (result?.block) block = result;
+  }
+
+  assert.equal(block?.block, true);
+  assert.match(block?.reason ?? "", /HARD BLOCK: Cannot write to milestone CONTEXT\.md/);
+  assert.match(block?.reason ?? "", /ask_user_questions/);
+  assert.equal(block?.displayReason, "Depth check required before writing milestone context.");
+});
+
 test("register-hooks unlocks milestone depth verification from question id without guided-flow state (#4047)", async (t) => {
   const dir = makeTempDir("manual");
   const originalCwd = process.cwd();

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

@@ -123,6 +123,10 @@ test("#4782 phase 3: buildRunUatPrompt inlines UAT and keeps summary/project con
   // Project path is advertised on-demand; full project body is not inlined.
   assert.match(prompt, /\.gsd\/PROJECT\.md/);
   assert.ok(!prompt.includes("Run-UAT composer fixture project"), "run-uat should not inline full project context");
+
+  assert.match(prompt, /"toolPresentationPlanId": "run-uat\/default-v1"/);
+  assert.match(prompt, /"gsd_uat_result_save"/);
+  assert.match(prompt, /"read"/);
 });
 
 test("#4782 phase 3: buildRunUatPrompt omits optional slice summary when file is missing", async (t) => {

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

@@ -7,6 +7,7 @@ import assert from "node:assert/strict";
 import { classifyFailure } from "../recovery-classification.js";
 import { reconcileBeforeDispatch } from "../state-reconciliation.js";
 import { compileUnitToolContract } from "../tool-contract.js";
+import { shouldBlockAutoUnitToolCall } from "../auto-unit-tool-scope.js";
 import type { GSDState } from "../types.js";
 
 function makeState(overrides: Partial<GSDState> = {}): GSDState {
@@ -63,10 +64,35 @@ test("Tool Contract compiles known Unit prompt and tool policy", () => {
   assert.equal(result.ok, true);
   assert.equal(result.ok && result.contract.unitType, "execute-task");
   assert.deepEqual(result.ok && result.contract.requiredWorkflowTools, ["gsd_task_complete"]);
+  assert.deepEqual(result.ok && result.contract.forbiddenWorkflowTools, []);
   assert.equal(result.ok && result.contract.toolsPolicy.mode, "all");
   assert.ok(result.ok && result.contract.validationRules.includes("closeout-tool-present"));
 });
 
+test("Tool Contract records high-risk cross-phase tool boundaries without single-owning every tool", () => {
+  const completeSlice = compileUnitToolContract("complete-slice");
+  const runUat = compileUnitToolContract("run-uat");
+
+  assert.equal(completeSlice.ok, true);
+  assert.ok(
+    completeSlice.ok &&
+      completeSlice.contract.forbiddenWorkflowTools.some((tool) => tool.name === "gsd_uat_result_save"),
+    "complete-slice should explicitly forbid saving UAT Assessments",
+  );
+
+  assert.equal(runUat.ok, true);
+  assert.ok(
+    runUat.ok &&
+      runUat.contract.requiredWorkflowTools.includes("gsd_uat_result_save"),
+    "run-uat should own the UAT result-save tool",
+  );
+  assert.ok(
+    runUat.ok &&
+      runUat.contract.forbiddenWorkflowTools.some((tool) => tool.name === "gsd_exec"),
+    "run-uat should prefer typed UAT execution over generic gsd_exec",
+  );
+});
+
 test("Tool Contract fails closed for unknown Units", () => {
   const result = compileUnitToolContract("custom-step");
 
@@ -74,10 +100,40 @@ test("Tool Contract fails closed for unknown Units", () => {
   assert.equal(!result.ok && result.reason, "unknown-unit-type");
 });
 
+test("auto Unit tool scope blocks complete-slice from saving UAT Assessment", () => {
+  const result = shouldBlockAutoUnitToolCall("complete-slice", "gsd_uat_result_save");
+
+  assert.equal(result.block, true);
+  assert.match(result.reason ?? "", /Tool Contract failure/);
+  assert.match(result.reason ?? "", /Run UAT owns persisted UAT Assessment/);
+});
+
+test("auto Unit tool scope allows plan-slice to reassess invalid roadmap assumptions", () => {
+  const result = shouldBlockAutoUnitToolCall("plan-slice", "gsd_reassess_roadmap");
+
+  assert.equal(result.block, false);
+});
+
+test("auto Unit tool scope allows status/read helpers named by closeout prompts", () => {
+  for (const unitType of ["plan-milestone", "validate-milestone", "complete-milestone", "reassess-roadmap"]) {
+    const result = shouldBlockAutoUnitToolCall(unitType, "gsd_milestone_status");
+    assert.equal(result.block, false, `${unitType} should be able to call gsd_milestone_status`);
+  }
+});
+
+test("auto Unit tool scope blocks stale per-task planner in slice planning phases", () => {
+  for (const unitType of ["plan-slice", "refine-slice", "replan-slice"]) {
+    const result = shouldBlockAutoUnitToolCall(unitType, "gsd_plan_task");
+    assert.equal(result.block, true, `${unitType} should not call stale gsd_plan_task`);
+  }
+});
+
 test("Recovery Classification covers ADR-015 failure families", () => {
   const cases = [
     ["invalid tool schema enum", "tool-schema", "stop"],
+    ["Tool Contract failure: complete-slice cannot use gsd_uat_result_save", "tool-contract", "stop"],
     ["deterministic policy rejection", "deterministic-policy", "stop"],
+    ["cannot legally advance because required UAT Assessment artifact is missing", "lifecycle-progression", "stop"],
     ["stale worker lease", "stale-worker", "stop"],
     ["worktree root missing .git", "worktree-invalid", "stop"],
     ["verification drift in state snapshot", "verification-drift", "escalate"],

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

@@ -3,8 +3,8 @@
 // Focused tests for `resolveSkillManifest` and `filterSkillsByManifest`.
 // Covers the wildcard semantics, the newly seeded unit-type entries
 // (complete-milestone, validate-milestone, reassess-roadmap, research-slice,
-// plan-slice, refine-slice, replan-slice, run-uat), and the deliberate
-// wildcard fallback for the execute-task hot path (RFC #4779).
+// plan-slice, refine-slice, replan-slice, run-uat, complete-slice), and the
+// deliberate wildcard fallback for the execute-task hot path (RFC #4779).
 
 import test from "node:test";
 import assert from "node:assert/strict";
@@ -23,6 +23,7 @@ const NEWLY_WIRED_UNIT_TYPES = [
   "refine-slice",
   "replan-slice",
   "run-uat",
+  "complete-slice",
 ] as const;
 
 test("resolveSkillManifest returns null for undefined unit type (wildcard)", () => {
@@ -65,7 +66,7 @@ test("resolveSkillManifest: slice-level manifests include decompose-into-slices"
 });
 
 test("resolveSkillManifest: validation / completion flows include verify-before-complete", () => {
-  for (const unitType of ["complete-milestone", "validate-milestone", "run-uat"] as const) {
+  for (const unitType of ["complete-milestone", "validate-milestone", "run-uat", "complete-slice"] as const) {
     const allowlist = resolveSkillManifest(unitType);
     assert.ok(
       allowlist?.includes("verify-before-complete"),