gsd-pi 2.76.0 → 2.77.0-dev.2daa994b6

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

@@ -37,8 +37,9 @@ import { getRtkSessionSavings } from "../shared/rtk-session-stats.js";
 import { deactivateGSD } from "../shared/gsd-phase-state.js";
 import { initMetrics, resetMetrics, getLedger, getProjectTotals, formatCost, formatTokenCount, } from "./metrics.js";
 import { setLogBasePath, logWarning } from "./workflow-logger.js";
+import { preflightCleanRoot, postflightPopStash } from "./clean-root-preflight.js";
 import { homedir } from "node:os";
-import { join } from "node:path";
+import { isAbsolute, join } from "node:path";
 import { pathToFileURL } from "node:url";
 import { readFileSync, existsSync, mkdirSync, writeFileSync, unlinkSync } from "node:fs";
 import { atomicWriteSync } from "./atomic-write.js";
@@ -50,16 +51,24 @@ import { pruneQueueOrder } from "./queue-order.js";
 import { startCommandPolling as _startCommandPolling, isRemoteConfigured } from "../remote-questions/manager.js";
 import { debugLog, isDebugEnabled, writeDebugSummary } from "./debug-logger.js";
 import { reconcileMergeState, } from "./auto-recovery.js";
+import { classifyMilestoneSummaryContent } from "./milestone-summary-classifier.js";
 import { resolveDispatch, DISPATCH_RULES } from "./auto-dispatch.js";
 import { getErrorMessage } from "./error-utils.js";
 import { recoverFailedMigration } from "./migrate-external.js";
 import { initRegistry, convertDispatchRules } from "./rule-registry.js";
 import { emitJournalEvent as _emitJournalEvent } from "./journal.js";
-import { updateProgressWidget as _updateProgressWidget, updateSliceProgressCache, clearSliceProgressCache, hideFooter, } from "./auto-dashboard.js";
+import { updateProgressWidget as _updateProgressWidget, updateSliceProgressCache, clearSliceProgressCache, } from "./auto-dashboard.js";
 import { registerSigtermHandler as _registerSigtermHandler, deregisterSigtermHandler as _deregisterSigtermHandler, } from "./auto-supervisor.js";
 import { isDbAvailable, getMilestone } from "./gsd-db.js";
 import { countPendingCaptures } from "./captures.js";
-import { clearCmuxSidebar, logCmuxEvent, syncCmuxSidebar } from "../cmux/index.js";
+import { CMUX_CHANNELS } from "../shared/cmux-events.js";
+function makeCmuxEmitters(pi) {
+    return {
+        syncCmuxSidebar: (preferences, state) => pi.events.emit(CMUX_CHANNELS.SIDEBAR, { action: "sync", preferences, state }),
+        logCmuxEvent: (preferences, message, level) => pi.events.emit(CMUX_CHANNELS.LOG, { preferences, message, level: level ?? "info" }),
+        clearCmuxSidebar: (preferences) => pi.events.emit(CMUX_CHANNELS.SIDEBAR, { action: "clear", preferences }),
+    };
+}
 // ── Extracted modules ──────────────────────────────────────────────────────
 import { startUnitSupervision } from "./auto-timers.js";
 import { runPostUnitVerification } from "./auto-verification.js";
@@ -136,6 +145,24 @@ function restoreMilestoneLockEnv() {
     s.hadMilestoneLockEnv = false;
     s.milestoneLockEnvCaptured = false;
 }
