gsd-pi 2.50.0 → 2.51.0-dev.7d435fe

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

@@ -9,10 +9,10 @@
  * without modifying orchestration code.
  */
 import { loadFile, extractUatType, loadActiveOverrides } from "./files.js";
-import { isDbAvailable, getMilestoneSlices, getPendingGates, markAllGatesOmitted } from "./gsd-db.js";
+import { isDbAvailable, getMilestoneSlices, getPendingGates, markAllGatesOmitted, getMilestone } from "./gsd-db.js";
 import { extractVerdict, isAcceptableUatVerdict } from "./verdict-parser.js";
-import { resolveMilestoneFile, resolveMilestonePath, resolveSliceFile, resolveTaskFile, relSliceFile, buildMilestoneFileName, } from "./paths.js";
-import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+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, buildGateEvaluatePrompt, checkNeedsReassessment, checkNeedsRunUat, } from "./auto-prompts.js";
@@ -23,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 = [
     {
@@ -33,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",
@@ -408,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) {
@@ -467,29 +483,32 @@ export const DISPATCH_RULES = [
         match: async ({ state, mid, midTitle, basePath }) => {
             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);
+            // Safety guard (#2675): block completion when VALIDATION verdict is
+            // needs-remediation. The state machine treats needs-remediation as
+            // terminal (to prevent validate-milestone loops per #832), but
+            // completing-milestone should NOT proceed — remediation work is needed.
+            const validationFile = resolveMilestoneFile(basePath, mid, "VALIDATION");
+            if (validationFile) {
+                const validationContent = await loadFile(validationFile);
+                if (validationContent) {
+                    const verdict = extractVerdict(validationContent);
+                    if (verdict === "needs-remediation") {
+                        return {
+                            action: "stop",
+                            reason: `Cannot complete milestone ${mid}: VALIDATION verdict is "needs-remediation". Address the remediation findings and re-run validation, or update the verdict manually.`,
+                            level: "warning",
+                        };
                     }
                 }
-                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 (#1368): verify all roadmap slices have SUMMARY files.
+            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
@@ -501,6 +520,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");
+}

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

@@ -27,6 +27,21 @@ 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()`. */
@@ -174,6 +189,7 @@ export async function postUnitPreVerification(pctx, opts) {
     }
     // Auto-commit
     if (s.currentUnit) {
+        const unit = s.currentUnit;
         try {
             let taskContext;
             if (s.currentUnit.type === "execute-task") {
@@ -230,65 +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 { milestone: mid, slice: sid } = parseUnitId(s.currentUnit.id);
+            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") {
@@ -415,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()) {
@@ -510,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"}...`);
                     }
                 }
             }
@@ -547,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

@@ -675,6 +675,15 @@ export async function checkNeedsRunUat(base, mid, state, prefs) {
                 // 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 = getUatType(uatContent);
                 return { sliceId: sid, uatType };
             }
@@ -706,6 +715,14 @@ export async function checkNeedsRunUat(base, mid, state, prefs) {
     // 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 = getUatType(uatContentFb);
     return { sliceId: uatSid, uatType: uatTypeFb };
 }
