gsd-pi 2.23.0 → 2.25.0

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

@@ -16,9 +16,9 @@ import type {
   ExtensionCommandContext,
 } from "@gsd/pi-coding-agent";
 
-import { deriveState, invalidateStateCache } from "./state.js";
+import { deriveState } from "./state.js";
 import type { BudgetEnforcementMode, GSDState } from "./types.js";
-import { loadFile, parseRoadmap, getManifestStatus, resolveAllOverrides } from "./files.js";
+import { loadFile, parseRoadmap, getManifestStatus, resolveAllOverrides, parseSummary } from "./files.js";
 import { loadPrompt } from "./prompt-loader.js";
 export { inlinePriorMilestoneSummary } from "./files.js";
 import { collectSecretsFromManifest } from "../get-secrets-from-user.js";
@@ -94,7 +94,7 @@ import {
   parseSliceBranch,
   setActiveMilestoneId,
 } from "./worktree.js";
-import { GitServiceImpl } from "./git-service.js";
+import { GitServiceImpl, type TaskCommitContext } from "./git-service.js";
 import { getPriorSliceCompletionBlocker } from "./dispatch-guard.js";
 import { formatGitError } from "./git-self-heal.js";
 import {
@@ -108,6 +108,7 @@ import {
   autoWorktreeBranch,
 } from "./auto-worktree.js";
 import { pruneQueueOrder } from "./queue-order.js";
+import { consumeSignal } from "./session-status-io.js";
 import { showNextAction } from "../shared/next-action-ui.js";
 import { debugLog, debugTime, debugCount, debugPeak, enableDebug, isDebugEnabled, writeDebugSummary, getDebugLogPath } from "./debug-logger.js";
 import {
@@ -195,6 +196,35 @@ function syncStateToProjectRoot(worktreePath: string, projectRoot: string, miles
       cpSync(srcMilestone, dstMilestone, { recursive: true, force: true });
     }
   } catch { /* non-fatal */ }
+
+  // 3. Merge completed-units.json (set-union of both locations)
+  // Prevents already-completed units from being re-dispatched after crash/restart.
+  const srcKeysFile = join(wtGsd, "completed-units.json");
+  const dstKeysFile = join(prGsd, "completed-units.json");
+  if (existsSync(srcKeysFile)) {
+    try {
+      const srcKeys: string[] = JSON.parse(readFileSync(srcKeysFile, "utf8"));
+      let dstKeys: string[] = [];
+      if (existsSync(dstKeysFile)) {
+        try { dstKeys = JSON.parse(readFileSync(dstKeysFile, "utf8")); } catch { /* ignore corrupt dst */ }
+      }
+      const merged = [...new Set([...dstKeys, ...srcKeys])];
+      writeFileSync(dstKeysFile, JSON.stringify(merged, null, 2));
+    } catch { /* non-fatal */ }
+  }
+
+  // 4. Runtime records — unit dispatch state used by selfHealRuntimeRecords().
+  // Without this, a crash during a unit leaves the runtime record only in the
+  // worktree. If the next session resolves basePath before worktree re-entry,
+  // selfHeal can't find or clear the stale record (#769).
+  try {
+    const srcRuntime = join(wtGsd, "runtime", "units");
+    const dstRuntime = join(prGsd, "runtime", "units");
+    if (existsSync(srcRuntime)) {
+      mkdirSync(dstRuntime, { recursive: true });
+      cpSync(srcRuntime, dstRuntime, { recursive: true, force: true });
+    }
+  } catch { /* non-fatal */ }
 }
 
 // ─── State ────────────────────────────────────────────────────────────────────
@@ -361,11 +391,12 @@ let _sigtermHandler: (() => void) | null = null;
  */
 const inFlightTools = new Map<string, number>();
 
-type BudgetAlertLevel = 0 | 75 | 90 | 100;
+type BudgetAlertLevel = 0 | 75 | 80 | 90 | 100;
 
 export function getBudgetAlertLevel(budgetPct: number): BudgetAlertLevel {
   if (budgetPct >= 1.0) return 100;
   if (budgetPct >= 0.90) return 90;
+  if (budgetPct >= 0.80) return 80;
   if (budgetPct >= 0.75) return 75;
   return 0;
 }
@@ -552,11 +583,7 @@ function startDispatchGapWatchdog(ctx: ExtensionContext, pi: ExtensionAPI): void
       await dispatchNextUnit(ctx, pi);
     } catch (retryErr) {
       const message = retryErr instanceof Error ? retryErr.message : String(retryErr);
-      ctx.ui.notify(
-        `Dispatch gap recovery failed: ${message}. Stopping auto-mode.`,
-        "error",
-      );
-      await stopAuto(ctx, pi);
+      await stopAuto(ctx, pi, `Dispatch gap recovery failed: ${message}`);
       return;
     }
 
