gsd-pi 2.38.0-dev.bc2e21e → 2.38.0-dev.d533afb

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

@@ -5,12 +5,16 @@
  * pattern with a while loop. The agent_end event resolves a promise instead
  * of recursing.
  *
- * MAINTENANCE RULE: The only module-level mutable state here is `_activeSession`,
- * used by the agent_end bridge. Promise state itself lives on AutoSession so
- * concurrent auto sessions cannot corrupt each other.
+ * MAINTENANCE RULE: Module-level mutable state is limited to `_currentResolve`
+ * (per-unit one-shot resolver) and `_sessionSwitchInFlight` (guard for
+ * session rotation). No queue — stale agent_end events are dropped.
  */
+import { importExtensionModule } from "@gsd/pi-coding-agent";
 import { NEW_SESSION_TIMEOUT_MS } from "./auto/session.js";
 import { debugLog } from "./debug-logger.js";
+import { gsdRoot } from "./paths.js";
+import { atomicWriteSync } from "./atomic-write.js";
+import { join } from "node:path";
 /**
  * Maximum total loop iterations before forced stop. Prevents runaway loops
  * when units alternate IDs (bypassing the same-unit stuck detector).
@@ -18,79 +22,114 @@ import { debugLog } from "./debug-logger.js";
  * generous headroom including retries and sidecar work.
  */
 const MAX_LOOP_ITERATIONS = 500;
-/** Data-driven budget threshold notifications (75/80/90%). The 100% case is
- *  handled inline because it requires break/pause/stop control flow. */
+/** Maximum characters of failure/crash context included in recovery prompts. */
+const MAX_RECOVERY_CHARS = 50_000;
+/** Data-driven budget threshold notifications (descending). The 100% entry
+ *  triggers special enforcement logic (halt/pause/warn); sub-100 entries fire
+ *  a simple notification. */
 const BUDGET_THRESHOLDS = [
+    { pct: 100, label: "Budget ceiling reached", notifyLevel: "error", cmuxLevel: "error" },
     { pct: 90, label: "Budget 90%", notifyLevel: "warning", cmuxLevel: "warning" },
     { pct: 80, label: "Approaching budget ceiling — 80%", notifyLevel: "warning", cmuxLevel: "warning" },
     { pct: 75, label: "Budget 75%", notifyLevel: "info", cmuxLevel: "progress" },
 ];
-// ─── Session-scoped promise state ───────────────────────────────────────────
+// ─── Per-unit one-shot promise state ────────────────────────────────────────
 //