+function normalizeSessionFilePath(raw) {
+    if (typeof raw !== "string")
+        return null;
+    const trimmed = raw.trim();
+    if (!trimmed)
+        return null;
+    const firstLine = trimmed.split(/\r?\n/, 1)[0]?.trim() ?? "";
+    if (!firstLine)
+        return null;
+    // Guard against accidental message concatenation by trimming to .jsonl.
+    const jsonlIndex = firstLine.toLowerCase().indexOf(".jsonl");
+    const candidate = jsonlIndex >= 0 ? firstLine.slice(0, jsonlIndex + ".jsonl".length) : firstLine;
+    if (!isAbsolute(candidate))
+        return null;
+    if (!candidate.toLowerCase().endsWith(".jsonl"))
+        return null;
+    return candidate;
+}
 export function startAutoDetached(ctx, pi, base, verboseMode, options) {
     void startAuto(ctx, pi, base, verboseMode, options).catch((err) => {
         const message = getErrorMessage(err);
@@ -145,8 +172,8 @@ export function startAutoDetached(ctx, pi, base, verboseMode, options) {
     });
 }
 /** Returns true if the project is configured for `isolation:worktree` mode. */
-export function shouldUseWorktreeIsolation() {
-    const prefs = loadEffectiveGSDPreferences()?.preferences?.git;
+export function shouldUseWorktreeIsolation(basePath) {
+    const prefs = loadEffectiveGSDPreferences(basePath)?.preferences?.git;
     if (prefs?.isolation === "worktree")
         return true;
     // Default is false — worktree isolation requires explicit opt-in
@@ -215,7 +242,7 @@ export function getAutoDashboardData() {
     const rtkSavings = sessionId && s.basePath
         ? getRtkSessionSavings(s.basePath, sessionId)
         : null;
-    const rtkEnabled = loadEffectiveGSDPreferences()?.preferences.experimental?.rtk === true;
+    const rtkEnabled = loadEffectiveGSDPreferences(s.basePath || undefined)?.preferences.experimental?.rtk === true;
     // Pending capture count — lazy check, non-fatal
     let pendingCaptureCount = 0;
     try {
@@ -248,6 +275,10 @@ export function getAutoDashboardData() {
 export function isAutoActive() {
     return s.active;
 }
+/** Test-only seam for validating auto-mode guards (#4704). Do not use in production code. */
+export function _setAutoActiveForTest(active) {
+    s.active = active;
+}
 export function isAutoPaused() {
     return s.paused;
 }
@@ -393,7 +424,7 @@ function clearUnitTimeout() {
 }
 /** Build snapshot metric opts. */
 function buildSnapshotOpts(_unitType, _unitId) {
-    const prefs = loadEffectiveGSDPreferences()?.preferences;
+    const prefs = loadEffectiveGSDPreferences(s.basePath || undefined)?.preferences;
     const uokFlags = resolveUokFlags(prefs);
     return {
         ...(s.autoStartTime > 0 ? { autoSessionKey: String(s.autoStartTime) } : {}),
@@ -427,7 +458,6 @@ function handleLostSessionLock(ctx, lockStatus) {
     restoreProjectRootEnv();
     restoreMilestoneLockEnv();
     deregisterSigtermHandler();
-    clearCmuxSidebar(loadEffectiveGSDPreferences()?.preferences);
     const base = lockBase();
     const lockFilePath = base ? join(gsdRoot(base), "auto.lock") : "unknown";
     const recoverySuggestion = "\nTo recover, run: gsd doctor --fix";
@@ -443,7 +473,6 @@ function handleLostSessionLock(ctx, lockStatus) {
     ctx?.ui.notify(message, "error");
     ctx?.ui.setStatus("gsd-auto", undefined);
     ctx?.ui.setWidget("gsd-progress", undefined);
-    ctx?.ui.setFooter(undefined);
     if (ctx)
         initHealthWidget(ctx);
 }
@@ -480,7 +509,6 @@ function cleanupAfterLoopExit(ctx) {
     if (!s.paused) {
         ctx.ui.setStatus("gsd-auto", undefined);
         ctx.ui.setWidget("gsd-progress", undefined);
-        ctx.ui.setFooter(undefined);
         initHealthWidget(ctx);
     }
     // Restore CWD out of worktree back to original project root
@@ -498,8 +526,42 @@ function cleanupAfterLoopExit(ctx) {
 export async function stopAuto(ctx, pi, reason) {
     if (!s.active && !s.paused)
         return;
-    const loadedPreferences = loadEffectiveGSDPreferences()?.preferences;
+    const loadedPreferences = loadEffectiveGSDPreferences(s.basePath || undefined)?.preferences;
     const reasonSuffix = reason ? ` — ${reason}` : "";
+    // #4764 — telemetry: record the exit reason and whether the current milestone
+    // was merged before we entered stopAuto. This is the producer-side signal for
+    // the #4761 orphan class: milestoneMerged=false + currentMilestoneId present
+    // is exactly the pattern that strands work.
+    try {
+        const { emitAutoExit } = await import("./worktree-telemetry.js");
+        // Normalize the free-form reason to a closed set so the telemetry
+        // aggregator buckets stably. Raw detail is preserved in the phases.ts
+        // notification and the notify'd error string.
+        const rawReason = reason ?? "stop";
+        const normalizedReason = rawReason.startsWith("Blocked:")
+            ? "blocked"
+            : rawReason.startsWith("Merge conflict")
+                ? "merge-conflict"
+                : rawReason.startsWith("Merge error") || rawReason.startsWith("Merge failed")
+                    ? "merge-failed"
+                    : rawReason.startsWith("slice-merge-conflict")
+                        ? "slice-merge-conflict"
+                        : rawReason === "All milestones complete"
+                            ? "all-complete"
+                            : rawReason === "No active milestone"
+                                ? "no-active-milestone"
+                                : rawReason === "stop" || rawReason === "pause"
+                                    ? rawReason
+                                    : "other";
+        emitAutoExit(s.originalBasePath || s.basePath, {
+            reason: normalizedReason,
+            milestoneId: s.currentMilestoneId ?? undefined,
+            milestoneMerged: s.milestoneMergedInPhases === true,
+        });
+    }
+    catch (err) {
+        logWarning("engine", `auto-exit telemetry failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
     try {
         // ── Step 1: Timers and locks ──
         try {
@@ -657,8 +719,12 @@ export async function stopAuto(ctx, pi, reason) {
         }
         // ── Step 9: Cmux sidebar / event log ──
         try {
-            clearCmuxSidebar(loadedPreferences);
-            logCmuxEvent(loadedPreferences, `Auto-mode stopped${reasonSuffix || ""}.`, reason?.startsWith("Blocked:") ? "warning" : "info");
+            pi?.events.emit(CMUX_CHANNELS.SIDEBAR, { action: "clear", preferences: loadedPreferences });
+            pi?.events.emit(CMUX_CHANNELS.LOG, {
+                preferences: loadedPreferences,
+                message: `Auto-mode stopped${reasonSuffix || ""}.`,
+                level: reason?.startsWith("Blocked:") ? "warning" : "info",
+            });
         }
         catch (e) {
             debugLog("stop-cleanup-cmux", { error: e instanceof Error ? e.message : String(e) });
@@ -695,13 +761,16 @@ export async function stopAuto(ctx, pi, reason) {
         catch (err) { /* non-fatal */
             logWarning("engine", `file unlink failed: ${err instanceof Error ? err.message : String(err)}`, { file: "auto.ts" });
         }
-        // ── Step 13: Restore original model (before reset clears IDs) ──
+        // ── Step 13: Restore original model + thinking (before reset clears IDs) ──
         try {
             if (pi && ctx && s.originalModelId && s.originalModelProvider) {
                 const original = ctx.modelRegistry.find(s.originalModelProvider, s.originalModelId);
                 if (original)
                     await pi.setModel(original);
             }
+            if (pi && s.originalThinkingLevel) {
+                pi.setThinkingLevel(s.originalThinkingLevel);
+            }
         }
         catch (e) {
             debugLog("stop-cleanup-model", { error: e instanceof Error ? e.message : String(e) });
@@ -740,7 +809,6 @@ export async function stopAuto(ctx, pi, reason) {
         // UI cleanup
         ctx?.ui.setStatus("gsd-auto", undefined);
         ctx?.ui.setWidget("gsd-progress", undefined);
-        ctx?.ui.setFooter(undefined);
         if (ctx)
             initHealthWidget(ctx);
         restoreProjectRootEnv();
@@ -775,7 +843,7 @@ export async function pauseAuto(ctx, _pi, _errorContext) {
     // Pass errorContext so runUnitPhase can distinguish user-initiated pause
     // from provider-error pause and avoid hard-stopping (#2762).
     resolveAgentEndCancelled(_errorContext);
-    s.pausedSessionFile = ctx?.sessionManager?.getSessionFile() ?? null;
+    s.pausedSessionFile = normalizeSessionFilePath(ctx?.sessionManager?.getSessionFile() ?? null);
     // Persist paused-session metadata so resume survives /exit (#1383).
     // The fresh-start bootstrap checks for this file and restores worktree context.
     try {
@@ -829,7 +897,6 @@ export async function pauseAuto(ctx, _pi, _errorContext) {
     s.verificationRetryCount.clear();
     ctx?.ui.setStatus("gsd-auto", "paused");
     ctx?.ui.setWidget("gsd-progress", undefined);
-    ctx?.ui.setFooter(undefined);
     if (ctx)
         initHealthWidget(ctx);
     const resumeCmd = s.stepMode ? "/gsd next" : "/gsd auto";
@@ -874,11 +941,12 @@ function buildResolver() {
  * Build the LoopDeps object from auto.ts private scope.
  * This bundles all private functions that autoLoop needs without exporting them.
  */
-function buildLoopDeps() {
+function buildLoopDeps(pi) {
     // Initialize the unified rule registry with converted dispatch rules.
     // Must happen before LoopDeps is assembled so facade functions
     // (resolveDispatch, runPreDispatchHooks, etc.) delegate to the registry.
     initRegistry(convertDispatchRules(DISPATCH_RULES));
+    const cmux = makeCmuxEmitters(pi);
     return {
         lockBase,
         buildSnapshotOpts,
@@ -886,8 +954,11 @@ function buildLoopDeps() {
         pauseAuto,
         clearUnitTimeout,
         updateProgressWidget,
-        syncCmuxSidebar,
-        logCmuxEvent,
+        ...cmux,
+        handleLostSessionLock: (ctx, lockStatus) => {
+            cmux.clearCmuxSidebar(loadEffectiveGSDPreferences(s.basePath || undefined)?.preferences);
+            handleLostSessionLock(ctx, lockStatus);
+        },
         // State and cache
         invalidateAllCaches,
         deriveState,
@@ -902,7 +973,6 @@ function buildLoopDeps() {
         // Session lock
         validateSessionLock: getSessionLockStatus,
         updateSessionLock,
-        handleLostSessionLock,
         // Milestone transition
         sendDesktopNotification,
         setActiveMilestoneId,
@@ -975,6 +1045,9 @@ function buildLoopDeps() {
         },
         // Journal
         emitJournalEvent: (entry) => _emitJournalEvent(s.basePath, entry),
+        // Clean-root preflight gate (#2909)
+        preflightCleanRoot,
+        postflightPopStash,
     };
 }
 /**
@@ -1031,7 +1104,9 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
                     unlinkSync(pausedPath);
                 }
                 catch (e) {
-                    logWarning("session", `pause file cleanup failed: ${e instanceof Error ? e.message : String(e)}`, { file: "auto.ts" });
+                    if (e.code !== "ENOENT") {
+                        logWarning("session", `pause file cleanup failed: ${e instanceof Error ? e.message : String(e)}`, { file: "auto.ts" });
+                    }
                 }
                 ctx.ui.notify(`Resuming paused custom workflow${meta.activeRunDir ? ` (${meta.activeRunDir})` : ""}.`, "info");
             }
@@ -1044,12 +1119,23 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
                     // Validate the milestone still exists and isn't already complete (#1664).
                     const mDir = resolveMilestonePath(base, meta.milestoneId);
                     const summaryFile = resolveMilestoneFile(base, meta.milestoneId, "SUMMARY");
-                    if (!mDir || summaryFile) {
+                    let summaryIsTerminal = false;
+                    if (summaryFile) {
+                        try {
+                            summaryIsTerminal = classifyMilestoneSummaryContent(readFileSync(summaryFile, "utf-8")) !== "failure";
+                        }
+                        catch {
+                            summaryIsTerminal = false;
+                        }
+                    }
+                    if (!mDir || summaryIsTerminal) {
                         try {
                             unlinkSync(pausedPath);
                         }
                         catch (err) {
-                            logWarning("session", `pause file cleanup failed: ${err instanceof Error ? err.message : String(err)}`, { file: "auto.ts" });
+                            if (err.code !== "ENOENT") {
+                                logWarning("session", `pause file cleanup failed: ${err instanceof Error ? err.message : String(err)}`, { file: "auto.ts" });
+                            }
                         }
                         ctx.ui.notify(`Paused milestone ${meta.milestoneId} is ${!mDir ? "missing" : "already complete"}. Starting fresh.`, "info");
                     }
@@ -1057,7 +1143,7 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
                         s.currentMilestoneId = meta.milestoneId;
                         s.originalBasePath = meta.originalBasePath || base;
                         s.stepMode = meta.stepMode ?? requestedStepMode;
-                        s.pausedSessionFile = meta.sessionFile ?? null;
+                        s.pausedSessionFile = normalizeSessionFilePath(meta.sessionFile ?? null);
                         s.pausedUnitType = meta.unitType ?? null;
                         s.pausedUnitId = meta.unitId ?? null;
                         s.autoStartTime = meta.autoStartTime || Date.now();
@@ -1067,7 +1153,9 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
                             unlinkSync(pausedPath);
                         }
                         catch (e) {
-                            logWarning("session", `pause file cleanup failed: ${e instanceof Error ? e.message : String(e)}`, { file: "auto.ts" });
+                            if (e.code !== "ENOENT") {
+                                logWarning("session", `pause file cleanup failed: ${e instanceof Error ? e.message : String(e)}`, { file: "auto.ts" });
+                            }
                         }
                         ctx.ui.notify(`Resuming paused session for ${meta.milestoneId}${meta.worktreePath && existsSync(meta.worktreePath) ? ` (worktree)` : ""}.`, "info");
                     }
@@ -1077,7 +1165,9 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
                         unlinkSync(pausedPath);
                     }
                     catch (e) {
-                        logWarning("session", `stale pause file cleanup failed: ${e instanceof Error ? e.message : String(e)}`, { file: "auto.ts" });
+                        if (e.code !== "ENOENT") {
+                            logWarning("session", `stale pause file cleanup failed: ${e instanceof Error ? e.message : String(e)}`, { file: "auto.ts" });
+                        }
                     }
                 }
             }
@@ -1133,7 +1223,9 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
                 unlinkSync(s.pausedSessionFile);
             }
             catch (err) {
-                logWarning("session", `pause file cleanup failed: ${err instanceof Error ? err.message : String(err)}`, { file: "auto.ts" });
+                if (err.code !== "ENOENT") {
+                    logWarning("session", `pause file cleanup failed: ${err instanceof Error ? err.message : String(err)}`, { file: "auto.ts" });
+                }
             }
             s.pausedSessionFile = null;
         }
@@ -1143,6 +1235,17 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
         s.stepMode = requestedStepMode;
         s.cmdCtx = ctx;
         s.basePath = base;
+        // ── Resume worktree: if the paused session was inside a milestone worktree,
+        // apply that path as the dispatch basePath immediately (#3723).
+        // This ensures the dispatch loop runs from the worktree directory even when
+        // enterMilestone guard conditions differ between the original and resumed
+        // session (e.g. isolation mode changed, detectWorktreeName differs across
+        // process restarts).  We guard with existsSync so a stale or deleted
+        // worktree directory safely falls back to the project root.
+        const resumeWorktreePath = freshStartAssessment.pausedSession?.worktreePath;
+        if (resumeWorktreePath && existsSync(resumeWorktreePath)) {
+            s.basePath = resumeWorktreePath;
+        }
         // Ensure the workflow-logger audit log is pinned to the project root
         // even when auto-mode is entered via a path that bypasses the
         // bootstrap/dynamic-tools ensureDbOpen() → setLogBasePath() chain
@@ -1161,7 +1264,7 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
         });
         // ── Auto-worktree / branch-mode: re-enter on resume ──
         if (s.currentMilestoneId &&
-            getIsolationMode() !== "none" &&
+            getIsolationMode(s.originalBasePath || s.basePath) !== "none" &&
             s.originalBasePath &&
             !isInAutoWorktree(s.basePath) &&
             !detectWorktreeName(s.basePath) &&
@@ -1172,7 +1275,7 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
         }
         registerSigtermHandler(lockBase());
         ctx.ui.setStatus("gsd-auto", s.stepMode ? "next" : "auto");
-        ctx.ui.setFooter(hideFooter);
+        ctx.ui.setWidget("gsd-health", undefined);
         ctx.ui.notify(s.stepMode ? "Step-mode resumed." : "Auto-mode resumed.", "info");
         restoreHookState(s.basePath);
         // Re-sync managed resources on resume so long-lived auto sessions pick up
@@ -1194,7 +1297,7 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
         await openProjectDbIfPresent(s.basePath);
         try {
             await rebuildState(s.basePath);
-            syncCmuxSidebar(loadEffectiveGSDPreferences()?.preferences, await deriveState(s.basePath));
+            pi.events.emit(CMUX_CHANNELS.SIDEBAR, { action: "sync", preferences: loadEffectiveGSDPreferences(s.basePath || undefined)?.preferences, state: await deriveState(s.basePath) });
         }
         catch (e) {
             debugLog("resume-rebuild-state-failed", {
@@ -1224,14 +1327,14 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
         }
         updateSessionLock(lockBase(), "resuming", s.currentMilestoneId ?? "unknown");
         writeLock(lockBase(), "resuming", s.currentMilestoneId ?? "unknown");
-        logCmuxEvent(loadEffectiveGSDPreferences()?.preferences, s.stepMode ? "Step-mode resumed." : "Auto-mode resumed.", "progress");
+        pi.events.emit(CMUX_CHANNELS.LOG, { preferences: loadEffectiveGSDPreferences(s.basePath || undefined)?.preferences, message: s.stepMode ? "Step-mode resumed." : "Auto-mode resumed.", level: "progress" });
         captureProjectRootEnv(s.originalBasePath || s.basePath);
         startAutoCommandPolling(s.basePath);
         await runAutoLoopWithUok({
             ctx,
             pi,
             s,
-            deps: buildLoopDeps(),
+            deps: buildLoopDeps(pi),
             runKernelLoop: runUokKernelLoop,
             runLegacyLoop: runLegacyAutoLoop,
         });
@@ -1250,20 +1353,20 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
         return;
     captureProjectRootEnv(s.originalBasePath || s.basePath);
     try {
-        syncCmuxSidebar(loadEffectiveGSDPreferences()?.preferences, await deriveState(s.basePath));
+        pi.events.emit(CMUX_CHANNELS.SIDEBAR, { action: "sync", preferences: loadEffectiveGSDPreferences(s.basePath || undefined)?.preferences, state: await deriveState(s.basePath) });
     }
     catch (err) {
         // Best-effort only — sidebar sync must never block auto-mode startup
         logWarning("engine", `cmux sync failed: ${err instanceof Error ? err.message : String(err)}`, { file: "auto.ts" });
     }
-    logCmuxEvent(loadEffectiveGSDPreferences()?.preferences, requestedStepMode ? "Step-mode started." : "Auto-mode started.", "progress");
+    pi.events.emit(CMUX_CHANNELS.LOG, { preferences: loadEffectiveGSDPreferences(s.basePath || undefined)?.preferences, message: requestedStepMode ? "Step-mode started." : "Auto-mode started.", level: "progress" });
     startAutoCommandPolling(s.basePath);
     // Dispatch the first unit
     await runAutoLoopWithUok({
         ctx,
         pi,
         s,
-        deps: buildLoopDeps(),
+        deps: buildLoopDeps(pi),
         runKernelLoop: runUokKernelLoop,
         runLegacyLoop: runLegacyAutoLoop,
     });
@@ -1361,8 +1464,8 @@ export async function dispatchHookUnit(ctx, pi, hookName, triggerUnitType, trigg
                 `Ensure the model is defined in models.json and has auth configured.`, "warning");
         }
     }
-    const sessionFile = ctx.sessionManager.getSessionFile();
-    writeLock(lockBase(), hookUnitType, triggerUnitId, sessionFile);
+    const sessionFile = normalizeSessionFilePath(ctx.sessionManager.getSessionFile());
+    writeLock(lockBase(), hookUnitType, triggerUnitId, sessionFile ?? undefined);
     clearUnitTimeout();
     const supervisor = resolveAutoSupervisorConfig();
     const hookHardTimeoutMs = (supervisor.hard_timeout_minutes ?? 30) * 60 * 1000;

package/dist/resources/extensions/gsd/blocked-models.js

@@ -0,0 +1,68 @@
+// GSD — Persistent per-project blocklist of provider/model pairs that the
+// provider has rejected at request time for account entitlement reasons.
+//
+// Lives at `.gsd/runtime/blocked-models.json` so the block survives /gsd auto
+// restarts.  Auto-mode model selection skips blocked entries; agent-end
+// recovery adds entries when a runtime rejection is classified as
+// `unsupported-model`.  See issue #4513.
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { gsdRoot } from "./paths.js";
+import { withFileLockSync } from "./file-lock.js";
+function blockedModelsPath(basePath) {
+    return join(gsdRoot(basePath), "runtime", "blocked-models.json");
+}
+function modelKey(provider, id) {
+    return `${provider.toLowerCase()}/${id.toLowerCase()}`;
+}
+function readFileSafe(path) {
+    if (!existsSync(path))
+        return { version: 1, blocked: [] };
+    try {
+        const raw = readFileSync(path, "utf-8");
+        const parsed = JSON.parse(raw);
+        if (!parsed || !Array.isArray(parsed.blocked)) {
+            return { version: 1, blocked: [] };
+        }
+        const blocked = parsed.blocked.filter((e) => !!e && typeof e.provider === "string" && typeof e.id === "string");
+        return { version: 1, blocked };
+    }
+    catch {
+        // Corrupted JSON: treat as empty so a bad file never blocks dispatch.
+        return { version: 1, blocked: [] };
+    }
+}
+export function loadBlockedModels(basePath) {
+    return readFileSafe(blockedModelsPath(basePath)).blocked;
+}
+export function isModelBlocked(basePath, provider, id) {
+    if (!provider || !id)
+        return false;
+    const target = modelKey(provider, id);
+    return loadBlockedModels(basePath).some((e) => modelKey(e.provider, e.id) === target);
+}
+export function blockModel(basePath, provider, id, reason) {
+    const path = blockedModelsPath(basePath);
+    mkdirSync(dirname(path), { recursive: true });
+    // Ensure the file exists before we try to lock it — proper-lockfile requires
+    // the target path to exist (file-lock.ts falls through to an unlocked call
+    // otherwise).
+    if (!existsSync(path)) {
+        writeFileSync(path, JSON.stringify({ version: 1, blocked: [] }, null, 2) + "\n", "utf-8");
+    }
+    withFileLockSync(path, () => {
+        const current = readFileSafe(path);
+        const target = modelKey(provider, id);
+        if (current.blocked.some((e) => modelKey(e.provider, e.id) === target)) {
+            return;
+        }
+        const next = {
+            version: 1,
+            blocked: [
+                ...current.blocked,
+                { provider, id, reason, blockedAt: Date.now() },
+            ],
+        };
+        writeFileSync(path, JSON.stringify(next, null, 2) + "\n", "utf-8");
+    });
+}

package/dist/resources/extensions/gsd/bootstrap/agent-end-recovery.js

@@ -1,5 +1,6 @@
 import { logWarning } from "../workflow-logger.js";
-import { checkAutoStartAfterDiscuss } from "../guided-flow.js";
+import { checkAutoStartAfterDiscuss, maybeHandleReadyPhraseWithoutFiles, maybeHandleEmptyIntentTurn, resetEmptyTurnCounter, } from "../guided-flow.js";
+import { clearPathCache } from "../paths.js";
 import { getAutoDashboardData, getAutoModeStartModel, isAutoActive, pauseAuto, setCurrentDispatchedModelId } from "../auto.js";
 import { getNextFallbackModel, resolveModelWithFallbacksForUnit } from "../preferences.js";
 import { pauseAutoForProviderError } from "../provider-error-pause.js";
@@ -8,9 +9,18 @@ import { resolveModelId } from "../auto-model-selection.js";
 import { clearDiscussionFlowState } from "./write-gate.js";
 import { resumeAutoAfterProviderDelay } from "./provider-error-resume.js";
 import { classifyError, createRetryState, resetRetryState, isTransient, } from "../error-classifier.js";
+import { blockModel, isModelBlocked } from "../blocked-models.js";
 const retryState = createRetryState();
 const MAX_NETWORK_RETRIES = 2;
-const MAX_TRANSIENT_AUTO_RESUMES = 8;
+/**
+ * Cap on auto-resume attempts for sustained transient-provider errors.
+ *
+ * Exported so tests assert against the shared constant instead of
+ * regex-scraping the source literal (see #4837). Raising this value to
+ * handle longer provider overloads should update the single constant; the
+ * test in provider-errors.test.ts consumes it directly.
+ */
+export const MAX_TRANSIENT_AUTO_RESUMES = 8;
 /**
  * Reset the module-level retry state so a resumed auto-session starts fresh.
  * Called by provider-error-resume.ts before startAuto() — without this, the
@@ -48,10 +58,32 @@ async function pauseTransientWithBackoff(cls, pi, ctx, errorDetail, isRateLimit)
     });
 }
 export async function handleAgentEnd(pi, event, ctx) {
+    // #4648 — Invalidate the directory-listing cache before any artifact-existence
+    // checks. The LLM may have written milestone files (CONTEXT.md, ROADMAP.md,
+    // PROJECT.md, REQUIREMENTS.md) via tool calls during the turn that just
+    // ended. `paths.ts` caches readdir() results without a TTL, so without this
+    // flush, `resolveMilestoneFile` returns the pre-write listing and the guards
+    // below (`checkAutoStartAfterDiscuss` and `maybeHandleReadyPhraseWithoutFiles`)
+    // falsely report files as missing — producing a spurious "ready signal
+    // rejected" loop even though the files are on disk.
+    clearPathCache();
     if (checkAutoStartAfterDiscuss()) {
         clearDiscussionFlowState();
         return;
     }
+    // #4573 — When the LLM emits "Milestone X ready." but the required files
+    // are missing, `checkAutoStartAfterDiscuss` returns false silently. Surface
+    // that and nudge the LLM to complete the writes before the user hits the
+    // downstream "All milestones complete" warning loop.
+    if (maybeHandleReadyPhraseWithoutFiles(event))
+        return;
+    // #4573 — Empty-turn recovery: if the LLM announced intent in prose but
+    // emitted no tool calls, nudge it to execute. Fires only when auto-mode is
+    // active or a discussion autostart is pending (non-auto interactive discuss
+    // is user-driven). Runs before `isAutoActive` early return so pending
+    // discussions (where isAutoActive may be false) still get recovered.
+    if (maybeHandleEmptyIntentTurn(event, isAutoActive()))
+        return;
     if (!isAutoActive())
         return;
     if (isSessionSwitchInFlight())
@@ -106,6 +138,81 @@ export async function handleAgentEnd(pi, event, ctx) {
         const explicitRetryAfterMs = ("retryAfterMs" in lastMsg && typeof lastMsg.retryAfterMs === "number") ? lastMsg.retryAfterMs : undefined;
         // ── 1. Classify using rawErrorMsg to avoid prose false-positives ────
         const cls = classifyError(rawErrorMsg, explicitRetryAfterMs);
+        // ── 1a. Unsupported-model: provider rejected this model for the current
+        //        account/plan at request time (#4513).  Persist a block so the
+        //        same dead model isn't reselected on the next /gsd auto restart,
+        //        then try a fallback before pausing.
+        if (cls.kind === "unsupported-model") {
+            const dash = getAutoDashboardData();
+            const rejectedProvider = ctx.model?.provider;
+            const rejectedId = ctx.model?.id;
+            if (dash.basePath && rejectedProvider && rejectedId) {
+                try {
+                    blockModel(dash.basePath, rejectedProvider, rejectedId, rawErrorMsg || "unsupported for account");
+                    ctx.ui.notify(`Blocked ${rejectedProvider}/${rejectedId} for this project — provider rejected it for the current account.`, "warning");
+                }
+                catch (err) {
+                    const m = err instanceof Error ? err.message : String(err);
+                    logWarning("bootstrap", `Failed to persist blocked model: ${m}`);
+                }
+            }
+            // Try configured fallback chain, skipping anything already blocked.
+            if (dash.currentUnit && dash.basePath) {
+                const modelConfig = resolveModelWithFallbacksForUnit(dash.currentUnit.type);
+                if (modelConfig && modelConfig.fallbacks.length > 0) {
+                    const availableModels = ctx.modelRegistry.getAvailable();
+                    let cursorModelId = ctx.model?.id;
+                    while (true) {
+                        const nextModelId = getNextFallbackModel(cursorModelId, modelConfig);
+                        if (!nextModelId)
+                            break;
+                        const candidate = resolveModelId(nextModelId, availableModels, ctx.model?.provider);
+                        if (candidate && !isModelBlocked(dash.basePath, candidate.provider, candidate.id)) {
+                            const ok = await pi.setModel(candidate, { persist: false });
+                            if (ok) {
+                                setCurrentDispatchedModelId({ provider: candidate.provider, id: candidate.id });
+                                ctx.ui.notify(`Switched to fallback ${candidate.provider}/${candidate.id} after account entitlement rejection.`, "warning");
+                                pi.sendMessage({ customType: "gsd-auto-timeout-recovery", content: "Continue execution.", display: false }, { triggerTurn: true });
+                                return;
+                            }
+                        }
+                        cursorModelId = nextModelId;
+                    }
+                }
+                // Fallback chain exhausted — try the auto-mode start model if it isn't
+                // the same one we just blocked and isn't itself blocked.
+                const sessionModel = getAutoModeStartModel();
+                if (sessionModel &&
+                    !(sessionModel.provider === rejectedProvider && sessionModel.id === rejectedId) &&
+                    !isModelBlocked(dash.basePath, sessionModel.provider, sessionModel.id)) {
+                    const startModel = ctx.modelRegistry
+                        .getAvailable()
+                        .find((m) => m.provider === sessionModel.provider && m.id === sessionModel.id);
+                    if (startModel) {
+                        const ok = await pi.setModel(startModel, { persist: false });
+                        if (ok) {
+                            setCurrentDispatchedModelId({ provider: startModel.provider, id: startModel.id });
+                            ctx.ui.notify(`Restored auto-mode start model ${startModel.provider}/${startModel.id} after entitlement rejection.`, "warning");
+                            pi.sendMessage({ customType: "gsd-auto-timeout-recovery", content: "Continue execution.", display: false }, { triggerTurn: true });
+                            return;
+                        }
+                    }
+                }
+            }
+            // No usable fallback — pause with a clearly named message.
+            const blockedLabel = rejectedProvider && rejectedId ? `${rejectedProvider}/${rejectedId}` : "current model";
+            const pauseDetail = `Model ${blockedLabel} blocked for this account${errorDetail}. Configure a different model and restart /gsd auto.`;
+            await pauseAutoForProviderError(ctx.ui, pauseDetail, () => pauseAuto(ctx, pi, {
+                message: pauseDetail,
+                category: "provider",
+                isTransient: false,
+            }), {
+                isRateLimit: false,
+                isTransient: false,
+                retryAfterMs: 0,
+            });
+            return;
+        }
         // ── 1b. Defer to Core RetryHandler for most transient errors ────────
         // Core retries transient failures in-session after this handler.
         // Keep that behavior for non-rate-limit classes to avoid pause/retry races,
@@ -210,6 +317,9 @@ export async function handleAgentEnd(pi, event, ctx) {
     // ── Success path ─────────────────────────────────────────────────────────
     try {
         resetRetryState(retryState);
+        // #4573 — Reset the empty-turn counter on any successful agent turn so
+        // transient stalls don't accumulate across independent units.
+        resetEmptyTurnCounter();
         resolveAgentEnd(event);
     }
     catch (err) {