@@ -564,17 +591,14 @@ function startDispatchGapWatchdog(ctx: ExtensionContext, pi: ExtensionAPI): void
     // (no sendMessage called → no timeout set), auto-mode is permanently
     // stalled. Stop cleanly instead of leaving it active but idle (#537).
     if (active && !unitTimeoutHandle && !wrapupWarningHandle) {
-      ctx.ui.notify(
-        "Auto-mode stalled — no dispatchable unit found after retry. Stopping. Run /gsd auto to restart.",
-        "warning",
-      );
-      await stopAuto(ctx, pi);
+      await stopAuto(ctx, pi, "Stalled — no dispatchable unit after retry");
     }
   }, DISPATCH_GAP_TIMEOUT_MS);
 }
 
-export async function stopAuto(ctx?: ExtensionContext, pi?: ExtensionAPI): Promise<void> {
+export async function stopAuto(ctx?: ExtensionContext, pi?: ExtensionAPI, reason?: string): Promise<void> {
   if (!active && !paused) return;
+  const reasonSuffix = reason ? ` — ${reason}` : "";
   clearUnitTimeout();
   if (lockBase()) clearLock(lockBase());
   clearSkillSnapshot();
@@ -626,11 +650,11 @@ export async function stopAuto(ctx?: ExtensionContext, pi?: ExtensionAPI): Promi
   if (ledger && ledger.units.length > 0) {
     const totals = getProjectTotals(ledger.units);
     ctx?.ui.notify(
-      `Auto-mode stopped. Session: ${formatCost(totals.cost)} · ${formatTokenCount(totals.tokens.total)} tokens · ${ledger.units.length} units`,
+      `Auto-mode stopped${reasonSuffix}. Session: ${formatCost(totals.cost)} · ${formatTokenCount(totals.tokens.total)} tokens · ${ledger.units.length} units`,
       "info",
     );
   } else {
-    ctx?.ui.notify("Auto-mode stopped.", "info");
+    ctx?.ui.notify(`Auto-mode stopped${reasonSuffix}.`, "info");
   }
 
   // Sync disk state so next resume starts from accurate state
@@ -865,23 +889,37 @@ export async function startAuto(
       );
       return;
     }
-    // Stale lock from a dead process — synthesize crash recovery context.
-    const activityDir = join(gsdRoot(base), "activity");
-    const recovery = synthesizeCrashRecovery(
-      base, crashLock.unitType, crashLock.unitId,
-      crashLock.sessionFile, activityDir,
-    );
-    if (recovery && recovery.trace.toolCallCount > 0) {
-      pendingCrashRecovery = recovery.prompt;
+    // Stale lock from a dead process — validate before synthesizing recovery context.
+    // If the recovered unit belongs to a fully-completed milestone (SUMMARY exists),
+    // discard recovery context to prevent phantom skip loops (#790).
+    const recoveredMid = crashLock.unitId.split("/")[0];
+    const milestoneAlreadyComplete = recoveredMid
+      ? !!resolveMilestoneFile(base, recoveredMid, "SUMMARY")
+      : false;
+
+    if (milestoneAlreadyComplete) {
       ctx.ui.notify(
-        `${formatCrashInfo(crashLock)}\nRecovered ${recovery.trace.toolCallCount} tool calls from crashed session. Resuming with full context.`,
-        "warning",
+        `Crash recovery: discarding stale context for ${crashLock.unitId} — milestone ${recoveredMid} is already complete.`,
+        "info",
       );
     } else {
-      ctx.ui.notify(
-        `${formatCrashInfo(crashLock)}\nNo session data recovered. Resuming from disk state.`,
-        "warning",
+      const activityDir = join(gsdRoot(base), "activity");
+      const recovery = synthesizeCrashRecovery(
+        base, crashLock.unitType, crashLock.unitId,
+        crashLock.sessionFile, activityDir,
       );
+      if (recovery && recovery.trace.toolCallCount > 0) {
+        pendingCrashRecovery = recovery.prompt;
+        ctx.ui.notify(
+          `${formatCrashInfo(crashLock)}\nRecovered ${recovery.trace.toolCallCount} tool calls from crashed session. Resuming with full context.`,
+          "warning",
+        );
+      } else {
+        ctx.ui.notify(
+          `${formatCrashInfo(crashLock)}\nNo session data recovered. Resuming from disk state.`,
+          "warning",
+        );
+      }
     }
     clearLock(base);
   }
@@ -1094,6 +1132,13 @@ export async function startAuto(
       }
       // Re-register SIGTERM handler with the original basePath (lock lives there)
       registerSigtermHandler(originalBasePath);
+
+      // After worktree entry, load completed keys from BOTH locations (project root
+      // + worktree) so the in-memory set is the union. Prevents re-dispatch of units
+      // completed in either location after crash/restart (#769).
+      if (basePath !== originalBasePath) {
+        loadPersistedKeys(basePath, completedKeySet);
+      }
     } catch (err) {
       // Worktree creation is non-fatal — continue in the project root.
       ctx.ui.notify(
@@ -1130,11 +1175,12 @@ export async function startAuto(
     }
   }
 
-  // Initialize metrics — loads existing ledger from disk
-  initMetrics(base);
+  // Initialize metrics — loads existing ledger from disk.
+  // Use basePath (not base) so worktree-mode reads the worktree ledger (#769).
+  initMetrics(basePath);
 
   // Initialize routing history for adaptive learning
-  initRoutingHistory(base);
+  initRoutingHistory(basePath);
 
   // Capture the session's current model at auto-mode start (#650).
   // This prevents model bleed when multiple GSD instances share the
@@ -1185,8 +1231,10 @@ export async function startAuto(
     );
   }
 
-  // Self-heal: clear stale runtime records where artifacts already exist
-  await selfHealRuntimeRecords(base, ctx, completedKeySet);
+  // Self-heal: clear stale runtime records where artifacts already exist.
+  // Use basePath (not base) — in worktree mode, basePath points to the worktree
+  // where runtime records and artifacts actually live (#769).
+  await selfHealRuntimeRecords(basePath, ctx, completedKeySet);
 
   // Self-heal: remove stale .git/index.lock from prior crash.
   // A stale lock file blocks all git operations (commit, merge, checkout).
@@ -1252,6 +1300,27 @@ export async function handleAgentEnd(
   // Unit completed — clear its timeout
   clearUnitTimeout();
 
+    // ── Parallel worker signal check ─────────────────────────────────────
+    // When running as a parallel worker (GSD_MILESTONE_LOCK set), check for
+    // coordinator signals before dispatching the next unit.
+    const milestoneLock = process.env.GSD_MILESTONE_LOCK;
+    if (milestoneLock) {
+      const signal = consumeSignal(basePath, milestoneLock);
+      if (signal) {
+        if (signal.signal === "stop") {
+          _handlingAgentEnd = false;
+          await stopAuto(ctx, pi);
+          return;
+        }
+        if (signal.signal === "pause") {
+          _handlingAgentEnd = false;
+          await pauseAuto(ctx, pi);
+          return;
+        }
+        // "resume" and "rebase" signals are handled elsewhere or no-op here
+      }
+    }
+
   // Invalidate all caches — the unit just completed and may have
   // written planning files (task summaries, roadmap checkboxes, etc.)
   invalidateAllCaches();
@@ -1259,12 +1328,41 @@ export async function handleAgentEnd(
   // Small delay to let files settle (git commits, file writes)
   await new Promise(r => setTimeout(r, 500));
 
-  // Auto-commit any dirty files the LLM left behind on the current branch.
+  // Commit any dirty files the LLM left behind on the current branch.
+  // For execute-task units, build a meaningful commit message from the
+  // task summary (one-liner, key_files, inferred type). For other unit
+  // types, fall back to the generic chore() message.
   if (currentUnit) {
     try {
-      const commitMsg = autoCommitCurrentBranch(basePath, currentUnit.type, currentUnit.id);
+      let taskContext: TaskCommitContext | undefined;
+
+      if (currentUnit.type === "execute-task") {
+        const parts = currentUnit.id.split("/");
+        const [mid, sid, tid] = parts;
+        if (mid && sid && tid) {
+          const summaryPath = resolveTaskFile(basePath, mid, sid, tid, "SUMMARY");
+          if (summaryPath) {
+            try {
+              const summaryContent = await loadFile(summaryPath);
+              if (summaryContent) {
+                const summary = parseSummary(summaryContent);
+                taskContext = {
+                  taskId: `${sid}/${tid}`,
+                  taskTitle: summary.title?.replace(/^T\d+:\s*/, "") || tid,
+                  oneLiner: summary.oneLiner || undefined,
+                  keyFiles: summary.frontmatter.key_files?.filter(f => !f.includes("{{")) || undefined,
+                };
+              }
+            } catch {
+              // Non-fatal — fall back to generic message
+            }
+          }
+        }
+      }
+
+      const commitMsg = autoCommitCurrentBranch(basePath, currentUnit.type, currentUnit.id, taskContext);
       if (commitMsg) {
-        ctx.ui.notify(`Auto-committed uncommitted changes.`, "info");
+        ctx.ui.notify(`Committed: ${commitMsg.split("\n")[0]}`, "info");
       }
     } catch {
       // Non-fatal
@@ -1317,7 +1415,8 @@ export async function handleAgentEnd(
     }
     try {
       await rebuildState(basePath);
-      autoCommitCurrentBranch(basePath, currentUnit.type, currentUnit.id);
+      // State rebuild commit is bookkeeping — generic message is appropriate
+      autoCommitCurrentBranch(basePath, "state-rebuild", currentUnit.id);
     } catch {
       // Non-fatal
     }
@@ -1410,7 +1509,7 @@ export async function handleAgentEnd(
             persistCompletedKey(basePath, completionKey);
             completedKeySet.add(completionKey);
           }
-          invalidateStateCache();
+          invalidateAllCaches();
         }
       } catch {
         // Non-fatal — worst case we fall through to normal dispatch which has its own checks
@@ -1449,7 +1548,16 @@ export async function handleAgentEnd(
       if (currentUnit) {
         const modelId = ctx.model?.id ?? "unknown";
         snapshotUnitMetrics(ctx, currentUnit.type, currentUnit.id, currentUnit.startedAt, modelId, { promptCharCount: lastPromptCharCount, baselineCharCount: lastBaselineCharCount, ...(currentUnitRouting ?? {}) });
-        saveActivityLog(ctx, basePath, currentUnit.type, currentUnit.id);
+        const hookActivityFile = saveActivityLog(ctx, basePath, currentUnit.type, currentUnit.id);
+        if (hookActivityFile) {
+          try {
+            const { buildMemoryLLMCall, extractMemoriesFromUnit } = await import('./memory-extractor.js');
+            const llmCallFn = buildMemoryLLMCall(ctx);
+            if (llmCallFn) {
+              extractMemoriesFromUnit(hookActivityFile, currentUnit.type, currentUnit.id, llmCallFn).catch(() => {});
+            }
+          } catch { /* non-fatal */ }
+        }
       }
       currentUnit = { type: hookUnit.unitType, id: hookUnit.unitId, startedAt: hookStartedAt };
       writeUnitRuntimeRecord(basePath, hookUnit.unitType, hookUnit.unitId, hookStartedAt, {
@@ -1485,7 +1593,7 @@ export async function handleAgentEnd(
       const result = await cmdCtx!.newSession();
       if (result.cancelled) {
         resetHookState();
-        await stopAuto(ctx, pi);
+        await stopAuto(ctx, pi, "Hook session cancelled");
         return;
       }
       const sessionFile = ctx.sessionManager.getSessionFile();
@@ -1591,7 +1699,16 @@ export async function handleAgentEnd(
             if (currentUnit) {
               const modelId = ctx.model?.id ?? "unknown";
               snapshotUnitMetrics(ctx, currentUnit.type, currentUnit.id, currentUnit.startedAt, modelId);
-              saveActivityLog(ctx, basePath, currentUnit.type, currentUnit.id);
+              const triageActivityFile = saveActivityLog(ctx, basePath, currentUnit.type, currentUnit.id);
+              if (triageActivityFile) {
+                try {
+                  const { buildMemoryLLMCall, extractMemoriesFromUnit } = await import('./memory-extractor.js');
+                  const llmCallFn = buildMemoryLLMCall(ctx);
+                  if (llmCallFn) {
+                    extractMemoriesFromUnit(triageActivityFile, currentUnit.type, currentUnit.id, llmCallFn).catch(() => {});
+                  }
+                } catch { /* non-fatal */ }
+              }
             }
 
             // Dispatch triage as a new unit (early-dispatch-and-return)
@@ -1669,7 +1786,16 @@ export async function handleAgentEnd(
       if (currentUnit) {
         const modelId = ctx.model?.id ?? "unknown";
         snapshotUnitMetrics(ctx, currentUnit.type, currentUnit.id, currentUnit.startedAt, modelId);
-        saveActivityLog(ctx, basePath, currentUnit.type, currentUnit.id);
+        const qtActivityFile = saveActivityLog(ctx, basePath, currentUnit.type, currentUnit.id);
+        if (qtActivityFile) {
+          try {
+            const { buildMemoryLLMCall, extractMemoriesFromUnit } = await import('./memory-extractor.js');
+            const llmCallFn = buildMemoryLLMCall(ctx);
+            if (llmCallFn) {
+              extractMemoriesFromUnit(qtActivityFile, currentUnit.type, currentUnit.id, llmCallFn).catch(() => {});
+            }
+          } catch { /* non-fatal */ }
+        }
       }
 
       // Dispatch quick-task as a new unit
@@ -1783,7 +1909,15 @@ async function showStepWizard(
 
   // If no active milestone or everything is complete, stop
   if (!mid || state.phase === "complete") {
-    await stopAuto(ctx, pi);
+    const incomplete = state.registry.filter(m => m.status !== "complete");
+    if (incomplete.length > 0 && state.phase !== "complete" && state.phase !== "blocked") {
+      const ids = incomplete.map(m => m.id).join(", ");
+      const diag = `basePath=${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 stopAuto(ctx, pi, `No active milestone — ${incomplete.length} incomplete (${ids})`);
+    } else {
+      await stopAuto(ctx, pi, state.phase === "complete" ? "All work complete" : "No active milestone");
+    }
     return;
   }
 
@@ -1906,8 +2040,7 @@ async function dispatchNextUnit(
   // doesn't provide. Stop gracefully instead of crashing.
   const staleMsg = checkResourcesStale();
   if (staleMsg) {
-    await stopAuto(ctx, pi);
-    ctx.ui.notify(staleMsg, "error");
+    await stopAuto(ctx, pi, staleMsg);
     return;
   }
 
@@ -2054,8 +2187,25 @@ async function dispatchNextUnit(
       snapshotUnitMetrics(ctx, currentUnit.type, currentUnit.id, currentUnit.startedAt, modelId, { promptCharCount: lastPromptCharCount, baselineCharCount: lastBaselineCharCount, ...(currentUnitRouting ?? {}) });
       saveActivityLog(ctx, basePath, currentUnit.type, currentUnit.id);
     }
-    sendDesktopNotification("GSD", "All milestones complete!", "success", "milestone");
-    await stopAuto(ctx, pi);
+
+    const incomplete = state.registry.filter(m => m.status !== "complete");
+    if (incomplete.length === 0) {
+      // Genuinely all complete
+      sendDesktopNotification("GSD", "All milestones complete!", "success", "milestone");
+      await stopAuto(ctx, pi, "All milestones complete");
+    } else if (state.phase === "blocked") {
+      // Milestones exist but are dependency-blocked
+      const blockerMsg = `Blocked: ${state.blockers.join(", ")}`;
+      await stopAuto(ctx, pi, blockerMsg);
+      ctx.ui.notify(`${blockerMsg}. Fix and run /gsd auto.`, "warning");
+      sendDesktopNotification("GSD", blockerMsg, "error", "attention");
+    } else {
+      // Milestones with remaining work exist but none became active — unexpected
+      const ids = incomplete.map(m => m.id).join(", ");
+      const diag = `basePath=${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 stopAuto(ctx, pi, `No active milestone — ${incomplete.length} incomplete (${ids}), see diagnostic above`);
+    }
     return;
   }
 
@@ -2063,8 +2213,8 @@ async function dispatchNextUnit(
   // The !mid check above returns early if mid is falsy; midTitle comes from
   // the same object so it should always be present when mid is.
   if (!midTitle) {
-    await stopAuto(ctx, pi);
-    return;
+    midTitle = mid; // Defensive fallback: use milestone ID as title
+    ctx.ui.notify(`Milestone ${mid} has no title in roadmap — using ID as fallback.`, "warning");
   }
 
   // ── Mid-merge safety check: detect leftover merge state from a prior session ──
@@ -2082,7 +2232,10 @@ async function dispatchNextUnit(
       snapshotUnitMetrics(ctx, currentUnit.type, currentUnit.id, currentUnit.startedAt, modelId, { promptCharCount: lastPromptCharCount, baselineCharCount: lastBaselineCharCount, ...(currentUnitRouting ?? {}) });
       saveActivityLog(ctx, basePath, currentUnit.type, currentUnit.id);
     }
-    await stopAuto(ctx, pi);
+    const noMilestoneReason = !mid
+      ? "No active milestone after merge reconciliation"
+      : `Milestone ${mid} has no title after reconciliation`;
+    await stopAuto(ctx, pi, noMilestoneReason);
     return;
   }
 
@@ -2157,7 +2310,7 @@ async function dispatchNextUnit(
       }
     }
     sendDesktopNotification("GSD", `Milestone ${mid} complete!`, "success", "milestone");
-    await stopAuto(ctx, pi);
+    await stopAuto(ctx, pi, `Milestone ${mid} complete`);
     return;
   }
 
@@ -2167,8 +2320,8 @@ async function dispatchNextUnit(
       snapshotUnitMetrics(ctx, currentUnit.type, currentUnit.id, currentUnit.startedAt, modelId, { promptCharCount: lastPromptCharCount, baselineCharCount: lastBaselineCharCount, ...(currentUnitRouting ?? {}) });
       saveActivityLog(ctx, basePath, currentUnit.type, currentUnit.id);
     }
-    await stopAuto(ctx, pi);
     const blockerMsg = `Blocked: ${state.blockers.join(", ")}`;
+    await stopAuto(ctx, pi, blockerMsg);
     ctx.ui.notify(`${blockerMsg}. Fix and run /gsd auto.`, "warning");
     sendDesktopNotification("GSD", blockerMsg, "error", "attention");
     return;
@@ -2194,9 +2347,8 @@ async function dispatchNextUnit(
       const msg = `Budget ceiling ${formatCost(budgetCeiling)} reached (spent ${formatCost(totalCost)}).`;
       lastBudgetAlertLevel = newBudgetAlertLevel;
       if (budgetEnforcementAction === "halt") {
-        ctx.ui.notify(`${msg} Stopping auto-mode.`, "error");
         sendDesktopNotification("GSD", msg, "error", "budget");
-        await stopAuto(ctx, pi);
+        await stopAuto(ctx, pi, "Budget ceiling reached");
         return;
       }
       if (budgetEnforcementAction === "pause") {
@@ -2211,6 +2363,10 @@ async function dispatchNextUnit(
       lastBudgetAlertLevel = newBudgetAlertLevel;
       ctx.ui.notify(`Budget 90%: ${formatCost(totalCost)} / ${formatCost(budgetCeiling)}`, "warning");
       sendDesktopNotification("GSD", `Budget 90%: ${formatCost(totalCost)} / ${formatCost(budgetCeiling)}`, "warning", "budget");
+    } else if (newBudgetAlertLevel === 80) {
+      lastBudgetAlertLevel = newBudgetAlertLevel;
+      ctx.ui.notify(`Approaching budget ceiling — 80%: ${formatCost(totalCost)} / ${formatCost(budgetCeiling)}`, "warning");
+      sendDesktopNotification("GSD", `Approaching budget ceiling — 80%: ${formatCost(totalCost)} / ${formatCost(budgetCeiling)}`, "warning", "budget");
     } else if (newBudgetAlertLevel === 75) {
       lastBudgetAlertLevel = newBudgetAlertLevel;
       ctx.ui.notify(`Budget 75%: ${formatCost(totalCost)} / ${formatCost(budgetCeiling)}`, "info");
@@ -2275,8 +2431,7 @@ async function dispatchNextUnit(
       snapshotUnitMetrics(ctx, currentUnit.type, currentUnit.id, currentUnit.startedAt, modelId, { promptCharCount: lastPromptCharCount, baselineCharCount: lastBaselineCharCount, ...(currentUnitRouting ?? {}) });
       saveActivityLog(ctx, basePath, currentUnit.type, currentUnit.id);
     }
-    await stopAuto(ctx, pi);
-    ctx.ui.notify(dispatchResult.reason, dispatchResult.level);
+    await stopAuto(ctx, pi, dispatchResult.reason);
     return;
   }
 
@@ -2316,8 +2471,7 @@ async function dispatchNextUnit(
 
   const priorSliceBlocker = getPriorSliceCompletionBlocker(basePath, getMainBranch(basePath), unitType, unitId);
   if (priorSliceBlocker) {
-    await stopAuto(ctx, pi);
-    ctx.ui.notify(priorSliceBlocker, "error");
+    await stopAuto(ctx, pi, priorSliceBlocker);
     return;
   }
 
@@ -2335,26 +2489,61 @@ async function dispatchNextUnit(
       const skipCount = (unitConsecutiveSkips.get(idempotencyKey) ?? 0) + 1;
       unitConsecutiveSkips.set(idempotencyKey, skipCount);
       if (skipCount > MAX_CONSECUTIVE_SKIPS) {
+        // Cross-check: verify deriveState actually returns this unit (#790).
+        // If the unit's milestone is already complete, this is a phantom skip
+        // loop from stale crash recovery context — don't evict.
+        const skippedMid = unitId.split("/")[0];
+        const skippedMilestoneComplete = skippedMid
+          ? !!resolveMilestoneFile(basePath, skippedMid, "SUMMARY")
+          : false;
+        if (skippedMilestoneComplete) {
+          // Milestone is complete — evicting this key would fight self-heal.
+          // Clear skip counter and re-dispatch from fresh state.
+          unitConsecutiveSkips.delete(idempotencyKey);
+          invalidateAllCaches();
+          ctx.ui.notify(
+            `Phantom skip loop cleared: ${unitType} ${unitId} belongs to completed milestone ${skippedMid}. Re-dispatching from fresh state.`,
+            "info",
+          );
+          _skipDepth++;
+          await new Promise(r => setTimeout(r, 50));
+          await dispatchNextUnit(ctx, pi);
+          _skipDepth = Math.max(0, _skipDepth - 1);
+          return;
+        }
         unitConsecutiveSkips.delete(idempotencyKey);
         completedKeySet.delete(idempotencyKey);
         removePersistedKey(basePath, idempotencyKey);
-        invalidateStateCache();
+        invalidateAllCaches();
         ctx.ui.notify(
           `Skip loop detected: ${unitType} ${unitId} skipped ${skipCount} times without advancing. Evicting completion record and forcing reconciliation.`,
           "warning",
         );
+        if (!active) return;
         _skipDepth++;
-        await new Promise(r => setTimeout(r, 50));
+        await new Promise(r => setTimeout(r, 150));
         await dispatchNextUnit(ctx, pi);
         _skipDepth = Math.max(0, _skipDepth - 1);
         return;
       }
+      // Count toward lifetime cap so hard-stop fires during skip loops (#792)
+      const lifeSkip = (unitLifetimeDispatches.get(idempotencyKey) ?? 0) + 1;
+      unitLifetimeDispatches.set(idempotencyKey, lifeSkip);
+      if (lifeSkip > MAX_LIFETIME_DISPATCHES) {
+        await stopAuto(ctx, pi, `Hard loop: ${unitType} ${unitId} (skip cycle)`);
+        ctx.ui.notify(
+          `Hard loop detected: ${unitType} ${unitId} hit lifetime cap during skip cycle (${lifeSkip} iterations).`,
+          "error",
+        );
+        return;
+      }
       ctx.ui.notify(
         `Skipping ${unitType} ${unitId} — already completed in a prior session. Advancing.`,
         "info",
       );
+      if (!active) return;
       _skipDepth++;
-      await new Promise(r => setTimeout(r, 50));
+      await new Promise(r => setTimeout(r, 150));
       await dispatchNextUnit(ctx, pi);
       _skipDepth = Math.max(0, _skipDepth - 1);
       return;
@@ -2377,31 +2566,62 @@ async function dispatchNextUnit(
   if (verifyExpectedArtifact(unitType, unitId, basePath)) {
     persistCompletedKey(basePath, idempotencyKey);
     completedKeySet.add(idempotencyKey);
-    invalidateStateCache();
+    invalidateAllCaches();
     // Same consecutive-skip guard as the idempotency path above.
     const skipCount2 = (unitConsecutiveSkips.get(idempotencyKey) ?? 0) + 1;
     unitConsecutiveSkips.set(idempotencyKey, skipCount2);
     if (skipCount2 > MAX_CONSECUTIVE_SKIPS) {
+      // Cross-check: verify the unit's milestone is still active (#790).
+      const skippedMid2 = unitId.split("/")[0];
+      const skippedMilestoneComplete2 = skippedMid2
+        ? !!resolveMilestoneFile(basePath, skippedMid2, "SUMMARY")
+        : false;
+      if (skippedMilestoneComplete2) {
+        unitConsecutiveSkips.delete(idempotencyKey);
+        invalidateAllCaches();
+        ctx.ui.notify(
+          `Phantom skip loop cleared: ${unitType} ${unitId} belongs to completed milestone ${skippedMid2}. Re-dispatching from fresh state.`,
+          "info",
+        );
+        _skipDepth++;
+        await new Promise(r => setTimeout(r, 50));
+        await dispatchNextUnit(ctx, pi);
+        _skipDepth = Math.max(0, _skipDepth - 1);
+        return;
+      }
       unitConsecutiveSkips.delete(idempotencyKey);
       completedKeySet.delete(idempotencyKey);
       removePersistedKey(basePath, idempotencyKey);
-      invalidateStateCache();
+      invalidateAllCaches();
       ctx.ui.notify(
         `Skip loop detected: ${unitType} ${unitId} skipped ${skipCount2} times without advancing. Evicting completion record and forcing reconciliation.`,
         "warning",
       );
+      if (!active) return;
       _skipDepth++;
-      await new Promise(r => setTimeout(r, 50));
+      await new Promise(r => setTimeout(r, 150));
       await dispatchNextUnit(ctx, pi);
       _skipDepth = Math.max(0, _skipDepth - 1);
       return;
     }
+    // Count toward lifetime cap so hard-stop fires during skip loops (#792)
+    const lifeSkip2 = (unitLifetimeDispatches.get(idempotencyKey) ?? 0) + 1;
+    unitLifetimeDispatches.set(idempotencyKey, lifeSkip2);
+    if (lifeSkip2 > MAX_LIFETIME_DISPATCHES) {
+      await stopAuto(ctx, pi, `Hard loop: ${unitType} ${unitId} (skip cycle)`);
+      ctx.ui.notify(
+        `Hard loop detected: ${unitType} ${unitId} hit lifetime cap during skip cycle (${lifeSkip2} iterations).`,
+        "error",
+      );
+      return;
+    }
     ctx.ui.notify(
       `Skipping ${unitType} ${unitId} — artifact exists but completion key was missing. Repaired and advancing.`,
       "info",
     );
+    if (!active) return;
     _skipDepth++;
-    await new Promise(r => setTimeout(r, 50));
+    await new Promise(r => setTimeout(r, 150));
     await dispatchNextUnit(ctx, pi);
     _skipDepth = Math.max(0, _skipDepth - 1);
     return;
@@ -2434,9 +2654,9 @@ async function dispatchNextUnit(
     }
     saveActivityLog(ctx, basePath, unitType, unitId);
     const expected = diagnoseExpectedArtifact(unitType, unitId, basePath);
-    await stopAuto(ctx, pi);
+    await stopAuto(ctx, pi, `Hard loop: ${unitType} ${unitId}`);
     ctx.ui.notify(
-      `Hard loop detected: ${unitType} ${unitId} dispatched ${lifetimeCount} times total (across reconciliation cycles). Stopping.${expected ? `\n   Expected artifact: ${expected}` : ""}\n   This may indicate deriveState() keeps returning the same unit despite artifacts existing.\n   Check .gsd/completed-units.json and the slice plan checkbox state.`,
+      `Hard loop detected: ${unitType} ${unitId} dispatched ${lifetimeCount} times total (across reconciliation cycles).${expected ? `\n   Expected artifact: ${expected}` : ""}\n   This may indicate deriveState() keeps returning the same unit despite artifacts existing.\n   Check .gsd/completed-units.json and the slice plan checkbox state.`,
       "error",
     );
     return;
@@ -2471,7 +2691,7 @@ async function dispatchNextUnit(
             persistCompletedKey(basePath, reconciledKey);
             completedKeySet.add(reconciledKey);
             unitDispatchCount.delete(dispatchKey);
-            invalidateStateCache();
+            invalidateAllCaches();
             await new Promise(r => setImmediate(r));
             await dispatchNextUnit(ctx, pi);
             return;
@@ -2498,7 +2718,7 @@ async function dispatchNextUnit(
       persistCompletedKey(basePath, dispatchKey);
       completedKeySet.add(dispatchKey);
       unitDispatchCount.delete(dispatchKey);
-      invalidateStateCache();
+      invalidateAllCaches();
       await new Promise(r => setImmediate(r));
       await dispatchNextUnit(ctx, pi);
       return;
@@ -2518,7 +2738,7 @@ async function dispatchNextUnit(
             persistCompletedKey(basePath, dispatchKey);
             completedKeySet.add(dispatchKey);
             unitDispatchCount.delete(dispatchKey);
-            invalidateStateCache();
+            invalidateAllCaches();
             await new Promise(r => setImmediate(r));
             await dispatchNextUnit(ctx, pi);
             return;
@@ -2529,7 +2749,7 @@ async function dispatchNextUnit(
 
     const expected = diagnoseExpectedArtifact(unitType, unitId, basePath);
     const remediation = buildLoopRemediationSteps(unitType, unitId, basePath);
-    await stopAuto(ctx, pi);
+    await stopAuto(ctx, pi, `Loop: ${unitType} ${unitId}`);
     sendDesktopNotification("GSD", `Loop detected: ${unitType} ${unitId}`, "error", "error");
     ctx.ui.notify(
       `Loop detected: ${unitType} ${unitId} dispatched ${prevCount + 1} times total. Expected artifact not found.${expected ? `\n   Expected: ${expected}` : ""}${remediation ? `\n\n   Remediation steps:\n${remediation}` : "\n   Check branch state and .gsd/ artifacts."}`,
@@ -2559,7 +2779,7 @@ async function dispatchNextUnit(
             persistCompletedKey(basePath, repairedKey);
             completedKeySet.add(repairedKey);
             unitDispatchCount.delete(dispatchKey);
-            invalidateStateCache();
+            invalidateAllCaches();
             await new Promise(r => setImmediate(r));
             await dispatchNextUnit(ctx, pi);
             return;
@@ -2603,7 +2823,18 @@ async function dispatchNextUnit(
   if (currentUnit) {
     const modelId = ctx.model?.id ?? "unknown";
     snapshotUnitMetrics(ctx, currentUnit.type, currentUnit.id, currentUnit.startedAt, modelId, { promptCharCount: lastPromptCharCount, baselineCharCount: lastBaselineCharCount, ...(currentUnitRouting ?? {}) });
-    saveActivityLog(ctx, basePath, currentUnit.type, currentUnit.id);
+    const activityFile = saveActivityLog(ctx, basePath, currentUnit.type, currentUnit.id);
+
+    // Fire-and-forget memory extraction from completed unit
+    if (activityFile) {
+      try {
+        const { buildMemoryLLMCall, extractMemoriesFromUnit } = await import('./memory-extractor.js');
+        const llmCallFn = buildMemoryLLMCall(ctx);
+        if (llmCallFn) {
+          extractMemoriesFromUnit(activityFile, currentUnit.type, currentUnit.id, llmCallFn).catch(() => {});
+        }
+      } catch { /* non-fatal */ }
+    }
 
     // Record routing outcome for adaptive learning
     if (currentUnitRouting) {
@@ -2670,8 +2901,7 @@ async function dispatchNextUnit(
   // Fresh session
   const result = await cmdCtx!.newSession();
   if (result.cancelled) {
-    await stopAuto(ctx, pi);
-    ctx.ui.notify("Auto-mode stopped.", "info");
+    await stopAuto(ctx, pi, "Session cancelled");
     return;
   }