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

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

@@ -0,0 +1,130 @@
+// Project/App: gsd-pi
+// File Purpose: Central UAT mode policy for dispatch, tool presentation, and result validation.
+import { extractUatType } from "./files.js";
+import { hasBrowserRequiredText } from "./browser-evidence.js";
+export const UAT_TYPES = [
+    "artifact-driven",
+    "browser-executable",
+    "runtime-executable",
+    "live-runtime",
+    "mixed",
+    "human-experience",
+];
+export const UAT_MODE_POLICIES = {
+    "artifact-driven": {
+        browserTools: false,
+        partialEligible: false,
+        passWithHumanFollowUp: false,
+        requiredAnyModes: [],
+    },
+    "browser-executable": {
+        browserTools: true,
+        partialEligible: false,
+        passWithHumanFollowUp: false,
+        requiredAnyModes: ["browser"],
+    },
+    "runtime-executable": {
+        browserTools: false,
+        partialEligible: false,
+        passWithHumanFollowUp: false,
+        requiredAnyModes: ["runtime"],
+    },
+    "live-runtime": {
+        browserTools: true,
+        partialEligible: true,
+        passWithHumanFollowUp: true,
+        requiredAnyModes: ["runtime", "browser"],
+    },
+    mixed: {
+        browserTools: true,
+        partialEligible: true,
+        passWithHumanFollowUp: true,
+        requiredAnyModes: [],
+    },
+    "human-experience": {
+        browserTools: true,
+        partialEligible: true,
+        passWithHumanFollowUp: true,
+        requiredAnyModes: [],
+    },
+};
+export function isUatType(value) {
+    return typeof value === "string" && UAT_TYPES.includes(value);
+}
+export function getDeclaredUatType(content) {
+    return extractUatType(content) ?? "artifact-driven";
+}
+export function classifyUatContent(content) {
+    const declaredType = getDeclaredUatType(content);
+    const browserRequired = hasBrowserRequiredText(content);
+    const effectiveType = declaredType === "artifact-driven" && browserRequired
+        ? "browser-executable"
+        : declaredType;
+    return {
+        declaredType,
+        effectiveType,
+        browserRequired,
+        shouldDispatchByDefault: effectiveType !== "artifact-driven" || browserRequired,
+    };
+}
+export function shouldEscalateArtifactUatToBrowser(content) {
+    const policy = classifyUatContent(content);
+    return policy.declaredType === "artifact-driven" && policy.browserRequired;
+}
+export function resolveEffectiveUatType(content) {
+    return classifyUatContent(content).effectiveType;
+}
+export function shouldDispatchUatForContent(content, prefs) {
+    return !!prefs?.uat_dispatch || classifyUatContent(content).shouldDispatchByDefault;
+}
+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_");
+}
+export function hasUatBrowserToolSurface(activeTools) {
+    return Array.isArray(activeTools) && activeTools.some(isUatBrowserToolName);
+}
+export function getUatBrowserToolSupportError(options) {
+    if (!uatTypeIncludesBrowser(options.uatType))
+        return null;
+    if (!Array.isArray(options.activeTools))
+        return null;
+    if (hasUatBrowserToolSurface(options.activeTools))
+        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.`;
+}
+export function isPartialEligibleUatType(uatType) {
+    return !!uatType && UAT_MODE_POLICIES[uatType].partialEligible;
+}
+function modeList(modes) {
+    if (modes.length === 1)
+        return modes[0];
+    return modes.slice(0, -1).join(", ") + " or " + modes[modes.length - 1];
+}
+export function validateUatModePolicy(params) {
+    const policy = UAT_MODE_POLICIES[params.uatType];
+    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" &&
+        !policy.passWithHumanFollowUp &&
+        !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 (policy.requiredAnyModes.length > 0 &&
+        !policy.requiredAnyModes.some((mode) => modes.has(mode))) {
+        return `${params.uatType} UAT requires ${modeList(policy.requiredAnyModes)} evidence`;
+    }
+    return null;
+}

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

@@ -0,0 +1,414 @@
+// Project/App: gsd-pi
+// File Purpose: Owns the durable UAT run lifecycle behind gsd_uat_result_save.
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { isAbsolute, join, resolve } from "node:path";
+import { hasUatBrowserToolSurface, isUatType, UAT_MODE_POLICIES, UAT_TYPES, validateUatModePolicy, } from "./uat-policy.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";
+import { saveFile } from "./files.js";
+import { relSliceFile, resolveGsdPathContract } from "./paths.js";
+import { buildManualValidationGuidance, resolveCanonicalMilestoneRoot } from "./worktree-manager.js";
+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,
+        },
+    };
+}
+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 (!isUatType(params.uatType)) {
+        return `uatType must be one of: ${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 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 resolveUatAttempt(basePath, params) {
+    if (params.attempt === "auto" || params.attempt === undefined) {
+        return nextUatAttempt(basePath, params.milestoneId, params.sliceId);
+    }
+    const attempt = typeof params.attempt === "string"
+        ? Number.parseInt(params.attempt, 10)
+        : params.attempt;
+    if (!Number.isInteger(attempt) || attempt < 1) {
+        return {
+            code: "invalid_attempt",
+            message: "attempt must be a positive integer or auto",
+        };
+    }
+    return attempt;
+}
+function escapeMarkdownTableCell(value) {
+    return String(value ?? "")
+        .replace(/[\\|]/g, (char) => `\\${char}`)
+        .replace(/\r?\n/g, "<br>");
+}
+function renderCheckRow(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)} |`;
+}
+function renderUatAssessment(params, run) {
+    const lines = [
+        "---",
+        `sliceId: ${params.sliceId}`,
+        `uatType: ${params.uatType}`,
+        `verdict: ${params.verdict}`,
+        `attempt: ${run.attempt}`,
+        `runId: ${run.runId}`,
+        `worktreeRoot: ${run.worktreeRoot}`,
+        `date: ${run.evaluatedAt}`,
+        "---",
+        "",
+        `# UAT Result - ${params.sliceId}`,
+        "",
+        "## Checks",
+        "",
+        "| Check | Mode | Result | Evidence | Notes |",
+        "|-------|------|--------|----------|-------|",
+        ...params.checks.map(renderCheckRow),
+        "",
+        "## Overall Verdict",
+        "",
+        `${params.verdict} - ${params.notes ?? "UAT result saved."}`,
+        "",
+        "## Tool Presentation",
+        "",
+        "```json",
+        JSON.stringify(params.presentation, null, 2),
+        "```",
+        "",
+        "## Gate",
+        "",
+        `Aggregate UAT gate saved as ${run.gateVerdict}.`,
+    ];
+    if (run.manualGuidance) {
+        lines.push("", "## Manual Validation", "", "One or more checks are marked `NEEDS-HUMAN` and require a person to validate:", "", ...run.manualGuidance.split("\n").map((line) => `- ${line}`));
+    }
+    return `${lines.join("\n")}\n`;
+}
+export function prepareUatRun(basePath, rawParams) {
+    let params = normalizeUatVerdict(rawParams);
+    params = supplyDefaultPresentation(params);
+    const requiredError = ensureUatRequiredFields(params);
+    if (requiredError)
+        return { ok: false, error: { code: "invalid_params", message: requiredError } };
+    const presentationError = validateCanonicalPresentation(params);
+    if (presentationError)
+        return { ok: false, error: { code: "alias_tool_name", message: presentationError } };
+    params = mergeCanonicalPresentation(params);
+    const checkError = validateUatChecks(basePath, params);
+    if (checkError)
+        return { ok: false, error: { code: "invalid_evidence", message: checkError } };
+    const freshEvidenceError = validateFreshUatOwnedEvidence(params);
+    if (freshEvidenceError) {
+        return { ok: false, error: { code: "missing_fresh_uat_evidence", message: freshEvidenceError } };
+    }
+    const modeError = validateUatModePolicy(params);
+    if (modeError)
+        return { ok: false, error: { code: "uat_mode_mismatch", message: modeError } };
+    const attempt = resolveUatAttempt(basePath, params);
+    if (typeof attempt !== "number")
+        return { ok: false, error: attempt };
+    const gateVerdict = params.verdict === "PASS" ? "pass" : "flag";
+    const gateOutcome = params.verdict === "PASS" ? "pass" : "fail";
+    const rationale = params.notes ?? `UAT ${params.verdict} for ${params.sliceId}.`;
+    const evaluatedAt = new Date().toISOString();
+    const runId = `uat:${params.milestoneId}:${params.sliceId}:attempt-${attempt}`;
+    const worktreeRoot = resolveCanonicalMilestoneRoot(basePath, params.milestoneId);
+    const hasHuman = params.checks.some((check) => check.result === "NEEDS-HUMAN");
+    const manualGuidance = hasHuman
+        ? buildManualValidationGuidance(basePath, params.milestoneId, {
+            uatPath: relSliceFile(basePath, params.milestoneId, params.sliceId, "UAT"),
+        })
+        : null;
+    const browserToolsPresented = hasUatBrowserToolSurface(params.presentation.presentedTools);
+    const assessment = renderUatAssessment(params, {
+        attempt,
+        gateVerdict,
+        runId,
+        worktreeRoot,
+        evaluatedAt,
+        manualGuidance,
+    });
+    return {
+        ok: true,
+        run: {
+            params,
+            runId,
+            attempt,
+            gateVerdict,
+            gateOutcome,
+            rationale,
+            assessment,
+            evaluatedAt,
+            hasHuman,
+            manualGuidance,
+            worktreeRoot,
+            browserToolsPresented,
+        },
+    };
+}
+export async function saveUatAttemptArtifact(basePath, run) {
+    const contract = resolveGsdPathContract(basePath);
+    const relativePath = `uat/${run.params.milestoneId}/${run.params.sliceId}/attempt-${run.attempt}.json`;
+    const payload = {
+        runId: run.runId,
+        attempt: run.attempt,
+        milestoneId: run.params.milestoneId,
+        sliceId: run.params.sliceId,
+        uatType: run.params.uatType,
+        verdict: run.params.verdict,
+        gateVerdict: run.gateVerdict,
+        evaluatedAt: run.evaluatedAt,
+        worktreeRoot: run.worktreeRoot,
+        browserToolsPresented: run.browserToolsPresented,
+        modePolicy: UAT_MODE_POLICIES[run.params.uatType],
+        checks: run.params.checks,
+        presentation: run.params.presentation,
+        notes: run.params.notes,
+        previousAttemptId: run.params.previousAttemptId,
+    };
+    await saveFile(join(contract.projectGsd, relativePath), `${JSON.stringify(payload, null, 2)}\n`);
+    return relativePath;
+}