-// pendingResolve and pendingAgentEndQueue live on AutoSession (not module-level)
-// so concurrent sessions cannot corrupt each other's promises.
-/**
- * The singleton session reference used by resolveAgentEnd. Set by autoLoop
- * on entry so that the agent_end handler in index.ts can resolve the correct
- * session's promise without needing a direct reference to `s`.
- */
-let _activeSession = null;
+// A single module-level resolve function scoped to the current unit execution.
+// No queue — if an agent_end arrives with no pending resolver, it is dropped
+// (logged as warning). This is simpler and safer than the previous session-
+// scoped pendingResolve + pendingAgentEndQueue pattern.
+let _currentResolve = null;
+let _sessionSwitchInFlight = false;
 // ─── resolveAgentEnd ─────────────────────────────────────────────────────────
 /**
  * Called from the agent_end event handler in index.ts to resolve the
  * in-flight unit promise. One-shot: the resolver is nulled before calling
  * to prevent double-resolution from model fallback retries.
  *
- * If no pendingResolve exists (event arrived between loop iterations),
- * the event is queued on the session so the next runUnit can drain it.
+ * If no resolver exists (event arrived between loop iterations or during
+ * session switch), the event is dropped with a debug warning.
  */
 export function resolveAgentEnd(event) {
-    const s = _activeSession;
-    if (!s) {
-        debugLog("resolveAgentEnd", {
-            status: "no-active-session",
-            warning: "agent_end with no active loop session",
-        });
+    if (_sessionSwitchInFlight) {
+        debugLog("resolveAgentEnd", { status: "ignored-during-switch" });
         return;
     }
-    if (s.pendingResolve) {
+    if (_currentResolve) {
         debugLog("resolveAgentEnd", { status: "resolving", hasEvent: true });
-        const r = s.pendingResolve;
-        s.pendingResolve = null;
+        const r = _currentResolve;
+        _currentResolve = null;
         r({ status: "completed", event });
     }
     else {
-        // Queue the event so the next runUnit picks it up immediately
         debugLog("resolveAgentEnd", {
-            status: "queued",
-            queueLength: s.pendingAgentEndQueue.length + 1,
-            unitId: s.currentUnit?.id,
-            warning: "agent_end arrived between loop iterations — queued for next runUnit",
+            status: "no-pending-resolve",
+            warning: "agent_end with no pending unit",
         });
-        s.pendingAgentEndQueue.push({ ...event, unitId: s.currentUnit?.id });
     }
 }
 export function isSessionSwitchInFlight() {
-    return _activeSession?.sessionSwitchInFlight ?? false;
+    return _sessionSwitchInFlight;
 }
 // ─── resetPendingResolve (test helper) ───────────────────────────────────────
 /**
- * Reset session promise state. Only exported for test cleanup — production code
- * should never call this.
+ * Reset module-level promise state. Only exported for test cleanup —
+ * production code should never call this.
  */
 export function _resetPendingResolve() {
-    if (_activeSession) {
-        _activeSession.pendingResolve = null;
-        _activeSession.pendingAgentEndQueue = [];
-    }
-    _activeSession = null;
+    _currentResolve = null;
+    _sessionSwitchInFlight = false;
 }
 /**
- * Set the active session for resolveAgentEnd. Only exported for test setup —
- * production code sets this via autoLoop entry.
+ * No-op for backward compatibility with tests that previously set the
+ * active session. The module no longer holds a session reference.
  */
-export function _setActiveSession(session) {
-    _activeSession = session;
+export function _setActiveSession(_session) {
+    // No-op — kept for test backward compatibility
+}
+/**
+ * Analyze a sliding window of recent unit dispatches for stuck patterns.
+ * Returns a signal with reason if stuck, null otherwise.
+ *
+ * Rule 1: Same error string twice in a row → stuck immediately.
+ * Rule 2: Same unit key 3+ consecutive times → stuck (preserves prior behavior).
+ * Rule 3: Oscillation A→B→A→B in last 4 entries → stuck.
+ */
+export function detectStuck(window) {
+    if (window.length < 2)
+        return null;
+    const last = window[window.length - 1];
+    const prev = window[window.length - 2];
+    // Rule 1: Same error repeated consecutively
+    if (last.error && prev.error && last.error === prev.error) {
+        return {
+            stuck: true,
+            reason: `Same error repeated: ${last.error.slice(0, 200)}`,
+        };
+    }
+    // Rule 2: Same unit 3+ consecutive times
+    if (window.length >= 3) {
+        const lastThree = window.slice(-3);
+        if (lastThree.every((u) => u.key === last.key)) {
+            return {
+                stuck: true,
+                reason: `${last.key} derived 3 consecutive times without progress`,
+            };
+        }
+    }
+    // Rule 3: Oscillation (A→B→A→B in last 4)
+    if (window.length >= 4) {
+        const w = window.slice(-4);
+        if (w[0].key === w[2].key &&
+            w[1].key === w[3].key &&
+            w[0].key !== w[1].key) {
+            return {
+                stuck: true,
+                reason: `Oscillation detected: ${w[0].key} ↔ ${w[1].key}`,
+            };
+        }
+    }
+    return null;
 }
 // ─── runUnit ─────────────────────────────────────────────────────────────────
 /**
@@ -101,62 +140,16 @@ export function _setActiveSession(session) {
  * On session creation failure or timeout, returns { status: 'cancelled' }
  * without awaiting the promise.
  */
-export async function runUnit(ctx, pi, s, unitType, unitId, prompt, _prefs) {
+export async function runUnit(ctx, pi, s, unitType, unitId, prompt) {
     debugLog("runUnit", { phase: "start", unitType, unitId });
-    // ── Drain queued events from error-recovery retries ──
-    // If an agent_end arrived between iterations (e.g. from a model fallback
-    // sendMessage retry), consume it immediately instead of creating a new promise.
-    // Cap queue to 3 entries to prevent unbounded growth from stale events.
-    if (s.pendingAgentEndQueue.length > 3) {
-        debugLog("runUnit", {
-            phase: "queue-overflow",
-            dropped: s.pendingAgentEndQueue.length - 1,
-            unitType,
-            unitId,
-        });
-        s.pendingAgentEndQueue = [
-            s.pendingAgentEndQueue[s.pendingAgentEndQueue.length - 1],
-        ];
-    }
-    if (s.pendingAgentEndQueue.length > 0) {
-        // Find an event matching this unit; discard stale events from other units
-        const matchIdx = s.pendingAgentEndQueue.findIndex((e) => !e.unitId || e.unitId === unitId);
-        if (matchIdx >= 0) {
-            // Discard any stale events before the match
-            if (matchIdx > 0) {
-                debugLog("runUnit", {
-                    phase: "discarded-stale-events",
-                    count: matchIdx,
-                    unitType,
-                    unitId,
-                });
-            }
-            const queued = s.pendingAgentEndQueue.splice(0, matchIdx + 1).pop();
-            debugLog("runUnit", {
-                phase: "drained-queued-event",
-                unitType,
-                unitId,
-                queueRemaining: s.pendingAgentEndQueue.length,
-            });
-            return { status: "completed", event: queued };
-        }
-        // No matching event — discard all stale events and proceed to new session
-        debugLog("runUnit", {
-            phase: "discarded-all-stale-events",
-            count: s.pendingAgentEndQueue.length,
-            unitType,
-            unitId,
-        });
-        s.pendingAgentEndQueue = [];
-    }
     // ── Session creation with timeout ──
     debugLog("runUnit", { phase: "session-create", unitType, unitId });
     let sessionResult;
     let sessionTimeoutHandle;
-    s.sessionSwitchInFlight = true;
+    _sessionSwitchInFlight = true;
     try {
         const sessionPromise = s.cmdCtx.newSession().finally(() => {
-            s.sessionSwitchInFlight = false;
+            _sessionSwitchInFlight = false;
         });
         const timeoutPromise = new Promise((resolve) => {
             sessionTimeoutHandle = setTimeout(() => resolve({ cancelled: true }), NEW_SESSION_TIMEOUT_MS);
@@ -184,11 +177,12 @@ export async function runUnit(ctx, pi, s, unitType, unitId, prompt, _prefs) {
     if (!s.active) {
         return { status: "cancelled" };
     }
-    // ── Create the agent_end promise (session-scoped) ──
+    // ── Create the agent_end promise (per-unit one-shot) ──
     // This happens after newSession completes so session-switch agent_end events
     // from the previous session cannot resolve the new unit.
+    _sessionSwitchInFlight = false;
     const unitPromise = new Promise((resolve) => {
-        s.pendingResolve = resolve;
+        _currentResolve = resolve;
     });
     // Ensure cwd matches basePath before dispatch (#1389).
     // async_bash and background jobs can drift cwd away from the worktree.
@@ -213,6 +207,60 @@ export async function runUnit(ctx, pi, s, unitType, unitId, prompt, _prefs) {
     });
     return result;
 }
+// ─── generateMilestoneReport ──────────────────────────────────────────────────
+/**
+ * Generate and write an HTML milestone report snapshot.
+ * Extracted from the milestone-transition block in autoLoop.
+ */
+async function generateMilestoneReport(s, ctx, milestoneId) {
+    const { loadVisualizerData } = await importExtensionModule(import.meta.url, "./visualizer-data.js");
+    const { generateHtmlReport } = await importExtensionModule(import.meta.url, "./export-html.js");
+    const { writeReportSnapshot } = await importExtensionModule(import.meta.url, "./reports.js");
+    const { basename } = await import("node:path");
+    const snapData = await loadVisualizerData(s.basePath);
+    const completedMs = snapData.milestones.find((m) => m.id === milestoneId);
+    const msTitle = completedMs?.title ?? milestoneId;
+    const gsdVersion = process.env.GSD_VERSION ?? "0.0.0";
+    const projName = basename(s.basePath);
+    const doneSlices = snapData.milestones.reduce((acc, m) => acc + m.slices.filter((sl) => sl.done).length, 0);
+    const totalSlices = snapData.milestones.reduce((acc, m) => acc + m.slices.length, 0);
+    const outPath = writeReportSnapshot({
+        basePath: s.basePath,
+        html: generateHtmlReport(snapData, {
+            projectName: projName,
+            projectPath: s.basePath,
+            gsdVersion,
+            milestoneId,
+            indexRelPath: "index.html",
+        }),
+        milestoneId,
+        milestoneTitle: msTitle,
+        kind: "milestone",
+        projectName: projName,
+        projectPath: s.basePath,
+        gsdVersion,
+        totalCost: snapData.totals?.cost ?? 0,
+        totalTokens: snapData.totals?.tokens.total ?? 0,
+        totalDuration: snapData.totals?.duration ?? 0,
+        doneSlices,
+        totalSlices,
+        doneMilestones: snapData.milestones.filter((m) => m.status === "complete").length,
+        totalMilestones: snapData.milestones.length,
+        phase: snapData.phase,
+    });
+    ctx.ui.notify(`Report saved: .gsd/reports/${basename(outPath)} — open index.html to browse progression.`, "info");
+}
+// ─── closeoutAndStop ──────────────────────────────────────────────────────────
+/**
+ * If a unit is in-flight, close it out, then stop auto-mode.
+ * Extracted from ~4 identical if-closeout-then-stop sequences in autoLoop.
+ */
+async function closeoutAndStop(ctx, pi, s, deps, reason) {
+    if (s.currentUnit) {
+        await deps.closeoutUnit(ctx, s.basePath, s.currentUnit.type, s.currentUnit.id, s.currentUnit.startedAt, deps.buildSnapshotOpts(s.currentUnit.type, s.currentUnit.id));
+    }
+    await deps.stopAuto(ctx, pi, reason);
+}
 // ─── autoLoop ────────────────────────────────────────────────────────────────
 /**
  * Main auto-mode execution loop. Iterates: derive → dispatch → guards →
@@ -224,10 +272,11 @@ export async function runUnit(ctx, pi, s, unitType, unitId, prompt, _prefs) {
  */
 export async function autoLoop(ctx, pi, s, deps) {
     debugLog("autoLoop", { phase: "enter" });
-    _activeSession = s;
     let iteration = 0;
-    let lastDerivedUnit = "";
-    let sameUnitCount = 0;
+    // ── Sliding-window stuck detection ──
+    const recentUnits = [];
+    const STUCK_WINDOW_SIZE = 6;
+    let stuckRecoveryAttempts = 0;
     let consecutiveErrors = 0;
     while (s.active) {
         iteration++;
@@ -247,6 +296,7 @@ export async function autoLoop(ctx, pi, s, deps) {
         }
         try {
             // ── Blanket try/catch: one bad iteration must not kill the session
+            const prefs = deps.loadEffectiveGSDPreferences()?.preferences;
             const sessionLockBase = deps.lockBase();
             if (sessionLockBase) {
                 const lockStatus = deps.validateSessionLock(sessionLockBase);
@@ -301,7 +351,7 @@ export async function autoLoop(ctx, pi, s, deps) {
             }
             // Derive state
             let state = await deps.deriveState(s.basePath);
-            deps.syncCmuxSidebar(deps.loadEffectiveGSDPreferences()?.preferences, state);
+            deps.syncCmuxSidebar(prefs, state);
             let mid = state.activeMilestone?.id;
             let midTitle = state.activeMilestone?.title;
             debugLog("autoLoop", {
@@ -314,50 +364,14 @@ export async function autoLoop(ctx, pi, s, deps) {
             if (mid && s.currentMilestoneId && mid !== s.currentMilestoneId) {
                 ctx.ui.notify(`Milestone ${s.currentMilestoneId} complete. Advancing to ${mid}: ${midTitle}.`, "info");
                 deps.sendDesktopNotification("GSD", `Milestone ${s.currentMilestoneId} complete!`, "success", "milestone");
-                deps.logCmuxEvent(deps.loadEffectiveGSDPreferences()?.preferences, `Milestone ${s.currentMilestoneId} complete. Advancing to ${mid}.`, "success");
-                const vizPrefs = deps.loadEffectiveGSDPreferences()?.preferences;
+                deps.logCmuxEvent(prefs, `Milestone ${s.currentMilestoneId} complete. Advancing to ${mid}.`, "success");
+                const vizPrefs = prefs;
                 if (vizPrefs?.auto_visualize) {
                     ctx.ui.notify("Run /gsd visualize to see progress overview.", "info");
                 }
                 if (vizPrefs?.auto_report !== false) {
                     try {
-                        const { loadVisualizerData } = await import("./visualizer-data.js");
-                        const { generateHtmlReport } = await import("./export-html.js");
-                        const { writeReportSnapshot } = await import("./reports.js");
-                        const { basename } = await import("node:path");
-                        const snapData = await loadVisualizerData(s.basePath);
-                        const completedMs = snapData.milestones.find((m) => m.id === s.currentMilestoneId);
-                        const msTitle = completedMs?.title ?? s.currentMilestoneId;
-                        const gsdVersion = process.env.GSD_VERSION ?? "0.0.0";
-                        const projName = basename(s.basePath);
-                        const doneSlices = snapData.milestones.reduce((acc, m) => acc +
-                            m.slices.filter((sl) => sl.done).length, 0);
-                        const totalSlices = snapData.milestones.reduce((acc, m) => acc + m.slices.length, 0);
-                        const outPath = writeReportSnapshot({
-                            basePath: s.basePath,
-                            html: generateHtmlReport(snapData, {
-                                projectName: projName,
-                                projectPath: s.basePath,
-                                gsdVersion,
-                                milestoneId: s.currentMilestoneId,
-                                indexRelPath: "index.html",
-                            }),
-                            milestoneId: s.currentMilestoneId,
-                            milestoneTitle: msTitle,
-                            kind: "milestone",
-                            projectName: projName,
-                            projectPath: s.basePath,
-                            gsdVersion,
-                            totalCost: snapData.totals?.cost ?? 0,
-                            totalTokens: snapData.totals?.tokens.total ?? 0,
-                            totalDuration: snapData.totals?.duration ?? 0,
-                            doneSlices,
-                            totalSlices,
-                            doneMilestones: snapData.milestones.filter((m) => m.status === "complete").length,
-                            totalMilestones: snapData.milestones.length,
-                            phase: snapData.phase,
-                        });
-                        ctx.ui.notify(`Report saved: .gsd/reports/${(await import("node:path")).basename(outPath)} — open index.html to browse progression.`, "info");
+                        await generateMilestoneReport(s, ctx, s.currentMilestoneId);
                     }
                     catch (err) {
                         ctx.ui.notify(`Report generation failed: ${err instanceof Error ? err.message : String(err)}`, "warning");
@@ -367,8 +381,8 @@ export async function autoLoop(ctx, pi, s, deps) {
                 s.unitDispatchCount.clear();
                 s.unitRecoveryCount.clear();
                 s.unitLifetimeDispatches.clear();
-                lastDerivedUnit = "";
-                sameUnitCount = 0;
+                recentUnits.length = 0;
+                stuckRecoveryAttempts = 0;
                 // Worktree lifecycle on milestone transition — merge current, enter next
                 deps.resolver.mergeAndExit(s.currentMilestoneId, ctx.ui);
                 deps.invalidateAllCaches();
@@ -378,8 +392,7 @@ export async function autoLoop(ctx, pi, s, deps) {
                 if (mid) {
                     if (deps.getIsolationMode() !== "none") {
                         deps.captureIntegrationBranch(s.basePath, mid, {
-                            commitDocs: deps.loadEffectiveGSDPreferences()?.preferences?.git
-                                ?.commit_docs,
+                            commitDocs: prefs?.git?.commit_docs,
                         });
                     }
                     deps.resolver.enterMilestone(mid, ctx.ui);
@@ -408,7 +421,7 @@ export async function autoLoop(ctx, pi, s, deps) {
                         deps.resolver.mergeAndExit(s.currentMilestoneId, ctx.ui);
                     }
                     deps.sendDesktopNotification("GSD", "All milestones complete!", "success", "milestone");
-                    deps.logCmuxEvent(deps.loadEffectiveGSDPreferences()?.preferences, "All milestones complete.", "success");
+                    deps.logCmuxEvent(prefs, "All milestones complete.", "success");
                     await deps.stopAuto(ctx, pi, "All milestones complete");
                 }
                 else if (incomplete.length === 0 && state.registry.length === 0) {
@@ -422,7 +435,7 @@ export async function autoLoop(ctx, pi, s, deps) {
                     await deps.stopAuto(ctx, pi, blockerMsg);
                     ctx.ui.notify(`${blockerMsg}. Fix and run /gsd auto.`, "warning");
                     deps.sendDesktopNotification("GSD", blockerMsg, "error", "attention");
-                    deps.logCmuxEvent(deps.loadEffectiveGSDPreferences()?.preferences, blockerMsg, "error");
+                    deps.logCmuxEvent(prefs, blockerMsg, "error");
                 }
                 else {
                     const ids = incomplete.map((m) => m.id).join(", ");
@@ -445,13 +458,10 @@ export async function autoLoop(ctx, pi, s, deps) {
                 midTitle = state.activeMilestone?.title;
             }
             if (!mid || !midTitle) {
-                if (s.currentUnit) {
-                    await deps.closeoutUnit(ctx, s.basePath, s.currentUnit.type, s.currentUnit.id, s.currentUnit.startedAt, deps.buildSnapshotOpts(s.currentUnit.type, s.currentUnit.id));
-                }
                 const noMilestoneReason = !mid
                     ? "No active milestone after merge reconciliation"
                     : `Milestone ${mid} has no title after reconciliation`;
-                await deps.stopAuto(ctx, pi, noMilestoneReason);
+                await closeoutAndStop(ctx, pi, s, deps, noMilestoneReason);
                 debugLog("autoLoop", {
                     phase: "exit",
                     reason: "no-milestone-after-reconciliation",
@@ -460,34 +470,27 @@ export async function autoLoop(ctx, pi, s, deps) {
             }
             // Terminal: complete
             if (state.phase === "complete") {
-                if (s.currentUnit) {
-                    await deps.closeoutUnit(ctx, s.basePath, s.currentUnit.type, s.currentUnit.id, s.currentUnit.startedAt, deps.buildSnapshotOpts(s.currentUnit.type, s.currentUnit.id));
-                }
-                // Milestone merge on complete
+                // Milestone merge on complete (before closeout so branch state is clean)
                 if (s.currentMilestoneId) {
                     deps.resolver.mergeAndExit(s.currentMilestoneId, ctx.ui);
                 }
                 deps.sendDesktopNotification("GSD", `Milestone ${mid} complete!`, "success", "milestone");
-                deps.logCmuxEvent(deps.loadEffectiveGSDPreferences()?.preferences, `Milestone ${mid} complete.`, "success");
-                await deps.stopAuto(ctx, pi, `Milestone ${mid} complete`);
+                deps.logCmuxEvent(prefs, `Milestone ${mid} complete.`, "success");
+                await closeoutAndStop(ctx, pi, s, deps, `Milestone ${mid} complete`);
                 debugLog("autoLoop", { phase: "exit", reason: "milestone-complete" });
                 break;
             }
             // Terminal: blocked
             if (state.phase === "blocked") {
-                if (s.currentUnit) {
-                    await deps.closeoutUnit(ctx, s.basePath, s.currentUnit.type, s.currentUnit.id, s.currentUnit.startedAt, deps.buildSnapshotOpts(s.currentUnit.type, s.currentUnit.id));
-                }
                 const blockerMsg = `Blocked: ${state.blockers.join(", ")}`;
-                await deps.stopAuto(ctx, pi, blockerMsg);
+                await closeoutAndStop(ctx, pi, s, deps, blockerMsg);
                 ctx.ui.notify(`${blockerMsg}. Fix and run /gsd auto.`, "warning");
                 deps.sendDesktopNotification("GSD", blockerMsg, "error", "attention");
-                deps.logCmuxEvent(deps.loadEffectiveGSDPreferences()?.preferences, blockerMsg, "error");
+                deps.logCmuxEvent(prefs, blockerMsg, "error");
                 debugLog("autoLoop", { phase: "exit", reason: "blocked" });
                 break;
             }
             // ── Phase 2: Guards ─────────────────────────────────────────────────
-            const prefs = deps.loadEffectiveGSDPreferences()?.preferences;
             // Budget ceiling guard
             const budgetCeiling = prefs?.budget_ceiling;
             if (budgetCeiling !== undefined && budgetCeiling > 0) {
@@ -500,42 +503,42 @@ export async function autoLoop(ctx, pi, s, deps) {
                 const newBudgetAlertLevel = deps.getNewBudgetAlertLevel(s.lastBudgetAlertLevel, budgetPct);
                 const enforcement = prefs?.budget_enforcement ?? "pause";
                 const budgetEnforcementAction = deps.getBudgetEnforcementAction(enforcement, budgetPct);
-                if (newBudgetAlertLevel === 100 && budgetEnforcementAction !== "none") {
-                    const msg = `Budget ceiling ${deps.formatCost(budgetCeiling)} reached (spent ${deps.formatCost(totalCost)}).`;
+                // Data-driven threshold check — loop descending, fire first match
+                const threshold = BUDGET_THRESHOLDS.find((t) => newBudgetAlertLevel >= t.pct);
+                if (threshold) {
                     s.lastBudgetAlertLevel =
                         newBudgetAlertLevel;
-                    if (budgetEnforcementAction === "halt") {
-                        deps.sendDesktopNotification("GSD", msg, "error", "budget");
-                        await deps.stopAuto(ctx, pi, "Budget ceiling reached");
-                        debugLog("autoLoop", { phase: "exit", reason: "budget-halt" });
-                        break;
-                    }
-                    if (budgetEnforcementAction === "pause") {
-                        ctx.ui.notify(`${msg} Pausing auto-mode — /gsd auto to override and continue.`, "warning");
+                    if (threshold.pct === 100 && budgetEnforcementAction !== "none") {
+                        // 100% — special enforcement logic (halt/pause/warn)
+                        const msg = `Budget ceiling ${deps.formatCost(budgetCeiling)} reached (spent ${deps.formatCost(totalCost)}).`;
+                        if (budgetEnforcementAction === "halt") {
+                            deps.sendDesktopNotification("GSD", msg, "error", "budget");
+                            await deps.stopAuto(ctx, pi, "Budget ceiling reached");
+                            debugLog("autoLoop", { phase: "exit", reason: "budget-halt" });
+                            break;
+                        }
+                        if (budgetEnforcementAction === "pause") {
+                            ctx.ui.notify(`${msg} Pausing auto-mode — /gsd auto to override and continue.`, "warning");
+                            deps.sendDesktopNotification("GSD", msg, "warning", "budget");
+                            deps.logCmuxEvent(prefs, msg, "warning");
+                            await deps.pauseAuto(ctx, pi);
+                            debugLog("autoLoop", { phase: "exit", reason: "budget-pause" });
+                            break;
+                        }
+                        ctx.ui.notify(`${msg} Continuing (enforcement: warn).`, "warning");
                         deps.sendDesktopNotification("GSD", msg, "warning", "budget");
                         deps.logCmuxEvent(prefs, msg, "warning");
-                        await deps.pauseAuto(ctx, pi);
-                        debugLog("autoLoop", { phase: "exit", reason: "budget-pause" });
-                        break;
                     }
-                    ctx.ui.notify(`${msg} Continuing (enforcement: warn).`, "warning");
-                    deps.sendDesktopNotification("GSD", msg, "warning", "budget");
-                    deps.logCmuxEvent(prefs, msg, "warning");
-                }
-                else {
-                    // Data-driven 75/80/90% threshold notifications
-                    const threshold = BUDGET_THRESHOLDS.find((t) => newBudgetAlertLevel === t.pct);
-                    if (threshold) {
-                        s.lastBudgetAlertLevel =
-                            newBudgetAlertLevel;
+                    else if (threshold.pct < 100) {
+                        // Sub-100% — simple notification
                         const msg = `${threshold.label}: ${deps.formatCost(totalCost)} / ${deps.formatCost(budgetCeiling)}`;
                         ctx.ui.notify(msg, threshold.notifyLevel);
                         deps.sendDesktopNotification("GSD", msg, threshold.notifyLevel, "budget");
                         deps.logCmuxEvent(prefs, msg, threshold.cmuxLevel);
                     }
-                    else if (budgetAlertLevel === 0) {
-                        s.lastBudgetAlertLevel = 0;
-                    }
+                }
+                else if (budgetAlertLevel === 0) {
+                    s.lastBudgetAlertLevel = 0;
                 }
             }
             else {
@@ -586,10 +589,7 @@ export async function autoLoop(ctx, pi, s, deps) {
                 session: s,
             });
             if (dispatchResult.action === "stop") {
-                if (s.currentUnit) {
-                    await deps.closeoutUnit(ctx, s.basePath, s.currentUnit.type, s.currentUnit.id, s.currentUnit.startedAt, deps.buildSnapshotOpts(s.currentUnit.type, s.currentUnit.id));
-                }
-                await deps.stopAuto(ctx, pi, dispatchResult.reason);
+                await closeoutAndStop(ctx, pi, s, deps, dispatchResult.reason);
                 debugLog("autoLoop", { phase: "exit", reason: "dispatch-stop" });
                 break;
             }
@@ -602,55 +602,62 @@ export async function autoLoop(ctx, pi, s, deps) {
             let unitId = dispatchResult.unitId;
             let prompt = dispatchResult.prompt;
             const pauseAfterUatDispatch = dispatchResult.pauseAfterDispatch ?? false;
-            // ── Same-unit stuck counter with graduated recovery ──
+            // ── Sliding-window stuck detection with graduated recovery ──
             const derivedKey = `${unitType}/${unitId}`;
-            if (derivedKey === lastDerivedUnit && !s.pendingVerificationRetry) {
-                sameUnitCount++;
-                debugLog("autoLoop", {
-                    phase: "stuck-check",
-                    unitType,
-                    unitId,
-                    sameUnitCount,
-                });
-                if (sameUnitCount === 3) {
-                    // Level 1: try verifying the artifact — maybe it was written but not detected
-                    const artifactExists = deps.verifyExpectedArtifact(unitType, unitId, s.basePath);
-                    if (artifactExists) {
-                        debugLog("autoLoop", {
-                            phase: "stuck-recovery",
-                            level: 1,
-                            action: "artifact-found",
-                        });
-                        ctx.ui.notify(`Stuck recovery: artifact for ${unitType} ${unitId} found on disk. Invalidating caches.`, "info");
-                        deps.invalidateAllCaches();
-                        continue;
-                    }
-                    ctx.ui.notify(`Stuck on ${unitType} ${unitId} (attempt ${sameUnitCount}). Invalidating caches and retrying.`, "warning");
-                    deps.invalidateAllCaches();
-                }
-                else if (sameUnitCount === 5) {
-                    // Level 2: hard stop — genuinely stuck
+            if (!s.pendingVerificationRetry) {
+                recentUnits.push({ key: derivedKey });
+                if (recentUnits.length > STUCK_WINDOW_SIZE)
+                    recentUnits.shift();
+                const stuckSignal = detectStuck(recentUnits);
+                if (stuckSignal) {
                     debugLog("autoLoop", {
-                        phase: "stuck-detected",
+                        phase: "stuck-check",
                         unitType,
                         unitId,
-                        sameUnitCount,
+                        reason: stuckSignal.reason,
+                        recoveryAttempts: stuckRecoveryAttempts,
                     });
-                    await deps.stopAuto(ctx, pi, `Stuck: ${unitType} ${unitId} derived ${sameUnitCount} consecutive times without progress`);
-                    ctx.ui.notify(`Stuck on ${unitType} ${unitId} — deriveState returns the same unit after ${sameUnitCount} attempts. The expected artifact was not written.`, "error");
-                    break;
+                    if (stuckRecoveryAttempts === 0) {
+                        // Level 1: try verifying the artifact, then cache invalidation + retry
+                        stuckRecoveryAttempts++;
+                        const artifactExists = deps.verifyExpectedArtifact(unitType, unitId, s.basePath);
+                        if (artifactExists) {
+                            debugLog("autoLoop", {
+                                phase: "stuck-recovery",
+                                level: 1,
+                                action: "artifact-found",
+                            });
+                            ctx.ui.notify(`Stuck recovery: artifact for ${unitType} ${unitId} found on disk. Invalidating caches.`, "info");
+                            deps.invalidateAllCaches();
+                            continue;
+                        }
+                        ctx.ui.notify(`Stuck on ${unitType} ${unitId} (${stuckSignal.reason}). Invalidating caches and retrying.`, "warning");
+                        deps.invalidateAllCaches();
+                    }
+                    else {
+                        // Level 2: hard stop — genuinely stuck
+                        debugLog("autoLoop", {
+                            phase: "stuck-detected",
+                            unitType,
+                            unitId,
+                            reason: stuckSignal.reason,
+                        });
+                        await deps.stopAuto(ctx, pi, `Stuck: ${stuckSignal.reason}`);
+                        ctx.ui.notify(`Stuck on ${unitType} ${unitId} — ${stuckSignal.reason}. The expected artifact was not written.`, "error");
+                        break;
+                    }
                 }
-            }
-            else {
-                if (derivedKey !== lastDerivedUnit) {
-                    debugLog("autoLoop", {
-                        phase: "stuck-counter-reset",
-                        from: lastDerivedUnit,
-                        to: derivedKey,
-                    });
+                else {
+                    // Progress detected — reset recovery counter
+                    if (stuckRecoveryAttempts > 0) {
+                        debugLog("autoLoop", {
+                            phase: "stuck-counter-reset",
+                            from: recentUnits[recentUnits.length - 2]?.key ?? "",
+                            to: derivedKey,
+                        });
+                        stuckRecoveryAttempts = 0;
+                    }
                 }
-                lastDerivedUnit = derivedKey;
-                sameUnitCount = 0;
             }
             // Pre-dispatch hooks
             const preDispatchResult = deps.runPreDispatchHooks(unitType, unitId, prompt, s.basePath);
@@ -689,33 +696,6 @@ export async function autoLoop(ctx, pi, s, deps) {
                 s.currentUnit.type === unitType &&
                 s.currentUnit.id === unitId);
             const previousTier = s.currentUnitRouting?.tier;
-            // Closeout previous unit
-            if (s.currentUnit) {
-                await deps.closeoutUnit(ctx, s.basePath, s.currentUnit.type, s.currentUnit.id, s.currentUnit.startedAt, deps.buildSnapshotOpts(s.currentUnit.type, s.currentUnit.id));
-                if (s.currentUnitRouting) {
-                    const isRetry = s.currentUnit.type === unitType && s.currentUnit.id === unitId;
-                    deps.recordOutcome(s.currentUnit.type, s.currentUnitRouting.tier, !isRetry);
-                }
-                const closeoutKey = `${s.currentUnit.type}/${s.currentUnit.id}`;
-                const incomingKey = `${unitType}/${unitId}`;
-                const isHookUnit = s.currentUnit.type.startsWith("hook/");
-                const artifactVerified = isHookUnit ||
-                    deps.verifyExpectedArtifact(s.currentUnit.type, s.currentUnit.id, s.basePath);
-                if (closeoutKey !== incomingKey && artifactVerified) {
-                    s.completedUnits.push({
-                        type: s.currentUnit.type,
-                        id: s.currentUnit.id,
-                        startedAt: s.currentUnit.startedAt,
-                        finishedAt: Date.now(),
-                    });
-                    if (s.completedUnits.length > 200) {
-                        s.completedUnits = s.completedUnits.slice(-200);
-                    }
-                    deps.clearUnitRuntimeRecord(s.basePath, s.currentUnit.type, s.currentUnit.id);
-                    s.unitDispatchCount.delete(`${s.currentUnit.type}/${s.currentUnit.id}`);
-                    s.unitRecoveryCount.delete(`${s.currentUnit.type}/${s.currentUnit.id}`);
-                }
-            }
             s.currentUnit = { type: unitType, id: unitId, startedAt: Date.now() };
             deps.captureAvailableSkills();
             deps.writeUnitRuntimeRecord(s.basePath, unitType, unitId, s.currentUnit.startedAt, {
@@ -733,7 +713,6 @@ export async function autoLoop(ctx, pi, s, deps) {
             deps.updateProgressWidget(ctx, unitType, unitId, state);
             deps.ensurePreconditions(unitType, unitId, s.basePath, state);
             // Prompt injection
-            const MAX_RECOVERY_CHARS = 50_000;
             let finalPrompt = prompt;
             if (s.pendingVerificationRetry) {
                 const retryCtx = s.pendingVerificationRetry;
@@ -771,7 +750,7 @@ export async function autoLoop(ctx, pi, s, deps) {
             s.lastBaselineCharCount = undefined;
             if (deps.isDbAvailable()) {
                 try {
-                    const { inlineGsdRootFile } = await import("./auto-prompts.js");
+                    const { inlineGsdRootFile } = await importExtensionModule(import.meta.url, "./auto-prompts.js");
                     const [decisionsContent, requirementsContent, projectContent] = await Promise.all([
                         inlineGsdRootFile(s.basePath, "decisions.md", "Decisions"),
                         inlineGsdRootFile(s.basePath, "requirements.md", "Requirements"),
@@ -821,7 +800,7 @@ export async function autoLoop(ctx, pi, s, deps) {
                 unitType,
                 unitId,
             });
-            const unitResult = await runUnit(ctx, pi, s, unitType, unitId, finalPrompt, prefs);
+            const unitResult = await runUnit(ctx, pi, s, unitType, unitId, finalPrompt);
             debugLog("autoLoop", {
                 phase: "runUnit-end",
                 iteration,
@@ -829,12 +808,60 @@ export async function autoLoop(ctx, pi, s, deps) {
                 unitId,
                 status: unitResult.status,
             });
+            // Tag the most recent window entry with error info for stuck detection
+            if (unitResult.status === "error" || unitResult.status === "cancelled") {
+                const lastEntry = recentUnits[recentUnits.length - 1];
+                if (lastEntry) {
+                    lastEntry.error = `${unitResult.status}:${unitType}/${unitId}`;
+                }
+            }
+            else if (unitResult.event?.messages?.length) {
+                const lastMsg = unitResult.event.messages[unitResult.event.messages.length - 1];
+                const msgStr = typeof lastMsg === "string" ? lastMsg : JSON.stringify(lastMsg);
+                if (/error|fail|exception/i.test(msgStr)) {
+                    const lastEntry = recentUnits[recentUnits.length - 1];
+                    if (lastEntry) {
+                        lastEntry.error = msgStr.slice(0, 200);
+                    }
+                }
+            }
             if (unitResult.status === "cancelled") {
                 ctx.ui.notify(`Session creation timed out or was cancelled for ${unitType} ${unitId}. Will retry.`, "warning");
                 await deps.stopAuto(ctx, pi, "Session creation failed");
                 debugLog("autoLoop", { phase: "exit", reason: "session-failed" });
                 break;
             }
+            // ── Immediate unit closeout (metrics, activity log, memory) ────────
+            // Run right after runUnit() returns so telemetry is never lost to a
+            // crash between iterations.
+            await deps.closeoutUnit(ctx, s.basePath, unitType, unitId, s.currentUnit.startedAt, deps.buildSnapshotOpts(unitType, unitId));
+            if (s.currentUnitRouting) {
+                deps.recordOutcome(unitType, s.currentUnitRouting.tier, true);
+            }
+            const isHookUnit = unitType.startsWith("hook/");
+            const artifactVerified = isHookUnit ||
+                deps.verifyExpectedArtifact(unitType, unitId, s.basePath);
+            if (artifactVerified) {
+                s.completedUnits.push({
+                    type: unitType,
+                    id: unitId,
+                    startedAt: s.currentUnit.startedAt,
+                    finishedAt: Date.now(),
+                });
+                if (s.completedUnits.length > 200) {
+                    s.completedUnits = s.completedUnits.slice(-200);
+                }
+                // Flush completed-units to disk so the record survives crashes
+                try {
+                    const completedKeysPath = join(gsdRoot(s.basePath), "completed-units.json");
+                    const keys = s.completedUnits.map((u) => `${u.type}/${u.id}`);
+                    atomicWriteSync(completedKeysPath, JSON.stringify(keys, null, 2));
+                }
+                catch { /* non-fatal: disk flush failure */ }
+                deps.clearUnitRuntimeRecord(s.basePath, unitType, unitId);
+                s.unitDispatchCount.delete(`${unitType}/${unitId}`);
+                s.unitRecoveryCount.delete(`${unitType}/${unitId}`);
+            }
             // ── Phase 5: Finalize ───────────────────────────────────────────────
             debugLog("autoLoop", { phase: "finalize", iteration });
             // Clear unit timeout (unit completed)
@@ -935,7 +962,7 @@ export async function autoLoop(ctx, pi, s, deps) {
                 const sidecarSessionFile = deps.getSessionFile(ctx);
                 deps.writeLock(deps.lockBase(), item.unitType, item.unitId, s.completedUnits.length, sidecarSessionFile);
                 // Execute via standard runUnit
-                const sidecarResult = await runUnit(ctx, pi, s, item.unitType, item.unitId, item.prompt, prefs);
+                const sidecarResult = await runUnit(ctx, pi, s, item.unitType, item.unitId, item.prompt);
                 deps.clearUnitTimeout();
                 if (sidecarResult.status === "cancelled") {
                     ctx.ui.notify(`Sidecar unit ${item.unitType} ${item.unitId} session cancelled. Stopping.`, "warning");
@@ -943,6 +970,8 @@ export async function autoLoop(ctx, pi, s, deps) {
                     sidecarBroke = true;
                     break;
                 }
+                // Immediate closeout for sidecar unit
+                await deps.closeoutUnit(ctx, s.basePath, item.unitType, item.unitId, sidecarStartedAt, deps.buildSnapshotOpts(item.unitType, item.unitId));
                 // Run pre-verification for the sidecar unit (lightweight path)
                 const sidecarPreOpts = item.kind === "hook"
                     ? { skipSettleDelay: true, skipDoctor: true, skipStateRebuild: true, skipWorktreeSync: true }
@@ -1020,6 +1049,6 @@ export async function autoLoop(ctx, pi, s, deps) {
             }
         }
     }
-    _activeSession = null;
+    _currentResolve = null;
     debugLog("autoLoop", { phase: "exit", totalIterations: iteration });
 }