@opengsd/gsd-pi 1.1.1-dev.616a1a1 → 1.1.1-dev.75048e7

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

@@ -7,7 +7,7 @@
  * artifacts so the DB-filesystem reconciler does not auto-correct
  * entities back to "complete".
  */
-import { getMilestone, getMilestoneSlices, getSliceTasks, updateMilestoneStatus, updateSliceStatus, updateTaskStatus, transaction, } from "../gsd-db.js";
+import { getMilestone, getMilestoneSlices, getSliceTasks, reopenMilestoneStatus, updateSliceStatus, updateTaskStatus, transaction, } from "../gsd-db.js";
 import { invalidateStateCache } from "../state.js";
 import { isClosedStatus } from "../status-guards.js";
 import { renderAllProjections } from "../workflow-projections.js";
@@ -37,7 +37,7 @@ export async function handleReopenMilestone(params, basePath) {
             guardError = `milestone ${params.milestoneId} is not closed (status: ${milestone.status}) — nothing to reopen`;
             return;
         }
-        updateMilestoneStatus(params.milestoneId, "active", null);
+        reopenMilestoneStatus(params.milestoneId);
         const slices = getMilestoneSlices(params.milestoneId);
         slicesResetCount = slices.length;
         for (const slice of slices) {

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

@@ -44,19 +44,12 @@ function getRequiredVerificationClasses(milestoneId) {
         required.push("UAT");
     return required;
 }
-async function collectPersistedBrowserEvidence(basePath, milestoneId) {
-    const chunks = [];
-    for (const slice of getMilestoneSlices(milestoneId)) {
-        const artifactPath = `milestones/${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, milestoneId, slice.id, "ASSESSMENT");
-        const assessmentContent = assessmentPath ? await loadFile(assessmentPath) : null;
-        if (assessmentContent)
-            chunks.push(assessmentContent);
-    }
-    return chunks.join("\n\n");
+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")
@@ -77,7 +70,36 @@ async function browserEvidenceGateRequiresAttention(params, basePath) {
     ]);
     if (!hasBrowserRequiredText(requirementText))
         return false;
-    const persistedEvidence = await collectPersistedBrowserEvidence(basePath, params.milestoneId);
+    // 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,
@@ -138,12 +160,20 @@ export async function handleValidateMilestone(params, basePath, opts) {
     const requiredClasses = getRequiredVerificationClasses(params.milestoneId);
     if (requiredClasses.length > 0) {
         const verificationClasses = params.verificationClasses ?? "";
-        const missingClass = requiredClasses.find((className) => !new RegExp(`\\b${className}\\b`, "i").test(verificationClasses));
-        if (missingClass) {
+        const missingClasses = requiredClasses.filter((className) => !new RegExp(`\\b${className}\\b`, "i").test(verificationClasses));
+        if (missingClasses.length === 1) {
+            const missingClass = missingClasses[0];
             return {
                 error: `verificationClasses must include canonical row "${missingClass}" because this milestone planned ${missingClass.toLowerCase()} verification`,
             };
         }
+        if (missingClasses.length > 1) {
+            const quotedClasses = missingClasses.map((className) => `"${className}"`).join(", ");
+            const plannedClasses = missingClasses.map((className) => className.toLowerCase()).join(", ");
+            return {
+                error: `verificationClasses must include canonical rows ${quotedClasses} because this milestone planned ${plannedClasses} verification`,
+            };
+        }
     }
     const artifactBasePath = resolveCanonicalMilestoneRoot(basePath, params.milestoneId);
     const shouldApplyBrowserEvidenceGate = !opts?.skipBrowserEvidenceGate &&

package/dist/resources/extensions/gsd/tools/workflow-tool-executors.js

@@ -3,13 +3,13 @@
 import { ensureDbOpen } from "../bootstrap/dynamic-tools.js";
 import { sanitizeCompleteMilestoneParams } from "../bootstrap/sanitize-complete-milestone.js";
 import { loadWriteGateSnapshot, shouldBlockContextArtifactSaveInSnapshot, shouldBlockRootArtifactSaveInSnapshot } from "../bootstrap/write-gate.js";
-import { getActiveRequirements, insertMilestone, getMilestone, getSliceStatusSummary, getSliceTaskCounts, readTransaction, saveGateResult, } from "../gsd-db.js";
+import { getActiveRequirements, insertMilestone, getMilestone, getSliceStatusSummary, getSliceTaskCounts, insertGateRun, readTransaction, saveGateResult, upsertQualityGate, } from "../gsd-db.js";
 import { GATE_REGISTRY } from "../gate-registry.js";
 import { generateRequirementsMd, saveArtifactToDb } from "../db-writer.js";
 import { clearPathCache, resolveGsdPathContract, resolveMilestoneFile, resolveSliceFile } from "../paths.js";
 import { saveFile, clearParseCache } from "../files.js";
-import { unlinkSync } from "node:fs";
-import { join } from "node:path";
+import { existsSync, readdirSync, readFileSync, unlinkSync } from "node:fs";
+import { isAbsolute, join, resolve } from "node:path";
 import { handleCompleteMilestone } from "./complete-milestone.js";
 import { handleCompleteTask } from "./complete-task.js";
 import { handleCompleteSlice } from "./complete-slice.js";
@@ -26,6 +26,7 @@ import { invalidateStateCache } from "../state.js";
 import { loadEffectiveGSDPreferences } from "../preferences.js";
 import { parseProject } from "../schemas/parsers.js";
 import { getAutoRuntimeSnapshot } from "../auto-runtime-state.js";
+import { buildRunUatPresentationForType, canonicalWorkflowToolName, parseMcpToolName, RUN_UAT_FORBIDDEN_TOOL_NAMES, RUN_UAT_TOOL_PRESENTATION_PLAN_ID, RUN_UAT_WORKFLOW_TOOL_NAMES, } from "../tool-presentation-plan.js";
 export const SUPPORTED_SUMMARY_ARTIFACT_TYPES = [
     "SUMMARY",
     "RESEARCH",
@@ -52,7 +53,7 @@ function blockIfWrongAutoUnit(requiredUnitType, operation) {
         return null;
     if (snapshot.currentUnit.type === requiredUnitType)
         return null;
-    const error = `HARD BLOCK: ${operation} may only run from ${requiredUnitType}; active unit is ${snapshot.currentUnit.type}. The orchestrator owns phase transitions.`;
+    const error = `HARD BLOCK: Tool Contract failure: ${operation} may only run from ${requiredUnitType}; active unit is ${snapshot.currentUnit.type}. Fix unit-tool-contracts.ts or the active Unit prompt. The orchestrator owns phase transitions.`;
     return {
         content: [{ type: "text", text: error }],
         details: { operation, error },
@@ -120,7 +121,11 @@ export async function executeSummarySave(params, basePath = process.cwd()) {
     if (rootArtifactGuard.block) {
         return {
             content: [{ type: "text", text: `Error saving artifact: ${rootArtifactGuard.reason ?? "root artifact write blocked"}` }],
-            details: { operation: "save_summary", error: "root_artifact_write_blocked" },
+            details: {
+                operation: "save_summary",
+                error: "root_artifact_write_blocked",
+                displayReason: "Approval confirmation required before saving final project setup artifacts.",
+            },
             isError: true,
         };
     }
@@ -128,7 +133,11 @@ export async function executeSummarySave(params, basePath = process.cwd()) {
     if (contextGuard.block) {
         return {
             content: [{ type: "text", text: `Error saving artifact: ${contextGuard.reason ?? "context write blocked"}` }],
-            details: { operation: "save_summary", error: "context_write_blocked" },
+            details: {
+                operation: "save_summary",
+                error: "context_write_blocked",
+                displayReason: "Depth check required before writing milestone context.",
+            },
             isError: true,
         };
     }
@@ -333,6 +342,28 @@ export async function executeTaskComplete(params, basePath = process.cwd()) {
                 isError: true,
             };
         }
+        if (result.escalation) {
+            const recommended = result.escalation.options.find((option) => option.id === result.escalation?.recommendation);
+            const optionIds = result.escalation.options.map((option) => option.id).join("|");
+            return {
+                content: [{
+                        type: "text",
+                        text: [
+                            `Task completed with escalation decision required: ${result.escalation.question}`,
+                            `Recommendation: ${result.escalation.recommendation}${recommended ? ` (${recommended.label})` : ""} — ${result.escalation.recommendationRationale}`,
+                            `Resolve with: /gsd escalate resolve ${result.taskId} <${optionIds}|accept|reject-blocker> [rationale...]`,
+                        ].join("\n"),
+                    }],
+                details: {
+                    operation: "complete_task",
+                    taskId: result.taskId,
+                    sliceId: result.sliceId,
+                    milestoneId: result.milestoneId,
+                    summaryPath: result.summaryPath,
+                    escalation: result.escalation,
+                },
+            };
+        }
         return {
             content: [{ type: "text", text: `Completed task ${result.taskId} (${result.sliceId}/${result.milestoneId})` }],
             details: {
@@ -775,6 +806,452 @@ export async function executeSaveGateResult(params, basePath = process.cwd()) {
         };
     }
 }
+function errorResult(operation, message, error) {
+    return {
+        content: [{ type: "text", text: `Error: ${message}` }],
+        details: { operation, error },
+        isError: true,
+    };
+}
+function isNonEmptyString(value) {
+    return typeof value === "string" && value.trim().length > 0;
+}
+function mergeBlockedTools(current, canonical) {
+    const merged = new Map();
+    for (const entry of [...(current ?? []), ...canonical]) {
+        merged.set(canonicalWorkflowToolName(parseMcpToolName(entry.name)?.tool ?? entry.name), entry);
+    }
+    return [...merged.values()];
+}
+function mergePresentedTools(current, canonical) {
+    return [...new Set([...(current ?? []), ...canonical])];
+}
+function normalizeUatVerdict(params) {
+    const raw = params;
+    if (typeof raw.verdict === "string") {
+        return { ...params, verdict: raw.verdict.toUpperCase() };
+    }
+    return params;
+}
+function supplyDefaultPresentation(params) {
+    const raw = params;
+    if (!raw.presentation) {
+        return { ...params, presentation: buildRunUatPresentationForType(params.uatType) };
+    }
+    return params;
+}
+function mergeCanonicalPresentation(params) {
+    const canonicalPresentation = buildRunUatPresentationForType(params.uatType);
+    const providedPresentation = params.presentation;
+    return {
+        ...params,
+        presentation: {
+            ...providedPresentation,
+            surface: providedPresentation.surface ?? canonicalPresentation.surface,
+            presentedTools: mergePresentedTools(providedPresentation.presentedTools, canonicalPresentation.presentedTools),
+            blockedTools: mergeBlockedTools(providedPresentation.blockedTools, canonicalPresentation.blockedTools),
+            toolPresentationPlanId: RUN_UAT_TOOL_PRESENTATION_PLAN_ID,
+        },
+    };
+}
+const VALID_UAT_TYPES = [
+    "artifact-driven",
+    "browser-executable",
+    "runtime-executable",
+    "live-runtime",
+    "mixed",
+    "human-experience",
+];
+function ensureUatRequiredFields(params) {
+    if (!isNonEmptyString(params.milestoneId))
+        return "milestoneId is required";
+    if (!isNonEmptyString(params.sliceId))
+        return "sliceId is required";
+    if (!isNonEmptyString(params.uatType))
+        return "uatType is required";
+    if (!VALID_UAT_TYPES.includes(params.uatType)) {
+        return `uatType must be one of: ${VALID_UAT_TYPES.join(", ")}`;
+    }
+    if (!["PASS", "FAIL", "PARTIAL"].includes(params.verdict))
+        return "verdict must be PASS, FAIL, or PARTIAL";
+    if (!Array.isArray(params.checks) || params.checks.length === 0)
+        return "checks must contain at least one UAT check";
+    if (!params.presentation || !Array.isArray(params.presentation.presentedTools))
+        return "presentation.presentedTools is required";
+    if (!Array.isArray(params.presentation.blockedTools))
+        return "presentation.blockedTools is required";
+    return null;
+}
+function approvedEvidenceRoots(basePath) {
+    const contract = resolveGsdPathContract(basePath);
+    return [contract.worktreeGsd, contract.projectGsd].filter((root) => typeof root === "string");
+}
+function approvedBrowserArtifactRoots(basePath) {
+    const contract = resolveGsdPathContract(basePath);
+    const roots = [contract.workRoot, contract.projectRoot].map((root) => join(root, ".artifacts", "browser"));
+    return [...new Set(roots)];
+}
+function pathStartsWithin(parent, target) {
+    const normalizedParent = parent.replace(/\\/g, "/").replace(/\/+$/, "");
+    const normalizedTarget = target.replace(/\\/g, "/").replace(/\/+$/, "");
+    return normalizedTarget === normalizedParent || normalizedTarget.startsWith(`${normalizedParent}/`);
+}
+function pushUnique(paths, candidate) {
+    if (!paths.includes(candidate))
+        paths.push(candidate);
+}
+function execMetaPathCandidates(basePath, ref) {
+    const trimmed = ref.trim();
+    const candidates = [];
+    const execDirs = approvedEvidenceRoots(basePath).map((root) => join(root, "exec"));
+    const normalizedRef = trimmed.replace(/\\/g, "/");
+    const pathLike = normalizedRef.endsWith(".meta.json") || normalizedRef.includes("/.gsd/exec/");
+    if (pathLike) {
+        const rawPath = isAbsolute(trimmed) ? resolve(trimmed) : resolve(basePath, trimmed);
+        pushUnique(candidates, rawPath);
+        const relativeExecMarker = ".gsd/exec/";
+        const markerIndex = normalizedRef.indexOf(relativeExecMarker);
+        if (markerIndex >= 0) {
+            const execRelative = normalizedRef.slice(markerIndex + relativeExecMarker.length);
+            for (const execDir of execDirs) {
+                pushUnique(candidates, join(execDir, execRelative));
+            }
+        }
+        return candidates.filter((candidate) => execDirs.some((execDir) => pathStartsWithin(execDir, candidate)));
+    }
+    for (const execDir of execDirs) {
+        pushUnique(candidates, join(execDir, `${trimmed}.meta.json`));
+    }
+    return candidates;
+}
+function resolveExecMetaPath(basePath, ref) {
+    for (const candidate of execMetaPathCandidates(basePath, ref)) {
+        if (existsSync(candidate))
+            return candidate;
+    }
+    return null;
+}
+function evidencePathIsApproved(basePath, ref) {
+    const normalizedRef = ref.replace(/\\/g, "/");
+    if (normalizedRef.startsWith(".gsd/exec/") || normalizedRef.startsWith(".gsd/uat/"))
+        return true;
+    if (normalizedRef.startsWith(".artifacts/browser/")) {
+        const resolvedRef = resolve(basePath, ref);
+        return approvedBrowserArtifactRoots(basePath).some((root) => pathStartsWithin(root, resolvedRef));
+    }
+    const gsdEvidenceApproved = approvedEvidenceRoots(basePath).some((root) => {
+        return pathStartsWithin(join(root, "exec"), ref) || pathStartsWithin(join(root, "uat"), ref);
+    });
+    if (gsdEvidenceApproved)
+        return true;
+    return approvedBrowserArtifactRoots(basePath).some((root) => pathStartsWithin(root, ref));
+}
+function validateEvidenceRef(basePath, evidence) {
+    if (!isNonEmptyString(evidence.ref))
+        return "evidence.ref is required";
+    if (evidence.kind === "gsd_uat_exec" || evidence.kind === "gsd_exec") {
+        const path = resolveExecMetaPath(basePath, evidence.ref.trim());
+        if (!path)
+            return `missing gsd_exec metadata for evidence id "${evidence.ref}"`;
+        if (evidence.kind === "gsd_uat_exec") {
+            try {
+                const meta = JSON.parse(readFileSync(path, "utf-8"));
+                if (meta.metadata?.kind !== "uat_exec")
+                    return `evidence id "${evidence.ref}" is not typed as uat_exec`;
+            }
+            catch {
+                return `invalid gsd_exec metadata JSON for evidence id "${evidence.ref}"`;
+            }
+        }
+        return null;
+    }
+    if (evidence.kind === "url") {
+        try {
+            const parsed = new URL(evidence.ref);
+            return parsed.protocol === "http:" || parsed.protocol === "https:"
+                ? null
+                : `invalid URL evidence ref "${evidence.ref}"`;
+        }
+        catch {
+            return `invalid URL evidence ref "${evidence.ref}"`;
+        }
+    }
+    return evidencePathIsApproved(basePath, evidence.ref)
+        ? null
+        : `evidence ref "${evidence.ref}" is outside approved evidence locations`;
+}
+function validateUatChecks(basePath, params) {
+    for (const check of params.checks) {
+        if (!isNonEmptyString(check.id))
+            return "every check must have a non-empty id";
+        if (!isNonEmptyString(check.description))
+            return `check ${check.id} must have a description`;
+        if (!["artifact", "runtime", "browser", "human-follow-up"].includes(check.mode)) {
+            return `check ${check.id} has invalid mode "${check.mode}"`;
+        }
+        if (!["PASS", "FAIL", "NEEDS-HUMAN"].includes(check.result)) {
+            return `check ${check.id} has invalid result "${check.result}"`;
+        }
+        if (check.result === "PASS" || check.result === "FAIL") {
+            if (!Array.isArray(check.evidence) || check.evidence.length === 0) {
+                return `check ${check.id} is ${check.result} but has no objective evidence`;
+            }
+            for (const evidence of check.evidence) {
+                const error = validateEvidenceRef(basePath, evidence);
+                if (error)
+                    return `check ${check.id}: ${error}`;
+            }
+        }
+        else if (!isNonEmptyString(check.notes)) {
+            return `check ${check.id} is NEEDS-HUMAN but has no manual instruction or reason`;
+        }
+    }
+    return null;
+}
+function validateFreshUatOwnedEvidence(params) {
+    const hasFreshUatEvidence = params.checks.some((check) => (check.evidence ?? []).some((evidence) => evidence.kind === "gsd_uat_exec"));
+    return hasFreshUatEvidence
+        ? null
+        : "UAT Assessment requires at least one fresh gsd_uat_exec evidence reference from run-uat";
+}
+function validateUatMode(params) {
+    const modes = new Set(params.checks.map((check) => check.mode));
+    const hasHuman = params.checks.some((check) => check.result === "NEEDS-HUMAN");
+    if (params.uatType === "artifact-driven" && hasHuman && params.verdict === "PASS") {
+        return "artifact-driven UAT cannot PASS with human-only checks";
+    }
+    if (hasHuman &&
+        params.verdict === "PASS" &&
+        !["human-experience", "mixed", "live-runtime"].includes(params.uatType) &&
+        !params.checks.every((check) => check.result !== "NEEDS-HUMAN" || check.nonAutomatable === true)) {
+        return "NEEDS-HUMAN checks can only coexist with PASS for human-experience, mixed, live-runtime, or explicitly non-automatable checks";
+    }
+    if (params.uatType === "runtime-executable" && !modes.has("runtime")) {
+        return "runtime-executable UAT requires at least one runtime check";
+    }
+    if (params.uatType === "browser-executable" && !modes.has("browser")) {
+        return "browser-executable UAT requires at least one browser check";
+    }
+    if (params.uatType === "live-runtime" && !modes.has("runtime") && !modes.has("browser")) {
+        return "live-runtime UAT requires runtime or browser evidence";
+    }
+    return null;
+}
+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)
+            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 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]}"`);
+    }
+    else if (missingRequiredTools.length > 1) {
+        errors.push(`presentation is missing required UAT tools ${quoteToolNames(missingRequiredTools)}`);
+    }
+    const forbiddenCanonical = new Set(RUN_UAT_FORBIDDEN_TOOL_NAMES
+        .filter((toolName) => !toolName.includes("*"))
+        .map((toolName) => canonicalWorkflowToolName(parseMcpToolName(toolName)?.tool ?? toolName)));
+    const forbiddenPresentedTools = [];
+    for (const toolName of params.presentation.presentedTools) {
+        const canonical = canonicalWorkflowToolName(parseMcpToolName(toolName)?.tool ?? toolName);
+        if (toolName === "mcp__gsd-workflow__*" || forbiddenCanonical.has(canonical)) {
+            forbiddenPresentedTools.push(toolName);
+        }
+    }
+    if (forbiddenPresentedTools.length === 1) {
+        errors.push(`presentation includes forbidden run-uat tool "${forbiddenPresentedTools[0]}"`);
+    }
+    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 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`);
+    }
+    else if (missingBlockedTools.length > 1) {
+        errors.push(`presentation must record ${quoteToolNames(missingBlockedTools)} as blocked during run-uat`);
+    }
+    return errors.length > 0 ? errors.join("; ") : null;
+}
+function nextUatAttempt(basePath, milestoneId, sliceId) {
+    const contract = resolveGsdPathContract(basePath);
+    const dir = join(contract.projectGsd, "uat", milestoneId, sliceId);
+    if (!existsSync(dir))
+        return 1;
+    let max = 0;
+    for (const entry of readdirSync(dir)) {
+        const match = /^attempt-(\d+)\.json$/.exec(entry);
+        if (match)
+            max = Math.max(max, Number(match[1]));
+    }
+    return max + 1;
+}
+function escapeMarkdownTableCell(value) {
+    return String(value ?? "")
+        .replace(/[\\|]/g, (char) => `\\${char}`)
+        .replace(/\r?\n/g, "<br>");
+}
+function renderUatAssessment(params, attempt, gateVerdict) {
+    const lines = [
+        "---",
+        `sliceId: ${params.sliceId}`,
+        `uatType: ${params.uatType}`,
+        `verdict: ${params.verdict}`,
+        `attempt: ${attempt}`,
+        `date: ${new Date().toISOString()}`,
+        "---",
+        "",
+        `# UAT Result - ${params.sliceId}`,
+        "",
+        "## Checks",
+        "",
+        "| Check | Mode | Result | Evidence | Notes |",
+        "|-------|------|--------|----------|-------|",
+        ...params.checks.map((check) => {
+            const evidence = (check.evidence ?? []).map((entry) => `${entry.kind}:${entry.ref}`).join("<br>") || "-";
+            return `| ${escapeMarkdownTableCell(check.description)} | ${escapeMarkdownTableCell(check.mode)} | ${escapeMarkdownTableCell(check.result)} | ${escapeMarkdownTableCell(evidence)} | ${escapeMarkdownTableCell(check.notes)} |`;
+        }),
+        "",
+        "## Overall Verdict",
+        "",
+        `${params.verdict} - ${params.notes ?? "UAT result saved."}`,
+        "",
+        "## Tool Presentation",
+        "",
+        "```json",
+        JSON.stringify(params.presentation, null, 2),
+        "```",
+        "",
+        "## Gate",
+        "",
+        `Aggregate UAT gate saved as ${gateVerdict}.`,
+    ];
+    return `${lines.join("\n")}\n`;
+}
+async function saveUatAttemptArtifact(basePath, params, attempt) {
+    const contract = resolveGsdPathContract(basePath);
+    const relativePath = `uat/${params.milestoneId}/${params.sliceId}/attempt-${attempt}.json`;
+    await saveFile(join(contract.projectGsd, relativePath), `${JSON.stringify({ ...params, attempt }, null, 2)}\n`);
+    return relativePath;
+}
+export async function executeUatResultSave(params, basePath = process.cwd()) {
+    const unitGuard = blockIfWrongAutoUnit("run-uat", "save_uat_result");
+    if (unitGuard)
+        return unitGuard;
+    // Phase 1: normalize verdict and supply the canonical presentation when none was provided.
+    params = normalizeUatVerdict(params);
+    params = supplyDefaultPresentation(params);
+    const dbAvailable = await ensureDbOpen(basePath);
+    if (!dbAvailable)
+        return errorResult("save_uat_result", "GSD database is not available.", "db_unavailable");
+    // Phase 2: validate the submitted presentation before the canonical merge so that
+    // presentations missing required workflow tools are rejected rather than silently patched.
+    const requiredError = ensureUatRequiredFields(params);
+    if (requiredError)
+        return errorResult("save_uat_result", requiredError, "invalid_params");
+    const presentationError = validateCanonicalPresentation(params);
+    if (presentationError)
+        return errorResult("save_uat_result", presentationError, "alias_tool_name");
+    // Phase 3: merge in the canonical plan ID and read-only audit tools so the persisted
+    // artifact always carries the full audit surface even when the provider omitted them.
+    params = mergeCanonicalPresentation(params);
+    const checkError = validateUatChecks(basePath, params);
+    if (checkError)
+        return errorResult("save_uat_result", checkError, "invalid_evidence");
+    const freshEvidenceError = validateFreshUatOwnedEvidence(params);
+    if (freshEvidenceError)
+        return errorResult("save_uat_result", freshEvidenceError, "missing_fresh_uat_evidence");
+    const modeError = validateUatMode(params);
+    if (modeError)
+        return errorResult("save_uat_result", modeError, "uat_mode_mismatch");
+    try {
+        const attempt = params.attempt === "auto" || params.attempt === undefined
+            ? nextUatAttempt(basePath, params.milestoneId, params.sliceId)
+            : typeof params.attempt === "string"
+                ? Number.parseInt(params.attempt, 10)
+                : params.attempt;
+        if (!Number.isInteger(attempt) || attempt < 1) {
+            return errorResult("save_uat_result", "attempt must be a positive integer or auto", "invalid_attempt");
+        }
+        const gateVerdict = params.verdict === "PASS" ? "pass" : "flag";
+        const rationale = params.notes ?? `UAT ${params.verdict} for ${params.sliceId}.`;
+        const assessment = renderUatAssessment(params, attempt, gateVerdict);
+        const summary = await executeSummarySave({
+            milestone_id: params.milestoneId,
+            slice_id: params.sliceId,
+            artifact_type: "ASSESSMENT",
+            content: assessment,
+        }, basePath);
+        if (summary.isError)
+            return summary;
+        const attemptPath = await saveUatAttemptArtifact(basePath, params, attempt);
+        const evaluatedAt = new Date().toISOString();
+        upsertQualityGate({
+            milestoneId: params.milestoneId,
+            sliceId: params.sliceId,
+            gateId: "UAT",
+            scope: "slice",
+            taskId: "",
+            status: "complete",
+            verdict: gateVerdict,
+            rationale,
+            findings: assessment,
+            evaluatedAt,
+        });
+        insertGateRun({
+            traceId: `uat:${params.milestoneId}:${params.sliceId}`,
+            turnId: `uat:${params.sliceId}:attempt-${attempt}`,
+            gateId: "UAT",
+            gateType: "uat",
+            unitType: "run-uat",
+            unitId: `run-uat:${params.milestoneId}/${params.sliceId}`,
+            milestoneId: params.milestoneId,
+            sliceId: params.sliceId,
+            outcome: params.verdict === "PASS" ? "pass" : "fail",
+            failureClass: params.verdict === "PASS" ? "none" : "verification",
+            rationale,
+            findings: assessment,
+            attempt,
+            maxAttempts: attempt,
+            retryable: params.verdict !== "PASS",
+            evaluatedAt,
+        });
+        invalidateStateCache();
+        return {
+            content: [{ type: "text", text: `UAT result saved for ${params.milestoneId}/${params.sliceId}: ${params.verdict}` }],
+            details: {
+                operation: "save_uat_result",
+                milestoneId: params.milestoneId,
+                sliceId: params.sliceId,
+                verdict: params.verdict,
+                gateVerdict,
+                attempt,
+                attemptPath,
+                recommendedNextUnit: params.verdict === "PASS" ? null : "reactive-execute",
+            },
+        };
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        logError("tool", `gsd_uat_result_save failed: ${msg}`, { tool: "gsd_uat_result_save", error: String(err) });
+        return errorResult("save_uat_result", `saving UAT result failed: ${msg}`, msg);
+    }
+}
 export async function executePlanMilestone(params, basePath = process.cwd()) {
     const dbAvailable = await ensureDbOpen(basePath);
     if (!dbAvailable) {