@opengsd/gsd-pi 1.2.0-dev.844675c9 → 1.2.0-dev.b1abb545

package/dist/resources/extensions/gsd/tool-presentation-plan.js

@@ -1,7 +1,10 @@
 // Project/App: gsd-pi
 // File Purpose: Resolve phase-aware tool surfaces for GSD model presentations.
 import { RUN_UAT_BROWSER_TOOL_NAMES, RUN_UAT_READ_ONLY_TOOL_NAMES, RUN_UAT_TOOL_PRESENTATION_PLAN_ID, RUN_UAT_WORKFLOW_TOOL_NAMES, } from "./unit-tool-contracts.js";
+import { toMcpToolName } from "./mcp-tool-name.js";
+import { createToolSurfaceSnapshot } from "./tool-surface-snapshot.js";
 import { uatTypeIncludesBrowser } from "./uat-policy.js";
+import { canonicalWorkflowSurfaceToolName } from "./workflow-tool-surface.js";
 export { RUN_UAT_BROWSER_TOOL_NAMES, RUN_UAT_READ_ONLY_TOOL_NAMES, RUN_UAT_TOOL_PRESENTATION_PLAN_ID, RUN_UAT_WORKFLOW_TOOL_NAMES, } from "./unit-tool-contracts.js";
 export const RUN_UAT_FORBIDDEN_TOOL_NAMES = [
     "edit",
@@ -21,43 +24,12 @@ export const RUN_UAT_CLAUDE_NATIVE_TOOL_NAMES = [
     "Glob",
     "Grep",
 ];
-const WORKFLOW_ALIAS_TO_CANONICAL = {
-    gsd_save_decision: "gsd_decision_save",
-    gsd_update_requirement: "gsd_requirement_update",
-    gsd_save_requirement: "gsd_requirement_save",
-    gsd_save_summary: "gsd_summary_save",
-    gsd_generate_milestone_id: "gsd_milestone_generate_id",
-    gsd_milestone_plan: "gsd_plan_milestone",
-    gsd_slice_plan: "gsd_plan_slice",
-    gsd_task_plan: "gsd_plan_task",
-    gsd_slice_replan: "gsd_replan_slice",
-    gsd_complete_slice: "gsd_slice_complete",
-    gsd_milestone_complete: "gsd_complete_milestone",
-    gsd_milestone_validate: "gsd_validate_milestone",
-    gsd_roadmap_reassess: "gsd_reassess_roadmap",
-    gsd_complete_task: "gsd_task_complete",
-    gsd_reopen_task: "gsd_task_reopen",
-    gsd_reopen_slice: "gsd_slice_reopen",
-    gsd_reopen_milestone: "gsd_milestone_reopen",
-};
 export function canonicalWorkflowToolName(toolName) {
-    const mcp = parseMcpToolName(toolName);
-    const baseName = mcp?.tool ?? toolName;
-    return WORKFLOW_ALIAS_TO_CANONICAL[baseName] ?? baseName;
-}
-export function parseMcpToolName(toolName) {
-    if (!toolName.startsWith("mcp__"))
-        return null;
-    const toolSeparator = toolName.indexOf("__", "mcp__".length);
-    if (toolSeparator < 0)
-        return null;
-    return {
-        server: toolName.slice("mcp__".length, toolSeparator),
-        tool: toolName.slice(toolSeparator + 2),
-    };
+    return canonicalWorkflowSurfaceToolName(toolName);
 }
+export { parseMcpToolName } from "./mcp-tool-name.js";
 export function toWorkflowMcpToolName(serverName, toolName) {
-    return `mcp__${serverName}__${canonicalWorkflowToolName(toolName)}`;
+    return toMcpToolName(serverName, canonicalWorkflowToolName(toolName));
 }
 function dedupe(values) {
     return [...new Set(values)];
@@ -134,6 +106,14 @@ export function resolveToolPresentationPlan(options) {
             ? toWorkflowMcpToolName(workflowServerName, name)
             : name)
         : allowedToolNames;
+    const toolSurface = createToolSurfaceSnapshot({
+        source: "presentation-plan",
+        phase: options.phase,
+        modelFacingToolNames: options.availableToolNames ?? requested,
+        registeredToolNames: options.availableToolNames ?? requested,
+        scopedToolNames: allowedToolNames,
+        presentedToolNames,
+    });
     if (options.phase === "run-uat") {
         for (const forbidden of RUN_UAT_FORBIDDEN_TOOL_NAMES) {
             addBlockedTool(blockedToolNames, forbidden, "forbidden during run-uat");
@@ -148,5 +128,6 @@ export function resolveToolPresentationPlan(options) {
         blockedToolNames,
         aliases,
         diagnostics: [],
+        toolSurface,
     };
 }

package/dist/resources/extensions/gsd/tool-surface-snapshot.js

@@ -0,0 +1,17 @@
+// Project/App: gsd-pi
+// File Purpose: Typed snapshots for model-facing, registered, scoped, and presented tool surfaces.
+function dedupeToolNames(toolNames) {
+    return [...new Set(toolNames ?? [])];
+}
+export function createToolSurfaceSnapshot(input) {
+    return {
+        source: input.source,
+        unitType: input.unitType,
+        phase: input.phase,
+        modelFacingToolNames: dedupeToolNames(input.modelFacingToolNames),
+        registeredToolNames: dedupeToolNames(input.registeredToolNames),
+        scopedToolNames: dedupeToolNames(input.scopedToolNames),
+        presentedToolNames: dedupeToolNames(input.presentedToolNames),
+        capturedAt: input.capturedAt ?? Date.now(),
+    };
+}

package/dist/resources/extensions/gsd/tools/plan-milestone.js

@@ -1,15 +1,7 @@
 // Project/App: gsd-pi
 // File Purpose: Plans milestone roadmap state through DB-backed workflow tools.
-import { clearParseCache } from "../files.js";
-import { isClosedStatus } from "../status-guards.js";
 import { isNonEmptyString, validateStringArray, validateTitle } from "../validation.js";
-import { transaction, getMilestone, getMilestoneSlices, getSlice, insertMilestone, insertSlice, upsertMilestonePlanning, upsertSlicePlanning, } from "../gsd-db.js";
-import { invalidateStateCache } from "../state.js";
-import { renderRoadmapFromDb } from "../markdown-renderer.js";
-import { renderAllProjections } from "../workflow-projections.js";
-import { writeManifest } from "../workflow-manifest.js";
-import { appendEvent } from "../workflow-events.js";
-import { logWarning } from "../workflow-logger.js";
+import { persistMilestonePlan } from "../milestone-planning-persistence.js";
 function validateRiskEntries(value) {
     if (!Array.isArray(value)) {
         throw new Error("keyRisks must be an array");
@@ -43,10 +35,16 @@ function validateProofStrategy(value) {
         return { riskOrUnknown, retireIn, whatWillBeProven };
     });
 }
+const SLICE_ID_RE = /^[A-Za-z0-9][A-Za-z0-9-]*$/;
 function validateSlices(value) {
     if (!Array.isArray(value) || value.length === 0) {
         throw new Error("slices must be a non-empty array");
     }
+    // Pre-collect all slice IDs so depends cross-validation can reference the full set.
+    const allSliceIds = new Set(value
+        .filter((e) => !!e && typeof e === "object")
+        .map(e => e.sliceId)
+        .filter((id) => isNonEmptyString(id)));
     const seen = new Set();
     return value.map((entry, index) => {
         if (!entry || typeof entry !== "object") {
@@ -84,8 +82,13 @@ function validateSlices(value) {
             throw new Error(`slices[${index}].title is invalid: ${titleIssue}`);
         if (!isNonEmptyString(risk))
             throw new Error(`slices[${index}].risk must be a non-empty string`);
-        if (!Array.isArray(depends) || depends.some((item) => !isNonEmptyString(item))) {
-            throw new Error(`slices[${index}].depends must be an array of non-empty strings`);
+        if (!Array.isArray(depends) || depends.some((item) => !isNonEmptyString(item) || !SLICE_ID_RE.test(item))) {
+            throw new Error(`slices[${index}].depends must be an array of valid slice IDs (e.g. "S01")`);
+        }
+        for (const dep of depends) {
+            if (!allSliceIds.has(dep)) {
+                throw new Error(`slices[${index}].depends references unknown slice "${dep}" — check that it is defined in the same milestone`);
+            }
         }
         if (!isNonEmptyString(demo))
             throw new Error(`slices[${index}].demo must be a non-empty string`);
@@ -160,136 +163,5 @@ export async function handlePlanMilestone(rawParams, basePath) {
     catch (err) {
         return { error: `validation failed: ${err.message}` };
     }
-    // ── Guards + DB writes inside a single transaction (prevents TOCTOU) ───
-    // Guards must be inside the transaction so the state they check cannot
-    // change between the read and the write (#2723).
-    let guardError = null;
-    try {
-        transaction(() => {
-            const existingMilestone = getMilestone(params.milestoneId);
-            if (existingMilestone && isClosedStatus(existingMilestone.status)) {
-                guardError = `cannot re-plan milestone ${params.milestoneId}: it is already complete`;
-                return;
-            }
-            // Guard: refuse to re-plan a milestone that would drop completed slices (#2960).
-            // Allow re-planning when all completed slices are still present in the
-            // incoming plan — their status is preserved below (#2558). Block only when
-            // the new plan omits a completed slice, which could shadow completed work.
-            const existingSlices = getMilestoneSlices(params.milestoneId);
-            const completedSlices = existingSlices.filter(s => isClosedStatus(s.status));
-            if (completedSlices.length > 0) {
-                const incomingSliceIds = new Set(params.slices.map(s => s.sliceId));
-                const droppedCompleted = completedSlices.filter(s => !incomingSliceIds.has(s.id));
-                if (droppedCompleted.length > 0) {
-                    guardError = `cannot re-plan milestone ${params.milestoneId}: ${droppedCompleted.length} completed slice(s) would be dropped (${droppedCompleted.map(s => s.id).join(", ")}). Use gsd_reassess_roadmap to modify the roadmap.`;
-                    return;
-                }
-            }
-            // Validate depends_on: all dependencies must exist and be complete
-            if (params.dependsOn && params.dependsOn.length > 0) {
-                for (const depId of params.dependsOn) {
-                    const dep = getMilestone(depId);
-                    if (!dep) {
-                        guardError = `depends_on references unknown milestone: ${depId}`;
-                        return;
-                    }
-                    if (!isClosedStatus(dep.status)) {
-                        guardError = `depends_on milestone ${depId} is not yet complete (status: ${dep.status})`;
-                        return;
-                    }
-                }
-            }
-            insertMilestone({
-                id: params.milestoneId,
-                title: params.title,
-                status: params.status ?? "active",
-                depends_on: params.dependsOn ?? [],
-            });
-            upsertMilestonePlanning(params.milestoneId, {
-                title: params.title,
-                status: params.status ?? "active",
-                depends_on: params.dependsOn ?? [],
-                vision: params.vision,
-                successCriteria: params.successCriteria,
-                keyRisks: params.keyRisks,
-                proofStrategy: params.proofStrategy,
-                verificationContract: params.verificationContract,
-                verificationIntegration: params.verificationIntegration,
-                verificationOperational: params.verificationOperational,
-                verificationUat: params.verificationUat,
-                definitionOfDone: params.definitionOfDone,
-                requirementCoverage: params.requirementCoverage,
-                boundaryMapMarkdown: params.boundaryMapMarkdown,
-            });
-            for (let i = 0; i < params.slices.length; i++) {
-                const slice = params.slices[i];
-                // Preserve completed/done status on re-plan (#2558).
-                // Without this, a re-plan after milestone transition would reset
-                // already-completed slices back to "pending".
-                const existing = getSlice(params.milestoneId, slice.sliceId);
-                const status = existing && (existing.status === "complete" || existing.status === "done")
-                    ? existing.status
-                    : "pending";
-                insertSlice({
-                    id: slice.sliceId,
-                    milestoneId: params.milestoneId,
-                    title: slice.title,
-                    status,
-                    risk: slice.risk,
-                    depends: slice.depends,
-                    demo: slice.demo,
-                    sequence: i + 1, // Preserve agent-ordered sequence (#3356)
-                    // ADR-011: pass undefined through so ON CONFLICT preserves existing values
-                    // when the caller omitted the fields on a re-plan.
-                    isSketch: slice.isSketch,
-                    sketchScope: slice.sketchScope,
-                });
-                upsertSlicePlanning(params.milestoneId, slice.sliceId, {
-                    goal: slice.goal,
-                    successCriteria: slice.successCriteria,
-                    proofLevel: slice.proofLevel,
-                    integrationClosure: slice.integrationClosure,
-                    observabilityImpact: slice.observabilityImpact,
-                });
-            }
-        });
-    }
-    catch (err) {
-        return { error: `db write failed: ${err.message}` };
-    }
-    if (guardError) {
-        return { error: guardError };
-    }
-    let roadmapPath;
-    try {
-        const renderResult = await renderRoadmapFromDb(basePath, params.milestoneId);
-        roadmapPath = renderResult.roadmapPath;
-    }
-    catch (renderErr) {
-        logWarning("tool", `plan_milestone — render failed (DB rows preserved for debugging): ${renderErr.message}`);
-        invalidateStateCache();
-        return { error: `render failed: ${renderErr.message}` };
-    }
-    invalidateStateCache();
-    clearParseCache();
-    // ── Post-mutation hook: projections, manifest, event log ───────────────
-    try {
-        await renderAllProjections(basePath, params.milestoneId);
-        writeManifest(basePath);
-        appendEvent(basePath, {
-            cmd: "plan-milestone",
-            params: { milestoneId: params.milestoneId },
-            ts: new Date().toISOString(),
-            actor: "agent",
-            actor_name: params.actorName,
-            trigger_reason: params.triggerReason,
-        });
-    }
-    catch (hookErr) {
-        logWarning("tool", `plan-milestone post-mutation hook warning: ${hookErr.message}`);
-    }
-    return {
-        milestoneId: params.milestoneId,
-        roadmapPath,
-    };
+    return persistMilestonePlan(params, basePath);
 }

package/dist/resources/extensions/gsd/tools/reassess-roadmap.js

@@ -31,6 +31,7 @@ function validateParams(params) {
     if (!Array.isArray(params.sliceChanges.removed)) {
         throw new Error("sliceChanges.removed must be an array");
     }
+    const SLICE_ID_RE = /^[A-Za-z0-9][A-Za-z0-9-]*$/;
     // Validate each modified slice
     for (let i = 0; i < params.sliceChanges.modified.length; i++) {
         const s = params.sliceChanges.modified[i];
@@ -40,6 +41,11 @@ function validateParams(params) {
             throw new Error(`sliceChanges.modified[${i}].sliceId is required`);
         if (!isNonEmptyString(s.title))
             throw new Error(`sliceChanges.modified[${i}].title is required`);
+        if (s.depends !== undefined) {
+            if (!Array.isArray(s.depends) || s.depends.some((item) => !isNonEmptyString(item) || !SLICE_ID_RE.test(item))) {
+                throw new Error(`sliceChanges.modified[${i}].depends must be an array of valid slice IDs (e.g. "S01")`);
+            }
+        }
     }
     // Validate each added slice
     for (let i = 0; i < params.sliceChanges.added.length; i++) {
@@ -50,6 +56,11 @@ function validateParams(params) {
             throw new Error(`sliceChanges.added[${i}].sliceId is required`);
         if (!isNonEmptyString(s.title))
             throw new Error(`sliceChanges.added[${i}].title is required`);
+        if (s.depends !== undefined) {
+            if (!Array.isArray(s.depends) || s.depends.some((item) => !isNonEmptyString(item) || !SLICE_ID_RE.test(item))) {
+                throw new Error(`sliceChanges.added[${i}].depends must be an array of valid slice IDs (e.g. "S01")`);
+            }
+        }
     }
     return params;
 }
@@ -111,6 +122,34 @@ export async function handleReassessRoadmap(rawParams, basePath) {
                     return;
                 }
             }
+            // Cross-milestone depends validation — effective slice ID set after this reassessment
+            const removedIds = new Set(params.sliceChanges.removed);
+            const effectiveSliceIds = new Set(existingSlices.map(s => s.id).filter(id => !removedIds.has(id)));
+            for (const added of params.sliceChanges.added) {
+                effectiveSliceIds.add(added.sliceId);
+            }
+            for (let i = 0; i < params.sliceChanges.modified.length; i++) {
+                const mod = params.sliceChanges.modified[i];
+                if (mod.depends !== undefined) {
+                    for (const dep of mod.depends) {
+                        if (!effectiveSliceIds.has(dep)) {
+                            guardError = `sliceChanges.modified[${i}].depends references unknown slice "${dep}" — check that it is defined in this milestone`;
+                            return;
+                        }
+                    }
+                }
+            }
+            for (let i = 0; i < params.sliceChanges.added.length; i++) {
+                const added = params.sliceChanges.added[i];
+                if (added.depends !== undefined) {
+                    for (const dep of added.depends) {
+                        if (!effectiveSliceIds.has(dep)) {
+                            guardError = `sliceChanges.added[${i}].depends references unknown slice "${dep}" — check that it is defined in this milestone`;
+                            return;
+                        }
+                    }
+                }
+            }
             // Record assessment
             insertAssessment({
                 path: assessmentRelPath,

package/dist/resources/extensions/gsd/tools/validate-milestone.js

@@ -11,10 +11,11 @@
  * despite passing validation.
  */
 import { join } from "node:path";
-import { transaction, insertAssessment, getMilestoneSlices, getMilestone, getArtifact, } from "../gsd-db.js";
-import { gsdProjectionRoot, clearPathCache, resolveSliceFile } from "../paths.js";
+import { transaction, insertAssessment, getMilestoneSlices, getMilestone, } from "../gsd-db.js";
+import { gsdProjectionRoot, clearPathCache } from "../paths.js";
 import { resolveCanonicalMilestoneRoot } from "../worktree-manager.js";
-import { saveFile, clearParseCache, loadFile } from "../files.js";
+import { resolveWorktreeProjectRoot } from "../worktree-root.js";
+import { saveFile, clearParseCache } from "../files.js";
 import { invalidateStateCache } from "../state.js";
 import { VALIDATION_VERDICTS, isValidMilestoneVerdict } from "../verdict-parser.js";
 import { insertMilestoneValidationGates } from "../milestone-validation-gates.js";
@@ -22,7 +23,7 @@ import { logWarning } from "../workflow-logger.js";
 import { UokGateRunner } from "../uok/gate-runner.js";
 import { loadEffectiveGSDPreferences } from "../preferences.js";
 import { resolveUokFlags } from "../uok/flags.js";
-import { compactTextParts, hasBrowserEvidenceText, hasBrowserRequiredText } from "../browser-evidence.js";
+import { applyBrowserEvidenceGate, browserEvidenceGateRequiresAttention, } from "../milestone-validation-evidence.js";
 function isVerificationNotApplicable(value) {
     const v = (value ?? "").toLowerCase().trim().replace(/[.\s]+$/, "");
     if (!v || v === "none")
@@ -44,80 +45,6 @@ function getRequiredVerificationClasses(milestoneId) {
         required.push("UAT");
     return required;
 }
-function hasRuntimeExecutableUatEvidenceText(text) {
-    if (!/\buatType:\s*runtime-executable\b/i.test(text))
-        return false;
-    if (!/\bverdict:\s*PASS\b/i.test(text))
-        return false;
-    return /^\|\s*[^|\n]+\s*\|\s*runtime\s*\|\s*PASS\s*\|[^|\n]*\bgsd_uat_exec\b/mi.test(text);
-}
-async function browserEvidenceGateRequiresAttention(params, basePath) {
-    if (params.verdict !== "pass")
-        return false;
-    const milestone = getMilestone(params.milestoneId);
-    const slices = getMilestoneSlices(params.milestoneId);
-    const requirementText = compactTextParts([
-        milestone?.vision,
-        milestone?.success_criteria,
-        milestone?.verification_uat,
-        params.successCriteriaChecklist,
-        params.verificationClasses,
-        ...slices.flatMap((slice) => [
-            slice.demo,
-            slice.goal,
-            slice.success_criteria,
-        ]),
-    ]);
-    if (!hasBrowserRequiredText(requirementText))
-        return false;
-    // Collect per-slice evidence so the runtime bypass is checked independently
-    // for each slice. Concatenating all slices before checking would allow runtime
-    // evidence from one slice to cover another slice's browser requirements.
-    const sliceEvidencePairs = [];
-    for (const slice of slices) {
-        const chunks = [];
-        const artifactPath = `milestones/${params.milestoneId}/slices/${slice.id}/${slice.id}-ASSESSMENT.md`;
-        const artifact = getArtifact(artifactPath);
-        if (artifact?.full_content)
-            chunks.push(artifact.full_content);
-        const assessmentPath = resolveSliceFile(basePath, params.milestoneId, slice.id, "ASSESSMENT");
-        const assessmentContent = assessmentPath ? await loadFile(assessmentPath) : null;
-        if (assessmentContent)
-            chunks.push(assessmentContent);
-        sliceEvidencePairs.push({
-            sliceRequirementText: compactTextParts([slice.demo, slice.goal, slice.success_criteria]),
-            evidenceText: chunks.join("\n\n"),
-        });
-    }
-    const persistedEvidence = sliceEvidencePairs.map((s) => s.evidenceText).join("\n\n");
-    // Runtime bypass: each slice whose own requirement text has browser-observable
-    // criteria must have its own runtime-executable UAT evidence. When no individual
-    // slice has slice-level browser requirements (e.g., they come from milestone-level
-    // fields only), fall back to checking whether any slice has runtime evidence.
-    const browserRequiringSlices = sliceEvidencePairs.filter((s) => hasBrowserRequiredText(s.sliceRequirementText));
-    const runtimeBypasses = browserRequiringSlices.length > 0
-        ? browserRequiringSlices.every((s) => hasRuntimeExecutableUatEvidenceText(s.evidenceText))
-        : sliceEvidencePairs.some((s) => hasRuntimeExecutableUatEvidenceText(s.evidenceText));
-    if (runtimeBypasses)
-        return false;
-    const validationEvidence = compactTextParts([
-        params.successCriteriaChecklist,
-        params.verificationClasses,
-        params.verdictRationale,
-        params.remediationPlan,
-    ]);
-    return !hasBrowserEvidenceText(`${persistedEvidence}\n\n${validationEvidence}`);
-}
-function applyBrowserEvidenceGate(params) {
-    const note = "Browser evidence gate: Browser-observable acceptance criteria were detected, but no persisted ASSESSMENT or validation evidence recorded browser actions with assertions. Downgraded from pass to needs-attention.";
-    return {
-        ...params,
-        verdict: "needs-attention",
-        verdictRationale: params.verdictRationale.trim()
-            ? `${params.verdictRationale.trim()}\n\n${note}`
-            : note,
-    };
-}
 function renderValidationMarkdown(params) {
     let md = `---
 verdict: ${params.verdict}
@@ -214,6 +141,16 @@ export async function handleValidateMilestone(params, basePath, opts) {
     let projectionStale = false;
     try {
         await saveFile(validationPath, validationMd);
+        const projectRoot = resolveWorktreeProjectRoot(basePath);
+        if (projectRoot !== artifactBasePath) {
+            const projectValidationPath = join(gsdProjectionRoot(projectRoot), "milestones", effectiveParams.milestoneId, `${effectiveParams.milestoneId}-VALIDATION.md`);
+            try {
+                await saveFile(projectValidationPath, validationMd);
+            }
+            catch (mirrorErr) {
+                logWarning("projection", `validate_milestone project-root VALIDATION mirror failed for ${effectiveParams.milestoneId}`, { error: mirrorErr.message });
+            }
+        }
     }
     catch (renderErr) {
         projectionStale = true;

package/dist/resources/extensions/gsd/uat-policy.js

@@ -2,6 +2,7 @@
 // File Purpose: Central UAT mode policy for dispatch, tool presentation, and result validation.
 import { extractUatType } from "./files.js";
 import { hasBrowserRequiredText } from "./browser-evidence.js";
+import { parseMcpToolName } from "./mcp-tool-name.js";
 export const UAT_TYPES = [
     "artifact-driven",
     "browser-executable",
@@ -80,26 +81,31 @@ export function shouldDispatchUatForContent(content, prefs) {
 export function uatTypeIncludesBrowser(uatType) {
     return isUatType(uatType) && UAT_MODE_POLICIES[uatType].browserTools;
 }
-function canonicalPresentedToolName(toolName) {
-    if (!toolName.startsWith("mcp__"))
-        return toolName;
-    const toolSeparator = toolName.indexOf("__", "mcp__".length);
-    return toolSeparator >= 0 ? toolName.slice(toolSeparator + 2) : toolName;
-}
 export function isUatBrowserToolName(toolName) {
-    return canonicalPresentedToolName(toolName).startsWith("browser_");
+    const parsed = parseMcpToolName(toolName);
+    const canonicalName = parsed?.toolName ?? toolName;
+    if (canonicalName.startsWith("browser_"))
+        return true;
+    return parsed?.toolName === "*" && parsed.serverName.toLowerCase().includes("browser");
 }
 export function hasUatBrowserToolSurface(activeTools) {
     return Array.isArray(activeTools) && activeTools.some(isUatBrowserToolName);
 }
+export function resolveUatBrowserToolSurface(options) {
+    const surfaces = [options.activeTools, options.registeredTools].filter(Array.isArray);
+    if (surfaces.length === 0)
+        return undefined;
+    return [...new Set(surfaces.flat())];
+}
 export function getUatBrowserToolSupportError(options) {
     if (!uatTypeIncludesBrowser(options.uatType))
         return null;
-    if (!Array.isArray(options.activeTools))
+    const toolSurface = resolveUatBrowserToolSurface(options);
+    if (!toolSurface)
         return null;
-    if (hasUatBrowserToolSurface(options.activeTools))
+    if (hasUatBrowserToolSurface(toolSurface))
         return null;
-    return `Cannot dispatch browser-backed run-uat for ${options.milestoneId}/${options.sliceId}: UAT mode "${options.uatType}" requires browser tools, but the active tool surface has none. Enable browser tools or change the UAT to a runtime-executable Playwright command, then rerun /gsd auto.`;
+    return `Cannot dispatch browser-backed run-uat for ${options.milestoneId}/${options.sliceId}: UAT mode "${options.uatType}" requires browser tools, but the run-uat tool surface has none. Enable browser tools or change the UAT to a runtime-executable Playwright command, then rerun /gsd auto.`;
 }
 export function isPartialEligibleUatType(uatType) {
     return !!uatType && UAT_MODE_POLICIES[uatType].partialEligible;

package/dist/resources/extensions/gsd/uat-run.js

@@ -13,7 +13,7 @@ function isNonEmptyString(value) {
 function mergeBlockedTools(current, canonical) {
     const merged = new Map();
     for (const entry of [...(current ?? []), ...canonical]) {
-        merged.set(canonicalWorkflowToolName(parseMcpToolName(entry.name)?.tool ?? entry.name), entry);
+        merged.set(canonicalWorkflowToolName(parseMcpToolName(entry.name)?.toolName ?? entry.name), entry);
     }
     return [...merged.values()];
 }
@@ -204,20 +204,15 @@ function quoteToolNames(toolNames) {
     return toolNames.map((toolName) => `"${toolName}"`).join(", ");
 }
 function validateCanonicalPresentation(params) {
-    const aliasHints = {
-        gsd_save_summary: "gsd_summary_save",
-        gsd_complete_task: "gsd_task_complete",
-        gsd_complete_slice: "gsd_slice_complete",
-        gsd_milestone_complete: "gsd_complete_milestone",
-    };
     const errors = [];
     for (const toolName of params.presentation.presentedTools) {
-        const baseName = parseMcpToolName(toolName)?.tool ?? toolName;
-        const canonical = aliasHints[baseName];
-        if (canonical)
+        const baseName = parseMcpToolName(toolName)?.toolName ?? toolName;
+        const canonical = canonicalWorkflowToolName(baseName);
+        if (canonical !== baseName) {
             errors.push(`presentation tool "${toolName}" uses an alias; use canonical "${canonical}"`);
+        }
     }
-    const presentedCanonical = new Set(params.presentation.presentedTools.map((toolName) => canonicalWorkflowToolName(parseMcpToolName(toolName)?.tool ?? toolName)));
+    const presentedCanonical = new Set(params.presentation.presentedTools.map((toolName) => canonicalWorkflowToolName(parseMcpToolName(toolName)?.toolName ?? toolName)));
     const missingRequiredTools = RUN_UAT_WORKFLOW_TOOL_NAMES.filter((requiredTool) => !presentedCanonical.has(requiredTool));
     if (missingRequiredTools.length === 1) {
         errors.push(`presentation is missing required UAT tool "${missingRequiredTools[0]}"`);
@@ -227,10 +222,10 @@ function validateCanonicalPresentation(params) {
     }
     const forbiddenCanonical = new Set(RUN_UAT_FORBIDDEN_TOOL_NAMES
         .filter((toolName) => !toolName.includes("*"))
-        .map((toolName) => canonicalWorkflowToolName(parseMcpToolName(toolName)?.tool ?? toolName)));
+        .map((toolName) => canonicalWorkflowToolName(parseMcpToolName(toolName)?.toolName ?? toolName)));
     const forbiddenPresentedTools = [];
     for (const toolName of params.presentation.presentedTools) {
-        const canonical = canonicalWorkflowToolName(parseMcpToolName(toolName)?.tool ?? toolName);
+        const canonical = canonicalWorkflowToolName(parseMcpToolName(toolName)?.toolName ?? toolName);
         if (toolName === "mcp__gsd-workflow__*" || forbiddenCanonical.has(canonical)) {
             forbiddenPresentedTools.push(toolName);
         }
@@ -241,7 +236,7 @@ function validateCanonicalPresentation(params) {
     else if (forbiddenPresentedTools.length > 1) {
         errors.push(`presentation includes forbidden run-uat tools ${quoteToolNames(forbiddenPresentedTools)}`);
     }
-    const blockedCanonical = new Set(params.presentation.blockedTools.map((entry) => canonicalWorkflowToolName(parseMcpToolName(entry.name)?.tool ?? entry.name)));
+    const blockedCanonical = new Set(params.presentation.blockedTools.map((entry) => canonicalWorkflowToolName(parseMcpToolName(entry.name)?.toolName ?? entry.name)));
     const missingBlockedTools = ["gsd_exec", "gsd_summary_save", "gsd_save_gate_result"].filter((blockedTool) => !blockedCanonical.has(blockedTool));
     if (missingBlockedTools.length === 1) {
         errors.push(`presentation must record "${missingBlockedTools[0]}" as blocked during run-uat`);