gsd-pi 2.49.0 → 2.50.0-dev.d210a87

package/dist/resources/extensions/gsd/auto-post-unit.js

@@ -15,17 +15,33 @@ import { loadFile, parseSummary, resolveAllOverrides } from "./files.js";
 import { loadPrompt } from "./prompt-loader.js";
 import { resolveSliceFile, resolveTaskFile, resolveMilestoneFile, resolveTasksDir, buildTaskFileName, } from "./paths.js";
 import { invalidateAllCaches } from "./cache.js";
+import { parseUnitId } from "./unit-id.js";
 import { closeoutUnit } from "./auto-unit-closeout.js";
 import { autoCommitCurrentBranch, } from "./worktree.js";
 import { verifyExpectedArtifact, resolveExpectedArtifactPath, } from "./auto-recovery.js";
 import { regenerateIfMissing } from "./workflow-projections.js";
-import { syncStateToProjectRoot } from "./auto-worktree-sync.js";
+import { syncStateToProjectRoot } from "./auto-worktree.js";
 import { isDbAvailable, getTask, getSlice, getMilestone, updateTaskStatus, _getAdapter } from "./gsd-db.js";
 import { renderPlanCheckboxes } from "./markdown-renderer.js";
 import { consumeSignal } from "./session-status-io.js";
 import { checkPostUnitHooks, isRetryPending, consumeRetryTrigger, persistHookState, resolveHookArtifactPath, } from "./post-unit-hooks.js";
 import { hasPendingCaptures, loadPendingCaptures } from "./captures.js";
 import { debugLog } from "./debug-logger.js";
+import { runSafely } from "./auto-utils.js";
+/** Enqueue a sidecar item (hook, triage, or quick-task) for the main loop to
+ *  drain via runUnit. Logs the enqueue event and notifies the UI. */
+function enqueueSidecar(s, ctx, entry, debugExtra, notification) {
+    s.sidecarQueue.push(entry);
+    debugLog("postUnitPostVerification", {
+        phase: "sidecar-enqueue",
+        kind: entry.kind,
+        unitId: entry.unitId,
+        ...debugExtra,
+    });
+    if (notification)
+        ctx.ui.notify(notification, "info");
+    return "continue";
+}
 /** Unit types that only touch `.gsd/` internal state files (no code changes).
  *  Auto-commit is skipped for these — their state files are picked up by the
  *  next actual task commit via `smartStage()`. */