@@ -1173,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 {
@@ -1203,6 +1242,24 @@ export async function buildValidateMilestonePrompt(mid, midTitle, base, level) {
         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");

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

@@ -6,9 +6,10 @@
  * Pure functions that receive all needed state as parameters — no module-level
  * globals or AutoContext dependency.
  */
+import { parseUnitId } from "./unit-id.js";
 import { clearParseCache } from "./files.js";
 import { parseRoadmap as parseLegacyRoadmap, parsePlan as parseLegacyPlan } from "./parsers-legacy.js";
-import { isDbAvailable, getTask, getSlice, getSliceTasks } from "./gsd-db.js";
+import { isDbAvailable, getTask, getSlice, getSliceTasks, updateTaskStatus } from "./gsd-db.js";
 import { isValidationTerminal } from "./state.js";
 import { nativeConflictFiles, nativeCommit, nativeCheckoutTheirs, nativeAddPaths, nativeMergeAbort, nativeResetHard, } from "./native-git-bridge.js";
 import { resolveSlicePath, resolveSliceFile, resolveTasksDir, resolveTaskFiles, relMilestoneFile, relSliceFile, buildSliceFileName, resolveMilestoneFile, clearPathCache, resolveGsdRootFile, } from "./paths.js";
@@ -148,13 +149,9 @@ export function verifyExpectedArtifact(unitType, unitId, base) {
     // Reactive-execute: verify that each dispatched task's summary exists.
     // The unitId encodes the batch: "{mid}/{sid}/reactive+T02,T03"
     if (unitType === "reactive-execute") {
-        const parts = unitId.split("/");
-        const mid = parts[0];
-        const sidAndBatch = parts[1];
-        const batchPart = parts[2]; // "reactive+T02,T03"
-        if (!mid || !sidAndBatch || !batchPart)
+        const { milestone: mid, slice: sid, task: batchPart } = parseUnitId(unitId);
+        if (!mid || !sid || !batchPart)
             return false;
-        const sid = sidAndBatch;
         const plusIdx = batchPart.indexOf("+");
         if (plusIdx === -1) {
             // Legacy format "reactive" without batch IDs — fall back to "any summary"
@@ -181,10 +178,7 @@ export function verifyExpectedArtifact(unitType, unitId, base) {
     // Gate-evaluate: verify that each dispatched gate has been resolved in the DB.
     // The unitId encodes the batch: "{mid}/{sid}/gates+Q3,Q4"
     if (unitType === "gate-evaluate") {
-        const parts = unitId.split("/");
-        const mid = parts[0];
-        const sid = parts[1];
-        const batchPart = parts[2]; // "gates+Q3,Q4"
+        const { milestone: mid, slice: sid, task: batchPart } = parseUnitId(unitId);
         if (!mid || !sid || !batchPart)
             return false;
         const plusIdx = batchPart.indexOf("+");
@@ -236,10 +230,7 @@ export function verifyExpectedArtifact(unitType, unitId, base) {
     // execute-task: DB status is authoritative. Fall back to heading-style plan
     // detection when the DB is unavailable (unmigrated projects).
     if (unitType === "execute-task") {
-        const parts = unitId.split("/");
-        const mid = parts[0];
-        const sid = parts[1];
-        const tid = parts[2];
+        const { milestone: mid, slice: sid, task: tid } = parseUnitId(unitId);
         if (mid && sid && tid) {
             const dbTask = getTask(mid, sid, tid);
             if (dbTask) {
@@ -271,9 +262,7 @@ export function verifyExpectedArtifact(unitType, unitId, base) {
     // but omitted T{tid}-PLAN.md files would be marked complete, causing execute-task
     // to dispatch with a missing task plan (see issue #739).
     if (unitType === "plan-slice") {
-        const parts = unitId.split("/");
-        const mid = parts[0];
-        const sid = parts[1];
+        const { milestone: mid, slice: sid } = parseUnitId(unitId);
         if (mid && sid) {
             try {
                 // DB primary path — get task IDs to verify task plan files exist
@@ -309,9 +298,7 @@ export function verifyExpectedArtifact(unitType, unitId, base) {
     // complete-slice: DB status is authoritative for whether the slice is done.
     // Fall back to file-based check (roadmap [x]) when DB is unavailable.
     if (unitType === "complete-slice") {
-        const parts = unitId.split("/");
-        const mid = parts[0];
-        const sid = parts[1];
+        const { milestone: mid, slice: sid } = parseUnitId(unitId);
         if (mid && sid) {
             const dir = resolveSlicePath(base, mid, sid);
             if (dir) {
@@ -377,6 +364,18 @@ export function writeBlockerPlaceholder(unitType, unitId, base, reason) {
         `Review and replace this file before relying on downstream artifacts.`,
     ].join("\n");
     writeFileSync(absPath, content, "utf-8");
+    // Mark the task as complete in the DB so verifyExpectedArtifact passes.
+    // Without this, the DB status stays "pending" and the dispatch loop
+    // re-derives the same task indefinitely (#2531).
+    if (unitType === "execute-task" && isDbAvailable()) {
+        const { milestone: mid, slice: sid, task: tid } = parseUnitId(unitId);
+        if (mid && sid && tid) {
+            try {
+                updateTaskStatus(mid, sid, tid, "complete", new Date().toISOString());
+            }
+            catch { /* non-fatal */ }
+        }
+    }
     return diagnoseExpectedArtifact(unitType, unitId, base);
 }
 // ─── Merge State Reconciliation ───────────────────────────────────────────────
@@ -476,10 +475,7 @@ export function reconcileMergeState(basePath, ctx) {
  * These are shown when automatic reconciliation is not possible.
  */
 export function buildLoopRemediationSteps(unitType, unitId, base) {
-    const parts = unitId.split("/");
-    const mid = parts[0];
-    const sid = parts[1];
-    const tid = parts[2];
+    const { milestone: mid, slice: sid, task: tid } = parseUnitId(unitId);
     switch (unitType) {
         case "execute-task": {
             if (!mid || !sid || !tid)

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

@@ -34,6 +34,7 @@ import { isDbAvailable, getMilestone } from "./gsd-db.js";
 import { hideFooter } from "./auto-dashboard.js";
 import { debugLog, enableDebug, isDebugEnabled, getDebugLogPath, } from "./debug-logger.js";
 import { parseUnitId } from "./unit-id.js";
+import { setLogBasePath } from "./workflow-logger.js";
 import { existsSync, mkdirSync, readdirSync, statSync, unlinkSync, } from "node:fs";
 import { join } from "node:path";
 import { sep as pathSep } from "node:path";
@@ -312,6 +313,7 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
         s.verbose = verboseMode;
         s.cmdCtx = ctx;
         s.basePath = base;
+        setLogBasePath(base);
         s.unitDispatchCount.clear();
         s.unitRecoveryCount.clear();
         s.lastBudgetAlertLevel = 0;