gsd-pi 2.26.0 → 2.27.0

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

@@ -93,9 +93,57 @@ export function writeExportFile(
 }
 
 /**
- * Export session/milestone data to JSON or markdown.
+ * Export session/milestone data to JSON, markdown, or HTML.
  */
 export async function handleExport(args: string, ctx: ExtensionCommandContext, basePath: string): Promise<void> {
+  // HTML report — delegates to the full visualizer-data pipeline
+  if (args.includes("--html")) {
+    try {
+      const { loadVisualizerData } = await import("./visualizer-data.js");
+      const { generateHtmlReport } = await import("./export-html.js");
+      const { writeReportSnapshot, reportsDir } = await import("./reports.js");
+      const { basename: bn } = await import("node:path");
+      const data = await loadVisualizerData(basePath);
+      const projName = basename(basePath);
+      const gsdVersion = process.env.GSD_VERSION ?? "0.0.0";
+      const doneSlices = data.milestones.reduce((s, m) => s + m.slices.filter(sl => sl.done).length, 0);
+      const totalSlices = data.milestones.reduce((s, m) => s + m.slices.length, 0);
+      const outPath = writeReportSnapshot({
+        basePath,
+        html: generateHtmlReport(data, {
+          projectName: projName,
+          projectPath: basePath,
+          gsdVersion,
+          indexRelPath: "index.html",
+        }),
+        milestoneId: data.milestones.find(m => m.status === "active")?.id ?? "manual",
+        milestoneTitle: data.milestones.find(m => m.status === "active")?.title ?? "",
+        kind: "manual",
+        projectName: projName,
+        projectPath: basePath,
+        gsdVersion,
+        totalCost: data.totals?.cost ?? 0,
+        totalTokens: data.totals?.tokens.total ?? 0,
+        totalDuration: data.totals?.duration ?? 0,
+        doneSlices,
+        totalSlices,
+        doneMilestones: data.milestones.filter(m => m.status === "complete").length,
+        totalMilestones: data.milestones.length,
+        phase: data.phase,
+      });
+      ctx.ui.notify(
+        `HTML report saved: .gsd/reports/${bn(outPath)}\nBrowse all reports: .gsd/reports/index.html`,
+        "success",
+      );
+    } catch (err) {
+      ctx.ui.notify(
+        `HTML export failed: ${err instanceof Error ? err.message : String(err)}`,
+        "error",
+      );
+    }
+    return;
+  }
+
   const format = args.includes("--json") ? "json" : "markdown";
 
   const ledger = getLedger();

package/dist/resources/extensions/gsd/git-service.ts

@@ -53,6 +53,12 @@ export interface GitPreferences {
    *  Default: true (planning docs are tracked in git).
    */
   commit_docs?: boolean;
+  /** When false, GSD will not modify .gitignore at all — no baseline patterns
+   *  are added and no self-healing occurs. Use this if you manage your own
+   *  .gitignore and don't want GSD touching it.
+   *  Default: true (GSD ensures baseline patterns are present).
+   */
+  manage_gitignore?: boolean;
   /** Script to run after a worktree is created (#597).
    *  Receives SOURCE_DIR and WORKTREE_DIR as environment variables.
    *  Can be an absolute path or relative to the project root.

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

@@ -85,7 +85,10 @@ const BASELINE_PATTERNS = [
  * .gitignore instead of individual runtime patterns, keeping all GSD
  * artifacts local-only.
  */
-export function ensureGitignore(basePath: string, options?: { commitDocs?: boolean }): boolean {
+export function ensureGitignore(basePath: string, options?: { commitDocs?: boolean; manageGitignore?: boolean }): boolean {
+  // If manage_gitignore is explicitly false, do not touch .gitignore at all
+  if (options?.manageGitignore === false) return false;
+
   const gitignorePath = join(basePath, ".gitignore");
   const commitDocs = options?.commitDocs !== false; // default true
 

package/dist/resources/extensions/gsd/guided-flow.ts

@@ -10,7 +10,7 @@ import type { ExtensionAPI, ExtensionContext, ExtensionCommandContext } from "@g
 import { showNextAction } from "../shared/next-action-ui.js";
 import { loadFile, parseRoadmap } from "./files.js";
 import { loadPrompt, inlineTemplate } from "./prompt-loader.js";
-import { deriveState } from "./state.js";
+import { deriveState, invalidateStateCache } from "./state.js";
 import { startAuto } from "./auto.js";
 import { readCrashLock, clearLock, formatCrashInfo } from "./crash-recovery.js";
 import { listUnitRuntimeRecords, clearUnitRuntimeRecord } from "./unit-runtime.js";
@@ -959,10 +959,28 @@ export async function showDiscuss(
 
   // Loop: show picker, dispatch discuss, repeat until "not_yet"
   while (true) {
-    const actions = pendingSlices.map((s, i) => {
-      // Check if this slice has already been discussed (CONTEXT file exists)
+    // Build discussion-state map: which slices have CONTEXT files already?
+    const discussedMap = new Map<string, boolean>();
+    for (const s of pendingSlices) {
       const contextFile = resolveSliceFile(basePath, mid, s.id, "CONTEXT");
-      const discussed = !!contextFile;
+      discussedMap.set(s.id, !!contextFile);
+    }
+
+    // If all pending slices are discussed, notify and exit instead of looping
+    const allDiscussed = pendingSlices.every(s => discussedMap.get(s.id));
+    if (allDiscussed) {
+      ctx.ui.notify(
+        `All ${pendingSlices.length} slices discussed. Run /gsd to start planning.`,
+        "info",
+      );
+      return;
+    }
+
+    // Find the first undiscussed slice to recommend
+    const firstUndiscussedId = pendingSlices.find(s => !discussedMap.get(s.id))?.id;
+
+    const actions = pendingSlices.map((s) => {
+      const discussed = discussedMap.get(s.id) ?? false;
       const statusParts: string[] = [];
       if (state.activeSlice?.id === s.id) statusParts.push("active");
       else statusParts.push("upcoming");
@@ -972,7 +990,7 @@ export async function showDiscuss(
         id: s.id,
         label: `${s.id}: ${s.title}`,
         description: statusParts.join(" · "),
-        recommended: i === 0,
+        recommended: s.id === firstUndiscussedId,
       };
     });
 
@@ -996,6 +1014,7 @@ export async function showDiscuss(
 
     // Wait for the discuss session to finish, then loop back to the picker
     await ctx.waitForIdle();
+    invalidateStateCache();
   }
 }
 

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

@@ -44,6 +44,7 @@ import {
   resolveAllSkillReferences,
   resolveModelWithFallbacksForUnit,
   getNextFallbackModel,
+  isTransientNetworkError,
 } from "./preferences.js";
 import { hasSkillSnapshot, detectNewSkills, formatSkillsXml } from "./skill-discovery.js";
 import {
@@ -60,6 +61,7 @@ import { shortcutDesc } from "../shared/terminal.js";
 import { Text } from "@gsd/pi-tui";
 import { pauseAutoForProviderError } from "./provider-error-pause.js";
 import { toPosixPath } from "../shared/path-display.js";
+import { isParallelActive, shutdownParallel } from "./parallel-orchestrator.js";
 
 // ── Agent Instructions ────────────────────────────────────────────────────
 // Lightweight "always follow" files injected into every GSD agent session.
@@ -92,6 +94,11 @@ function loadAgentInstructions(): string | null {
 // ── Depth verification state ──────────────────────────────────────────────
 let depthVerificationDone = false;
 
+// ── Network error retry counters ──────────────────────────────────────────
+// Tracks per-model retry attempts for transient network errors.
+// Cleared when a model switch occurs or retries are exhausted.
+const networkRetryCounters = new Map<string, number>();
+
 export function isDepthVerified(): boolean {
   return depthVerificationDone;
 }
@@ -727,6 +734,43 @@ export default function (pi: ExtensionAPI) {
           ? `: ${lastMsg.errorMessage}`
           : "";
 
+      const errorMsg = ("errorMessage" in lastMsg && lastMsg.errorMessage) ? String(lastMsg.errorMessage) : "";
+
+      // ── Transient network error retry ──────────────────────────────────
+      // Before falling back to a different model, retry the current model
+      // for transient network errors (connection reset, timeout, DNS, etc.).
+      // This prevents providers with occasional network flakiness from being
+      // immediately abandoned in favor of fallback models (#941).
+      if (isTransientNetworkError(errorMsg)) {
+        const currentModelId = ctx.model?.id ?? "unknown";
+        const retryKey = `network-retry:${currentModelId}`;
+        const maxRetries = 2;
+        const currentRetries = networkRetryCounters.get(retryKey) ?? 0;
+
+        if (currentRetries < maxRetries) {
+          networkRetryCounters.set(retryKey, currentRetries + 1);
+          const attempt = currentRetries + 1;
+          const delayMs = attempt * 3000; // 3s, 6s backoff
+          ctx.ui.notify(
+            `Network error on ${currentModelId}${errorDetail}. Retry ${attempt}/${maxRetries} in ${delayMs / 1000}s...`,
+            "warning",
+          );
+          setTimeout(() => {
+            pi.sendMessage(
+              { customType: "gsd-auto-timeout-recovery", content: "Continue execution — retrying after transient network error.", display: false },
+              { triggerTurn: true },
+            );
+          }, delayMs);
+          return;
+        }
+        // Retries exhausted — clear counter and fall through to fallback logic
+        networkRetryCounters.delete(retryKey);
+        ctx.ui.notify(
+          `Network retries exhausted for ${currentModelId}. Attempting model fallback.`,
+          "warning",
+        );
+      }
+
       const dash = getAutoDashboardData();
       if (dash.currentUnit) {
         const modelConfig = resolveModelWithFallbacksForUnit(dash.currentUnit.type);
@@ -737,6 +781,9 @@ export default function (pi: ExtensionAPI) {
           const nextModelId = getNextFallbackModel(currentModelId, modelConfig);
 
           if (nextModelId) {
+            // Clear any network retry counters when switching models
+            networkRetryCounters.clear();
+
             let modelToSet;
             const slashIdx = nextModelId.indexOf("/");
             if (slashIdx !== -1) {
@@ -771,7 +818,6 @@ export default function (pi: ExtensionAPI) {
       }
 
       // Detect rate-limit errors and extract retry delay for auto-resume
-      const errorMsg = ("errorMessage" in lastMsg && lastMsg.errorMessage) ? String(lastMsg.errorMessage) : "";
       const isRateLimit = /rate.?limit|too many requests|429/i.test(errorMsg);
       const retryAfterMs = ("retryAfterMs" in lastMsg && typeof lastMsg.retryAfterMs === "number")
         ? lastMsg.retryAfterMs
@@ -791,6 +837,7 @@ export default function (pi: ExtensionAPI) {
     }
 
     try {
+      networkRetryCounters.clear(); // Clear network retry state on successful unit completion
       await handleAgentEnd(ctx, pi);
     } catch (err) {
       // Safety net: if handleAgentEnd throws despite its internal try-catch,
@@ -856,6 +903,12 @@ export default function (pi: ExtensionAPI) {
 
   // ── session_shutdown: save activity log on Ctrl+C / SIGTERM ─────────────
   pi.on("session_shutdown", async (_event, ctx: ExtensionContext) => {
+    if (isParallelActive()) {
+      try {
+        await shutdownParallel(process.cwd());
+      } catch { /* best-effort */ }
+    }
+
     if (!isAutoActive() && !isAutoPaused()) return;
 
     // Save the current session — the lock file stays on disk

package/dist/resources/extensions/gsd/native-git-bridge.ts

@@ -249,18 +249,46 @@ export function nativeWorkingTreeStatus(basePath: string): string {
   return gitExec(basePath, ["status", "--porcelain"], true);
 }
 
+// ─── nativeHasChanges fallback cache (10s TTL) ─────────────────────────
+let _hasChangesCachedResult: boolean = false;
+let _hasChangesCachedAt: number = 0;
+let _hasChangesCachedPath: string = "";
+const HAS_CHANGES_CACHE_TTL_MS = 10_000; // 10 seconds
+
 /**
  * Quick check: any staged or unstaged changes?
  * Native: libgit2 status check (single syscall).
- * Fallback: `git status --short`.
+ * Fallback: `git status --short` (cached for 10s per basePath).
  */
 export function nativeHasChanges(basePath: string): boolean {
   const native = loadNative();
   if (native) {
     return native.gitHasChanges(basePath);
   }
+
+  const now = Date.now();
+  if (
+    basePath === _hasChangesCachedPath &&
+    now - _hasChangesCachedAt < HAS_CHANGES_CACHE_TTL_MS
+  ) {
+    return _hasChangesCachedResult;
+  }
+
   const result = gitExec(basePath, ["status", "--short"], true);
-  return result !== "";
+  const hasChanges = result !== "";
+
+  _hasChangesCachedResult = hasChanges;
+  _hasChangesCachedAt = now;
+  _hasChangesCachedPath = basePath;
+
+  return hasChanges;
+}
+
+/** Reset the nativeHasChanges fallback cache (exported for testing). */
+export function _resetHasChangesCache(): void {
+  _hasChangesCachedResult = false;
+  _hasChangesCachedAt = 0;
+  _hasChangesCachedPath = "";
 }
 
 /**

package/dist/resources/extensions/gsd/observability-validator.ts

@@ -298,6 +298,27 @@ export function validateTaskSummaryContent(file: string, content: string): Valid
     });
   }
 
+  const evidence = getSection(content, "Verification Evidence", 2);
+  if (!evidence) {
+    issues.push({
+      severity: "warning",
+      scope: "task-summary",
+      file,
+      ruleId: "evidence_block_missing",
+      message: "Task summary is missing `## Verification Evidence`.",
+      suggestion: "Add a verification evidence table showing gate check results (command, exit code, verdict, duration).",
+    });
+  } else if (sectionLooksPlaceholderOnly(evidence)) {
+    issues.push({
+      severity: "warning",
+      scope: "task-summary",
+      file,
+      ruleId: "evidence_block_placeholder",
+      message: "Task summary verification evidence section still looks like placeholder text.",
+      suggestion: "Replace placeholders with actual gate results or note that no verification commands were discovered.",
+    });
+  }
+
   return issues;
 }
 

package/dist/resources/extensions/gsd/parallel-orchestrator.ts

@@ -8,7 +8,14 @@
  */
 
 import { spawn, type ChildProcess } from "node:child_process";
-import { existsSync } from "node:fs";
+import {
+  existsSync,
+  writeFileSync,
+  readFileSync,
+  renameSync,
+  unlinkSync,
+  mkdirSync,
+} from "node:fs";
 import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 import { gsdRoot } from "./paths.js";
@@ -58,6 +65,142 @@ export interface OrchestratorState {
 
 let state: OrchestratorState | null = null;
 
+// ─── Persistence ──────────────────────────────────────────────────────────
+
+const ORCHESTRATOR_STATE_FILE = "orchestrator.json";
+const TMP_SUFFIX = ".tmp";
+
+export interface PersistedState {
+  active: boolean;
+  workers: Array<{
+    milestoneId: string;
+    title: string;
+    pid: number;
+    worktreePath: string;
+    startedAt: number;
+    state: "running" | "paused" | "stopped" | "error";
+    completedUnits: number;
+    cost: number;
+  }>;
+  totalCost: number;
+  startedAt: number;
+  configSnapshot: { max_workers: number; budget_ceiling?: number };
+}
+
+function stateFilePath(basePath: string): string {
+  return join(gsdRoot(basePath), ORCHESTRATOR_STATE_FILE);
+}
+
+/**
+ * Persist the current orchestrator state to .gsd/orchestrator.json.
+ * Uses atomic write (tmp + rename) to prevent partial reads.
+ */
+export function persistState(basePath: string): void {
+  if (!state) return;
+  try {
+    const dir = gsdRoot(basePath);
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+
+    const persisted: PersistedState = {
+      active: state.active,
+      workers: [...state.workers.values()].map((w) => ({
+        milestoneId: w.milestoneId,
+        title: w.title,
+        pid: w.pid,
+        worktreePath: w.worktreePath,
+        startedAt: w.startedAt,
+        state: w.state,
+        completedUnits: w.completedUnits,
+        cost: w.cost,
+      })),
+      totalCost: state.totalCost,
+      startedAt: state.startedAt,
+      configSnapshot: {
+        max_workers: state.config.max_workers,
+        budget_ceiling: state.config.budget_ceiling,
+      },
+    };
+
+    const dest = stateFilePath(basePath);
+    const tmp = dest + TMP_SUFFIX;
+    writeFileSync(tmp, JSON.stringify(persisted, null, 2), "utf-8");
+    renameSync(tmp, dest);
+  } catch { /* non-fatal */ }
+}
+
+/**
+ * Remove the persisted state file.
+ */
+function removeStateFile(basePath: string): void {
+  try {
+    const p = stateFilePath(basePath);
+    if (existsSync(p)) unlinkSync(p);
+  } catch { /* non-fatal */ }
+}
+
+function isPidAlive(pid: number): boolean {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Restore orchestrator state from .gsd/orchestrator.json.
+ * Checks PID liveness for each worker:
+ * - Living PID → state "running", process stays null (no handle)
+ * - Dead PID → removed from restored state
+ * Returns null if no state file exists or no workers survive.
+ */
+export function restoreState(basePath: string): PersistedState | null {
+  try {
+    const p = stateFilePath(basePath);
+    if (!existsSync(p)) return null;
+    const raw = readFileSync(p, "utf-8");
+    const persisted = JSON.parse(raw) as PersistedState;
+
+    // Filter to only workers with living PIDs
+    persisted.workers = persisted.workers.filter((w) => {
+      if (w.state === "stopped" || w.state === "error") return false;
+      return isPidAlive(w.pid);
+    });
+
+    if (persisted.workers.length === 0) {
+      // No surviving workers — clean up and return null
+      removeStateFile(basePath);
+      return null;
+    }
+
+    return persisted;
+  } catch {
+    return null;
+  }
+}
+
+async function waitForWorkerExit(worker: WorkerInfo, timeoutMs: number): Promise<boolean> {
+  if (worker.process) {
+    await new Promise<void>((resolve) => {
+      const done = () => resolve();
+      const timer = setTimeout(done, timeoutMs);
+      worker.process!.once("exit", () => {
+        clearTimeout(timer);
+        resolve();
+      });
+    });
+    return worker.process === null || !isPidAlive(worker.pid);
+  }
+
+  const startedAt = Date.now();
+  while (Date.now() - startedAt < timeoutMs) {
+    if (!isPidAlive(worker.pid)) return true;
+    await new Promise((resolve) => setTimeout(resolve, 50));
+  }
+  return !isPidAlive(worker.pid);
+}
+
 // ─── Accessors ─────────────────────────────────────────────────────────────
 
 /** Returns true if the orchestrator is active and has been initialized. */
@@ -81,12 +224,26 @@ export function getWorkerStatuses(): WorkerInfo[] {
 /**
  * Analyze eligibility and prepare for parallel start.
  * Returns the candidates report without actually starting workers.
+ * Also detects orphaned sessions from prior crashes.
  */
 export async function prepareParallelStart(
   basePath: string,
   _prefs: GSDPreferences | undefined,
-): Promise<ParallelCandidates> {
-  return analyzeParallelEligibility(basePath);
+): Promise<ParallelCandidates & { orphans?: Array<{ milestoneId: string; pid: number; alive: boolean }> }> {
+  // Detect orphaned sessions before eligibility analysis
+  const sessions = readAllSessionStatuses(basePath);
+  const orphans: Array<{ milestoneId: string; pid: number; alive: boolean }> = [];
+  for (const session of sessions) {
+    const alive = isPidAlive(session.pid);
+    orphans.push({ milestoneId: session.milestoneId, pid: session.pid, alive });
+    if (!alive) {
+      // Clean up dead session
+      removeSessionStatus(basePath, session.milestoneId);
+    }
+  }
+
+  const candidates = await analyzeParallelEligibility(basePath);
+  return orphans.length > 0 ? { ...candidates, orphans } : candidates;
 }
 
 // ─── Start ─────────────────────────────────────────────────────────────────
@@ -106,6 +263,36 @@ export async function startParallel(
   }
 
   const config = resolveParallelConfig(prefs);
+
+  // Try to restore from a previous crash
+  const restored = restoreState(basePath);
+  if (restored && restored.workers.length > 0) {
+    // Adopt surviving workers instead of starting new ones
+    state = {
+      active: true,
+      workers: new Map(),
+      config,
+      totalCost: restored.totalCost,
+      startedAt: restored.startedAt,
+    };
+    const adopted: string[] = [];
+    for (const w of restored.workers) {
+      state.workers.set(w.milestoneId, {
+        milestoneId: w.milestoneId,
+        title: w.title,
+        pid: w.pid,
+        process: null, // no handle for adopted workers
+        worktreePath: w.worktreePath,
+        startedAt: w.startedAt,
+        state: "running",
+        completedUnits: w.completedUnits,
+        cost: w.cost,
+      });
+      adopted.push(w.milestoneId);
+    }
+    return { started: adopted, errors: [] };
+  }
+
   const now = Date.now();
 
   // Initialize orchestrator state
@@ -144,7 +331,7 @@ export async function startParallel(
       const worker: WorkerInfo = {
         milestoneId: mid,
         title: mid,
-        pid: process.pid,
+        pid: 0,  // placeholder — real PID set by spawnWorker()
         process: null,
         worktreePath: wtPath,
         startedAt: now,
@@ -155,28 +342,24 @@ export async function startParallel(
 
       state.workers.set(mid, worker);
 
-      // Write initial session status
-      const sessionStatus: SessionStatus = {
+      // Spawn BEFORE writing session status so the file gets the real worker PID.
+      const spawned = spawnWorker(basePath, mid);
+      if (!spawned) {
+        worker.state = "error";
+      }
+
+      // Write session status with real PID (or 0 if spawn failed)
+      writeSessionStatus(basePath, {
         milestoneId: mid,
         pid: worker.pid,
-        state: "running",
+        state: worker.state,
         currentUnit: null,
         completedUnits: 0,
         cost: 0,
         lastHeartbeat: now,
         startedAt: now,
         worktreePath: wtPath,
-      };
-      writeSessionStatus(basePath, sessionStatus);
-
-      // Attempt to spawn the worker process.
-      // Spawning may fail if the CLI binary is not available (e.g., in tests).
-      // The worker is still tracked and can be spawned later via spawnWorker().
-      const spawned = spawnWorker(basePath, mid);
-      if (!spawned) {
-        // Worker tracked but not yet running a process.
-        // State stays "running" so coordinator can retry or user can investigate.
-      }
+      });
 
       started.push(mid);
     } catch (err) {
@@ -190,6 +373,9 @@ export async function startParallel(
     state.active = false;
   }
 
+  // Persist state for crash recovery
+  persistState(basePath);
+
   return { started, errors };
 }
 
@@ -323,7 +509,7 @@ export function spawnWorker(
       w.state = "error";
     }
 
-    // Update session status
+    // Update session status and persist orchestrator state for crash recovery
     writeSessionStatus(basePath, {
       milestoneId,
       pid: w.pid,
@@ -335,6 +521,7 @@ export function spawnWorker(
       startedAt: w.startedAt,
       worktreePath: w.worktreePath,
     });
+    persistState(basePath);
   });
 
   return true;
@@ -485,12 +672,24 @@ export async function stopParallel(
       try {
         if (worker.process) {
           worker.process.kill("SIGTERM");
-        } else {
+        } else if (worker.pid !== process.pid) {
           process.kill(worker.pid, "SIGTERM");
         }
       } catch { /* process may already be dead */ }
     }
 
+    const exitedAfterTerm = await waitForWorkerExit(worker, 750);
+    if (!exitedAfterTerm && worker.pid > 0) {
+      try {
+        if (worker.process) {
+          worker.process.kill("SIGKILL");
+        } else if (worker.pid !== process.pid) {
+          process.kill(worker.pid, "SIGKILL");
+        }
+      } catch { /* process may already be dead */ }
+      await waitForWorkerExit(worker, 250);
+    }
+
     // Update in-memory state
     worker.state = "stopped";
     worker.process = null;
@@ -503,6 +702,15 @@ export async function stopParallel(
   if (!milestoneId) {
     state.active = false;
   }
+
+  // Persist final state and clean up state file
+  removeStateFile(basePath);
+}
+
+export async function shutdownParallel(basePath: string): Promise<void> {
+  if (!state) return;
+  await stopParallel(basePath);
+  resetOrchestrator();
 }
 
 // ─── Pause / Resume ────────────────────────────────────────────────────────
@@ -589,6 +797,9 @@ export function refreshWorkerStatuses(basePath: string): void {
   for (const worker of state.workers.values()) {
     state.totalCost += worker.cost;
   }
+
+  // Persist updated state for crash recovery
+  persistState(basePath);
 }
 
 // ─── Budget ────────────────────────────────────────────────────────────────