@@ -47,13 +63,20 @@ import { _resetHasChangesCache } from "./native-git-bridge.js";
  * in postUnitPostVerification() eventually ingests rogue files, but explicit
  * detection provides immediate diagnostics so operators know the prompt failed.
  */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function hasNonEmptyFields(row, fields) {
+    if (!row)
+        return false;
+    return fields.some(f => String(row[f] || "").trim().length > 0);
+}
+const MILESTONE_PLANNING_FIELDS = ["title", "vision", "requirement_coverage", "boundary_map_markdown"];
+const SLICE_PLANNING_FIELDS = ["title", "demo", "risk", "depends"];
 export function detectRogueFileWrites(unitType, unitId, basePath) {
     if (!isDbAvailable())
         return [];
-    const parts = unitId.split("/");
+    const { milestone: mid, slice: sid, task: tid } = parseUnitId(unitId);
     const rogues = [];
     if (unitType === "execute-task") {
-        const [mid, sid, tid] = parts;
         if (!mid || !sid || !tid)
             return [];
         const summaryPath = resolveTaskFile(basePath, mid, sid, tid, "SUMMARY");
@@ -65,7 +88,6 @@ export function detectRogueFileWrites(unitType, unitId, basePath) {
         }
     }
     else if (unitType === "complete-slice") {
-        const [mid, sid] = parts;
         if (!mid || !sid)
             return [];
         const summaryPath = resolveSliceFile(basePath, mid, sid, "SUMMARY");
@@ -77,33 +99,25 @@ export function detectRogueFileWrites(unitType, unitId, basePath) {
         }
     }
     else if (unitType === "plan-milestone") {
-        const [mid] = parts;
         if (!mid)
             return [];
         const roadmapPath = resolveMilestoneFile(basePath, mid, "ROADMAP");
         if (!roadmapPath || !existsSync(roadmapPath))
             return [];
         const dbRow = getMilestone(mid);
-        const hasPlanningState = !!dbRow && (String(dbRow.title || "").trim().length > 0 ||
-            String(dbRow.vision || "").trim().length > 0 ||
-            String(dbRow.requirement_coverage || "").trim().length > 0 ||
-            String(dbRow.boundary_map_markdown || "").trim().length > 0);
+        const hasPlanningState = hasNonEmptyFields(dbRow, MILESTONE_PLANNING_FIELDS);
         if (!hasPlanningState) {
             rogues.push({ path: roadmapPath, unitType, unitId });
         }
     }
     else if (unitType === "plan-slice" || unitType === "replan-slice") {
-        const [mid, sid] = parts;
         if (!mid || !sid)
             return [];
         const planPath = resolveSliceFile(basePath, mid, sid, "PLAN");
         if (!planPath || !existsSync(planPath))
             return [];
         const dbRow = getSlice(mid, sid);
-        const hasPlanningState = !!dbRow && (String(dbRow.title || "").trim().length > 0 ||
-            String(dbRow.demo || "").trim().length > 0 ||
-            String(dbRow.risk || "").trim().length > 0 ||
-            String(dbRow.depends || "").trim().length > 0);
+        const hasPlanningState = hasNonEmptyFields(dbRow, SLICE_PLANNING_FIELDS);
         if (!hasPlanningState) {
             rogues.push({ path: planPath, unitType, unitId });
         }
@@ -114,7 +128,6 @@ export function detectRogueFileWrites(unitType, unitId, basePath) {
         }
     }
     else if (unitType === "reassess-roadmap") {
-        const [mid, sid] = parts;
         if (!mid || !sid)
             return [];
         const assessPath = resolveSliceFile(basePath, mid, sid, "ASSESSMENT");
@@ -130,7 +143,6 @@ export function detectRogueFileWrites(unitType, unitId, basePath) {
         }
     }
     else if (unitType === "plan-task") {
-        const [mid, sid, tid] = parts;
         if (!mid || !sid || !tid)
             return [];
         const taskPlanPath = resolveTaskFile(basePath, mid, sid, tid, "PLAN");
@@ -177,11 +189,11 @@ export async function postUnitPreVerification(pctx, opts) {
     }
     // Auto-commit
     if (s.currentUnit) {
+        const unit = s.currentUnit;
         try {
             let taskContext;
             if (s.currentUnit.type === "execute-task") {
-                const parts = s.currentUnit.id.split("/");
-                const [mid, sid, tid] = parts;
+                const { milestone: mid, slice: sid, task: tid } = parseUnitId(s.currentUnit.id);
                 if (mid && sid && tid) {
                     const summaryPath = resolveTaskFile(s.basePath, mid, sid, tid, "SUMMARY");
                     if (summaryPath) {
@@ -234,66 +246,51 @@ export async function postUnitPreVerification(pctx, opts) {
             ctx.ui.notify(`Auto-commit failed: ${String(e).split("\n")[0]}`, "warning");
         }
         // GitHub sync (non-blocking, opt-in)
-        try {
+        await runSafely("postUnit", "github-sync", async () => {
             const { runGitHubSync } = await import("../github-sync/sync.js");
-            await runGitHubSync(s.basePath, s.currentUnit.type, s.currentUnit.id);
-        }
-        catch (e) {
-            debugLog("postUnit", { phase: "github-sync", error: String(e) });
-        }
+            await runGitHubSync(s.basePath, unit.type, unit.id);
+        });
         // Prune dead bg-shell processes
-        try {
+        await runSafely("postUnit", "prune-bg-shell", async () => {
             const { pruneDeadProcesses } = await import("../bg-shell/process-manager.js");
             pruneDeadProcesses();
-        }
-        catch (e) {
-            debugLog("postUnit", { phase: "prune-bg-shell", error: String(e) });
-        }
+        });
         // Tear down browser between units to prevent Chrome process accumulation (#1733)
-        try {
+        await runSafely("postUnit", "browser-teardown", async () => {
             const { getBrowser } = await import("../browser-tools/state.js");
             if (getBrowser()) {
                 const { closeBrowser } = await import("../browser-tools/lifecycle.js");
                 await closeBrowser();
                 debugLog("postUnit", { phase: "browser-teardown", status: "closed" });
             }
-        }
-        catch (e) {
-            debugLog("postUnit", { phase: "browser-teardown", error: String(e) });
-        }
+        });
         // Sync worktree state back to project root (skipped for lightweight sidecars)
         if (!opts?.skipWorktreeSync && s.originalBasePath && s.originalBasePath !== s.basePath) {
-            try {
+            await runSafely("postUnit", "worktree-sync", () => {
                 syncStateToProjectRoot(s.basePath, s.originalBasePath, s.currentMilestoneId);
-            }
-            catch (e) {
-                debugLog("postUnit", { phase: "worktree-sync", error: String(e) });
-            }
+            });
         }
         // Rewrite-docs completion
         if (s.currentUnit.type === "rewrite-docs") {
-            try {
+            await runSafely("postUnit", "rewrite-docs-resolve", async () => {
                 await resolveAllOverrides(s.basePath);
+                // Reset both disk and in-memory counters. Disk counter is authoritative
+                // (survives restarts); in-memory is kept in sync for the current session.
+                const { setRewriteCount } = await import("./auto-dispatch.js");
+                setRewriteCount(s.basePath, 0);
                 s.rewriteAttemptCount = 0;
                 ctx.ui.notify("Override(s) resolved — rewrite-docs completed.", "info");
-            }
-            catch (e) {
-                debugLog("postUnit", { phase: "rewrite-docs-resolve", error: String(e) });
-            }
+            });
         }
         // Reactive state cleanup on slice completion
         if (s.currentUnit.type === "complete-slice") {
-            try {
-                const parts = s.currentUnit.id.split("/");
-                const [mid, sid] = parts;
+            await runSafely("postUnit", "reactive-state-cleanup", async () => {
+                const { milestone: mid, slice: sid } = parseUnitId(unit.id);
                 if (mid && sid) {
                     const { clearReactiveState } = await import("./reactive-graph.js");
                     clearReactiveState(s.basePath, mid, sid);
                 }
-            }
-            catch (e) {
-                debugLog("postUnit", { phase: "reactive-state-cleanup", error: String(e) });
-            }
+            });
         }
         // Post-triage: execute actionable resolutions
         if (s.currentUnit.type === "triage-captures") {
@@ -356,8 +353,7 @@ export async function postUnitPreVerification(pctx, opts) {
             // from DB data before giving up (e.g. research-slice produces PLAN from engine).
             if (!triggerArtifactVerified) {
                 try {
-                    const parts = s.currentUnit.id.split("/");
-                    const [mid, sid] = parts;
+                    const { milestone: mid, slice: sid } = parseUnitId(s.currentUnit.id);
                     if (mid && sid) {
                         const regenerated = regenerateIfMissing(s.basePath, mid, sid, "PLAN");
                         if (regenerated) {
@@ -421,21 +417,7 @@ export async function postUnitPostVerification(pctx) {
                 await closeoutUnit(ctx, s.basePath, s.currentUnit.type, s.currentUnit.id, s.currentUnit.startedAt, buildSnapshotOpts(s.currentUnit.type, s.currentUnit.id));
             }
             persistHookState(s.basePath);
-            s.sidecarQueue.push({
-                kind: "hook",
-                unitType: hookUnit.unitType,
-                unitId: hookUnit.unitId,
-                prompt: hookUnit.prompt,
-                model: hookUnit.model,
-            });
-            debugLog("postUnitPostVerification", {
-                phase: "sidecar-enqueue",
-                kind: "hook",
-                unitType: hookUnit.unitType,
-                unitId: hookUnit.unitId,
-                hookName: hookUnit.hookName,
-            });
-            return "continue";
+            return enqueueSidecar(s, ctx, { kind: "hook", unitType: hookUnit.unitType, unitId: hookUnit.unitId, prompt: hookUnit.prompt, model: hookUnit.model }, { hookName: hookUnit.hookName });
         }
         // Check if a hook requested a retry of the trigger unit
         if (isRetryPending()) {
@@ -444,8 +426,7 @@ export async function postUnitPostVerification(pctx) {
                 ctx.ui.notify(`Hook requested retry of ${trigger.unitType} ${trigger.unitId} — resetting task state.`, "info");
                 // ── State reset: undo the completion so deriveState re-derives the unit ──
                 try {
-                    const parts = trigger.unitId.split("/");
-                    const [mid, sid, tid] = parts;
+                    const { milestone: mid, slice: sid, task: tid } = parseUnitId(trigger.unitId);
                     // 1. Reset task status in DB and re-render plan checkboxes
                     if (mid && sid && tid) {
                         try {
@@ -517,20 +498,7 @@ export async function postUnitPostVerification(pctx) {
                             await closeoutUnit(ctx, s.basePath, s.currentUnit.type, s.currentUnit.id, s.currentUnit.startedAt);
                         }
                         const triageUnitId = `${mid}/${sid}/triage`;
-                        s.sidecarQueue.push({
-                            kind: "triage",
-                            unitType: "triage-captures",
-                            unitId: triageUnitId,
-                            prompt,
-                        });
-                        debugLog("postUnitPostVerification", {
-                            phase: "sidecar-enqueue",
-                            kind: "triage",
-                            unitId: triageUnitId,
-                            pendingCount: pending.length,
-                        });
-                        ctx.ui.notify(`Triaging ${pending.length} pending capture${pending.length === 1 ? "" : "s"}...`, "info");
-                        return "continue";
+                        return enqueueSidecar(s, ctx, { kind: "triage", unitType: "triage-captures", unitId: triageUnitId, prompt }, { pendingCount: pending.length }, `Triaging ${pending.length} pending capture${pending.length === 1 ? "" : "s"}...`);
                     }
                 }
             }
@@ -554,21 +522,7 @@ export async function postUnitPostVerification(pctx) {
             }
             markCaptureExecuted(s.basePath, capture.id);
             const qtUnitId = `${s.currentMilestoneId}/${capture.id}`;
-            s.sidecarQueue.push({
-                kind: "quick-task",
-                unitType: "quick-task",
-                unitId: qtUnitId,
-                prompt,
-                captureId: capture.id,
-            });
-            debugLog("postUnitPostVerification", {
-                phase: "sidecar-enqueue",
-                kind: "quick-task",
-                unitId: qtUnitId,
-                captureId: capture.id,
-            });
-            ctx.ui.notify(`Executing quick-task: ${capture.id} — "${capture.text}"`, "info");
-            return "continue";
+            return enqueueSidecar(s, ctx, { kind: "quick-task", unitType: "quick-task", unitId: qtUnitId, prompt, captureId: capture.id }, { captureId: capture.id }, `Executing quick-task: ${capture.id} — "${capture.text}"`);
         }
         catch (e) {
             debugLog("postUnit", { phase: "quick-task-dispatch", error: String(e) });

package/dist/resources/extensions/gsd/auto-prompts.js

@@ -5,7 +5,8 @@
  * state, no globals — every dependency is passed as a parameter or imported as a
  * utility.
  */
-import { loadFile, parseContinue, parseSummary, extractUatType, loadActiveOverrides, formatOverridesSection, parseTaskPlanFile } from "./files.js";
+import { loadFile, parseContinue, parseSummary, loadActiveOverrides, formatOverridesSection, parseTaskPlanFile } from "./files.js";
+import { hasVerdict, getUatType } from "./verdict-parser.js";
 import { loadPrompt, inlineTemplate } from "./prompt-loader.js";
 import { resolveMilestoneFile, resolveSliceFile, resolveSlicePath, resolveTasksDir, resolveTaskFiles, resolveTaskFile, relMilestoneFile, relSliceFile, relSlicePath, relMilestonePath, resolveGsdRootFile, relGsdRootFile, resolveRuntimeFile, } from "./paths.js";
 import { resolveSkillDiscoveryMode, resolveInlineLevel, loadEffectiveGSDPreferences, resolveAllSkillReferences } from "./preferences.js";
@@ -14,6 +15,7 @@ import { getLoadedSkills } from "@gsd/pi-coding-agent";
 import { join, basename } from "node:path";
 import { existsSync } from "node:fs";
 import { computeBudgets, resolveExecutorContextWindow, truncateAtSectionBoundary } from "./context-budget.js";
+import { getPendingGates } from "./gsd-db.js";
 import { formatDecisionsCompact, formatRequirementsCompact } from "./structured-data-formatter.js";
 // ─── Preamble Cap ─────────────────────────────────────────────────────────────
 const MAX_PREAMBLE_CHARS = 30_000;
@@ -354,10 +356,17 @@ function resolvePreferredSkillNames(prefs, visibleSkills, contextTokens, base) {
         .filter(skill => preferred.has(normalizeSkillReference(skill.name)) && skillMatchesContext(skill, contextTokens))
         .map(skill => normalizeSkillReference(skill.name));
 }
+/** Skill names must be lowercase alphanumeric with hyphens — reject anything else
+ *  to prevent prompt injection via crafted directory names. */
+const SAFE_SKILL_NAME = /^[a-z0-9][a-z0-9-]*$/;
 function formatSkillActivationBlock(skillNames) {
-    if (skillNames.length === 0)
+    const safe = skillNames.filter(name => SAFE_SKILL_NAME.test(name));
+    if (safe.length === 0)
         return "";
-    const calls = skillNames.map(name => `Call Skill('${name}')`).join('. ');
+    // Use explicit parameter syntax so LLMs pass { skill: "..." } instead of { name: "..." }.
+    // The function-call-like syntax `Skill('name')` led LLMs to infer a positional
+    // parameter name, causing tool validation failures — see #2224.
+    const calls = safe.map(name => `Call Skill({ skill: '${name}' })`).join('. ');
     return `<skill_activation>${calls}.</skill_activation>`;
 }
 export function buildSkillActivationBlock(params) {
@@ -663,13 +672,19 @@ export async function checkNeedsRunUat(base, mid, state, prefs) {
                 const uatContent = await loadFile(uatFile);
                 if (!uatContent)
                     return null;
-                const uatResultFile = resolveSliceFile(base, mid, sid, "UAT-RESULT");
-                if (uatResultFile) {
-                    const hasResult = !!(await loadFile(uatResultFile));
-                    if (hasResult)
+                // If the UAT file already contains a verdict, UAT has been run — skip
+                if (hasVerdict(uatContent))
+                    return null;
+                // Also check the ASSESSMENT file — the run-uat prompt writes the verdict
+                // there (via gsd_summary_save artifact_type:"ASSESSMENT"), not into the
+                // UAT spec file. Without this check the unit re-dispatches indefinitely.
+                const assessmentFile = resolveSliceFile(base, mid, sid, "ASSESSMENT");
+                if (assessmentFile) {
+                    const assessmentContent = await loadFile(assessmentFile);
+                    if (assessmentContent && hasVerdict(assessmentContent))
                         return null;
                 }
-                const uatType = extractUatType(uatContent) ?? "artifact-driven";
+                const uatType = getUatType(uatContent);
                 return { sliceId: sid, uatType };
             }
         }
@@ -697,13 +712,18 @@ export async function checkNeedsRunUat(base, mid, state, prefs) {
     const uatContentFb = await loadFile(uatFileFb);
     if (!uatContentFb)
         return null;
-    const uatResultFb = resolveSliceFile(base, mid, uatSid, "UAT-RESULT");
-    if (uatResultFb) {
-        const hasResultFb = !!(await loadFile(uatResultFb));
-        if (hasResultFb)
+    // If the UAT file already contains a verdict, UAT has been run — skip
+    if (hasVerdict(uatContentFb))
+        return null;
+    // Also check the ASSESSMENT file for the file-based fallback path (same
+    // reason as the DB path above — verdict lives in ASSESSMENT, not UAT).
+    const assessmentFileFb = resolveSliceFile(base, mid, uatSid, "ASSESSMENT");
+    if (assessmentFileFb) {
+        const assessmentContentFb = await loadFile(assessmentFileFb);
+        if (assessmentContentFb && hasVerdict(assessmentContentFb))
             return null;
     }
-    const uatTypeFb = extractUatType(uatContentFb) ?? "artifact-driven";
+    const uatTypeFb = getUatType(uatContentFb);
     return { sliceId: uatSid, uatType: uatTypeFb };
 }
 // ─── Prompt Builders ──────────────────────────────────────────────────────
@@ -1170,6 +1190,28 @@ export async function buildValidateMilestonePrompt(mid, midTitle, base, level) {
     const roadmapRel = relMilestoneFile(base, mid, "ROADMAP");
     const inlined = [];
     inlined.push(await inlineFile(roadmapPath, roadmapRel, "Milestone Roadmap"));
+    // Inline verification classes from planning (if available in DB)
+    try {
+        const { isDbAvailable, getMilestone } = await import("./gsd-db.js");
+        if (isDbAvailable()) {
+            const milestone = getMilestone(mid);
+            if (milestone) {
+                const classes = [];
+                if (milestone.verification_contract)
+                    classes.push(`- **Contract:** ${milestone.verification_contract}`);
+                if (milestone.verification_integration)
+                    classes.push(`- **Integration:** ${milestone.verification_integration}`);
+                if (milestone.verification_operational)
+                    classes.push(`- **Operational:** ${milestone.verification_operational}`);
+                if (milestone.verification_uat)
+                    classes.push(`- **UAT:** ${milestone.verification_uat}`);
+                if (classes.length > 0) {
+                    inlined.push(`### Verification Classes (from planning)\n\nThese verification tiers were defined during milestone planning. Each non-empty class must be checked for evidence during validation.\n\n${classes.join("\n")}`);
+                }
+            }
+        }
+    }
+    catch { /* fall through */ }
     // Inline all slice summaries and UAT results
     let valSliceIds = [];
     try {
@@ -1194,12 +1236,30 @@ export async function buildValidateMilestonePrompt(mid, midTitle, base, level) {
         const summaryPath = resolveSliceFile(base, mid, sid, "SUMMARY");
         const summaryRel = relSliceFile(base, mid, sid, "SUMMARY");
         inlined.push(await inlineFile(summaryPath, summaryRel, `${sid} Summary`));
-        const uatPath = resolveSliceFile(base, mid, sid, "UAT-RESULT");
-        const uatRel = relSliceFile(base, mid, sid, "UAT-RESULT");
+        const uatPath = resolveSliceFile(base, mid, sid, "UAT");
+        const uatRel = relSliceFile(base, mid, sid, "UAT");
         const uatInline = await inlineFileOptional(uatPath, uatRel, `${sid} UAT Result`);
         if (uatInline)
             inlined.push(uatInline);
     }
+    // Aggregate unresolved follow-ups and known limitations across slices
+    const outstandingItems = [];
+    for (const sid of valSliceIds) {
+        const summaryPath = resolveSliceFile(base, mid, sid, "SUMMARY");
+        if (!summaryPath)
+            continue;
+        const content = await loadFile(summaryPath);
+        if (!content)
+            continue;
+        const summary = parseSummary(content);
+        if (summary.followUps)
+            outstandingItems.push(`- **${sid} Follow-ups:** ${summary.followUps.trim()}`);
+        if (summary.knownLimitations)
+            outstandingItems.push(`- **${sid} Known Limitations:** ${summary.knownLimitations.trim()}`);
+    }
+    if (outstandingItems.length > 0) {
+        inlined.push(`### Outstanding Items (aggregated from slice summaries)\n\nThese follow-ups and known limitations were documented during slice completion but have not been resolved.\n\n${outstandingItems.join('\n')}`);
+    }
     // Inline existing VALIDATION file if this is a re-validation round
     const validationPath = resolveMilestoneFile(base, mid, "VALIDATION");
     const validationRel = relMilestoneFile(base, mid, "VALIDATION");
@@ -1334,8 +1394,8 @@ export async function buildRunUatPrompt(mid, sliceId, uatPath, uatContent, base)
     if (projectInline)
         inlined.push(projectInline);
     const inlinedContext = capPreamble(`## Inlined Context (preloaded — do not re-read these files)\n\n${inlined.join("\n\n---\n\n")}`);
-    const uatResultPath = join(base, relSliceFile(base, mid, sliceId, "UAT-RESULT"));
-    const uatType = extractUatType(uatContent) ?? "artifact-driven";
+    const uatResultPath = join(base, relSliceFile(base, mid, sliceId, "UAT"));
+    const uatType = getUatType(uatContent);
     return loadPrompt("run-uat", {
         workingDirectory: base,
         milestoneId: mid,
@@ -1465,6 +1525,84 @@ export async function buildReactiveExecutePrompt(mid, midTitle, sid, sTitle, rea
         inlinedTemplates,
     });
 }
+// ─── Gate Evaluation ──────────────────────────────────────────────────────
+const GATE_QUESTIONS = {
+    Q3: {
+        question: "How can this be exploited?",
+        guidance: [
+            "Identify abuse scenarios: parameter tampering, replay attacks, privilege escalation.",
+            "Map data exposure risks: PII, tokens, secrets accessible through this slice.",
+            "Define input trust boundaries: untrusted user input reaching DB, API, or filesystem.",
+            "If none apply, return verdict 'omitted' with rationale explaining why.",
+        ].join("\n"),
+    },
+    Q4: {
+        question: "What existing promises does this break?",
+        guidance: [
+            "List which existing requirements (R001, R003, etc.) are touched by this slice.",
+            "Identify what must be re-tested after shipping.",
+            "Flag decisions that should be revisited given the new scope.",
+            "If no existing requirements are affected, return verdict 'omitted'.",
+        ].join("\n"),
+    },
+};
+export async function buildGateEvaluatePrompt(mid, midTitle, sid, sTitle, base) {
+    const pending = getPendingGates(mid, sid, "slice");
+    // Load the slice plan for context
+    const planFile = resolveSliceFile(base, mid, sid, "PLAN");
+    const planContent = planFile ? (await loadFile(planFile)) ?? "(plan file empty)" : "(plan file not found)";
+    // Build per-gate subagent prompts
+    const subagentSections = [];
+    const gateListLines = [];
+    for (const gate of pending) {
+        const meta = GATE_QUESTIONS[gate.gate_id];
+        if (!meta)
+            continue;
+        gateListLines.push(`- **${gate.gate_id}**: ${meta.question}`);
+        const subPrompt = [
+            `You are evaluating quality gate **${gate.gate_id}** for slice ${sid} (${sTitle}).`,
+            "",
+            `## Question: ${meta.question}`,
+            "",
+            meta.guidance,
+            "",
+            "## Slice Plan",
+            "",
+            planContent,
+            "",
+            "## Instructions",
+            "",
+            "Analyze the slice plan above and answer the gate question.",
+            `Call the \`gsd_save_gate_result\` tool with:`,
+            `- \`milestoneId\`: "${mid}"`,
+            `- \`sliceId\`: "${sid}"`,
+            `- \`gateId\`: "${gate.gate_id}"`,
+            "- `verdict`: \"pass\" (no concerns), \"flag\" (concerns found), or \"omitted\" (not applicable)",
+            "- `rationale`: one-sentence justification",
+            "- `findings`: detailed markdown findings (or empty if omitted)",
+        ].join("\n");
+        subagentSections.push([
+            `### ${gate.gate_id}: ${meta.question}`,
+            "",
+            "Use this as the prompt for a `subagent` call:",
+            "",
+            "```",
+            subPrompt,
+            "```",
+        ].join("\n"));
+    }
+    return loadPrompt("gate-evaluate", {
+        workingDirectory: base,
+        milestoneId: mid,
+        milestoneTitle: midTitle,
+        sliceId: sid,
+        sliceTitle: sTitle,
+        slicePlanContent: planContent,
+        gateCount: String(pending.length),
+        gateList: gateListLines.join("\n"),
+        subagentPrompts: subagentSections.join("\n\n---\n\n"),
+    });
+}
 export async function buildRewriteDocsPrompt(mid, midTitle, activeSlice, base, overrides) {
     const sid = activeSlice?.id;
     const sTitle = activeSlice?.title ?? "";