gsd-pi 2.49.0 → 2.50.0-dev.d210a87

package/dist/resources/extensions/gsd/auto-artifact-paths.js

@@ -4,14 +4,13 @@
 // auto-recovery.ts (Phase 5 dead-code cleanup). The artifact verification
 // function was removed entirely — callers now query WorkflowEngine directly.
 import { resolveMilestonePath, resolveSlicePath, relMilestoneFile, relSliceFile, buildMilestoneFileName, buildSliceFileName, buildTaskFileName, } from "./paths.js";
+import { parseUnitId } from "./unit-id.js";
 import { join } from "node:path";
 /**
  * Resolve the expected artifact for a unit to an absolute path.
  */
 export function resolveExpectedArtifactPath(unitType, unitId, base) {
-    const parts = unitId.split("/");
-    const mid = parts[0];
-    const sid = parts[1];
+    const { milestone: mid, slice: sid, task: tid } = parseUnitId(unitId);
     switch (unitType) {
         case "discuss-milestone": {
             const dir = resolveMilestonePath(base, mid);
@@ -39,10 +38,9 @@ export function resolveExpectedArtifactPath(unitType, unitId, base) {
         }
         case "run-uat": {
             const dir = resolveSlicePath(base, mid, sid);
-            return dir ? join(dir, buildSliceFileName(sid, "UAT-RESULT")) : null;
+            return dir ? join(dir, buildSliceFileName(sid, "UAT")) : null;
         }
         case "execute-task": {
-            const tid = parts[2];
             const dir = resolveSlicePath(base, mid, sid);
             return dir && tid
                 ? join(dir, "tasks", buildTaskFileName(tid, "SUMMARY"))
@@ -66,6 +64,9 @@ export function resolveExpectedArtifactPath(unitType, unitId, base) {
         }
         case "rewrite-docs":
             return null;
+        case "gate-evaluate":
+            // Gate evaluate writes to DB quality_gates table — verified via state derivation
+            return null;
         case "reactive-execute":
             // Reactive execute produces multiple task summaries — verified separately
             return null;
@@ -74,9 +75,7 @@ export function resolveExpectedArtifactPath(unitType, unitId, base) {
     }
 }
 export function diagnoseExpectedArtifact(unitType, unitId, base) {
-    const parts = unitId.split("/");
-    const mid = parts[0];
-    const sid = parts[1];
+    const { milestone: mid, slice: sid, task: tid } = parseUnitId(unitId);
     switch (unitType) {
         case "discuss-milestone":
             return `${relMilestoneFile(base, mid, "CONTEXT")} (milestone context from discussion)`;
@@ -89,7 +88,6 @@ export function diagnoseExpectedArtifact(unitType, unitId, base) {
         case "plan-slice":
             return `${relSliceFile(base, mid, sid, "PLAN")} (slice plan)`;
         case "execute-task": {
-            const tid = parts[2];
             return `Task ${tid} marked [x] in ${relSliceFile(base, mid, sid, "PLAN")} + summary written`;
         }
         case "complete-slice":
@@ -101,7 +99,7 @@ export function diagnoseExpectedArtifact(unitType, unitId, base) {
         case "reassess-roadmap":
             return `${relSliceFile(base, mid, sid, "ASSESSMENT")} (roadmap reassessment)`;
         case "run-uat":
-            return `${relSliceFile(base, mid, sid, "UAT-RESULT")} (UAT result)`;
+            return `${relSliceFile(base, mid, sid, "UAT")} (UAT result)`;
         case "validate-milestone":
             return `${relMilestoneFile(base, mid, "VALIDATION")} (milestone validation report)`;
         case "complete-milestone":

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

@@ -18,15 +18,17 @@ import { computeProgressScore } from "./progress-score.js";
 import { getActiveWorktreeName } from "./worktree-command.js";
 import { loadEffectiveGSDPreferences, getGlobalGSDPreferencesPath } from "./preferences.js";
 import { resolveServiceTierIcon, getEffectiveServiceTier } from "./service-tier.js";
+import { parseUnitId } from "./unit-id.js";
+import { formatRtkSavingsLabel, getRtkSessionSavings, } from "../shared/rtk-session-stats.js";
 // ─── UAT Slice Extraction ─────────────────────────────────────────────────────
 /**
  * Extract the target slice ID from a run-uat unit ID (e.g. "M001/S01" → "S01").
  * Returns null if the format doesn't match.
  */
 export function extractUatSliceId(unitId) {
-    const parts = unitId.split("/");
-    if (parts.length >= 2 && parts[1].startsWith("S"))
-        return parts[1];
+    const { slice } = parseUnitId(unitId);
+    if (slice?.startsWith("S"))
+        return slice;
     return null;
 }
 // ─── Unit Description Helpers ─────────────────────────────────────────────────
@@ -115,6 +117,8 @@ export function describeNextUnit(state) {
             return { label: `Replan ${sid}: ${sTitle}`, description: "Blocker found — replan the slice." };
         case "completing-milestone":
             return { label: "Complete milestone", description: "Write milestone summary." };
+        case "evaluating-gates":
+            return { label: `Evaluate gates for ${sid}: ${sTitle}`, description: "Parallel quality gate assessment before execution." };
         default:
             return { label: "Continue", description: "Execute the next step." };
     }
@@ -380,6 +384,18 @@ export function updateProgressWidget(ctx, unitType, unitId, state, accessors, ti
         let pulseBright = true;
         let cachedLines;
         let cachedWidth;
+        let cachedRtkLabel;
+        const refreshRtkLabel = () => {
+            try {
+                const sessionId = ctx.sessionManager.getSessionId();
+                const savings = sessionId ? getRtkSessionSavings(accessors.getBasePath(), sessionId) : null;
+                cachedRtkLabel = formatRtkSavingsLabel(savings);
+            }
+            catch {
+                cachedRtkLabel = null;
+            }
+        };
+        refreshRtkLabel();
         const pulseTimer = setInterval(() => {
             pulseBright = !pulseBright;
             cachedLines = undefined;
@@ -389,13 +405,16 @@ export function updateProgressWidget(ctx, unitType, unitId, state, accessors, ti
         // task/slice completion mid-unit. Without this, the progress bar only
         // updates at dispatch time, appearing frozen during long-running units.
         // 15s (vs 5s) reduces synchronous file I/O on the hot path.
-        const progressRefreshTimer = mid ? setInterval(() => {
+        const progressRefreshTimer = setInterval(() => {
             try {
-                updateSliceProgressCache(accessors.getBasePath(), mid.id, slice?.id);
+                if (mid) {
+                    updateSliceProgressCache(accessors.getBasePath(), mid.id, slice?.id);
+                }
+                refreshRtkLabel();
                 cachedLines = undefined;
             }
             catch { /* non-fatal */ }
-        }, 15_000) : null;
+        }, 15_000);
         return {
             render(width) {
                 if (cachedLines && cachedWidth === width)
@@ -656,6 +675,9 @@ export function updateProgressWidget(ctx, unitType, unitId, state, accessors, ti
                     if (statsLine) {
                         lines.push(rightAlign("", statsLine, width));
                     }
+                    if (cachedRtkLabel) {
+                        lines.push(rightAlign("", theme.fg("dim", cachedRtkLabel), width));
+                    }
                 }
                 // PWD line with last commit info right-aligned
                 const lastCommit = getLastCommit(accessors.getBasePath());

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

@@ -9,12 +9,13 @@
  * without modifying orchestration code.
  */
 import { loadFile, extractUatType, loadActiveOverrides } from "./files.js";
-import { isDbAvailable, getMilestoneSlices } from "./gsd-db.js";
-import { resolveMilestoneFile, resolveMilestonePath, resolveSliceFile, resolveTaskFile, relSliceFile, buildMilestoneFileName, } from "./paths.js";
-import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { isDbAvailable, getMilestoneSlices, getPendingGates, markAllGatesOmitted, getMilestone } from "./gsd-db.js";
+import { extractVerdict, isAcceptableUatVerdict } from "./verdict-parser.js";
+import { gsdRoot, resolveMilestoneFile, resolveMilestonePath, resolveSliceFile, resolveTaskFile, relSliceFile, buildMilestoneFileName, } from "./paths.js";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { hasImplementationArtifacts } from "./auto-recovery.js";
-import { buildDiscussMilestonePrompt, buildResearchMilestonePrompt, buildPlanMilestonePrompt, buildResearchSlicePrompt, buildPlanSlicePrompt, buildExecuteTaskPrompt, buildCompleteSlicePrompt, buildCompleteMilestonePrompt, buildValidateMilestonePrompt, buildReplanSlicePrompt, buildRunUatPrompt, buildReassessRoadmapPrompt, buildRewriteDocsPrompt, buildReactiveExecutePrompt, checkNeedsReassessment, checkNeedsRunUat, } from "./auto-prompts.js";
+import { buildDiscussMilestonePrompt, buildResearchMilestonePrompt, buildPlanMilestonePrompt, buildResearchSlicePrompt, buildPlanSlicePrompt, buildExecuteTaskPrompt, buildCompleteSlicePrompt, buildCompleteMilestonePrompt, buildValidateMilestonePrompt, buildReplanSlicePrompt, buildRunUatPrompt, buildReassessRoadmapPrompt, buildRewriteDocsPrompt, buildReactiveExecutePrompt, buildGateEvaluatePrompt, checkNeedsReassessment, checkNeedsRunUat, } from "./auto-prompts.js";
 function missingSliceStop(mid, phase) {
     return {
         action: "stop",
@@ -22,8 +23,42 @@ function missingSliceStop(mid, phase) {
         level: "error",
     };
 }
+/**
+ * Check for milestone slices missing SUMMARY files.
+ * Returns array of missing slice IDs, or empty array if all present or DB unavailable.
+ */
+function findMissingSummaries(basePath, mid) {
+    if (!isDbAvailable())
+        return [];
+    const sliceIds = getMilestoneSlices(mid).map(s => s.id);
+    return sliceIds.filter(sid => {
+        const summaryPath = resolveSliceFile(basePath, mid, sid, "SUMMARY");
+        return !summaryPath || !existsSync(summaryPath);
+    });
+}
 // ─── Rewrite Circuit Breaker ──────────────────────────────────────────────
 const MAX_REWRITE_ATTEMPTS = 3;
+// ─── Disk-persisted rewrite attempt counter ──────────────────────────────────
+// The counter must survive session restarts (crash recovery, pause/resume,
+// step-mode). Storing it on the in-memory session object caused the circuit
+// breaker to never trip — see https://github.com/gsd-build/gsd-2/issues/2203
+function rewriteCountPath(basePath) {
+    return join(gsdRoot(basePath), "runtime", "rewrite-count.json");
+}
+export function getRewriteCount(basePath) {
+    try {
+        const data = JSON.parse(readFileSync(rewriteCountPath(basePath), "utf-8"));
+        return typeof data.count === "number" ? data.count : 0;
+    }
+    catch {
+        return 0;
+    }
+}
+export function setRewriteCount(basePath, count) {
+    const filePath = rewriteCountPath(basePath);
+    mkdirSync(join(gsdRoot(basePath), "runtime"), { recursive: true });
+    writeFileSync(filePath, JSON.stringify({ count, updatedAt: new Date().toISOString() }) + "\n");
+}
 // ─── Rules ────────────────────────────────────────────────────────────────
 export const DISPATCH_RULES = [
     {
@@ -32,16 +67,14 @@ export const DISPATCH_RULES = [
             const pendingOverrides = await loadActiveOverrides(basePath);
             if (pendingOverrides.length === 0)
                 return null;
-            const count = session?.rewriteAttemptCount ?? 0;
+            const count = getRewriteCount(basePath);
             if (count >= MAX_REWRITE_ATTEMPTS) {
                 const { resolveAllOverrides } = await import("./files.js");
                 await resolveAllOverrides(basePath);
-                if (session)
-                    session.rewriteAttemptCount = 0;
+                setRewriteCount(basePath, 0);
                 return null;
             }
-            if (session)
-                session.rewriteAttemptCount++;
+            setRewriteCount(basePath, count + 1);
             const unitId = state.activeSlice ? `${mid}/${state.activeSlice.id}` : mid;
             return {
                 action: "dispatch",
@@ -104,30 +137,15 @@ export const DISPATCH_RULES = [
                 return null;
             }
             for (const sliceId of completedSliceIds) {
-                const resultFile = resolveSliceFile(basePath, mid, sliceId, "UAT-RESULT");
+                const resultFile = resolveSliceFile(basePath, mid, sliceId, "UAT");
                 if (!resultFile)
                     continue;
                 const content = await loadFile(resultFile);
                 if (!content)
                     continue;
-                const verdictMatch = content.match(/verdict:\s*([\w-]+)/i);
-                const verdict = verdictMatch?.[1]?.toLowerCase();
-                // Determine acceptable verdicts based on UAT type.
-                // mixed / human-experience / live-runtime modes may legitimately
-                // produce PARTIAL when all automatable checks pass but human-only
-                // checks remain — this should not block progression.
-                const acceptableVerdicts = ["pass", "passed"];
-                const uatFile = resolveSliceFile(basePath, mid, sliceId, "UAT");
-                if (uatFile) {
-                    const uatContent = await loadFile(uatFile);
-                    if (uatContent) {
-                        const uatType = extractUatType(uatContent);
-                        if (uatType === "mixed" || uatType === "human-experience" || uatType === "live-runtime") {
-                            acceptableVerdicts.push("partial");
-                        }
-                    }
-                }
-                if (verdict && !acceptableVerdicts.includes(verdict)) {
+                const verdict = extractVerdict(content);
+                const uatType = extractUatType(content);
+                if (verdict && !isAcceptableUatVerdict(verdict, uatType)) {
                     return {
                         action: "stop",
                         reason: `UAT verdict for ${sliceId} is "${verdict}" — blocking progression until resolved.\nReview the UAT result and update the verdict to PASS, or re-run /gsd auto after fixing.`,
@@ -261,6 +279,32 @@ export const DISPATCH_RULES = [
             };
         },
     },
+    {
+        name: "evaluating-gates → gate-evaluate",
+        match: async ({ state, mid, midTitle, basePath, prefs }) => {
+            if (state.phase !== "evaluating-gates")
+                return null;
+            if (!state.activeSlice)
+                return missingSliceStop(mid, state.phase);
+            const sid = state.activeSlice.id;
+            const sTitle = state.activeSlice.title;
+            // Gate evaluation is opt-in via preferences
+            const gateConfig = prefs?.gate_evaluation;
+            if (!gateConfig?.enabled) {
+                markAllGatesOmitted(mid, sid);
+                return { action: "skip" };
+            }
+            const pending = getPendingGates(mid, sid, "slice");
+            if (pending.length === 0)
+                return { action: "skip" };
+            return {
+                action: "dispatch",
+                unitType: "gate-evaluate",
+                unitId: `${mid}/${sid}/gates+${pending.map(g => g.gate_id).join(",")}`,
+                prompt: await buildGateEvaluatePrompt(mid, midTitle, sid, sTitle, basePath),
+            };
+        },
+    },
     {
         name: "replanning-slice → replan-slice",
         match: async ({ state, mid, midTitle, basePath }) => {
@@ -396,30 +440,14 @@ export const DISPATCH_RULES = [
             if (state.phase !== "validating-milestone")
                 return null;
             // Safety guard (#1368): verify all roadmap slices have SUMMARY files before
-            // allowing milestone validation. If any slice lacks a summary, the milestone
-            // is not genuinely complete — something skipped earlier slices.
-            let sliceIds;
-            if (isDbAvailable()) {
-                sliceIds = getMilestoneSlices(mid).map(s => s.id);
-            }
-            else {
-                sliceIds = [];
-            }
-            if (sliceIds.length > 0) {
-                const missingSlices = [];
-                for (const sid of sliceIds) {
-                    const summaryPath = resolveSliceFile(basePath, mid, sid, "SUMMARY");
-                    if (!summaryPath || !existsSync(summaryPath)) {
-                        missingSlices.push(sid);
-                    }
-                }
-                if (missingSlices.length > 0) {
-                    return {
-                        action: "stop",
-                        reason: `Cannot validate milestone ${mid}: slices ${missingSlices.join(", ")} are missing SUMMARY files. These slices may have been skipped.`,
-                        level: "error",
-                    };
-                }
+            // allowing milestone validation.
+            const missingSlices = findMissingSummaries(basePath, mid);
+            if (missingSlices.length > 0) {
+                return {
+                    action: "stop",
+                    reason: `Cannot validate milestone ${mid}: slices ${missingSlices.join(", ")} are missing SUMMARY files. These slices may have been skipped.`,
+                    level: "error",
+                };
             }
             // Skip preference: write a minimal pass-through VALIDATION file
             if (prefs?.phases?.skip_milestone_validation) {
@@ -456,28 +484,13 @@ export const DISPATCH_RULES = [
             if (state.phase !== "completing-milestone")
                 return null;
             // Safety guard (#1368): verify all roadmap slices have SUMMARY files.
-            let sliceIds;
-            if (isDbAvailable()) {
-                sliceIds = getMilestoneSlices(mid).map(s => s.id);
-            }
-            else {
-                sliceIds = [];
-            }
-            if (sliceIds.length > 0) {
-                const missingSlices = [];
-                for (const sid of sliceIds) {
-                    const summaryPath = resolveSliceFile(basePath, mid, sid, "SUMMARY");
-                    if (!summaryPath || !existsSync(summaryPath)) {
-                        missingSlices.push(sid);
-                    }
-                }
-                if (missingSlices.length > 0) {
-                    return {
-                        action: "stop",
-                        reason: `Cannot complete milestone ${mid}: slices ${missingSlices.join(", ")} are missing SUMMARY files. Run /gsd doctor to diagnose.`,
-                        level: "error",
-                    };
-                }
+            const missingSlices = findMissingSummaries(basePath, mid);
+            if (missingSlices.length > 0) {
+                return {
+                    action: "stop",
+                    reason: `Cannot complete milestone ${mid}: slices ${missingSlices.join(", ")} are missing SUMMARY files. Run /gsd doctor to diagnose.`,
+                    level: "error",
+                };
             }
             // Safety guard (#1703): verify the milestone produced implementation
             // artifacts (non-.gsd/ files). A milestone with only plan files and
@@ -489,6 +502,32 @@ export const DISPATCH_RULES = [
                     level: "error",
                 };
             }
+            // Verification class compliance: if operational verification was planned,
+            // ensure the validation output documents it before allowing completion.
+            try {
+                if (isDbAvailable()) {
+                    const milestone = getMilestone(mid);
+                    if (milestone?.verification_operational &&
+                        milestone.verification_operational.toLowerCase() !== "none") {
+                        const validationPath = resolveMilestoneFile(basePath, mid, "VALIDATION");
+                        if (validationPath) {
+                            const validationContent = await loadFile(validationPath);
+                            if (validationContent) {
+                                const hasOperationalCheck = validationContent.includes("Operational") &&
+                                    (validationContent.includes("MET") || validationContent.includes("N/A"));
+                                if (!hasOperationalCheck) {
+                                    return {
+                                        action: "stop",
+                                        reason: `Milestone ${mid} has planned operational verification ("${milestone.verification_operational.substring(0, 100)}") but the validation output does not address it. Re-run validation with verification class awareness, or update the validation to document operational compliance.`,
+                                        level: "warning",
+                                    };
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            catch { /* fall through — don't block on DB errors */ }
             return {
                 action: "dispatch",
                 unitType: "complete-milestone",

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

@@ -0,0 +1,54 @@
+/**
+ * Pre-dispatch observability checks for auto-mode units.
+ * Validates plan/summary file quality and builds repair instructions
+ * for the agent to fix gaps before proceeding with the unit.
+ */
+import { validatePlanBoundary, validateExecuteBoundary, validateCompleteBoundary, formatValidationIssues, } from "./observability-validator.js";
+import { parseUnitId } from "./unit-id.js";
+export async function collectObservabilityWarnings(ctx, basePath, unitType, unitId) {
+    // Hook units have custom artifacts — skip standard observability checks
+    if (unitType.startsWith("hook/"))
+        return [];
+    const { milestone: mid, slice: sid, task: tid } = parseUnitId(unitId);
+    if (!mid || !sid)
+        return [];
+    let issues = [];
+    if (unitType === "plan-slice") {
+        issues = await validatePlanBoundary(basePath, mid, sid);
+    }
+    else if (unitType === "execute-task" && tid) {
+        issues = await validateExecuteBoundary(basePath, mid, sid, tid);
+    }
+    else if (unitType === "complete-slice") {
+        issues = await validateCompleteBoundary(basePath, mid, sid);
+    }
+    if (issues.length > 0) {
+        ctx.ui.notify(`Observability check (${unitType}) found ${issues.length} warning${issues.length === 1 ? "" : "s"}:\n${formatValidationIssues(issues)}`, "warning");
+    }
+    return issues;
+}
+export function buildObservabilityRepairBlock(issues) {
+    if (issues.length === 0)
+        return "";
+    const items = issues.map(issue => {
+        const fileName = issue.file.split("/").pop() || issue.file;
+        let line = `- **${fileName}**: ${issue.message}`;
+        if (issue.suggestion)
+            line += ` → ${issue.suggestion}`;
+        return line;
+    });
+    return [
+        "",
+        "---",
+        "",
+        "## Pre-flight: Observability gaps to fix FIRST",
+        "",
+        "The following issues were detected in plan/summary files for this unit.",
+        "**Read each flagged file, apply the fix described, then proceed with the unit.**",
+        "",
+        ...items,
+        "",
+        "---",
+        "",
+    ].join("\n");
+}