package/dist/resources/extensions/gsd/unit-context-manifest.js

@@ -93,11 +93,10 @@ const TOOLS_PLANNING_DISPATCH_RECON = {
     mode: "planning-dispatch",
     allowedSubagents: ["scout", "planner"],
 };
-// Like TOOLS_PLANNING_DISPATCH_RECON, but for closeout units that fan out
-// verification work to review-tier specialists.
+// Like TOOLS_PLANNING_DISPATCH_RECON, but for gate-evaluate's tester fanout.
 const TOOLS_PLANNING_DISPATCH_REVIEW = {
     mode: "planning-dispatch",
-    allowedSubagents: ["reviewer", "security", "tester"],
+    allowedSubagents: ["tester"],
 };
 const TOOLS_DOCS = {
     mode: "docs",
@@ -395,7 +394,7 @@ export const UNIT_MANIFESTS = {
         // plan and report via the DB-backed gate-result tool.
         tools: TOOLS_PLANNING_DISPATCH_REVIEW,
         artifacts: {
-            inline: ["slice-plan", "prior-task-summaries"],
+            inline: ["slice-plan"],
             excerpt: [],
             onDemand: [],
         },

package/dist/resources/extensions/gsd/verdict-parser.js

@@ -4,9 +4,9 @@
  * All verdict-related logic lives here so that normalization rules
  * (e.g. `passed` → `pass`) are applied consistently across the codebase.
  */
-import { extractUatType } from "./files.js";
 import { splitFrontmatter, parseFrontmatterMap } from "../shared/frontmatter.js";
 import { parse as parseYaml } from "yaml";
+import { getDeclaredUatType, isPartialEligibleUatType } from "./uat-policy.js";
 function normalizeVerdict(value) {
     if (typeof value !== "string")
         return undefined;
@@ -98,11 +98,6 @@ export const UAT_ACCEPTABLE_VERDICTS = ["pass", "passed"];
  * UAT types whose results may legitimately produce a `partial` verdict
  * when all automatable checks pass but human-only checks remain.
  */
-const PARTIAL_ELIGIBLE_UAT_TYPES = [
-    "mixed",
-    "human-experience",
-    "live-runtime",
-];
 /**
  * Check whether a verdict is acceptable for a given UAT type.
  *
@@ -112,7 +107,7 @@ const PARTIAL_ELIGIBLE_UAT_TYPES = [
 export function isAcceptableUatVerdict(verdict, uatType) {
     if (UAT_ACCEPTABLE_VERDICTS.includes(verdict))
         return true;
-    if (verdict === "partial" && uatType && PARTIAL_ELIGIBLE_UAT_TYPES.includes(uatType)) {
+    if (verdict === "partial" && isPartialEligibleUatType(uatType)) {
         return true;
     }
     return false;
@@ -136,5 +131,5 @@ export function isValidMilestoneVerdict(verdict) {
  * the codebase when a UAT file lacks an explicit `## UAT Type` section.
  */
 export function getUatType(content) {
-    return extractUatType(content) ?? "artifact-driven";
+    return getDeclaredUatType(content);
 }