gsd-pi 2.38.0-dev.4d4d14a → 2.38.0-dev.5492881

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

@@ -9,8 +9,12 @@
  * (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,6 +22,8 @@ import { debugLog } from "./debug-logger.js";
  * generous headroom including retries and sidecar work.
  */
 const MAX_LOOP_ITERATIONS = 500;
+/** 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. */
@@ -81,6 +87,50 @@ export function _resetPendingResolve() {
 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 ─────────────────────────────────────────────────────────────────
 /**
  * Execute a single unit: create a new session, send the prompt, and await
@@ -163,9 +213,9 @@ export async function runUnit(ctx, pi, s, unitType, unitId, prompt) {
  * Extracted from the milestone-transition block in autoLoop.
  */
 async function generateMilestoneReport(s, ctx, milestoneId) {
-    const { loadVisualizerData } = await import("./visualizer-data.js");
-    const { generateHtmlReport } = await import("./export-html.js");
-    const { writeReportSnapshot } = await import("./reports.js");
+    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);
@@ -223,8 +273,10 @@ async function closeoutAndStop(ctx, pi, s, deps, reason) {
 export async function autoLoop(ctx, pi, s, deps) {
     debugLog("autoLoop", { phase: "enter" });
     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++;
@@ -244,6 +296,18 @@ 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;
+            // ── Check sidecar queue before deriveState ──
+            let sidecarItem;
+            if (s.sidecarQueue.length > 0) {
+                sidecarItem = s.sidecarQueue.shift();
+                debugLog("autoLoop", {
+                    phase: "sidecar-dequeue",
+                    kind: sidecarItem.kind,
+                    unitType: sidecarItem.unitType,
+                    unitId: sidecarItem.unitId,
+                });
+            }
             const sessionLockBase = deps.lockBase();
             if (sessionLockBase) {
                 const lockStatus = deps.validateSessionLock(sessionLockBase);
@@ -263,369 +327,436 @@ export async function autoLoop(ctx, pi, s, deps) {
                     break;
                 }
             }
-            // ── Phase 1: Pre-dispatch ───────────────────────────────────────────
-            // Resource version guard
-            const staleMsg = deps.checkResourcesStale(s.resourceVersionOnStart);
-            if (staleMsg) {
-                await deps.stopAuto(ctx, pi, staleMsg);
-                debugLog("autoLoop", { phase: "exit", reason: "resources-stale" });
-                break;
-            }
-            deps.invalidateAllCaches();
-            s.lastPromptCharCount = undefined;
-            s.lastBaselineCharCount = undefined;
-            // Pre-dispatch health gate
-            try {
-                const healthGate = await deps.preDispatchHealthGate(s.basePath);
-                if (healthGate.fixesApplied.length > 0) {
-                    ctx.ui.notify(`Pre-dispatch: ${healthGate.fixesApplied.join(", ")}`, "info");
-                }
-                if (!healthGate.proceed) {
-                    ctx.ui.notify(healthGate.reason ?? "Pre-dispatch health check failed.", "error");
-                    await deps.pauseAuto(ctx, pi);
-                    debugLog("autoLoop", { phase: "exit", reason: "health-gate-failed" });
+            // Variables shared between the sidecar and normal paths
+            let unitType;
+            let unitId;
+            let prompt;
+            let pauseAfterUatDispatch = false;
+            let state;
+            let mid;
+            let midTitle;
+            let observabilityIssues = [];
+            if (!sidecarItem) {
+                // ── Phase 1: Pre-dispatch ───────────────────────────────────────────
+                // Resource version guard
+                const staleMsg = deps.checkResourcesStale(s.resourceVersionOnStart);
+                if (staleMsg) {
+                    await deps.stopAuto(ctx, pi, staleMsg);
+                    debugLog("autoLoop", { phase: "exit", reason: "resources-stale" });
                     break;
                 }
-            }
-            catch {
-                // Non-fatal
-            }
-            // Sync project root artifacts into worktree
-            if (s.originalBasePath &&
-                s.basePath !== s.originalBasePath &&
-                s.currentMilestoneId) {
-                deps.syncProjectRootToWorktree(s.originalBasePath, s.basePath, s.currentMilestoneId);
-            }
-            // Derive state
-            let state = await deps.deriveState(s.basePath);
-            deps.syncCmuxSidebar(deps.loadEffectiveGSDPreferences()?.preferences, state);
-            let mid = state.activeMilestone?.id;
-            let midTitle = state.activeMilestone?.title;
-            debugLog("autoLoop", {
-                phase: "state-derived",
-                iteration,
-                mid,
-                statePhase: state.phase,
-            });
-            // ── Milestone transition ────────────────────────────────────────────
-            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;
-                if (vizPrefs?.auto_visualize) {
-                    ctx.ui.notify("Run /gsd visualize to see progress overview.", "info");
-                }
-                if (vizPrefs?.auto_report !== false) {
-                    try {
-                        await generateMilestoneReport(s, ctx, s.currentMilestoneId);
+                deps.invalidateAllCaches();
+                s.lastPromptCharCount = undefined;
+                s.lastBaselineCharCount = undefined;
+                // Pre-dispatch health gate
+                try {
+                    const healthGate = await deps.preDispatchHealthGate(s.basePath);
+                    if (healthGate.fixesApplied.length > 0) {
+                        ctx.ui.notify(`Pre-dispatch: ${healthGate.fixesApplied.join(", ")}`, "info");
                     }
-                    catch (err) {
-                        ctx.ui.notify(`Report generation failed: ${err instanceof Error ? err.message : String(err)}`, "warning");
+                    if (!healthGate.proceed) {
+                        ctx.ui.notify(healthGate.reason ?? "Pre-dispatch health check failed.", "error");
+                        await deps.pauseAuto(ctx, pi);
+                        debugLog("autoLoop", { phase: "exit", reason: "health-gate-failed" });
+                        break;
                     }
                 }
-                // Reset dispatch counters for new milestone
-                s.unitDispatchCount.clear();
-                s.unitRecoveryCount.clear();
-                s.unitLifetimeDispatches.clear();
-                lastDerivedUnit = "";
-                sameUnitCount = 0;
-                // Worktree lifecycle on milestone transition — merge current, enter next
-                deps.resolver.mergeAndExit(s.currentMilestoneId, ctx.ui);
-                deps.invalidateAllCaches();
+                catch {
+                    // Non-fatal
+                }
+                // Sync project root artifacts into worktree
+                if (s.originalBasePath &&
+                    s.basePath !== s.originalBasePath &&
+                    s.currentMilestoneId) {
+                    deps.syncProjectRootToWorktree(s.originalBasePath, s.basePath, s.currentMilestoneId);
+                }
+                // Derive state
                 state = await deps.deriveState(s.basePath);
+                deps.syncCmuxSidebar(prefs, state);
                 mid = state.activeMilestone?.id;
                 midTitle = state.activeMilestone?.title;
+                debugLog("autoLoop", {
+                    phase: "state-derived",
+                    iteration,
+                    mid,
+                    statePhase: state.phase,
+                });
+                // ── Milestone transition ────────────────────────────────────────────
+                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(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 {
+                            await generateMilestoneReport(s, ctx, s.currentMilestoneId);
+                        }
+                        catch (err) {
+                            ctx.ui.notify(`Report generation failed: ${err instanceof Error ? err.message : String(err)}`, "warning");
+                        }
+                    }
+                    // Reset dispatch counters for new milestone
+                    s.unitDispatchCount.clear();
+                    s.unitRecoveryCount.clear();
+                    s.unitLifetimeDispatches.clear();
+                    recentUnits.length = 0;
+                    stuckRecoveryAttempts = 0;
+                    // Worktree lifecycle on milestone transition — merge current, enter next
+                    deps.resolver.mergeAndExit(s.currentMilestoneId, ctx.ui);
+                    // Opt-in: create draft PR on milestone completion
+                    if (prefs?.git?.auto_pr) {
+                        try {
+                            const { createDraftPR } = await import("./git-service.js");
+                            const prUrl = createDraftPR(s.basePath, s.currentMilestoneId, `[GSD] ${s.currentMilestoneId} complete`, `Milestone ${s.currentMilestoneId} completed by GSD auto-mode.\n\nSee .gsd/${s.currentMilestoneId}/ for details.`);
+                            if (prUrl) {
+                                ctx.ui.notify(`Draft PR created: ${prUrl}`, "info");
+                            }
+                        }
+                        catch {
+                            // Non-fatal — PR creation is best-effort
+                        }
+                    }
+                    deps.invalidateAllCaches();
+                    state = await deps.deriveState(s.basePath);
+                    mid = state.activeMilestone?.id;
+                    midTitle = state.activeMilestone?.title;
+                    if (mid) {
+                        if (deps.getIsolationMode() !== "none") {
+                            deps.captureIntegrationBranch(s.basePath, mid, {
+                                commitDocs: prefs?.git?.commit_docs,
+                            });
+                        }
+                        deps.resolver.enterMilestone(mid, ctx.ui);
+                    }
+                    else {
+                        // mid is undefined — no milestone to capture integration branch for
+                    }
+                    const pendingIds = state.registry
+                        .filter((m) => m.status !== "complete" && m.status !== "parked")
+                        .map((m) => m.id);
+                    deps.pruneQueueOrder(s.basePath, pendingIds);
+                }
                 if (mid) {
-                    if (deps.getIsolationMode() !== "none") {
-                        deps.captureIntegrationBranch(s.basePath, mid, {
-                            commitDocs: deps.loadEffectiveGSDPreferences()?.preferences?.git
-                                ?.commit_docs,
-                        });
+                    s.currentMilestoneId = mid;
+                    deps.setActiveMilestoneId(s.basePath, mid);
+                }
+                // ── Terminal conditions ──────────────────────────────────────────────
+                if (!mid) {
+                    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));
                     }
-                    deps.resolver.enterMilestone(mid, ctx.ui);
+                    const incomplete = state.registry.filter((m) => m.status !== "complete" && m.status !== "parked");
+                    if (incomplete.length === 0 && state.registry.length > 0) {
+                        // All milestones complete — merge milestone branch before stopping
+                        if (s.currentMilestoneId) {
+                            deps.resolver.mergeAndExit(s.currentMilestoneId, ctx.ui);
+                            // Opt-in: create draft PR on milestone completion
+                            if (prefs?.git?.auto_pr) {
+                                try {
+                                    const { createDraftPR } = await import("./git-service.js");
+                                    const prUrl = createDraftPR(s.basePath, s.currentMilestoneId, `[GSD] ${s.currentMilestoneId} complete`, `Milestone ${s.currentMilestoneId} completed by GSD auto-mode.\n\nSee .gsd/${s.currentMilestoneId}/ for details.`);
+                                    if (prUrl) {
+                                        ctx.ui.notify(`Draft PR created: ${prUrl}`, "info");
+                                    }
+                                }
+                                catch {
+                                    // Non-fatal — PR creation is best-effort
+                                }
+                            }
+                        }
+                        deps.sendDesktopNotification("GSD", "All milestones complete!", "success", "milestone");
+                        deps.logCmuxEvent(prefs, "All milestones complete.", "success");
+                        await deps.stopAuto(ctx, pi, "All milestones complete");
+                    }
+                    else if (incomplete.length === 0 && state.registry.length === 0) {
+                        // Empty registry — no milestones visible, likely a path resolution bug
+                        const diag = `basePath=${s.basePath}, phase=${state.phase}`;
+                        ctx.ui.notify(`No milestones visible in current scope. Possible path resolution issue.\n   Diagnostic: ${diag}`, "error");
+                        await deps.stopAuto(ctx, pi, `No milestones found — check basePath resolution`);
+                    }
+                    else if (state.phase === "blocked") {
+                        const blockerMsg = `Blocked: ${state.blockers.join(", ")}`;
+                        await deps.stopAuto(ctx, pi, blockerMsg);
+                        ctx.ui.notify(`${blockerMsg}. Fix and run /gsd auto.`, "warning");
+                        deps.sendDesktopNotification("GSD", blockerMsg, "error", "attention");
+                        deps.logCmuxEvent(prefs, blockerMsg, "error");
+                    }
+                    else {
+                        const ids = incomplete.map((m) => m.id).join(", ");
+                        const diag = `basePath=${s.basePath}, milestones=[${state.registry.map((m) => `${m.id}:${m.status}`).join(", ")}], phase=${state.phase}`;
+                        ctx.ui.notify(`Unexpected: ${incomplete.length} incomplete milestone(s) (${ids}) but no active milestone.\n   Diagnostic: ${diag}`, "error");
+                        await deps.stopAuto(ctx, pi, `No active milestone — ${incomplete.length} incomplete (${ids}), see diagnostic above`);
+                    }
+                    debugLog("autoLoop", { phase: "exit", reason: "no-active-milestone" });
+                    break;
                 }
-                else {
-                    // mid is undefined — no milestone to capture integration branch for
+                if (!midTitle) {
+                    midTitle = mid;
+                    ctx.ui.notify(`Milestone ${mid} has no title in roadmap — using ID as fallback.`, "warning");
                 }
-                const pendingIds = state.registry
-                    .filter((m) => m.status !== "complete" && m.status !== "parked")
-                    .map((m) => m.id);
-                deps.pruneQueueOrder(s.basePath, pendingIds);
-            }
-            if (mid) {
-                s.currentMilestoneId = mid;
-                deps.setActiveMilestoneId(s.basePath, mid);
-            }
-            // ── Terminal conditions ──────────────────────────────────────────────
-            if (!mid) {
-                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 incomplete = state.registry.filter((m) => m.status !== "complete" && m.status !== "parked");
-                if (incomplete.length === 0 && state.registry.length > 0) {
-                    // All milestones complete — merge milestone branch before stopping
+                // Mid-merge safety check
+                if (deps.reconcileMergeState(s.basePath, ctx)) {
+                    deps.invalidateAllCaches();
+                    state = await deps.deriveState(s.basePath);
+                    mid = state.activeMilestone?.id;
+                    midTitle = state.activeMilestone?.title;
+                }
+                if (!mid || !midTitle) {
+                    const noMilestoneReason = !mid
+                        ? "No active milestone after merge reconciliation"
+                        : `Milestone ${mid} has no title after reconciliation`;
+                    await closeoutAndStop(ctx, pi, s, deps, noMilestoneReason);
+                    debugLog("autoLoop", {
+                        phase: "exit",
+                        reason: "no-milestone-after-reconciliation",
+                    });
+                    break;
+                }
+                // Terminal: complete
+                if (state.phase === "complete") {
+                    // Milestone merge on complete (before closeout so branch state is clean)
                     if (s.currentMilestoneId) {
                         deps.resolver.mergeAndExit(s.currentMilestoneId, ctx.ui);
+                        // Opt-in: create draft PR on milestone completion
+                        if (prefs?.git?.auto_pr) {
+                            try {
+                                const { createDraftPR } = await import("./git-service.js");
+                                const prUrl = createDraftPR(s.basePath, s.currentMilestoneId, `[GSD] ${s.currentMilestoneId} complete`, `Milestone ${s.currentMilestoneId} completed by GSD auto-mode.\n\nSee .gsd/${s.currentMilestoneId}/ for details.`);
+                                if (prUrl) {
+                                    ctx.ui.notify(`Draft PR created: ${prUrl}`, "info");
+                                }
+                            }
+                            catch {
+                                // Non-fatal — PR creation is best-effort
+                            }
+                        }
                     }
-                    deps.sendDesktopNotification("GSD", "All milestones complete!", "success", "milestone");
-                    deps.logCmuxEvent(deps.loadEffectiveGSDPreferences()?.preferences, "All milestones complete.", "success");
-                    await deps.stopAuto(ctx, pi, "All milestones complete");
-                }
-                else if (incomplete.length === 0 && state.registry.length === 0) {
-                    // Empty registry — no milestones visible, likely a path resolution bug
-                    const diag = `basePath=${s.basePath}, phase=${state.phase}`;
-                    ctx.ui.notify(`No milestones visible in current scope. Possible path resolution issue.\n   Diagnostic: ${diag}`, "error");
-                    await deps.stopAuto(ctx, pi, `No milestones found — check basePath resolution`);
+                    deps.sendDesktopNotification("GSD", `Milestone ${mid} complete!`, "success", "milestone");
+                    deps.logCmuxEvent(prefs, `Milestone ${mid} complete.`, "success");
+                    await closeoutAndStop(ctx, pi, s, deps, `Milestone ${mid} complete`);
+                    debugLog("autoLoop", { phase: "exit", reason: "milestone-complete" });
+                    break;
                 }
-                else if (state.phase === "blocked") {
+                // Terminal: blocked
+                if (state.phase === "blocked") {
                     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");
-                }
-                else {
-                    const ids = incomplete.map((m) => m.id).join(", ");
-                    const diag = `basePath=${s.basePath}, milestones=[${state.registry.map((m) => `${m.id}:${m.status}`).join(", ")}], phase=${state.phase}`;
-                    ctx.ui.notify(`Unexpected: ${incomplete.length} incomplete milestone(s) (${ids}) but no active milestone.\n   Diagnostic: ${diag}`, "error");
-                    await deps.stopAuto(ctx, pi, `No active milestone — ${incomplete.length} incomplete (${ids}), see diagnostic above`);
-                }
-                debugLog("autoLoop", { phase: "exit", reason: "no-active-milestone" });
-                break;
-            }
-            if (!midTitle) {
-                midTitle = mid;
-                ctx.ui.notify(`Milestone ${mid} has no title in roadmap — using ID as fallback.`, "warning");
-            }
-            // Mid-merge safety check
-            if (deps.reconcileMergeState(s.basePath, ctx)) {
-                deps.invalidateAllCaches();
-                state = await deps.deriveState(s.basePath);
-                mid = state.activeMilestone?.id;
-                midTitle = state.activeMilestone?.title;
-            }
-            if (!mid || !midTitle) {
-                const noMilestoneReason = !mid
-                    ? "No active milestone after merge reconciliation"
-                    : `Milestone ${mid} has no title after reconciliation`;
-                await closeoutAndStop(ctx, pi, s, deps, noMilestoneReason);
-                debugLog("autoLoop", {
-                    phase: "exit",
-                    reason: "no-milestone-after-reconciliation",
-                });
-                break;
-            }
-            // Terminal: complete
-            if (state.phase === "complete") {
-                // Milestone merge on complete (before closeout so branch state is clean)
-                if (s.currentMilestoneId) {
-                    deps.resolver.mergeAndExit(s.currentMilestoneId, ctx.ui);
+                    deps.logCmuxEvent(prefs, blockerMsg, "error");
+                    debugLog("autoLoop", { phase: "exit", reason: "blocked" });
+                    break;
                 }
-                deps.sendDesktopNotification("GSD", `Milestone ${mid} complete!`, "success", "milestone");
-                deps.logCmuxEvent(deps.loadEffectiveGSDPreferences()?.preferences, `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") {
-                const blockerMsg = `Blocked: ${state.blockers.join(", ")}`;
-                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");
-                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) {
-                const currentLedger = deps.getLedger();
-                const totalCost = currentLedger
-                    ? deps.getProjectTotals(currentLedger.units).cost
-                    : 0;
-                const budgetPct = totalCost / budgetCeiling;
-                const budgetAlertLevel = deps.getBudgetAlertLevel(budgetPct);
-                const newBudgetAlertLevel = deps.getNewBudgetAlertLevel(s.lastBudgetAlertLevel, budgetPct);
-                const enforcement = prefs?.budget_enforcement ?? "pause";
-                const budgetEnforcementAction = deps.getBudgetEnforcementAction(enforcement, budgetPct);
-                // Data-driven threshold check — loop descending, fire first match
-                const threshold = BUDGET_THRESHOLDS.find((t) => newBudgetAlertLevel >= t.pct);
-                if (threshold) {
-                    s.lastBudgetAlertLevel =
-                        newBudgetAlertLevel;
-                    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");
+                // ── Phase 2: Guards ─────────────────────────────────────────────────
+                // Budget ceiling guard
+                const budgetCeiling = prefs?.budget_ceiling;
+                if (budgetCeiling !== undefined && budgetCeiling > 0) {
+                    const currentLedger = deps.getLedger();
+                    const totalCost = currentLedger
+                        ? deps.getProjectTotals(currentLedger.units).cost
+                        : 0;
+                    const budgetPct = totalCost / budgetCeiling;
+                    const budgetAlertLevel = deps.getBudgetAlertLevel(budgetPct);
+                    const newBudgetAlertLevel = deps.getNewBudgetAlertLevel(s.lastBudgetAlertLevel, budgetPct);
+                    const enforcement = prefs?.budget_enforcement ?? "pause";
+                    const budgetEnforcementAction = deps.getBudgetEnforcementAction(enforcement, budgetPct);
+                    // Data-driven threshold check — loop descending, fire first match
+                    const threshold = BUDGET_THRESHOLDS.find((t) => newBudgetAlertLevel >= t.pct);
+                    if (threshold) {
+                        s.lastBudgetAlertLevel =
+                            newBudgetAlertLevel;
+                        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 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 (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) {
+                else {
                     s.lastBudgetAlertLevel = 0;
                 }
-            }
-            else {
-                s.lastBudgetAlertLevel = 0;
-            }
-            // Context window guard
-            const contextThreshold = prefs?.context_pause_threshold ?? 0;
-            if (contextThreshold > 0 && s.cmdCtx) {
-                const contextUsage = s.cmdCtx.getContextUsage();
-                if (contextUsage &&
-                    contextUsage.percent !== null &&
-                    contextUsage.percent >= contextThreshold) {
-                    const msg = `Context window at ${contextUsage.percent}% (threshold: ${contextThreshold}%). Pausing to prevent truncated output.`;
-                    ctx.ui.notify(`${msg} Run /gsd auto to continue (will start fresh session).`, "warning");
-                    deps.sendDesktopNotification("GSD", `Context ${contextUsage.percent}% — paused`, "warning", "attention");
-                    await deps.pauseAuto(ctx, pi);
-                    debugLog("autoLoop", { phase: "exit", reason: "context-window" });
-                    break;
-                }
-            }
-            // Secrets re-check gate
-            try {
-                const manifestStatus = await deps.getManifestStatus(s.basePath, mid, s.originalBasePath);
-                if (manifestStatus && manifestStatus.pending.length > 0) {
-                    const result = await deps.collectSecretsFromManifest(s.basePath, mid, ctx);
-                    if (result &&
-                        result.applied &&
-                        result.skipped &&
-                        result.existingSkipped) {
-                        ctx.ui.notify(`Secrets collected: ${result.applied.length} applied, ${result.skipped.length} skipped, ${result.existingSkipped.length} already set.`, "info");
+                // Context window guard
+                const contextThreshold = prefs?.context_pause_threshold ?? 0;
+                if (contextThreshold > 0 && s.cmdCtx) {
+                    const contextUsage = s.cmdCtx.getContextUsage();
+                    if (contextUsage &&
+                        contextUsage.percent !== null &&
+                        contextUsage.percent >= contextThreshold) {
+                        const msg = `Context window at ${contextUsage.percent}% (threshold: ${contextThreshold}%). Pausing to prevent truncated output.`;
+                        ctx.ui.notify(`${msg} Run /gsd auto to continue (will start fresh session).`, "warning");
+                        deps.sendDesktopNotification("GSD", `Context ${contextUsage.percent}% — paused`, "warning", "attention");
+                        await deps.pauseAuto(ctx, pi);
+                        debugLog("autoLoop", { phase: "exit", reason: "context-window" });
+                        break;
                     }
-                    else {
-                        ctx.ui.notify("Secrets collection skipped.", "info");
+                }
+                // Secrets re-check gate
+                try {
+                    const manifestStatus = await deps.getManifestStatus(s.basePath, mid, s.originalBasePath);
+                    if (manifestStatus && manifestStatus.pending.length > 0) {
+                        const result = await deps.collectSecretsFromManifest(s.basePath, mid, ctx);
+                        if (result &&
+                            result.applied &&
+                            result.skipped &&
+                            result.existingSkipped) {
+                            ctx.ui.notify(`Secrets collected: ${result.applied.length} applied, ${result.skipped.length} skipped, ${result.existingSkipped.length} already set.`, "info");
+                        }
+                        else {
+                            ctx.ui.notify("Secrets collection skipped.", "info");
+                        }
                     }
                 }
-            }
-            catch (err) {
-                ctx.ui.notify(`Secrets collection error: ${err instanceof Error ? err.message : String(err)}. Continuing with next task.`, "warning");
-            }
-            // ── Phase 3: Dispatch resolution ────────────────────────────────────
-            debugLog("autoLoop", { phase: "dispatch-resolve", iteration });
-            const dispatchResult = await deps.resolveDispatch({
-                basePath: s.basePath,
-                mid,
-                midTitle: midTitle,
-                state,
-                prefs,
-                session: s,
-            });
-            if (dispatchResult.action === "stop") {
-                await closeoutAndStop(ctx, pi, s, deps, dispatchResult.reason);
-                debugLog("autoLoop", { phase: "exit", reason: "dispatch-stop" });
-                break;
-            }
-            if (dispatchResult.action !== "dispatch") {
-                // Non-dispatch action (e.g. "skip") — re-derive state
-                await new Promise((r) => setImmediate(r));
-                continue;
-            }
-            let unitType = dispatchResult.unitType;
-            let unitId = dispatchResult.unitId;
-            let prompt = dispatchResult.prompt;
-            const pauseAfterUatDispatch = dispatchResult.pauseAfterDispatch ?? false;
-            // ── Same-unit stuck counter with graduated recovery ──
-            const derivedKey = `${unitType}/${unitId}`;
-            if (derivedKey === lastDerivedUnit && !s.pendingVerificationRetry) {
-                sameUnitCount++;
-                debugLog("autoLoop", {
-                    phase: "stuck-check",
-                    unitType,
-                    unitId,
-                    sameUnitCount,
+                catch (err) {
+                    ctx.ui.notify(`Secrets collection error: ${err instanceof Error ? err.message : String(err)}. Continuing with next task.`, "warning");
+                }
+                // ── Phase 3: Dispatch resolution ────────────────────────────────────
+                debugLog("autoLoop", { phase: "dispatch-resolve", iteration });
+                const dispatchResult = await deps.resolveDispatch({
+                    basePath: s.basePath,
+                    mid,
+                    midTitle: midTitle,
+                    state,
+                    prefs,
+                    session: s,
                 });
-                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) {
+                if (dispatchResult.action === "stop") {
+                    await closeoutAndStop(ctx, pi, s, deps, dispatchResult.reason);
+                    debugLog("autoLoop", { phase: "exit", reason: "dispatch-stop" });
+                    break;
+                }
+                if (dispatchResult.action !== "dispatch") {
+                    // Non-dispatch action (e.g. "skip") — re-derive state
+                    await new Promise((r) => setImmediate(r));
+                    continue;
+                }
+                unitType = dispatchResult.unitType;
+                unitId = dispatchResult.unitId;
+                prompt = dispatchResult.prompt;
+                pauseAfterUatDispatch = dispatchResult.pauseAfterDispatch ?? false;
+                // ── Sliding-window stuck detection with graduated recovery ──
+                const derivedKey = `${unitType}/${unitId}`;
+                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-recovery",
-                            level: 1,
-                            action: "artifact-found",
+                            phase: "stuck-check",
+                            unitType,
+                            unitId,
+                            reason: stuckSignal.reason,
+                            recoveryAttempts: stuckRecoveryAttempts,
                         });
-                        ctx.ui.notify(`Stuck recovery: artifact for ${unitType} ${unitId} found on disk. Invalidating caches.`, "info");
-                        deps.invalidateAllCaches();
-                        continue;
+                        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 {
+                        // Progress detected — reset recovery counter
+                        if (stuckRecoveryAttempts > 0) {
+                            debugLog("autoLoop", {
+                                phase: "stuck-counter-reset",
+                                from: recentUnits[recentUnits.length - 2]?.key ?? "",
+                                to: derivedKey,
+                            });
+                            stuckRecoveryAttempts = 0;
+                        }
                     }
-                    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
-                    debugLog("autoLoop", {
-                        phase: "stuck-detected",
-                        unitType,
-                        unitId,
-                        sameUnitCount,
-                    });
-                    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");
+                // Pre-dispatch hooks
+                const preDispatchResult = deps.runPreDispatchHooks(unitType, unitId, prompt, s.basePath);
+                if (preDispatchResult.firedHooks.length > 0) {
+                    ctx.ui.notify(`Pre-dispatch hook${preDispatchResult.firedHooks.length > 1 ? "s" : ""}: ${preDispatchResult.firedHooks.join(", ")}`, "info");
+                }
+                if (preDispatchResult.action === "skip") {
+                    ctx.ui.notify(`Skipping ${unitType} ${unitId} (pre-dispatch hook).`, "info");
+                    await new Promise((r) => setImmediate(r));
+                    continue;
+                }
+                if (preDispatchResult.action === "replace") {
+                    prompt = preDispatchResult.prompt ?? prompt;
+                    if (preDispatchResult.unitType)
+                        unitType = preDispatchResult.unitType;
+                }
+                else if (preDispatchResult.prompt) {
+                    prompt = preDispatchResult.prompt;
+                }
+                const priorSliceBlocker = deps.getPriorSliceCompletionBlocker(s.basePath, deps.getMainBranch(s.basePath), unitType, unitId);
+                if (priorSliceBlocker) {
+                    await deps.stopAuto(ctx, pi, priorSliceBlocker);
+                    debugLog("autoLoop", { phase: "exit", reason: "prior-slice-blocker" });
                     break;
                 }
+                observabilityIssues = await deps.collectObservabilityWarnings(ctx, s.basePath, unitType, unitId);
+                // Derive state for shared use in execution phase
+                // (state, mid, midTitle already set above)
             }
             else {
-                if (derivedKey !== lastDerivedUnit) {
-                    debugLog("autoLoop", {
-                        phase: "stuck-counter-reset",
-                        from: lastDerivedUnit,
-                        to: derivedKey,
-                    });
-                }
-                lastDerivedUnit = derivedKey;
-                sameUnitCount = 0;
-            }
-            // Pre-dispatch hooks
-            const preDispatchResult = deps.runPreDispatchHooks(unitType, unitId, prompt, s.basePath);
-            if (preDispatchResult.firedHooks.length > 0) {
-                ctx.ui.notify(`Pre-dispatch hook${preDispatchResult.firedHooks.length > 1 ? "s" : ""}: ${preDispatchResult.firedHooks.join(", ")}`, "info");
-            }
-            if (preDispatchResult.action === "skip") {
-                ctx.ui.notify(`Skipping ${unitType} ${unitId} (pre-dispatch hook).`, "info");
-                await new Promise((r) => setImmediate(r));
-                continue;
-            }
-            if (preDispatchResult.action === "replace") {
-                prompt = preDispatchResult.prompt ?? prompt;
-                if (preDispatchResult.unitType)
-                    unitType = preDispatchResult.unitType;
-            }
-            else if (preDispatchResult.prompt) {
-                prompt = preDispatchResult.prompt;
-            }
-            const priorSliceBlocker = deps.getPriorSliceCompletionBlocker(s.basePath, deps.getMainBranch(s.basePath), unitType, unitId);
-            if (priorSliceBlocker) {
-                await deps.stopAuto(ctx, pi, priorSliceBlocker);
-                debugLog("autoLoop", { phase: "exit", reason: "prior-slice-blocker" });
-                break;
+                // ── Sidecar path: use values from the sidecar item directly ──
+                unitType = sidecarItem.unitType;
+                unitId = sidecarItem.unitId;
+                prompt = sidecarItem.prompt;
+                // Derive minimal state for progress widget / execution context
+                state = await deps.deriveState(s.basePath);
+                mid = state.activeMilestone?.id;
+                midTitle = state.activeMilestone?.title;
             }
-            const observabilityIssues = await deps.collectObservabilityWarnings(ctx, s.basePath, unitType, unitId);
             // ── Phase 4: Unit execution ─────────────────────────────────────────
             debugLog("autoLoop", {
                 phase: "unit-execution",
@@ -638,33 +769,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 isRetryForOutcome = s.currentUnit.type === unitType && s.currentUnit.id === unitId;
-                    deps.recordOutcome(s.currentUnit.type, s.currentUnitRouting.tier, !isRetryForOutcome);
-                }
-                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, {
@@ -682,7 +786,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;
@@ -720,7 +823,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"),
@@ -743,8 +846,8 @@ export async function autoLoop(ctx, pi, s, deps) {
                 const msg = reorderErr instanceof Error ? reorderErr.message : String(reorderErr);
                 process.stderr.write(`[gsd] prompt reorder failed (non-fatal): ${msg}\n`);
             }
-            // Select and apply model (with tier escalation on retry)
-            const modelResult = await deps.selectAndApplyModel(ctx, pi, unitType, unitId, s.basePath, prefs, s.verbose, s.autoModeStartModel, { isRetry, previousTier });
+            // Select and apply model (with tier escalation on retry — normal units only)
+            const modelResult = await deps.selectAndApplyModel(ctx, pi, unitType, unitId, s.basePath, prefs, s.verbose, s.autoModeStartModel, sidecarItem ? undefined : { isRetry, previousTier });
             s.currentUnitRouting =
                 modelResult.routing;
             // Start unit supervision
@@ -778,12 +881,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)
@@ -800,7 +951,13 @@ export async function autoLoop(ctx, pi, s, deps) {
                 updateProgressWidget: deps.updateProgressWidget,
             };
             // Pre-verification processing (commit, doctor, state rebuild, etc.)
-            const preResult = await deps.postUnitPreVerification(postUnitCtx);
+            // Sidecar items use lightweight pre-verification opts
+            const preVerificationOpts = sidecarItem
+                ? sidecarItem.kind === "hook"
+                    ? { skipSettleDelay: true, skipDoctor: true, skipStateRebuild: true, skipWorktreeSync: true }
+                    : { skipSettleDelay: true, skipStateRebuild: true }
+                : undefined;
+            const preResult = await deps.postUnitPreVerification(postUnitCtx, preVerificationOpts);
             if (preResult === "dispatched") {
                 debugLog("autoLoop", {
                     phase: "exit",
@@ -814,17 +971,28 @@ export async function autoLoop(ctx, pi, s, deps) {
                 debugLog("autoLoop", { phase: "exit", reason: "uat-pause" });
                 break;
             }
-            // Verification gate — the loop handles retries via s.pendingVerificationRetry
-            const verificationResult = await deps.runPostUnitVerification({ s, ctx, pi }, deps.pauseAuto);
-            if (verificationResult === "pause") {
-                debugLog("autoLoop", { phase: "exit", reason: "verification-pause" });
-                break;
-            }
-            if (verificationResult === "retry") {
-                // s.pendingVerificationRetry was set by runPostUnitVerification.
-                // Continue the loop — next iteration will inject the retry context into the prompt.
-                debugLog("autoLoop", { phase: "verification-retry", iteration });
-                continue;
+            // Verification gate
+            // Hook sidecar items skip verification entirely.
+            // Non-hook sidecar items run verification but skip retries (just continue).
+            const skipVerification = sidecarItem?.kind === "hook";
+            if (!skipVerification) {
+                const verificationResult = await deps.runPostUnitVerification({ s, ctx, pi }, deps.pauseAuto);
+                if (verificationResult === "pause") {
+                    debugLog("autoLoop", { phase: "exit", reason: "verification-pause" });
+                    break;
+                }
+                if (verificationResult === "retry") {
+                    if (sidecarItem) {
+                        // Sidecar verification retries are skipped — just continue
+                        debugLog("autoLoop", { phase: "sidecar-verification-retry-skipped", iteration });
+                    }
+                    else {
+                        // s.pendingVerificationRetry was set by runPostUnitVerification.
+                        // Continue the loop — next iteration will inject the retry context into the prompt.
+                        debugLog("autoLoop", { phase: "verification-retry", iteration });
+                        continue;
+                    }
+                }
             }
             // Post-verification processing (DB dual-write, hooks, triage, quick-tasks)
             const postResult = await deps.postUnitPostVerification(postUnitCtx);
@@ -840,105 +1008,6 @@ export async function autoLoop(ctx, pi, s, deps) {
                 debugLog("autoLoop", { phase: "exit", reason: "step-wizard" });
                 break;
             }
-            // ── Sidecar drain: dispatch enqueued hooks/triage/quick-tasks ──
-            let sidecarBroke = false;
-            while (s.sidecarQueue.length > 0 && s.active) {
-                const item = s.sidecarQueue.shift();
-                debugLog("autoLoop", {
-                    phase: "sidecar-dequeue",
-                    kind: item.kind,
-                    unitType: item.unitType,
-                    unitId: item.unitId,
-                });
-                // Set up as current unit
-                const sidecarStartedAt = Date.now();
-                s.currentUnit = {
-                    type: item.unitType,
-                    id: item.unitId,
-                    startedAt: sidecarStartedAt,
-                };
-                deps.writeUnitRuntimeRecord(s.basePath, item.unitType, item.unitId, sidecarStartedAt, {
-                    phase: "dispatched",
-                    wrapupWarningSent: false,
-                    timeoutAt: null,
-                    lastProgressAt: sidecarStartedAt,
-                    progressCount: 0,
-                    lastProgressKind: "dispatch",
-                });
-                // Model selection (handles hook model override)
-                await deps.selectAndApplyModel(ctx, pi, item.unitType, item.unitId, s.basePath, prefs, s.verbose, s.autoModeStartModel);
-                // Supervision
-                deps.clearUnitTimeout();
-                deps.startUnitSupervision({
-                    s,
-                    ctx,
-                    pi,
-                    unitType: item.unitType,
-                    unitId: item.unitId,
-                    prefs,
-                    buildSnapshotOpts: () => deps.buildSnapshotOpts(item.unitType, item.unitId),
-                    buildRecoveryContext: () => ({}),
-                    pauseAuto: deps.pauseAuto,
-                });
-                // Write lock
-                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);
-                deps.clearUnitTimeout();
-                if (sidecarResult.status === "cancelled") {
-                    ctx.ui.notify(`Sidecar unit ${item.unitType} ${item.unitId} session cancelled. Stopping.`, "warning");
-                    await deps.stopAuto(ctx, pi, "Sidecar session creation failed");
-                    sidecarBroke = true;
-                    break;
-                }
-                // Run pre-verification for the sidecar unit (lightweight path)
-                const sidecarPreOpts = item.kind === "hook"
-                    ? { skipSettleDelay: true, skipDoctor: true, skipStateRebuild: true, skipWorktreeSync: true }
-                    : { skipSettleDelay: true, skipStateRebuild: true };
-                const sidecarPreResult = await deps.postUnitPreVerification(postUnitCtx, sidecarPreOpts);
-                if (sidecarPreResult === "dispatched") {
-                    // Pre-verification caused stop/pause
-                    debugLog("autoLoop", {
-                        phase: "exit",
-                        reason: "sidecar-pre-verification-stop",
-                    });
-                    sidecarBroke = true;
-                    break;
-                }
-                // Verification gate for non-hook sidecar units (triage, quick-tasks)
-                // Hook units are lightweight and don't need verification.
-                if (item.kind !== "hook") {
-                    const sidecarVerification = await deps.runPostUnitVerification({ s, ctx, pi }, deps.pauseAuto);
-                    if (sidecarVerification === "pause") {
-                        debugLog("autoLoop", {
-                            phase: "exit",
-                            reason: "sidecar-verification-pause",
-                        });
-                        sidecarBroke = true;
-                        break;
-                    }
-                    // "retry" for sidecars — skip retry, just continue (sidecar retries are not worth the complexity)
-                }
-                // Post-verification (may enqueue more sidecar items)
-                const sidecarPostResult = await deps.postUnitPostVerification(postUnitCtx);
-                if (sidecarPostResult === "stopped") {
-                    debugLog("autoLoop", { phase: "exit", reason: "sidecar-stopped" });
-                    sidecarBroke = true;
-                    break;
-                }
-                if (sidecarPostResult === "step-wizard") {
-                    debugLog("autoLoop", {
-                        phase: "exit",
-                        reason: "sidecar-step-wizard",
-                    });
-                    sidecarBroke = true;
-                    break;
-                }
-                // "continue" — loop checks sidecarQueue again
-            }
-            if (sidecarBroke)
-                break;
             consecutiveErrors = 0; // Iteration completed successfully
             debugLog("autoLoop", { phase: "iteration-complete", iteration });
         }