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

package/src/resources/extensions/gsd/tests/restore-tools-after-discuss.test.ts

@@ -51,7 +51,7 @@ test("discuss workflow scopes tools for the queued turn and restores the full to
     // discuss allowlist: gsd_summary_save and gsd_plan_milestone (the latter
     // is needed for the discuss.md output phase — see DISCUSS_TOOLS_ALLOWLIST).
     // gsd_task_complete and the broad shell_exec tool are scoped out.
-    assert.deepEqual(sentTools, ["gsd_summary_save", "gsd_plan_milestone", "ToolSearch"]);
+    assert.deepEqual(sentTools, ["gsd_plan_milestone", "gsd_summary_save", "ToolSearch"]);
     assert.deepEqual(activeTools, originalTools);
     assert.equal(triggerTurn, true);
   } finally {

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/skill-activation.test.ts

@@ -5,6 +5,7 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { loadSkills } from "@gsd/pi-coding-agent";
 import {
+  buildCompleteSlicePrompt,
   buildPlanMilestonePrompt,
   buildResearchMilestonePrompt,
   buildSkillActivationBlock,
@@ -143,6 +144,29 @@ test("buildSkillActivationBlock includes skill_rules matches and task-plan skill
   }
 });
 
+test("buildSkillActivationBlock matches skill_rules against exact unit type context", () => {
+  const base = makeTempBase();
+  try {
+    writeSkill(base, "complete-slice-policies", "Use for complete-slice closeout policy checks.");
+    writeSkill(base, "slice-broad", "Use for broad slice work.");
+    loadOnlyTestSkills(base);
+
+    const result = buildBlock(base, {
+      unitType: "complete-slice",
+    }, {
+      skill_rules: [
+        { when: "complete-slice", use: ["complete-slice-policies"] },
+        { when: "slice", use: ["slice-broad"] },
+      ],
+    });
+
+    assert.match(result, /Call Skill\(\{ skill: 'complete-slice-policies' \}\)/);
+    assert.doesNotMatch(result, /slice-broad/);
+  } finally {
+    cleanup(base);
+  }
+});
+
 test("buildSkillActivationBlock honors avoid_skills against always_use_skills", () => {
   const base = makeTempBase();
   try {
@@ -328,6 +352,37 @@ test("milestone prompt builders propagate always_use_skills through buildSkillAc
   }
 });
 
+test("complete-slice prompt propagates always_use_skills through buildSkillActivationBlock", async () => {
+  const base = makeTempBase();
+  try {
+    writeSkill(base, "write-docs", "Use when writing docs or RFCs.");
+    writeProjectPreferences(base, "always_use_skills:\n  - write-docs\n");
+    loadOnlyTestSkills(base);
+
+    const milestoneDir = join(base, ".gsd", "milestones", "M001");
+    const sliceDir = join(milestoneDir, "slices", "S01");
+    mkdirSync(sliceDir, { recursive: true });
+    writeFileSync(
+      join(milestoneDir, "M001-ROADMAP.md"),
+      [
+        "# M001: Test",
+        "",
+        "## Slices",
+        "",
+        "- [ ] **S01: Slice** `risk:low` `depends:[]`",
+        "",
+      ].join("\n"),
+    );
+    writeFileSync(join(sliceDir, "S01-PLAN.md"), "# S01: Slice\n\n## Tasks\n\n- [x] **T01: Done**\n");
+
+    const prompt = await buildCompleteSlicePrompt("M001", "Test", "S01", "Slice", base);
+
+    assert.match(prompt, /Call Skill\(\{ skill: 'write-docs' \}\)/);
+  } finally {
+    cleanup(base);
+  }
+});
+
 test("skill manifest strict warnings require GSD_SKILL_MANIFEST_STRICT=1", (t) => {
   const previousStrict = process.env.GSD_SKILL_MANIFEST_STRICT;
   const previousStderr = setStderrLoggingEnabled(false);

package/src/resources/extensions/gsd/tests/state-reconciliation-drift.test.ts

@@ -906,6 +906,51 @@ test("ADR-017 (#5704): registered milestone (DB row present) → no drift", asyn
 
 // ─── #5705: roadmap-divergence drift ─────────────────────────────────────────
 
+test("ADR-017 (#391): roadmap-divergence skips slices before task planning completes", async (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-adr017-roadmap-unplanned-"));
+  const milestoneDir = join(base, ".gsd", "milestones", "M001");
+  const roadmapPath = join(milestoneDir, "M001-ROADMAP.md");
+  mkdirSync(milestoneDir, { recursive: true });
+  const originalRoadmap = [
+    "# M001: Test",
+    "",
+    "**Vision:** Verify transient milestone planning state",
+    "",
+    "## Slices",
+    "",
+    "- [ ] **S01: Foundation** `risk:medium` `depends:[]`",
+    "- [ ] **S02: Feature** `risk:medium` `depends:[S01]`",
+    "",
+  ].join("\n");
+  writeFileSync(roadmapPath, originalRoadmap);
+  t.after(() => {
+    try { closeDatabase(); } catch { /* noop */ }
+    rmSync(base, { recursive: true, force: true });
+  });
+
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "Test", status: "active" });
+  insertSlice({ id: "S01", milestoneId: "M001", title: "Foundation", status: "pending", risk: "medium", depends: [], demo: "", sequence: 1 });
+  insertSlice({ id: "S02", milestoneId: "M001", title: "Feature", status: "pending", risk: "medium", depends: [], demo: "", sequence: 2 });
+
+  assert.equal(getSliceTasks("M001", "S01").length, 0, "pre: S01 has not been planned");
+  assert.equal(getSliceTasks("M001", "S02").length, 0, "pre: S02 has not been planned");
+
+  const result = await reconcileBeforeDispatch(base, {
+    invalidateStateCache: () => {},
+    deriveState: async () => makeState(),
+  });
+
+  assert.equal(result.ok, true);
+  assert.equal(
+    result.repaired.some((d) => d.kind === "roadmap-divergence"),
+    false,
+    "unplanned slices should not trigger roadmap-divergence repair",
+  );
+  assert.equal(readFileSync(roadmapPath, "utf-8"), originalRoadmap);
+  assert.deepEqual(getSlice("M001", "S02")?.depends, [], "DB remains unchanged");
+});
+
 test("ADR-017 (#5705): roadmap-divergence re-renders projection without syncing depends into DB", async (t) => {
   const base = mkdtempSync(join(tmpdir(), "gsd-adr017-roadmap-"));
   const milestoneDir = join(base, ".gsd", "milestones", "M001");
@@ -936,6 +981,8 @@ test("ADR-017 (#5705): roadmap-divergence re-renders projection without syncing
   // Seed DB with S02 depending on []  — diverges from ROADMAP.md
   insertSlice({ id: "S01", milestoneId: "M001", title: "Foundation", status: "pending", risk: "medium", depends: [], demo: "", sequence: 1 });
   insertSlice({ id: "S02", milestoneId: "M001", title: "Feature", status: "pending", risk: "medium", depends: [], demo: "", sequence: 2 });
+  insertTask({ id: "T01", sliceId: "S01", milestoneId: "M001", title: "Plan S01", status: "pending" });
+  insertTask({ id: "T01", sliceId: "S02", milestoneId: "M001", title: "Plan S02", status: "pending" });
 
   assert.deepEqual(getSlice("M001", "S02")?.depends, [], "pre: DB has S02.depends = []");
 
@@ -987,6 +1034,7 @@ test("ADR-017 (#5705): ROADMAP-only slice is removed from projection and not ins
   insertMilestone({ id: "M001", title: "Test", status: "active" });
   // Only insert S01 — S02 is intentionally absent from the DB.
   insertSlice({ id: "S01", milestoneId: "M001", title: "Foundation", status: "pending", risk: "medium", depends: [], demo: "", sequence: 1 });
+  insertTask({ id: "T01", sliceId: "S01", milestoneId: "M001", title: "Plan S01", status: "pending" });
 
   assert.equal(getSlice("M001", "S02"), null, "pre: S02 has no DB row");
 
@@ -1035,6 +1083,8 @@ test("ADR-017 (#5705): ROADMAP sequence drift re-renders from DB order without m
   insertMilestone({ id: "M001", title: "Test", status: "active" });
   insertSlice({ id: "S01", milestoneId: "M001", title: "Foundation", status: "pending", risk: "medium", depends: [], demo: "", sequence: 1 });
   insertSlice({ id: "S02", milestoneId: "M001", title: "Feature", status: "pending", risk: "medium", depends: [], demo: "", sequence: 2 });
+  insertTask({ id: "T01", sliceId: "S01", milestoneId: "M001", title: "Plan S01", status: "pending" });
+  insertTask({ id: "T01", sliceId: "S02", milestoneId: "M001", title: "Plan S02", status: "pending" });
 
   const result = await reconcileBeforeDispatch(base, {
     invalidateStateCache: () => {},
@@ -1078,6 +1128,7 @@ test("ADR-017 (#5705): ROADMAP checkbox drift re-renders from DB status without
   openDatabase(join(base, ".gsd", "gsd.db"));
   insertMilestone({ id: "M001", title: "Test", status: "active" });
   insertSlice({ id: "S01", milestoneId: "M001", title: "Foundation", status: "pending", risk: "medium", depends: [], demo: "", sequence: 1 });
+  insertTask({ id: "T01", sliceId: "S01", milestoneId: "M001", title: "Plan S01", status: "pending" });
 
   const result = await reconcileBeforeDispatch(base, {
     invalidateStateCache: () => {},
@@ -1119,6 +1170,7 @@ test("ADR-017 (#5705): in-sync ROADMAP and DB → no roadmap-divergence drift",
   openDatabase(join(base, ".gsd", "gsd.db"));
   insertMilestone({ id: "M001", title: "Test", status: "active" });
   insertSlice({ id: "S01", milestoneId: "M001", title: "Foundation", status: "pending", risk: "low", depends: [], demo: "", sequence: 1 });
+  insertTask({ id: "T01", sliceId: "S01", milestoneId: "M001", title: "Plan S01", status: "pending" });
 
   const result = await reconcileBeforeDispatch(base, {
     invalidateStateCache: () => {},
@@ -1300,6 +1352,145 @@ test("ADR-017: orphan task completion artifact fails closed", async (t) => {
   assert.match(result.blockers.join("\n"), /Artifact\/DB status drift/);
 });
 
+test("ADR-017 (#414): failure-path summary artifact blocker matches auto.ts filter phrase", async (t) => {
+  // When gsd_summary_save writes a SUMMARY artifact row for a task that never
+  // called gsd_task_complete, the task stays pending and the artifact DB row
+  // produces an artifact-db-status-divergence blocker. The auto.ts dispatch
+  // wrapper must be able to filter this class of blocker to allow re-dispatch.
+  // If this test fails, update the filter strings in auto.ts to match.
+  const base = mkdtempSync(join(tmpdir(), "gsd-failure-path-summary-drift-"));
+  t.after(() => cleanup(base));
+
+  mkdirSync(join(base, ".gsd", "milestones", "M001", "slices", "S04"), { recursive: true });
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "Milestone", status: "active" });
+  insertSlice({ id: "S04", milestoneId: "M001", title: "Slice", status: "pending" });
+  insertTask({ id: "T01", sliceId: "S04", milestoneId: "M001", title: "Task", status: "pending" });
+  insertArtifact({
+    path: join(base, ".gsd", "milestones", "M001", "slices", "S04", "tasks", "T01", "T01-SUMMARY.md"),
+    artifact_type: "SUMMARY",
+    milestone_id: "M001",
+    slice_id: "S04",
+    task_id: "T01",
+    full_content: "# T01 Failure Summary\n",
+  });
+
+  const result = await reconcileBeforeDispatch(base, {
+    invalidateStateCache: () => {},
+    deriveState: async () => makeState({ activeMilestone: { id: "M001", title: "Milestone" } }),
+  });
+
+  assert.equal(result.ok, true);
+  assert.ok(result.blockers.length > 0, "blocker must be produced for pending-task SUMMARY drift");
+  const blocker = result.blockers.join("\n");
+  assert.match(
+    blocker,
+    /has SUMMARY artifact while DB status is/,
+    "blocker phrase must match the filter in auto.ts reconcileBeforeDispatch wrapper",
+  );
+});
+
+test("ADR-017 (#414): no-db-tasks summary artifact blocker matches auto.ts filter phrase", async (t) => {
+  // When a slice has SUMMARY artifacts in the DB but no DB tasks, the auto.ts
+  // filter must be able to recognise this as a failure-path case and skip it.
+  const base = mkdtempSync(join(tmpdir(), "gsd-no-db-tasks-summary-drift-"));
+  t.after(() => cleanup(base));
+
+  mkdirSync(join(base, ".gsd", "milestones", "M001", "slices", "S04"), { recursive: true });
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "Milestone", status: "active" });
+  insertSlice({ id: "S04", milestoneId: "M001", title: "Slice", status: "pending" });
+  // No tasks inserted — slice has SUMMARY artifacts for a task that no longer exists.
+  insertArtifact({
+    path: join(base, ".gsd", "milestones", "M001", "slices", "S04", "tasks", "T01", "T01-SUMMARY.md"),
+    artifact_type: "SUMMARY",
+    milestone_id: "M001",
+    slice_id: "S04",
+    task_id: "T01",
+    full_content: "# T01 Failure Summary\n",
+  });
+
+  const result = await reconcileBeforeDispatch(base, {
+    invalidateStateCache: () => {},
+    deriveState: async () => makeState({ activeMilestone: { id: "M001", title: "Milestone" } }),
+  });
+
+  assert.equal(result.ok, true);
+  assert.ok(result.blockers.length > 0, "blocker must be produced for no-db-tasks SUMMARY drift");
+  const blocker = result.blockers.join("\n");
+  assert.match(
+    blocker,
+    /has task SUMMARY artifacts but no DB tasks/,
+    "blocker phrase must match the filter in auto.ts reconcileBeforeDispatch wrapper",
+  );
+});
+
+test("ADR-017 (#414): task-level on-disk summary blocker matches auto.ts filter phrase", async (t) => {
+  // When gsd_summary_save writes a SUMMARY file to disk for a task that never
+  // called gsd_task_complete, but the artifact DB row was not yet written (or
+  // the process crashed before insertion), reconciliation emits
+  // "has SUMMARY on disk while DB status is". The auto.ts filter must match
+  // this phrase so re-dispatch is not blocked.
+  const base = mkdtempSync(join(tmpdir(), "gsd-task-disk-summary-drift-"));
+  t.after(() => cleanup(base));
+
+  const tasksDir = join(base, ".gsd", "milestones", "M001", "slices", "S04", "tasks");
+  mkdirSync(tasksDir, { recursive: true });
+  writeFileSync(join(tasksDir, "T01-SUMMARY.md"), "# T01 Failure Summary\n");
+
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "Milestone", status: "active" });
+  insertSlice({ id: "S04", milestoneId: "M001", title: "Slice", status: "pending" });
+  insertTask({ id: "T01", sliceId: "S04", milestoneId: "M001", title: "Task", status: "pending" });
+  // No artifact row inserted — SUMMARY exists only on disk.
+
+  const result = await reconcileBeforeDispatch(base, {
+    invalidateStateCache: () => {},
+    deriveState: async () => makeState({ activeMilestone: { id: "M001", title: "Milestone" } }),
+  });
+
+  assert.equal(result.ok, true);
+  assert.ok(result.blockers.length > 0, "blocker must be produced for on-disk task SUMMARY drift");
+  const blocker = result.blockers.join("\n");
+  assert.match(
+    blocker,
+    /has SUMMARY on disk while DB status is/,
+    "blocker phrase must match the filter in auto.ts reconcileBeforeDispatch wrapper",
+  );
+});
+
+test("ADR-017 (#414): slice-level on-disk summary blocker matches auto.ts filter phrase", async (t) => {
+  // When a SUMMARY file exists on disk for a slice that is still pending
+  // (no gsd_task_complete for the slice), reconciliation emits
+  // "has SUMMARY on disk while DB status is". The auto.ts filter must match
+  // this phrase so re-dispatch is not blocked.
+  const base = mkdtempSync(join(tmpdir(), "gsd-slice-disk-summary-drift-"));
+  t.after(() => cleanup(base));
+
+  const sliceDir = join(base, ".gsd", "milestones", "M001", "slices", "S04");
+  mkdirSync(sliceDir, { recursive: true });
+  writeFileSync(join(sliceDir, "S04-SUMMARY.md"), "# S04 Failure Summary\n");
+
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "Milestone", status: "active" });
+  insertSlice({ id: "S04", milestoneId: "M001", title: "Slice", status: "pending" });
+  // No artifact row inserted — SUMMARY exists only on disk.
+
+  const result = await reconcileBeforeDispatch(base, {
+    invalidateStateCache: () => {},
+    deriveState: async () => makeState({ activeMilestone: { id: "M001", title: "Milestone" } }),
+  });
+
+  assert.equal(result.ok, true);
+  assert.ok(result.blockers.length > 0, "blocker must be produced for on-disk slice SUMMARY drift");
+  const blocker = result.blockers.join("\n");
+  assert.match(
+    blocker,
+    /has SUMMARY on disk while DB status is/,
+    "blocker phrase must match the filter in auto.ts reconcileBeforeDispatch wrapper",
+  );
+});
+
 test("ADR-017: completed milestone dispatch history blocks accidental re-planning", async (t) => {
   const base = mkdtempSync(join(tmpdir(), "gsd-completed-reopened-drift-"));
   t.after(() => cleanup(base));

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

@@ -4,8 +4,11 @@
 import assert from "node:assert/strict";
 import test from "node:test";
 
+import { registerToolCompatibility } from "@gsd/pi-coding-agent";
+
 import { DISCUSS_TOOLS_ALLOWLIST } from "../constants.ts";
 import { buildMinimalAutoGsdToolSet, buildMinimalGsdToolSet, buildMinimalGsdWorkflowToolSet, buildRequestScopedGsdToolSet, MINIMAL_AUTO_BASE_TOOL_NAMES, MINIMAL_GSD_TOOL_NAMES, requestHasGsdCustomType, restoreGsdWorkflowTools, scopeGsdWorkflowToolsForDispatch } from "../bootstrap/register-hooks.ts";
+import { filterToolsForProvider } from "../model-router.ts";
 import { applyUnitSkillVisibility } from "../skill-scope.ts";
 
 test("buildMinimalGsdToolSet preserves non-GSD tools and replaces broad GSD surface", () => {
@@ -31,7 +34,7 @@ test("buildMinimalGsdToolSet preserves non-GSD tools and replaces broad GSD surf
   for (const toolName of MINIMAL_GSD_TOOL_NAMES) {
     assert.ok(result.includes(toolName), `expected ${toolName}`);
   }
-  assert.ok(!result.includes("gsd_plan_milestone"));
+  assert.ok(result.includes("gsd_plan_milestone"));
   assert.ok(!result.includes("gsd_task_complete"));
   assert.ok(!result.includes("gsd_graph"));
 });
@@ -98,22 +101,39 @@ test("buildMinimalAutoGsdToolSet keeps unit-specific completion tools without al
   assert.ok(!result.includes("gsd_complete_slice"));
 });
 
-test("buildMinimalAutoGsdToolSet re-resolves run-uat browser tools from the registry when dropped from the active set", () => {
-  // B2 drops the browser surface from the advertised interactive set, but the
-  // tools stay registered. run-uat must still get them: resolution reads the
-  // full registry, not just the (browser-stripped) active set.
-  const active = ["ask_user_questions", "bash", "read", "gsd_summary_save"];
+test("buildMinimalAutoGsdToolSet scopes run-uat to UAT-specific tools", () => {
+  const active = ["ask_user_questions", "bash", "read", "edit", "write", "gsd_summary_save"];
   const registered = [
     ...active,
+    "gsd_uat_exec",
+    "gsd_uat_result_save",
+    "gsd_resume",
+    "gsd_milestone_status",
+    "gsd_journal_query",
+    "gsd_exec",
+    "gsd_save_gate_result",
+    "search-the-web",
     "browser_navigate",
     "browser_click",
     "browser_snapshot_refs",
-    "gsd_exec",
   ];
   const result = buildMinimalAutoGsdToolSet(active, "run-uat", registered);
+  assert.ok(result.includes("gsd_uat_exec"));
+  assert.ok(result.includes("gsd_uat_result_save"));
+  assert.ok(result.includes("gsd_resume"));
+  assert.ok(result.includes("gsd_milestone_status"));
+  assert.ok(result.includes("gsd_journal_query"));
   assert.ok(result.includes("browser_navigate"), "run-uat needs browser_navigate");
   assert.ok(result.includes("browser_click"), "run-uat needs browser_click");
-  assert.ok(result.includes("gsd_summary_save"));
+  assert.ok(!result.includes("ToolSearch"));
+  assert.ok(!result.includes("bash"));
+  assert.ok(!result.includes("read"));
+  assert.ok(!result.includes("edit"));
+  assert.ok(!result.includes("write"));
+  assert.ok(!result.includes("gsd_exec"));
+  assert.ok(!result.includes("gsd_summary_save"));
+  assert.ok(!result.includes("gsd_save_gate_result"));
+  assert.ok(!result.includes("search-the-web"));
 });
 
 test("buildMinimalAutoGsdToolSet keeps only the auto base non-GSD tools", () => {
@@ -175,17 +195,27 @@ test("buildMinimalAutoGsdToolSet re-injects registered base tools filtered from
   assert.ok(result.includes("search-the-web"));
 });
 
-test("buildMinimalAutoGsdToolSet preserves browser tools for run-uat", () => {
+test("buildMinimalAutoGsdToolSet preserves compatible browser add-ons for run-uat", () => {
   const result = buildMinimalAutoGsdToolSet([
     "bash",
     "read",
+    "edit",
+    "write",
     "browser_navigate",
     "browser_click",
     "browser_type",
     "browser_assert",
     "browser_screenshot",
     "browser_wait_for",
+    "gsd_uat_exec",
+    "gsd_uat_result_save",
+    "gsd_resume",
+    "gsd_milestone_status",
+    "gsd_journal_query",
+    "subagent",
     "gsd_summary_save",
+    "gsd_exec",
+    "gsd_save_gate_result",
     "gsd_task_complete",
     "memory_query",
     "capture_thought",
@@ -197,7 +227,17 @@ test("buildMinimalAutoGsdToolSet preserves browser tools for run-uat", () => {
   assert.ok(result.includes("browser_assert"));
   assert.ok(result.includes("browser_screenshot"));
   assert.ok(result.includes("browser_wait_for"));
-  assert.ok(result.includes("gsd_summary_save"));
+  assert.ok(result.includes("gsd_uat_exec"));
+  assert.ok(result.includes("gsd_uat_result_save"));
+  assert.ok(result.includes("subagent"));
+  assert.ok(!result.includes("ToolSearch"));
+  assert.ok(!result.includes("bash"));
+  assert.ok(!result.includes("read"));
+  assert.ok(!result.includes("edit"));
+  assert.ok(!result.includes("write"));
+  assert.ok(!result.includes("gsd_exec"));
+  assert.ok(!result.includes("gsd_summary_save"));
+  assert.ok(!result.includes("gsd_save_gate_result"));
   assert.ok(!result.includes("gsd_task_complete"));
 });
 
@@ -218,6 +258,40 @@ test("buildMinimalAutoGsdToolSet prefers MCP browser tools for run-uat when avai
   assert.ok(!result.includes("browser_click"));
 });
 
+test("buildMinimalAutoGsdToolSet honors provider-compatible registered tools for run-uat", () => {
+  registerToolCompatibility("browser_screenshot", { producesImages: true });
+  const registered = [
+    "bash",
+    "read",
+    "ToolSearch",
+    "browser_navigate",
+    "browser_click",
+    "browser_screenshot",
+    "gsd_uat_exec",
+    "gsd_uat_result_save",
+    "gsd_resume",
+    "gsd_milestone_status",
+    "gsd_journal_query",
+    "gsd_exec",
+    "gsd_summary_save",
+    "gsd_save_gate_result",
+  ];
+  const providerCompatible = filterToolsForProvider(registered, "openai-responses").compatible;
+  const result = buildMinimalAutoGsdToolSet(["gsd_uat_exec"], "run-uat", providerCompatible);
+
+  assert.ok(result.includes("gsd_uat_exec"));
+  assert.ok(result.includes("gsd_uat_result_save"));
+  assert.ok(result.includes("browser_navigate"));
+  assert.ok(result.includes("browser_click"));
+  assert.ok(!result.includes("browser_screenshot"), "provider-filtered screenshot tool must stay filtered");
+  assert.ok(!result.includes("ToolSearch"));
+  assert.ok(!result.includes("bash"));
+  assert.ok(!result.includes("read"));
+  assert.ok(!result.includes("gsd_exec"));
+  assert.ok(!result.includes("gsd_summary_save"));
+  assert.ok(!result.includes("gsd_save_gate_result"));
+});
+
 test("buildMinimalAutoGsdToolSet includes discuss-slice persistence tools", () => {
   const result = buildMinimalAutoGsdToolSet([
     "bash",

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

@@ -39,6 +39,12 @@ const RENAME_MAP: Array<{ canonical: string; alias: string }> = [
   { canonical: "gsd_milestone_reopen", alias: "gsd_reopen_milestone" },
 ];
 
+const STANDALONE_TOOLS = [
+  "gsd_save_gate_result",
+  "gsd_skip_slice",
+  "gsd_uat_result_save",
+];
+
 // ─── Registration count ──────────────────────────────────────────────────────
 
 console.log('\n── Tool naming: registration count ──');
@@ -48,10 +54,14 @@ registerDbTools(pi);
 
 assert.deepStrictEqual(
   pi.tools.length,
-  RENAME_MAP.length * 2 + 2,
-  'Should register canonical/alias tool pairs plus 1 gate tool and 1 gsd_skip_slice',
+  RENAME_MAP.length * 2 + STANDALONE_TOOLS.length,
+  'Should register canonical/alias tool pairs plus standalone DB tools',
 );
 
+for (const name of STANDALONE_TOOLS) {
+  assert.ok(pi.tools.some((t: any) => t.name === name), `Standalone tool "${name}" should be registered`);
+}
+
 // ─── Both names exist for each pair ──────────────────────────────────────────
 
 console.log('\n── Tool naming: canonical and alias names exist ──');