gsd-pi 2.76.0 → 2.77.0-dev.c9c8932c6

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

@@ -26,15 +26,24 @@ export async function runUnit(ctx, pi, s, unitType, unitId, prompt) {
     let sessionResult;
     let sessionTimeoutHandle;
     const mySessionSwitchGeneration = ++sessionSwitchGeneration;
+    // #3731: Cancellation controller for newSession(). When the session-creation
+    // timeout fires, we abort this controller so that the still-in-flight
+    // newSession() discards itself after await this.abort() completes, preventing
+    // it from capturing the (now-root) process.cwd() and rebuilding the tool
+    // runtime with the wrong cwd.
+    const sessionAbortController = new AbortController();
     _setSessionSwitchInFlight(true);
     try {
-        const sessionPromise = s.cmdCtx.newSession().finally(() => {
+        const sessionPromise = s.cmdCtx.newSession({ abortSignal: sessionAbortController.signal }).finally(() => {
             if (sessionSwitchGeneration === mySessionSwitchGeneration) {
                 _setSessionSwitchInFlight(false);
             }
         });
         const timeoutPromise = new Promise((resolve) => {
-            sessionTimeoutHandle = setTimeout(() => resolve({ cancelled: true }), NEW_SESSION_TIMEOUT_MS);
+            sessionTimeoutHandle = setTimeout(() => {
+                sessionAbortController.abort();
+                resolve({ cancelled: true });
+            }, NEW_SESSION_TIMEOUT_MS);
         });
         sessionResult = await Promise.race([sessionPromise, timeoutPromise]);
     }
@@ -92,6 +101,33 @@ export async function runUnit(ctx, pi, s, unitType, unitId, prompt) {
     catch (e) {
         logWarning("engine", "Failed to chdir to basePath before dispatch", { basePath: s.basePath, error: String(e) });
     }
+    // ── Provider request-readiness pre-check (#4555) ──
+    // Verify the provider can accept requests before dispatching. If the token
+    // has expired since bootstrap, return cancelled immediately so the unit is
+    // not wasted on a guaranteed 401.
+    {
+        const provider = s.currentUnitModel?.provider ?? ctx.model?.provider;
+        const registry = ctx.modelRegistry;
+        if (provider && registry != null && typeof registry.isProviderRequestReady === "function") {
+            let ready = false;
+            try {
+                ready = registry.isProviderRequestReady(provider);
+            }
+            catch {
+                ready = false;
+            }
+            if (!ready) {
+                return {
+                    status: "cancelled",
+                    errorContext: {
+                        message: `Provider ${provider} is not request-ready (login/token expired)`,
+                        category: "provider",
+                        isTransient: false,
+                    },
+                };
+            }
+        }
+    }
     // ── Send the prompt ──
     debugLog("runUnit", { phase: "send-message", unitType, unitId });
     pi.sendMessage({ customType: "gsd-auto", content: prompt, display: s.verbose }, { triggerTurn: true });

package/dist/resources/extensions/gsd/auto/session.js

@@ -65,6 +65,8 @@ export class AutoSession {
     currentDispatchedModelId = null;
     originalModelId = null;
     originalModelProvider = null;
+    autoModeStartThinkingLevel = null;
+    originalThinkingLevel = null;
     lastBudgetAlertLevel = 0;
     // ── Recovery ─────────────────────────────────────────────────────────────
     pendingCrashRecovery = null;
@@ -77,6 +79,17 @@ export class AutoSession {
     lastStateRebuildAt = 0;
     // ── Sidecar queue ─────────────────────────────────────────────────────
     sidecarQueue = [];
+    // ── Pre-exec gate failure context (#4551) ───────────────────────────
+    /**
+     * Persisted when a pre-execution gate fails on a plan-slice or refine-slice
+     * unit. The planning → plan-slice dispatch rule reads this field and injects
+     * the failure details into the next re-dispatch prompt so the LLM can fix the
+     * specific issues instead of producing an identical plan.
+     *
+     * Cleared after it has been consumed (injected into the prompt) to avoid
+     * stale context bleeding into unrelated slices.
+     */
+    lastPreExecFailure = null;
     // ── Tool invocation errors (#2883) ──────────────────────────────────
     /** Set when a GSD tool execution ends with isError due to malformed/truncated
      *  JSON arguments. Checked by postUnitPreVerification to break retry loops. */
@@ -137,7 +150,12 @@ export class AutoSession {
         this.unitLifetimeDispatches.clear();
     }
     get lockBasePath() {
-        return this.originalBasePath || this.basePath;
+        // Prefer originalBasePath (project root); fall back to basePath.
+        // Strip /.gsd/worktrees/ suffix if basePath is itself a worktree path
+        // to avoid reading/writing the lock inside the worktree (#3729).
+        const resolved = this.originalBasePath || this.basePath;
+        const markerIdx = resolved.indexOf("/.gsd/worktrees/");
+        return markerIdx !== -1 ? resolved.slice(0, markerIdx) : resolved;
     }
     reset() {
         this.clearTimers();
@@ -177,6 +195,8 @@ export class AutoSession {
         this.currentDispatchedModelId = null;
         this.originalModelId = null;
         this.originalModelProvider = null;
+        this.autoModeStartThinkingLevel = null;
+        this.originalThinkingLevel = null;
         this.lastBudgetAlertLevel = 0;
         // Recovery
         this.pendingCrashRecovery = null;
@@ -195,6 +215,7 @@ export class AutoSession {
         this.sidecarQueue = [];
         this.rewriteAttemptCount = 0;
         this.consecutiveCompleteBootstraps = 0;
+        this.lastPreExecFailure = null;
         this.lastToolInvocationError = null;
         this.lastGitActionFailure = null;
         this.lastGitActionStatus = null;

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

@@ -17,7 +17,7 @@ import { parseRoadmap } from "./parsers-legacy.js";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { logWarning, logError } from "./workflow-logger.js";
 import { join } from "node:path";
-import { hasImplementationArtifacts } from "./auto-recovery.js";
+import { hasImplementationArtifacts, classifyMilestoneSummaryContent } from "./auto-recovery.js";
 import { buildDiscussMilestonePrompt, buildResearchMilestonePrompt, buildPlanMilestonePrompt, buildResearchSlicePrompt, buildPlanSlicePrompt, buildRefineSlicePrompt, buildExecuteTaskPrompt, buildCompleteSlicePrompt, buildCompleteMilestonePrompt, buildValidateMilestonePrompt, buildReplanSlicePrompt, buildRunUatPrompt, buildReassessRoadmapPrompt, buildRewriteDocsPrompt, buildReactiveExecutePrompt, buildGateEvaluatePrompt, buildParallelResearchSlicesPrompt, checkNeedsReassessment, checkNeedsRunUat, } from "./auto-prompts.js";
 import { resolveModelWithFallbacksForUnit } from "./preferences-models.js";
 import { resolveUokFlags } from "./uok/flags.js";
@@ -451,18 +451,31 @@ export const DISPATCH_RULES = [
     },
     {
         name: "planning → plan-slice",
-        match: async ({ state, mid, midTitle, basePath, sessionContextWindow, modelRegistry }) => {
+        match: async ({ state, mid, midTitle, basePath, sessionContextWindow, modelRegistry, session }) => {
             if (state.phase !== "planning")
                 return null;
             if (!state.activeSlice)
                 return missingSliceStop(mid, state.phase);
             const sid = state.activeSlice.id;
             const sTitle = state.activeSlice.title;
+            // #4551: Consume any persisted pre-exec failure for this slice so the
+            // re-dispatched prompt includes the exact blocked references. Clear the
+            // field immediately after reading to prevent stale context leaking into
+            // a later, unrelated plan-slice run.
+            const unitId = `${mid}/${sid}`;
+            let priorPreExecFailure;
+            if (session?.lastPreExecFailure?.unitId === unitId) {
+                priorPreExecFailure = {
+                    blockingFindings: session.lastPreExecFailure.blockingFindings,
+                    verdictExcerpt: session.lastPreExecFailure.verdictExcerpt,
+                };
+                session.lastPreExecFailure = null;
+            }
             return {
                 action: "dispatch",
                 unitType: "plan-slice",
-                unitId: `${mid}/${sid}`,
-                prompt: await buildPlanSlicePrompt(mid, midTitle, sid, sTitle, basePath, undefined, { sessionContextWindow, modelRegistry }),
+                unitId,
+                prompt: await buildPlanSlicePrompt(mid, midTitle, sid, sTitle, basePath, undefined, { sessionContextWindow, modelRegistry, priorPreExecFailure }),
             };
         },
     },
@@ -689,22 +702,13 @@ export const DISPATCH_RULES = [
                     return { action: "skip" };
                 }
             }
-            // Reconciliation guard (#4324): when the SUMMARY file already exists
-            // on disk but the DB says the milestone is not complete, the DB is
-            // out of sync (e.g. journal reset, partial merge, crash recovery).
-            // Reconcile the DB status directly instead of re-dispatching the
-            // tool, which would overwrite the richer on-disk SUMMARY with a
-            // thinner regenerated version — causing silent data loss.
             const existingSummary = resolveMilestoneFile(basePath, mid, "SUMMARY");
+            let summaryOutcome = "unknown";
             if (existingSummary && isDbAvailable()) {
-                try {
-                    updateMilestoneStatus(mid, "complete", new Date().toISOString());
-                    logWarning("dispatch", `Milestone ${mid} has SUMMARY on disk but DB status was not complete — reconciled DB to complete (#4324)`);
-                }
-                catch (err) {
-                    logWarning("dispatch", `Failed to reconcile milestone ${mid} status: ${err instanceof Error ? err.message : String(err)}`);
+                const summaryContent = await loadFile(existingSummary);
+                if (summaryContent) {
+                    summaryOutcome = classifyMilestoneSummaryContent(summaryContent);
                 }
-                return { action: "skip" };
             }
             // Safety guard (#2675): block completion when VALIDATION verdict is
             // needs-remediation. The state machine treats needs-remediation as
@@ -782,6 +786,41 @@ export const DISPATCH_RULES = [
             catch (err) { /* fall through — don't block on DB errors */
                 logWarning("dispatch", `verification class check failed: ${err instanceof Error ? err.message : String(err)}`);
             }
+            // Disk/DB mismatch handling (#4658): SUMMARY presence alone is not enough.
+            // Apply post-gate policy:
+            // - success summary: reconcile DB and skip re-dispatch
+            // - failure summary: pause/fail-closed
+            // - unknown summary: pause/fail-closed
+            if (existingSummary && isDbAvailable()) {
+                const milestone = getMilestone(mid);
+                const status = milestone?.status ?? "missing";
+                if (summaryOutcome === "success") {
+                    try {
+                        updateMilestoneStatus(mid, "complete", new Date().toISOString());
+                        logWarning("dispatch", `Milestone ${mid} SUMMARY indicates completion while DB status was "${status}" — reconciled DB to complete (#4658)`);
+                        return { action: "skip" };
+                    }
+                    catch (err) {
+                        return {
+                            action: "stop",
+                            level: "warning",
+                            reason: `Milestone ${mid} SUMMARY indicates completion but DB reconciliation failed (${err instanceof Error ? err.message : String(err)}). Auto-mode paused for manual review.`,
+                        };
+                    }
+                }
+                if (summaryOutcome === "failure") {
+                    return {
+                        action: "stop",
+                        level: "warning",
+                        reason: `Milestone ${mid} has a failure-path SUMMARY while DB status is "${status}". Auto-mode will not promote completion from failure artifacts. Re-run complete-milestone only after blockers are resolved and verification passes.`,
+                    };
+                }
+                return {
+                    action: "stop",
+                    level: "warning",
+                    reason: `Milestone ${mid} has an ambiguous SUMMARY while DB status is "${status}". Auto-mode paused instead of promoting completion from file presence alone.`,
+                };
+            }
             return {
                 action: "dispatch",
                 unitType: "complete-milestone",

package/dist/resources/extensions/gsd/auto-model-selection.js

@@ -12,10 +12,20 @@ import { getSessionModelOverride } from "./session-model-override.js";
 import { logWarning } from "./workflow-logger.js";
 import { resolveUokFlags } from "./uok/flags.js";
 import { applyModelPolicyFilter } from "./uok/model-policy.js";
+import { isModelBlocked } from "./blocked-models.js";
+function reapplyThinkingLevel(pi, level) {
+    if (!level)
+        return;
+    pi.setThinkingLevel(level);
+}
 export function resolvePreferredModelConfig(unitType, autoModeStartModel, isAutoMode = true) {
     const explicitConfig = resolveModelWithFallbacksForUnit(unitType);
-    if (explicitConfig)
-        return explicitConfig;
+    if (explicitConfig) {
+        return {
+            ...explicitConfig,
+            source: "explicit",
+        };
+    }
     // In interactive mode, don't synthesize a routing-based model config.
     // The user's session model (/model) should be used as-is (#3962).
     if (!isAutoMode)
@@ -38,6 +48,7 @@ export function resolvePreferredModelConfig(unitType, autoModeStartModel, isAuto
     return {
         primary: ceilingModel,
         fallbacks: [],
+        source: "synthesized",
     };
 }
 /**
@@ -52,7 +63,9 @@ export async function selectAndApplyModel(ctx, pi, unitType, unitId, basePath, p
  *  Dynamic routing only applies in auto-mode where cost optimization is expected. (#3962) */
 isAutoMode = true, 
 /** Explicit /gsd model pin captured at bootstrap for long-running auto loops. */
-sessionModelOverride) {
+sessionModelOverride, 
+/** Thinking level captured at auto-mode start and re-applied after model swaps. */
+autoModeStartThinkingLevel) {
     const uokFlags = resolveUokFlags(prefs);
     const effectiveSessionModelOverride = sessionModelOverride === undefined
         ? getSessionModelOverride(ctx.sessionManager.getSessionId())
@@ -90,6 +103,11 @@ sessionModelOverride) {
         if (prefs?.token_profile === "burn-max") {
             routingConfig.enabled = false;
         }
+        if (modelConfig.source === "explicit") {
+            // Explicit per-phase model preferences express hard user intent.
+            // Dynamic routing may only treat synthesized tier ceilings as downgradeable.
+            routingConfig.enabled = false;
+        }
         let effectiveModelConfig = modelConfig;
         let routingTierLabel = "";
         let routingEligibleModels = availableModels;
@@ -210,6 +228,7 @@ sessionModelOverride) {
                     effectiveModelConfig = {
                         primary: routingResult.modelId,
                         fallbacks: routingResult.fallbacks,
+                        source: modelConfig.source,
                     };
                     // Always notify on model downgrade — users should see when their
                     // model selection is overridden, not just in verbose mode (#3962).
@@ -249,6 +268,14 @@ sessionModelOverride) {
                 }
                 attemptedPolicyEligible = true;
             }
+            // Skip models the provider has previously rejected for this account
+            // (issue #4513).  The block is persisted in .gsd/runtime/blocked-models.json
+            // so it survives /gsd auto restarts — without this, the same dead model
+            // gets reselected after every restart.
+            if (isModelBlocked(basePath, model.provider, model.id)) {
+                ctx.ui.notify(`Skipping blocked model ${model.provider}/${model.id} (provider rejected it for this account).`, "warning");
+                continue;
+            }
             // Warn if the ID is ambiguous across providers
             if (!modelId.includes("/")) {
                 const providers = availableModels.filter(m => m.id === modelId).map(m => m.provider);
@@ -260,10 +287,11 @@ sessionModelOverride) {
             const ok = await pi.setModel(model, { persist: false });
             if (ok) {
                 appliedModel = model;
+                reapplyThinkingLevel(pi, autoModeStartThinkingLevel);
                 // ADR-005: Adjust active tool set for the selected model's provider capabilities.
                 // Hard-filter incompatible tools, then let extensions override via adjust_tool_set hook.
                 const activeToolNames = pi.getActiveTools();
-                const { toolNames: compatibleTools, removedTools } = adjustToolSet(activeToolNames, model.api);
+                const { toolNames: compatibleTools, removedTools } = adjustToolSet(activeToolNames, model.api, model.provider);
                 let finalToolNames = compatibleTools;
                 // Fire adjust_tool_set hook — extensions can override the filtered tool set
                 if (routingConfig.hooks !== false) {
@@ -314,19 +342,28 @@ sessionModelOverride) {
         // No model preference for this unit type — re-apply the model captured
         // at auto-mode start to prevent bleed from shared global settings.json (#650).
         const availableModels = ctx.modelRegistry.getAvailable();
-        const startModel = availableModels.find(m => m.provider === autoModeStartModel.provider && m.id === autoModeStartModel.id);
-        if (startModel) {
-            const ok = await pi.setModel(startModel, { persist: false });
-            if (!ok) {
-                const byId = availableModels.find(m => m.id === autoModeStartModel.id);
-                if (byId) {
-                    const fallbackOk = await pi.setModel(byId, { persist: false });
-                    if (fallbackOk)
-                        appliedModel = byId;
+        const startBlocked = isModelBlocked(basePath, autoModeStartModel.provider, autoModeStartModel.id);
+        if (startBlocked) {
+            ctx.ui.notify(`Auto-mode start model ${autoModeStartModel.provider}/${autoModeStartModel.id} is blocked for this account. Using current session model instead.`, "warning");
+        }
+        else {
+            const startModel = availableModels.find(m => m.provider === autoModeStartModel.provider && m.id === autoModeStartModel.id);
+            if (startModel) {
+                const ok = await pi.setModel(startModel, { persist: false });
+                if (!ok) {
+                    const byId = availableModels.find(m => m.id === autoModeStartModel.id && !isModelBlocked(basePath, m.provider, m.id));
+                    if (byId) {
+                        const fallbackOk = await pi.setModel(byId, { persist: false });
+                        if (fallbackOk) {
+                            appliedModel = byId;
+                            reapplyThinkingLevel(pi, autoModeStartThinkingLevel);
+                        }
+                    }
+                }
+                else {
+                    appliedModel = startModel;
+                    reapplyThinkingLevel(pi, autoModeStartThinkingLevel);
                 }
-            }
-            else {
-                appliedModel = startModel;
             }
         }
     }

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

@@ -30,7 +30,7 @@ import { checkPostUnitHooks, isRetryPending, consumeRetryTrigger, persistHookSta
 import { hasPendingCaptures, loadPendingCaptures, revertExecutorResolvedCaptures } from "./captures.js";
 import { debugLog } from "./debug-logger.js";
 import { runSafely } from "./auto-utils.js";
-import { getEvidence } from "./safety/evidence-collector.js";
+import { getEvidence, clearEvidenceFromDisk } from "./safety/evidence-collector.js";
 import { validateFileChanges } from "./safety/file-change-validator.js";
 // crossReferenceEvidence available for future use when verification_evidence is stored in DB
 // import { crossReferenceEvidence, type ClaimedEvidence } from "./safety/evidence-cross-ref.js";
@@ -45,8 +45,23 @@ import { ensureCodebaseMapFresh } from "./codebase-generator.js";
 import { resolveUokFlags } from "./uok/flags.js";
 import { UokGateRunner } from "./uok/gate-runner.js";
 import { writeTurnGitTransaction } from "./uok/gitops.js";
+import { isClosedStatus } from "./status-guards.js";
 /** Maximum verification retry attempts before escalating to blocker placeholder (#2653). */
 const MAX_VERIFICATION_RETRIES = 3;
+const COMPLETE_MILESTONE_DB_SETTLE_MS = 1500;
+const COMPLETE_MILESTONE_DB_SETTLE_POLL_MS = 100;
+async function waitForMilestoneDbClose(mid) {
+    const deadline = Date.now() + COMPLETE_MILESTONE_DB_SETTLE_MS;
+    while (Date.now() < deadline) {
+        if (!isDbAvailable())
+            return false;
+        const milestone = getMilestone(mid);
+        if (milestone && isClosedStatus(milestone.status))
+            return true;
+        await new Promise((resolve) => setTimeout(resolve, COMPLETE_MILESTONE_DB_SETTLE_POLL_MS));
+    }
+    return false;
+}
 /** 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) {
@@ -535,7 +550,7 @@ export async function postUnitPreVerification(pctx, opts) {
                         if (taskRow) {
                             const expectedOutput = taskRow.expected_output ?? [];
                             const plannedFiles = taskRow.files ?? [];
-                            const audit = validateFileChanges(s.basePath, expectedOutput, plannedFiles);
+                            const audit = validateFileChanges(s.basePath, expectedOutput, plannedFiles, safetyConfig.file_change_allowlist);
                             if (audit && audit.violations.length > 0) {
                                 const warnings = audit.violations.filter(v => v.severity === "warning");
                                 for (const v of warnings) {
@@ -588,6 +603,16 @@ export async function postUnitPreVerification(pctx, opts) {
                         debugLog("postUnit", { phase: "safety-content-validation", error: String(e) });
                     }
                 }
+                // Clear persisted evidence file now that post-unit processing is complete
+                // (Bug #4385 — prevents stale evidence from affecting retries of same unit ID).
+                if (safetyConfig.evidence_collection && s.currentUnit.type === "execute-task" && sMid && sSid && sTid) {
+                    try {
+                        clearEvidenceFromDisk(s.basePath, sMid, sSid, sTid);
+                    }
+                    catch (e) {
+                        debugLog("postUnit", { phase: "safety-evidence-clear", error: String(e) });
+                    }
+                }
             }
         }
         catch (e) {
@@ -607,6 +632,25 @@ export async function postUnitPreVerification(pctx, opts) {
             }
             // If verification failed, attempt to regenerate missing projection files
             // from DB data before giving up (e.g. research-slice produces PLAN from engine).
+            if (!triggerArtifactVerified) {
+                if (s.currentUnit.type === "complete-milestone") {
+                    try {
+                        const { milestone: mid } = parseUnitId(s.currentUnit.id);
+                        if (mid) {
+                            const settled = await waitForMilestoneDbClose(mid);
+                            if (settled) {
+                                triggerArtifactVerified = verifyExpectedArtifact(s.currentUnit.type, s.currentUnit.id, s.basePath);
+                                if (triggerArtifactVerified) {
+                                    invalidateAllCaches();
+                                }
+                            }
+                        }
+                    }
+                    catch (e) {
+                        debugLog("postUnit", { phase: "artifact-verify-settle-db", error: String(e) });
+                    }
+                }
+            }
             if (!triggerArtifactVerified) {
                 try {
                     const { milestone: mid, slice: sid } = parseUnitId(s.currentUnit.id);
@@ -950,12 +994,25 @@ export async function postUnitPostVerification(pctx) {
                     const suffix = blockingChecks.length > 3 ? `\n  \u2022 ...and ${blockingChecks.length - 3} more` : "";
                     const evidenceNote = `\nSee ${sid}-PRE-EXEC-VERIFY.json for full details.`;
                     ctx.ui.notify(`Pre-execution checks failed: ${blockingCount} blocking issue${blockingCount === 1 ? "" : "s"} found\n${details}${suffix}${evidenceNote}`, "error");
+                    // Persist failure context so the next plan-slice re-dispatch can inject
+                    // it into the prompt and break the infinite loop (#4551).
+                    s.lastPreExecFailure = {
+                        unitId: currentUnit.id,
+                        blockingFindings: blockingChecks.map(c => `[${c.category}] ${c.target}: ${c.message}`),
+                        verdictExcerpt: `status=${result.status}; ${blockingCount} blocking issue${blockingCount === 1 ? "" : "s"} detected`,
+                    };
                     preExecPauseNeeded = true;
                 }
                 else if (result.status === "warn") {
                     ctx.ui.notify(`Pre-execution checks passed with warnings`, "warning");
                     // Strict mode: treat warnings as blocking
                     if (prefs?.enhanced_verification_strict === true) {
+                        const warnChecks = result.checks.filter(c => !c.passed);
+                        s.lastPreExecFailure = {
+                            unitId: currentUnit.id,
+                            blockingFindings: warnChecks.map(c => `[${c.category}] ${c.target}: ${c.message}`),
+                            verdictExcerpt: `status=${result.status} (strict mode); ${warnChecks.length} warning${warnChecks.length === 1 ? "" : "s"} treated as blocking`,
+                        };
                         preExecPauseNeeded = true;
                     }
                 }

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

@@ -1223,6 +1223,20 @@ export async function buildPlanSlicePrompt(mid, _midTitle, sid, sTitle, base, le
         prependBlocks.push(`## Prior Sketch Scope (soft hint — non-binding)\n\n${options.softScopeHint.trim()}\n\n` +
             `This scope was captured during an earlier progressive-planning pass that was later disabled. Treat it as context only — you may plan beyond it if the work genuinely requires more scope. Do NOT treat this as a hard boundary.`);
     }
+    // #4551: inject pre-exec failure context so the re-dispatched plan-slice
+    // addresses the exact blocked references rather than reproducing the same plan.
+    if (options?.priorPreExecFailure) {
+        const { blockingFindings, verdictExcerpt } = options.priorPreExecFailure;
+        const findingsList = blockingFindings.length > 0
+            ? blockingFindings.map(f => `- ${f}`).join("\n")
+            : "- (no specific findings recorded)";
+        prependBlocks.push(`## Fix these specific issues from the prior pre-exec check\n\n` +
+            `The previous plan-slice attempt was blocked by pre-execution validation.\n` +
+            `Gate verdict: ${verdictExcerpt}\n\n` +
+            `Blocked references that must be resolved in this plan:\n${findingsList}\n\n` +
+            `Revise the plan so that every reference listed above is satisfied before execution begins. ` +
+            `Do not reproduce the same file paths, package names, or task ordering that caused these failures.`);
+    }
     return renderSlicePrompt({
         mid, sid, sTitle, base,
         level: level ?? resolveInlineLevel(),

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

@@ -11,10 +11,12 @@ import { appendEvent } from "./workflow-events.js";
 import { atomicWriteSync } from "./atomic-write.js";
 import { clearParseCache } from "./files.js";
 import { parseRoadmap as parseLegacyRoadmap, parsePlan as parseLegacyPlan } from "./parsers-legacy.js";
-import { isDbAvailable, getTask, getSlice, getSliceTasks, getPendingGates, updateTaskStatus, updateSliceStatus } from "./gsd-db.js";
+import { isDbAvailable, getTask, getSlice, getSliceTasks, getPendingGates, updateTaskStatus, updateSliceStatus, insertSlice, getMilestone } from "./gsd-db.js";
 import { isValidationTerminal } from "./state.js";
 import { getErrorMessage } from "./error-utils.js";
 import { logWarning, logError } from "./workflow-logger.js";
+import { splitFrontmatter, parseFrontmatterMap } from "./files.js";
+import { isClosedStatus } from "./status-guards.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";
 import { existsSync, mkdirSync, readFileSync, writeFileSync, unlinkSync, } from "node:fs";
@@ -23,6 +25,30 @@ import { dirname, join } from "node:path";
 import { resolveExpectedArtifactPath, diagnoseExpectedArtifact, } from "./auto-artifact-paths.js";
 // Re-export so existing consumers of auto-recovery.ts keep working.
 export { resolveExpectedArtifactPath, diagnoseExpectedArtifact };
+/**
+ * Classify milestone summary content for recovery/dispatch decisions.
+ * - success: canonical completion summary (frontmatter status is closed)
+ * - failure: explicit blocker/failure markers
+ * - unknown: ambiguous content
+ */
+export function classifyMilestoneSummaryContent(content) {
+    const [fmLines] = splitFrontmatter(content);
+    const fm = fmLines ? parseFrontmatterMap(fmLines) : null;
+    const rawStatus = typeof fm?.status === "string" ? fm.status.trim().toLowerCase() : "";
+    if (rawStatus) {
+        if (isClosedStatus(rawStatus))
+            return "success";
+        if (["active", "pending", "blocked", "failed", "incomplete"].includes(rawStatus))
+            return "failure";
+    }
+    const failureSignal = /(?:^|\n)\s*#\s*BLOCKER\b/i.test(content)
+        || /auto-mode recovery failed/i.test(content)
+        || /verification\s+failed/i.test(content)
+        || /\bnot complete\b/i.test(content);
+    if (failureSignal)
+        return "failure";
+    return "unknown";
+}
 // ─── Artifact Resolution & Verification ───────────────────────────────────────
 /**
  * Check whether a milestone produced implementation artifacts (non-`.gsd/` files)
@@ -220,12 +246,25 @@ export function verifyExpectedArtifact(unitType, unitId, base) {
     // RESEARCH file. Without this, resolveExpectedArtifactPath returns null and
     // the retry/escalation machinery silently re-dispatches forever.
     //
+    // #4068: Also treat a PARALLEL-BLOCKER placeholder as a terminal completion
+    // so that timeout-recovery can write the blocker, have verifyExpectedArtifact
+    // return true, and let the dispatch loop advance past this unit.  Without
+    // this, the blocker is written but verification still returns false, the unit
+    // is never cleared from unitDispatchCount, and on the next iteration the
+    // dispatch rule (which correctly skips parallel-research when PARALLEL-BLOCKER
+    // exists) returns null — leaving the loop stuck re-deriving indefinitely.
+    //
     // NOTE: this predicate mirrors the dispatch rule at
     // auto-dispatch.ts parallel-research-slices — keep the two in sync.
     if (unitType === "research-slice" && unitId.endsWith("/parallel-research")) {
         const { milestone: mid } = parseUnitId(unitId);
         if (!mid)
             return false;
+        // #4068: PARALLEL-BLOCKER written by timeout-recovery is a terminal state.
+        const blockerPath = resolveExpectedArtifactPath(unitType, unitId, base);
+        if (blockerPath && existsSync(blockerPath)) {
+            return true;
+        }
         const roadmapFile = resolveMilestoneFile(base, mid, "ROADMAP");
         if (!roadmapFile || !existsSync(roadmapFile)) {
             logWarning("recovery", `verify-fail ${unitType} ${unitId}: roadmap missing`);
@@ -420,6 +459,17 @@ export function verifyExpectedArtifact(unitType, unitId, base) {
     // A milestone with only .gsd/ plan files and zero implementation code is
     // not genuinely complete — the LLM wrote plan files but skipped actual work.
     if (unitType === "complete-milestone") {
+        const summaryOutcome = classifyMilestoneSummaryContent(readFileSync(absPath, "utf-8"));
+        if (summaryOutcome === "failure")
+            return false;
+        const { milestone: mid } = parseUnitId(unitId);
+        if (mid && isDbAvailable()) {
+            const dbMilestone = getMilestone(mid);
+            if (!dbMilestone)
+                return false;
+            if (!isClosedStatus(dbMilestone.status) && summaryOutcome !== "success")
+                return false;
+        }
         if (hasImplementationArtifacts(base) === "absent")
             return false;
     }
@@ -497,6 +547,24 @@ export function writeBlockerPlaceholder(unitType, unitId, base, reason) {
                 logWarning("recovery", `appendEvent failed for slice recovery: ${e instanceof Error ? e.message : String(e)}`);
             }
         }
+        // Insert a placeholder complete slice so deriveState sees activeMilestoneSlices.length > 0
+        // and exits the pre-planning phase. Without this, activeMilestoneSlices stays empty
+        // after the blocker ROADMAP.md is written, causing deriveState to return phase:'pre-planning'
+        // indefinitely and re-dispatching plan-milestone in an infinite loop (#4378).
+        if (unitType === "plan-milestone" && mid) {
+            try {
+                insertSlice({ id: "S00-blocker", milestoneId: mid, title: "Blocker placeholder — planning failed", status: "complete", sequence: 0 });
+            }
+            catch (e) {
+                logWarning("recovery", `insertSlice placeholder failed for plan-milestone recovery: ${e instanceof Error ? e.message : String(e)}`);
+            }
+            try {
+                appendEvent(base, { cmd: "plan-milestone", params: { milestoneId: mid }, ts, actor: "system", trigger_reason: "blocker-placeholder-recovery" });
+            }
+            catch (e) {
+                logWarning("recovery", `appendEvent failed for plan-milestone recovery: ${e instanceof Error ? e.message : String(e)}`);
+            }
+        }
     }
     return diagnoseExpectedArtifact(unitType, unitId, base);
 }