cascade-ai 0.67.0 → 0.68.0

package/dist/index.js

@@ -1,6 +1,6 @@
 import Database from 'better-sqlite3';
-import path25, { dirname } from 'path';
-import fs24, { mkdirSync, writeFileSync, existsSync, readFileSync } from 'fs';
+import path26, { dirname } from 'path';
+import fs25, { promises, mkdirSync, writeFileSync, existsSync, readFileSync } from 'fs';
 import os6 from 'os';
 import crypto4, { randomUUID, randomBytes, createHash, timingSafeEqual, webcrypto } from 'crypto';
 import EventEmitter, { setMaxListeners } from 'events';
@@ -61,12 +61,12 @@ var init_audit_logger = __esm({
       constructor(workspacePath, debugMode = false) {
         this.workspacePath = workspacePath;
         this.debugMode = debugMode;
-        const cascadeDir = path25.join(workspacePath, ".cascade");
-        if (!fs24.existsSync(cascadeDir)) {
-          fs24.mkdirSync(cascadeDir, { recursive: true });
+        const cascadeDir = path26.join(workspacePath, ".cascade");
+        if (!fs25.existsSync(cascadeDir)) {
+          fs25.mkdirSync(cascadeDir, { recursive: true });
         }
-        this.keyPath = path25.join(cascadeDir, "audit_log.key");
-        this.dbPath = path25.join(cascadeDir, "audit_log.db");
+        this.keyPath = path26.join(cascadeDir, "audit_log.key");
+        this.dbPath = path26.join(cascadeDir, "audit_log.db");
         this.initEncryptionKey();
         this.db = new Database(this.dbPath);
         this.db.pragma("journal_mode = WAL");
@@ -96,11 +96,11 @@ var init_audit_logger = __esm({
         return crypto4.createHash("sha256").update(`${prevHash}|${timestamp}|${eventType}|${tierId}|${encryptedPayload}`).digest("hex");
       }
       initEncryptionKey() {
-        if (fs24.existsSync(this.keyPath)) {
-          this.encryptionKey = fs24.readFileSync(this.keyPath);
+        if (fs25.existsSync(this.keyPath)) {
+          this.encryptionKey = fs25.readFileSync(this.keyPath);
         } else {
           this.encryptionKey = crypto4.randomBytes(32);
-          fs24.writeFileSync(this.keyPath, this.encryptionKey);
+          fs25.writeFileSync(this.keyPath, this.encryptionKey);
         }
       }
       encrypt(text) {
@@ -178,9 +178,9 @@ var init_audit_logger = __esm({
       dumpDebugIfNeeded() {
         if (!this.debugMode) return;
         try {
-          const dumpPath = path25.join(os6.tmpdir(), "cascade_audit_logs_debug.json");
+          const dumpPath = path26.join(os6.tmpdir(), "cascade_audit_logs_debug.json");
           const entries = this.getAllLogs();
-          fs24.writeFileSync(dumpPath, JSON.stringify(entries, null, 2), "utf-8");
+          fs25.writeFileSync(dumpPath, JSON.stringify(entries, null, 2), "utf-8");
         } catch (err) {
           console.error("Failed to dump debug audit logs", err);
         }
@@ -1862,7 +1862,7 @@ function reconcilePrice(model, live) {
 }
 
 // src/constants.ts
-var CASCADE_VERSION = "0.67.0";
+var CASCADE_VERSION = "0.68.0";
 var CASCADE_CONFIG_DIR = ".cascade";
 var CASCADE_MD_FILE = "CASCADE.md";
 var CASCADE_IGNORE_FILE = ".cascadeignore";
@@ -4617,7 +4617,7 @@ function computeDelegationSavings(stats, t1Model) {
 var DEFAULT_SNAPSHOT_URL = "https://raw.githubusercontent.com/Varun-SV/Cascade-AI/main/src/core/router/benchmark-data.json";
 var OPENROUTER_MODELS_URL = "https://openrouter.ai/api/v1/models";
 var FETCH_TIMEOUT_MS = 8e3;
-var DEFAULT_CACHE_FILE = path25.join(os6.homedir(), GLOBAL_CONFIG_DIR, "benchmarks-cache.json");
+var DEFAULT_CACHE_FILE = path26.join(os6.homedir(), GLOBAL_CONFIG_DIR, "benchmarks-cache.json");
 function normalizeModelId2(id) {
   let s = id.toLowerCase();
   const slash = s.lastIndexOf("/");
@@ -4764,7 +4764,7 @@ var LiveDataProvider = class {
   }
   async saveCache() {
     try {
-      await fs5.mkdir(path25.dirname(this.opts.cacheFile), { recursive: true });
+      await fs5.mkdir(path26.dirname(this.opts.cacheFile), { recursive: true });
       const cache = {
         fetchedAt: this.fetchedAt,
         snapshot: this.snapshot ?? void 0,
@@ -6556,6 +6556,79 @@ function describeProviderError(c, modelId) {
   }
 }
 
+// src/core/verification/acceptance.ts
+var PATH_TOKEN = /[\w./\\-]{0,200}\w\.[A-Za-z0-9]{1,8}\b/g;
+var QUOTED_NEEDLE = /(?:contains?|includes?|mentions?)\s+["'`]([^"'`]+)["'`]/i;
+var EXISTS = /\b(?:exists?|is\s+created|is\s+present|was\s+created|be\s+created)\b/i;
+var NON_EMPTY = /\b(?:non-?empty|not\s+empty)\b/i;
+var NEGATION = /\b(?:not|no|never|without|absent|missing|does\s*n[o']t)\b/i;
+function targetFile(criterion, ownedFiles) {
+  const mentioned = [...new Set(criterion.match(PATH_TOKEN) ?? [])];
+  if (mentioned.length > 1) return null;
+  if (mentioned.length === 1) {
+    const candidate = mentioned[0];
+    return ownedFiles.find((file) => file === candidate || file.endsWith(`/${candidate}`)) ?? candidate;
+  }
+  return ownedFiles.length === 1 ? ownedFiles[0] : null;
+}
+async function evaluateAcceptance(criteria, ownedFiles, probe) {
+  const results = [];
+  for (const criterion of criteria) {
+    const text = criterion.trim();
+    if (!text) {
+      results.push({ criterion, verdict: "undecidable" });
+      continue;
+    }
+    if (NEGATION.test(text)) {
+      results.push({ criterion, verdict: "undecidable" });
+      continue;
+    }
+    const needle = text.match(QUOTED_NEEDLE)?.[1];
+    const wantsExists = EXISTS.test(text);
+    const wantsNonEmpty = NON_EMPTY.test(text);
+    if (!needle && !wantsExists && !wantsNonEmpty) {
+      results.push({ criterion, verdict: "undecidable" });
+      continue;
+    }
+    const file = targetFile(text, ownedFiles);
+    if (!file) {
+      results.push({ criterion, verdict: "undecidable" });
+      continue;
+    }
+    const stat = await probe.stat(file);
+    if (!stat) {
+      results.push({ criterion, verdict: "failed", detail: `${file} does not exist` });
+      continue;
+    }
+    if (wantsNonEmpty && stat.size === 0) {
+      results.push({ criterion, verdict: "failed", detail: `${file} is empty` });
+      continue;
+    }
+    if (needle) {
+      const content = await probe.read(file);
+      if (content === null) {
+        results.push({ criterion, verdict: "undecidable" });
+        continue;
+      }
+      const found = content.includes(needle);
+      results.push({
+        criterion,
+        verdict: found ? "passed" : "failed",
+        detail: found ? `${file} contains ${JSON.stringify(needle)}` : `${file} does not contain ${JSON.stringify(needle)}`
+      });
+      continue;
+    }
+    results.push({ criterion, verdict: "passed", detail: `${file} exists` });
+  }
+  return results;
+}
+function undecided(results) {
+  return results.filter((r) => r.verdict === "undecidable").map((r) => r.criterion);
+}
+function failures(results) {
+  return results.filter((r) => r.verdict === "failed").map((r) => `Acceptance not met \u2014 ${r.criterion}${r.detail ? ` (${r.detail})` : ""}`);
+}
+
 // src/core/tiers/t3-worker.ts
 var CriticalToolError = class extends Error {
   constructor(message, toolName) {
@@ -6872,7 +6945,7 @@ Now execute your subtask using this context where relevant.`
       }
       const artifactCheck = mustProduceArtifact ? await this.verifyArtifacts(assignment) : { ok: true, issues: [] };
       if (!artifactCheck.ok) {
-        correctionAttempts = 1;
+        correctionAttempts++;
         issues.push(...artifactCheck.issues);
         output = await this.correctOutput(output, artifactCheck.issues);
         const retryArtifactCheck = await this.verifyArtifacts(assignment);
@@ -6890,18 +6963,40 @@ Now execute your subtask using this context where relevant.`
         this.tools.map((t) => t.name)
       );
       if (visualIssue) {
-        correctionAttempts = 1;
+        correctionAttempts++;
         issues.push(visualIssue);
         this.sendStatusUpdate({ progressPct: 68, currentAction: "Verifying requested visuals", status: "IN_PROGRESS" });
         output = await this.correctOutput(output, [visualIssue]);
       }
+      const acceptanceResults = await this.checkAcceptance(assignment);
+      const acceptanceFailures = failures(acceptanceResults);
+      if (acceptanceFailures.length > 0) {
+        correctionAttempts++;
+        issues.push(...acceptanceFailures);
+        this.sendStatusUpdate({ progressPct: 69, currentAction: "Acceptance checks failed \u2014 correcting", status: "IN_PROGRESS" });
+        output = await this.correctOutput(output, acceptanceFailures);
+        const recheck = failures(await this.checkAcceptance(assignment));
+        if (recheck.length > 0) {
+          issues.push(...recheck);
+          checksRun.push(...acceptanceResults.map((r) => r.criterion));
+          failed.push(...recheck);
+          this.setStatus("FAILED");
+          this.peerBus?.publish(this.id, assignment.subtaskId, output, "ESCALATED");
+          return this.buildResult("ESCALATED", output, { checksRun, passed, failed }, issues, correctionAttempts);
+        }
+      }
+      for (const result2 of acceptanceResults) {
+        if (result2.verdict === "undecidable") continue;
+        checksRun.push(result2.criterion);
+        if (result2.verdict === "passed") passed.push(result2.criterion);
+      }
       this.sendStatusUpdate({ progressPct: 70, currentAction: "Self-testing output", status: "IN_PROGRESS" });
-      const testResult = await this.selfTest(assignment, output);
+      const testResult = await this.selfTest(assignment, output, undecided(acceptanceResults));
       checksRun.push(...testResult.checksRun);
       passed.push(...testResult.passed);
       failed.push(...testResult.failed);
       if (testResult.failed.length > 0) {
-        correctionAttempts = 1;
+        correctionAttempts++;
         issues.push(`Initial check failed: ${testResult.failed.join(", ")}`);
         const corrected = await this.correctOutput(output, testResult.failed);
         output = corrected;
@@ -7209,8 +7304,8 @@ HIERARCHY CONTEXT: ${this.hierarchyContext}` : "") + textToolSuffix,
         // Media generation can run for a minute; without this a cancelled run
         // still pays for an image nobody will see.
         ...this.signal ? { signal: this.signal } : {},
-        saveSnapshot: async (path27, content) => {
-          this.store?.addFileSnapshot(this.taskId, path27, content);
+        saveSnapshot: async (path28, content) => {
+          this.store?.addFileSnapshot(this.taskId, path28, content);
         },
         sendPeerSync: (to, syncType, content) => {
           this.peerBus?.send(this.id, to, syncType, this.assignment?.subtaskId ?? "", content);
@@ -7397,7 +7492,7 @@ ${assignment.expectedOutput}`;
     const { promisify: promisify4 } = await import('util');
     const execAsync2 = promisify4(exec2);
     for (const artifactPath of artifactPaths) {
-      const absolutePath = path25.resolve(process.cwd(), artifactPath);
+      const absolutePath = path26.resolve(process.cwd(), artifactPath);
       try {
         const stat = await fs5.stat(absolutePath);
         if (!stat.isFile()) {
@@ -7432,7 +7527,7 @@ ${assignment.expectedOutput}`;
           issues.push(`PDF artifact looks too small to be valid: ${artifactPath}`);
           continue;
         }
-        const ext = path25.extname(absolutePath).toLowerCase();
+        const ext = path26.extname(absolutePath).toLowerCase();
         try {
           if (ext === ".ts" || ext === ".tsx") {
             await execAsync2(`npx tsc --noEmit ${absolutePath}`, { timeout: 1e4 });
@@ -7518,14 +7613,42 @@ HIERARCHY CONTEXT: ${this.hierarchyContext}` : ""),
     }
     return current;
   }
-  async selfTest(assignment, output) {
+  /**
+   * Run the acceptance criteria that can be settled by looking at the workspace.
+   * Reads go through the same workspace-relative resolution verifyArtifacts uses.
+   */
+  async checkAcceptance(assignment) {
+    const criteria = assignment.acceptance ?? [];
+    if (!criteria.length) return [];
+    const resolve2 = (target) => path26.resolve(process.cwd(), target);
+    return evaluateAcceptance(criteria, assignment.files ?? [], {
+      stat: async (target) => {
+        try {
+          const stat = await fs5.stat(resolve2(target));
+          return stat.isFile() ? { size: stat.size } : null;
+        } catch {
+          return null;
+        }
+      },
+      read: async (target) => {
+        try {
+          const content = await fs5.readFile(resolve2(target), "utf-8");
+          return content.includes("\uFFFD") ? null : content;
+        } catch {
+          return null;
+        }
+      }
+    });
+  }
+  async selfTest(assignment, output, pendingAcceptance) {
+    const acceptance = pendingAcceptance ?? assignment.acceptance ?? [];
     const prompt = `Self-test this output against the assignment requirements.
 
 Assignment: ${assignment.description}
 Expected output: ${assignment.expectedOutput}
 Constraints: ${assignment.constraints.join("; ")}
-${assignment.acceptance?.length ? `Acceptance criteria \u2014 ALL must be satisfied for "completeness" to pass:
-${assignment.acceptance.map((a) => `- ${a}`).join("\n")}
+${acceptance.length ? `Acceptance criteria \u2014 ALL must be satisfied for "completeness" to pass:
+${acceptance.map((a) => `- ${a}`).join("\n")}
 ` : ""}
 Output to test:
 ${output}
@@ -7592,8 +7715,8 @@ ${output.slice(0, 4e3)}`;
     } catch {
     }
   }
-  async correctOutput(originalOutput, failures) {
-    const correctionPrompt = `The following output failed these checks: ${failures.join(", ")}.
+  async correctOutput(originalOutput, failures2) {
+    const correctionPrompt = `The following output failed these checks: ${failures2.join(", ")}.
 
 Original output:
 ${originalOutput}
@@ -8254,12 +8377,220 @@ function describeGenerationForPlanner(has) {
   return lines.join("\n");
 }
 
+// src/core/orchestration/task-graph.ts
+var TaskGraphValidationError = class extends Error {
+  constructor(issues) {
+    super(issues.map((issue) => issue.message).join("; "));
+    this.issues = issues;
+    this.name = "TaskGraphValidationError";
+  }
+  issues;
+};
+function normalizeDependencies(input) {
+  if (!input?.length) return [];
+  return [...new Set(input.map((dependency) => dependency.trim()).filter(Boolean))];
+}
+function cycleNodes(nodes) {
+  const adjacency = new Map(
+    nodes.map((node) => [node.id, node.dependsOn])
+  );
+  const index = /* @__PURE__ */ new Map();
+  const lowlink = /* @__PURE__ */ new Map();
+  const onStack = /* @__PURE__ */ new Set();
+  const stack = [];
+  const inCycle = /* @__PURE__ */ new Set();
+  let counter = 0;
+  const open = (id) => {
+    index.set(id, counter);
+    lowlink.set(id, counter);
+    counter++;
+    stack.push(id);
+    onStack.add(id);
+  };
+  for (const root of nodes) {
+    if (index.has(root.id)) continue;
+    open(root.id);
+    const frames = [{ id: root.id, edge: 0 }];
+    while (frames.length > 0) {
+      const frame = frames[frames.length - 1];
+      const neighbours = adjacency.get(frame.id) ?? [];
+      if (frame.edge < neighbours.length) {
+        const next = neighbours[frame.edge];
+        frame.edge++;
+        if (!adjacency.has(next)) continue;
+        if (!index.has(next)) {
+          open(next);
+          frames.push({ id: next, edge: 0 });
+        } else if (onStack.has(next)) {
+          lowlink.set(frame.id, Math.min(lowlink.get(frame.id), index.get(next)));
+        }
+        continue;
+      }
+      frames.pop();
+      const parent = frames[frames.length - 1];
+      if (parent) {
+        lowlink.set(parent.id, Math.min(lowlink.get(parent.id), lowlink.get(frame.id)));
+      }
+      if (lowlink.get(frame.id) === index.get(frame.id)) {
+        const component = [];
+        for (; ; ) {
+          const member = stack.pop();
+          onStack.delete(member);
+          component.push(member);
+          if (member === frame.id) break;
+        }
+        const cyclic = component.length > 1 || (adjacency.get(component[0]) ?? []).includes(component[0]);
+        if (cyclic) for (const member of component) inCycle.add(member);
+      }
+    }
+  }
+  return inCycle;
+}
+function throwIfStrict(mode, issues) {
+  if (mode === "strict" && issues.length > 0) {
+    throw new TaskGraphValidationError(issues);
+  }
+}
+function compileTaskGraph(inputNodes, options = {}) {
+  const mode = options.mode ?? "strict";
+  const issues = [];
+  if (inputNodes.length === 0) {
+    issues.push({ code: "INVALID_NODE", message: "Task graph requires at least one node" });
+    throwIfStrict(mode, issues);
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const nodes = [];
+  for (let ordinal = 0; ordinal < inputNodes.length; ordinal++) {
+    const input = inputNodes[ordinal];
+    const id = input.id?.trim();
+    const title = input.title?.trim();
+    if (!id || !title) {
+      issues.push({
+        code: "INVALID_NODE",
+        nodeId: id || void 0,
+        message: `Task graph node at index ${ordinal} requires a non-empty id and title`
+      });
+      continue;
+    }
+    if (seen.has(id)) {
+      issues.push({
+        code: "DUPLICATE_NODE_ID",
+        nodeId: id,
+        message: `Duplicate task graph node id: ${id}`
+      });
+      continue;
+    }
+    seen.add(id);
+    nodes.push({
+      id,
+      title,
+      kind: input.kind,
+      dependsOn: normalizeDependencies(input.dependsOn),
+      payload: input.payload,
+      ordinal
+    });
+  }
+  throwIfStrict(mode, issues);
+  const ids = new Set(nodes.map((node) => node.id));
+  const sanitized = nodes.map((node) => {
+    const dependsOn = [];
+    for (const dependencyId of node.dependsOn) {
+      if (dependencyId === node.id) {
+        issues.push({
+          code: "SELF_DEPENDENCY",
+          nodeId: node.id,
+          dependencyId,
+          message: `Task graph node ${node.id} cannot depend on itself`
+        });
+        continue;
+      }
+      if (!ids.has(dependencyId)) {
+        issues.push({
+          code: "UNKNOWN_DEPENDENCY",
+          nodeId: node.id,
+          dependencyId,
+          message: `Task graph node ${node.id} depends on unknown node ${dependencyId}`
+        });
+        continue;
+      }
+      dependsOn.push(dependencyId);
+    }
+    return { ...node, dependsOn };
+  });
+  throwIfStrict(mode, issues);
+  const cyclic = cycleNodes(sanitized);
+  let repaired = sanitized;
+  if (cyclic.size > 0) {
+    const cycleIssues = [];
+    repaired = sanitized.map((node) => {
+      if (!cyclic.has(node.id)) return node;
+      const dependsOn = node.dependsOn.filter((dependencyId) => {
+        if (!cyclic.has(dependencyId)) return true;
+        cycleIssues.push({
+          code: "CYCLE_EDGE_REMOVED",
+          nodeId: node.id,
+          dependencyId,
+          message: `Removed cyclic dependency ${dependencyId} -> ${node.id}`
+        });
+        return false;
+      });
+      return { ...node, dependsOn };
+    });
+    issues.push(...cycleIssues);
+    throwIfStrict(mode, cycleIssues);
+  }
+  const remainingCycle = cycleNodes(repaired);
+  if (remainingCycle.size > 0) {
+    throw new TaskGraphValidationError([
+      {
+        code: "INVALID_NODE",
+        message: `Task graph remained cyclic after repair: ${[...remainingCycle].join(", ")}`
+      }
+    ]);
+  }
+  return {
+    graph: { nodes: repaired.sort((a, b) => a.ordinal - b.ordinal) },
+    issues
+  };
+}
+
+// src/core/orchestration/adapters.ts
+function compileSectionGraph(sections) {
+  return compileTaskGraph(
+    sections.map((section) => ({
+      id: section.sectionId,
+      title: section.sectionTitle,
+      kind: "section",
+      dependsOn: section.dependsOn,
+      payload: section
+    })),
+    { mode: "repair" }
+  );
+}
+function compileSubtaskGraph(subtasks) {
+  return compileTaskGraph(
+    subtasks.map((subtask) => ({
+      id: subtask.subtaskId,
+      title: subtask.subtaskTitle,
+      kind: "subtask",
+      dependsOn: subtask.dependsOn,
+      payload: subtask
+    })),
+    { mode: "repair" }
+  );
+}
+
 // src/core/tiers/t2-manager.ts
 function buildT2SystemPrompt(has) {
   const generation = describeGenerationForPlanner(has);
   return [
     "You are a T2 Manager agent in the Cascade AI system.",
-    "Your role is to analyze a section of a task and decompose it into 2-5 discrete subtasks for T3 Workers.",
+    // Must agree with the decomposition prompt in decomposeSection(), which is
+    // the one carrying the actual instruction. It said 1-4 and "the FEWEST that
+    // fully cover it"; this said 2-5. The model received both, so its floor was
+    // simultaneously one and two, and the cheaper reading — pad to two — costs a
+    // real worker call on every small section.
+    "Your role is to analyze a section of a task and decompose it into 1-4 discrete subtasks for T3 Workers \u2014 the fewest that fully cover it.",
     'If subtasks have dependencies, you can specify "executionMode": "sequential" for the section.',
     has("peer_message") && 'Provide "peerT3Ids" to subtasks so they can coordinate using the peer_message tool.',
     "Return ONLY valid JSON matching the T3 subtask array schema \u2014 no other text.",
@@ -8655,21 +8986,30 @@ HIERARCHY CONTEXT: ${this.hierarchyContext}` : ""),
    *     then reduce in-degrees of their dependents and repeat.
    */
   async runWithDependencies(assignments, workerMap, taskId) {
+    const compiled = compileSubtaskGraph(assignments);
+    for (const issue of compiled.issues) {
+      this.log(`\u26A0 Subtask graph: ${issue.message}`);
+    }
+    const sanitizedAssignments = compiled.graph.nodes.map((node) => {
+      const assignment = node.payload;
+      const original = assignment.dependsOn ?? [];
+      const repaired = node.dependsOn;
+      const unchanged = repaired.length === original.length && repaired.every((dependencyId, index) => dependencyId === original[index]);
+      return unchanged ? assignment : { ...assignment, dependsOn: [...repaired] };
+    });
     const adj = /* @__PURE__ */ new Map();
     const inDegree = /* @__PURE__ */ new Map();
     const resultMap = /* @__PURE__ */ new Map();
-    for (const a of assignments) {
+    for (const a of sanitizedAssignments) {
       if (!adj.has(a.subtaskId)) adj.set(a.subtaskId, /* @__PURE__ */ new Set());
       inDegree.set(a.subtaskId, 0);
     }
-    for (const a of assignments) {
-      const deps = a.dependsOn ?? [];
-      for (const dep of deps) {
+    for (const a of sanitizedAssignments) {
+      for (const dep of a.dependsOn ?? []) {
         adj.get(dep).add(a.subtaskId);
         inDegree.set(a.subtaskId, (inDegree.get(a.subtaskId) ?? 0) + 1);
       }
     }
-    const sanitizedAssignments = this.breakCycles(assignments, adj, inDegree);
     let remaining = new Set(sanitizedAssignments.map((a) => a.subtaskId));
     let wave = 0;
     let respawnBudget = 1;
@@ -8876,49 +9216,6 @@ HIERARCHY CONTEXT: ${this.hierarchyContext}` : ""),
     }
     return [...resultMap.values()];
   }
-  /**
-   * Detects cyclic dependencies using Kahn's algorithm and breaks them
-   * by removing back-edges. Returns a sanitized copy of assignments.
-   *
-   * A cycle like t1→t2→t3→t1 is broken at the last edge (t3→t1),
-   * meaning t3 will start without waiting for t1, preventing deadlock.
-   */
-  breakCycles(assignments, adj, inDegree) {
-    const degree = new Map(inDegree);
-    const queue = [];
-    const visited = /* @__PURE__ */ new Set();
-    for (const [id, d] of degree) {
-      if (d === 0) queue.push(id);
-    }
-    while (queue.length > 0) {
-      const id = queue.shift();
-      visited.add(id);
-      for (const dep of adj.get(id) ?? []) {
-        const newDeg = (degree.get(dep) ?? 1) - 1;
-        degree.set(dep, newDeg);
-        if (newDeg === 0) queue.push(dep);
-      }
-    }
-    const cycleNodes = [...inDegree.keys()].filter((id) => !visited.has(id));
-    if (cycleNodes.length === 0) return assignments;
-    this.log(
-      `\u26A0 Circular dependency detected among subtasks: [${cycleNodes.join(", ")}]. Breaking cycles \u2014 affected tasks will run without their cyclic dependencies.`
-    );
-    return assignments.map((a) => {
-      if (!cycleNodes.includes(a.subtaskId)) return a;
-      const safeDeps = (a.dependsOn ?? []).filter((d) => !cycleNodes.includes(d));
-      if (safeDeps.length !== (a.dependsOn ?? []).length) {
-        this.log(
-          `  \u2192 Breaking cycle: removed ${(a.dependsOn ?? []).filter((d) => cycleNodes.includes(d)).join(", ")} from "${a.subtaskTitle}" dependsOn`
-        );
-        for (const removed of (a.dependsOn ?? []).filter((d) => cycleNodes.includes(d))) {
-          inDegree.set(a.subtaskId, Math.max(0, (inDegree.get(a.subtaskId) ?? 1) - 1));
-          adj.get(removed)?.delete(a.subtaskId);
-        }
-      }
-      return { ...a, dependsOn: safeDeps };
-    });
-  }
   async retryT3(assignment, taskId) {
     this.log(`Retrying T3 for subtask: ${assignment.subtaskTitle}`);
     const worker = new T3Worker(this.router, this.toolRegistry, this.id);
@@ -9054,6 +9351,57 @@ HIERARCHY CONTEXT: ${this.hierarchyContext}` : ""),
   }
 };
 
+// src/core/orchestration/scheduler.ts
+var DependencyScheduler = class {
+  constructor(graph, hooks, options = {}) {
+    this.graph = graph;
+    this.hooks = hooks;
+    this.options = options;
+  }
+  graph;
+  hooks;
+  options;
+  async run() {
+    const nodes = [...this.graph.nodes].sort((a, b) => a.ordinal - b.ordinal);
+    const inDegree = new Map(nodes.map((node) => [node.id, node.dependsOn.length]));
+    const dependents = /* @__PURE__ */ new Map();
+    for (const node of nodes) dependents.set(node.id, []);
+    for (const node of nodes) {
+      for (const dependencyId of node.dependsOn) {
+        dependents.get(dependencyId)?.push(node.id);
+      }
+    }
+    const completed = /* @__PURE__ */ new Set();
+    const results = /* @__PURE__ */ new Map();
+    const waves = [];
+    let wave = 0;
+    while (completed.size < nodes.length) {
+      const ready = nodes.filter((node) => !completed.has(node.id) && (inDegree.get(node.id) ?? 0) === 0);
+      if (ready.length === 0) {
+        throw new Error("Dependency scheduler received a cyclic or incomplete task graph");
+      }
+      waves.push(ready.map((node) => node.id));
+      await this.hooks.onWaveStart?.(ready, wave);
+      const runOne = async (node) => {
+        const result = await this.hooks.execute(node);
+        results.set(node.id, result);
+        completed.add(node.id);
+        for (const dependentId of dependents.get(node.id) ?? []) {
+          inDegree.set(dependentId, Math.max(0, (inDegree.get(dependentId) ?? 1) - 1));
+        }
+        await this.hooks.onNodeComplete?.(node, result);
+      };
+      if ((this.options.mode ?? "parallel") === "sequential") {
+        for (const node of ready) await runOne(node);
+      } else {
+        await Promise.all(ready.map(runOne));
+      }
+      wave++;
+    }
+    return { results, waves };
+  }
+};
+
 // src/utils/json-extract.ts
 function extractFirstJsonObject(input) {
   if (!input) return null;
@@ -9125,7 +9473,7 @@ function buildT1SystemPrompt(has) {
 Your responsibilities:
 1. Analyze task complexity: Simple | Moderate | Complex | Highly Complex
 2. Decompose the task into logical sections (one per T2 Manager)
-3. For each section, define 2-5 subtasks for T3 Workers
+3. For each section, define 1-4 subtasks for T3 Workers \u2014 the fewest that fully cover it
 4. Return a structured plan as JSON
 
 CRITICAL PATH RULE: If the user specifies a target directory (e.g. "inside python_exclusive",
@@ -9540,7 +9888,11 @@ SPEC RULES \u2014 each subtask is a self-contained spec slice (workers execute f
       }
     }
     const [min, max] = COMPLEXITY_T2_COUNT[plan.complexity] ?? [1, 8];
-    if (plan.sections.length < min) ;
+    if (plan.sections.length < min || plan.sections.length > max) {
+      this.log(
+        `\u26A0 Plan has ${plan.sections.length} section(s) but complexity "${plan.complexity}" expects ${min}-${max}. Keeping the plan as written \u2014 a right-sized plan is better than one padded to hit a floor.`
+      );
+    }
   }
   async dispatchT2Managers(sections) {
     for (const section of sections) {
@@ -9652,114 +10004,91 @@ SPEC RULES \u2014 each subtask is a self-contained spec slice (workers execute f
     return t2Results;
   }
   /**
-   * Runs T2 managers respecting dependsOn declarations using Kahn's algorithm.
+   * Runs T2 managers respecting dependsOn declarations.
+   *
+   * Graph construction, validation and cycle repair now live in
+   * compileSectionGraph (orchestration/adapters.ts), and wave execution in
+   * DependencyScheduler — the same pair T2 uses for its subtasks, so a plan is
+   * ordered by one implementation rather than two that drifted.
+   *
+   * The hand-rolled Kahn pass this replaces treated every node it could not
+   * reach as part of a cycle. That set also contains everything DOWNSTREAM of a
+   * cycle, whose in-degree can never fall to zero while its dependency is stuck,
+   * so breaking a cycle here also cut the dependencies of innocent later
+   * sections and started them immediately — before the sections they consume.
+   * compileTaskGraph uses strongly connected components, so only real cycle
+   * members are touched.
    */
   async runT2sWithDependencies(sections, managers, taskId) {
-    const adj = /* @__PURE__ */ new Map();
-    const inDegree = /* @__PURE__ */ new Map();
-    const resultMap = /* @__PURE__ */ new Map();
-    const allKeys = new Set(sections.map((s) => s.sectionId));
-    for (const s of sections) {
-      if (!adj.has(s.sectionId)) adj.set(s.sectionId, /* @__PURE__ */ new Set());
-      inDegree.set(s.sectionId, 0);
-      s.dependsOn = (s.dependsOn ?? []).filter((d) => allKeys.has(d));
+    const compiled = compileSectionGraph(sections);
+    for (const issue of compiled.issues) {
+      this.log(`\u26A0 Section graph: ${issue.message}`);
     }
-    for (const s of sections) {
-      for (const dep of s.dependsOn ?? []) {
-        adj.get(dep).add(s.sectionId);
-        inDegree.set(s.sectionId, (inDegree.get(s.sectionId) ?? 0) + 1);
-      }
-    }
-    const queue = [];
-    const degree = new Map(inDegree);
-    for (const [id, deg] of degree.entries()) if (deg === 0) queue.push(id);
-    const visited = /* @__PURE__ */ new Set();
-    while (queue.length > 0) {
-      const u = queue.shift();
-      visited.add(u);
-      for (const v of adj.get(u) ?? /* @__PURE__ */ new Set()) {
-        const newDeg = (degree.get(v) ?? 1) - 1;
-        degree.set(v, newDeg);
-        if (newDeg === 0) queue.push(v);
-      }
-    }
-    const cycleNodes = [...inDegree.keys()].filter((id) => !visited.has(id));
-    if (cycleNodes.length > 0) {
-      this.log(`\u26A0 Circular dependency detected among sections: [${cycleNodes.join(", ")}]. Breaking cycles.`);
-      for (const s of sections) {
-        if (cycleNodes.includes(s.sectionId)) {
-          const safeDeps = (s.dependsOn ?? []).filter((d) => !cycleNodes.includes(d));
-          for (const removed of (s.dependsOn ?? []).filter((d) => cycleNodes.includes(d))) {
-            inDegree.set(s.sectionId, Math.max(0, (inDegree.get(s.sectionId) ?? 1) - 1));
-            adj.get(removed)?.delete(s.sectionId);
-          }
-          s.dependsOn = safeDeps;
-        }
-      }
+    const byId = new Map(compiled.graph.nodes.map((node) => [node.id, node]));
+    for (const section of sections) {
+      const node = byId.get(section.sectionId);
+      if (node) section.dependsOn = [...node.dependsOn];
     }
-    const totalSections = sections.length;
+    const resultMap = /* @__PURE__ */ new Map();
+    const totalSections = compiled.graph.nodes.length;
     let completedSections = 0;
-    const executeWave = async () => {
-      const readyIds = [];
-      for (const [id, deg] of inDegree.entries()) {
-        if (deg === 0 && !resultMap.has(id)) {
-          readyIds.push(id);
-        }
-      }
-      if (readyIds.length === 0) return;
-      const runOne = async (id) => {
-        resultMap.set(id, null);
-        const index = sections.findIndex((s) => s.sectionId === id);
-        const section = sections[index];
-        const manager = managers[index];
-        const progressPct = 10 + Math.floor(completedSections / totalSections * 85);
-        this.sendStatusUpdate({
-          progressPct,
-          currentAction: `T2 working on: ${section.sectionTitle}`,
-          status: "IN_PROGRESS"
-        });
-        this.throwIfCancelled();
-        let result;
-        try {
-          result = await manager.execute(section, taskId, this.signal);
-          manager.shareCompletedOutput(section.sectionId, result.sectionSummary);
-          if (result.status === "ESCALATED") {
-            this.escalations.push({
-              raisedBy: `T2_${section.sectionId}`,
+    const scheduler = new DependencyScheduler(
+      compiled.graph,
+      {
+        execute: async (node) => {
+          const section = node.payload;
+          const manager = managers[node.ordinal];
+          const progressPct = 10 + Math.floor(completedSections / totalSections * 85);
+          this.sendStatusUpdate({
+            progressPct,
+            currentAction: `T2 working on: ${section.sectionTitle}`,
+            status: "IN_PROGRESS"
+          });
+          this.throwIfCancelled();
+          try {
+            const result = await manager.execute(section, taskId, this.signal);
+            manager.shareCompletedOutput(section.sectionId, result.sectionSummary);
+            if (result.status === "ESCALATED") {
+              this.escalations.push({
+                raisedBy: `T2_${section.sectionId}`,
+                sectionId: section.sectionId,
+                attempted: result.issues,
+                blocker: result.issues.join("; "),
+                needs: "Human review required"
+              });
+            }
+            return result;
+          } catch (err) {
+            return {
               sectionId: section.sectionId,
-              attempted: result.issues,
-              blocker: result.issues.join("; "),
-              needs: "Human review required"
-            });
+              sectionTitle: section.sectionTitle,
+              status: "FAILED",
+              t3Results: [],
+              sectionSummary: "",
+              issues: [err instanceof Error ? err.message : String(err)]
+            };
           }
-        } catch (err) {
-          result = {
-            sectionId: section.sectionId,
-            sectionTitle: section.sectionTitle,
-            status: "FAILED",
-            t3Results: [],
-            sectionSummary: "",
-            issues: [err instanceof Error ? err.message : String(err)]
-          };
-        }
-        resultMap.set(id, result);
-        completedSections++;
-        for (const dependentId of adj.get(id) ?? /* @__PURE__ */ new Set()) {
-          inDegree.set(dependentId, Math.max(0, (inDegree.get(dependentId) ?? 1) - 1));
-        }
-      };
-      if (this.router.getT3ExecutionMode?.() === "sequential") {
-        for (const id of readyIds) {
-          await runOne(id);
+        },
+        onNodeComplete: (node, result) => {
+          resultMap.set(node.id, result);
+          completedSections++;
+          this.emit("section:complete", {
+            id: node.id,
+            title: result.sectionTitle,
+            status: result.status,
+            output: result.sectionSummary
+          });
         }
-      } else {
-        await Promise.all(readyIds.map(runOne));
-      }
-      if (Array.from(inDegree.values()).some((deg) => deg === 0) && resultMap.size < totalSections) {
-        await executeWave();
+      },
+      {
+        // Cross-section concurrency respects the same t3Execution mode as the
+        // intra-section T3 wave (t2-manager.ts) — 'sequential' otherwise only
+        // serialized T3 workers within a single section while every section's
+        // T2Manager (and its T3 workers) still ran in parallel here.
+        mode: this.router.getT3ExecutionMode?.() === "sequential" ? "sequential" : "parallel"
       }
-    };
-    await executeWave();
+    );
+    await scheduler.run();
     return sections.map((s) => resultMap.get(s.sectionId)).filter(Boolean);
   }
   async compileFinalOutput(originalPrompt, plan, t2Results) {
@@ -10389,16 +10718,16 @@ function resolveInWorkspace(workspaceRoot, input) {
   if (typeof input !== "string" || input.length === 0) {
     throw new WorkspaceSandboxError(String(input), workspaceRoot);
   }
-  const root = path25.resolve(workspaceRoot);
-  const abs = path25.isAbsolute(input) ? path25.resolve(input) : path25.resolve(root, input);
-  const rel = path25.relative(root, abs);
-  if (rel === "" || rel === ".") ; else if (rel.startsWith("..") || path25.isAbsolute(rel)) {
+  const root = path26.resolve(workspaceRoot);
+  const abs = path26.isAbsolute(input) ? path26.resolve(input) : path26.resolve(root, input);
+  const rel = path26.relative(root, abs);
+  if (rel === "" || rel === ".") ; else if (rel.startsWith("..") || path26.isAbsolute(rel)) {
     throw new WorkspaceSandboxError(input, root);
   }
   try {
-    const real = fs24.realpathSync(abs);
-    const realRel = path25.relative(root, real);
-    if (realRel !== "" && realRel !== "." && (realRel.startsWith("..") || path25.isAbsolute(realRel))) {
+    const real = fs25.realpathSync(abs);
+    const realRel = path26.relative(root, real);
+    if (realRel !== "" && realRel !== "." && (realRel.startsWith("..") || path26.isAbsolute(realRel))) {
       throw new WorkspaceSandboxError(input, root);
     }
   } catch (e) {
@@ -11056,7 +11385,7 @@ var GenerateDocumentTool = class extends BaseTool {
       }
     }
     const bytes = await renderDocument(ext, content, { name: filePath, loadImageBytes });
-    await fs5.mkdir(path25.dirname(absPath), { recursive: true });
+    await fs5.mkdir(path26.dirname(absPath), { recursive: true });
     await fs5.writeFile(absPath, bytes);
     const charts = countCharts(content);
     return [
@@ -11451,7 +11780,7 @@ var FileWriteTool = class extends BaseTool {
       } catch {
       }
     }
-    await fs5.mkdir(path25.dirname(absPath), { recursive: true });
+    await fs5.mkdir(path26.dirname(absPath), { recursive: true });
     await fs5.writeFile(absPath, content, "utf-8");
     return `Written ${content.length} characters to ${filePath}`;
   }
@@ -11949,7 +12278,7 @@ var ImageAnalyzeTool = class extends BaseTool {
 };
 async function fileToImageAttachment(filePath) {
   const data = await fs5.readFile(filePath);
-  const ext = path25.extname(filePath).toLowerCase();
+  const ext = path26.extname(filePath).toLowerCase();
   const mimeMap = {
     ".jpg": "image/jpeg",
     ".jpeg": "image/jpeg",
@@ -11983,14 +12312,14 @@ var PDFCreateTool = class extends BaseTool {
     const filePath = input["path"];
     const content = input["content"];
     const title = input["title"];
-    const dir = path25.dirname(filePath);
-    if (!fs24.existsSync(dir)) {
-      fs24.mkdirSync(dir, { recursive: true });
+    const dir = path26.dirname(filePath);
+    if (!fs25.existsSync(dir)) {
+      fs25.mkdirSync(dir, { recursive: true });
     }
     return new Promise((resolve2, reject) => {
       try {
         const doc = new PDFDocument({ margin: 50 });
-        const stream = fs24.createWriteStream(filePath);
+        const stream = fs25.createWriteStream(filePath);
         doc.pipe(stream);
         if (title) {
           doc.info["Title"] = title;
@@ -12068,22 +12397,22 @@ var CodeInterpreterTool = class extends BaseTool {
       }
       cmdPrefix = NODE_CMD;
     }
-    const tmpDir = path25.join(this.workspaceRoot, ".cascade", "tmp");
-    if (!fs24.existsSync(tmpDir)) {
-      fs24.mkdirSync(tmpDir, { recursive: true });
+    const tmpDir = path26.join(this.workspaceRoot, ".cascade", "tmp");
+    if (!fs25.existsSync(tmpDir)) {
+      fs25.mkdirSync(tmpDir, { recursive: true });
     }
     const extension = language === "python" ? "py" : "js";
     const fileName = `intp_${randomUUID().slice(0, 8)}.${extension}`;
-    const filePath = path25.join(tmpDir, fileName);
-    fs24.writeFileSync(filePath, code, "utf-8");
+    const filePath = path26.join(tmpDir, fileName);
+    fs25.writeFileSync(filePath, code, "utf-8");
     const execArgs = [filePath, ...args];
     return new Promise((resolve2) => {
       const startMs = Date.now();
       execFile(cmdPrefix, execArgs, { cwd: this.workspaceRoot, timeout: 3e4 }, (error, stdout, stderr) => {
         const duration = Date.now() - startMs;
         try {
-          if (fs24.existsSync(filePath)) {
-            fs24.unlinkSync(filePath);
+          if (fs25.existsSync(filePath)) {
+            fs25.unlinkSync(filePath);
           }
         } catch (cleanupErr) {
           console.error(`Failed to cleanup interpreter script ${filePath}:`, cleanupErr);
@@ -12395,7 +12724,7 @@ var GlobTool = class extends BaseTool {
   };
   async execute(input, _options) {
     const pattern = input["pattern"];
-    const searchPath = input["path"] ? path25.resolve(this.workspaceRoot, input["path"]) : this.workspaceRoot;
+    const searchPath = input["path"] ? path26.resolve(this.workspaceRoot, input["path"]) : this.workspaceRoot;
     const matches = await glob(pattern, {
       cwd: searchPath,
       ignore: ["node_modules/**", ".git/**", "dist/**", "build/**"],
@@ -12408,7 +12737,7 @@ var GlobTool = class extends BaseTool {
     const withMtime = await Promise.all(
       matches.map(async (rel) => {
         try {
-          const stat = await fs5.stat(path25.join(searchPath, rel));
+          const stat = await fs5.stat(path26.join(searchPath, rel));
           return { rel, mtime: stat.mtimeMs };
         } catch {
           return { rel, mtime: 0 };
@@ -12457,7 +12786,7 @@ var GrepTool = class extends BaseTool {
   };
   async execute(input, _options) {
     const pattern = input["pattern"];
-    const searchPath = input["path"] ? path25.resolve(this.workspaceRoot, input["path"]) : this.workspaceRoot;
+    const searchPath = input["path"] ? path26.resolve(this.workspaceRoot, input["path"]) : this.workspaceRoot;
     const globPattern = input["glob"];
     const outputMode = input["output_mode"] ?? "content";
     const context = input["context"] ?? 0;
@@ -12511,12 +12840,12 @@ var GrepTool = class extends BaseTool {
         nodir: true
       });
     } catch {
-      files = [path25.relative(searchPath, searchPath) || "."];
+      files = [path26.relative(searchPath, searchPath) || "."];
     }
     const results = [];
     let totalCount = 0;
     for (const rel of files) {
-      const abs = path25.join(searchPath, rel);
+      const abs = path26.join(searchPath, rel);
       let content;
       try {
         content = await fs5.readFile(abs, "utf-8");
@@ -12903,10 +13232,10 @@ var ToolRegistry = class extends EventEmitter {
   }
   isIgnored(filePath) {
     if (!filePath) return false;
-    const abs = path25.resolve(this.workspaceRoot, filePath);
-    const rel = path25.relative(this.workspaceRoot, abs);
-    if (!rel || rel.startsWith("..") || path25.isAbsolute(rel)) return true;
-    const posixRel = rel.split(path25.sep).join("/");
+    const abs = path26.resolve(this.workspaceRoot, filePath);
+    const rel = path26.relative(this.workspaceRoot, abs);
+    if (!rel || rel.startsWith("..") || path26.isAbsolute(rel)) return true;
+    const posixRel = rel.split(path26.sep).join("/");
     return this.ignoreMatcher.ignores(posixRel);
   }
 };
@@ -13140,22 +13469,22 @@ var FileMcpOAuthStore = class {
   filePath;
   load() {
     try {
-      return JSON.parse(fs24.readFileSync(this.filePath, "utf-8"));
+      return JSON.parse(fs25.readFileSync(this.filePath, "utf-8"));
     } catch {
       return void 0;
     }
   }
   save(state) {
-    fs24.mkdirSync(path25.dirname(this.filePath), { recursive: true, mode: 448 });
-    fs24.writeFileSync(this.filePath, JSON.stringify(state, null, 2), { mode: 384 });
+    fs25.mkdirSync(path26.dirname(this.filePath), { recursive: true, mode: 448 });
+    fs25.writeFileSync(this.filePath, JSON.stringify(state, null, 2), { mode: 384 });
     try {
-      fs24.chmodSync(this.filePath, 384);
+      fs25.chmodSync(this.filePath, 384);
     } catch {
     }
   }
   clear() {
     try {
-      fs24.rmSync(this.filePath);
+      fs25.rmSync(this.filePath);
     } catch {
     }
   }
@@ -14052,6 +14381,14 @@ function heuristicAnalyze(prompt) {
   const estimatedTokens = wordCount * 5;
   return { type, complexity, requiresReasoning, requiresVision, estimatedTokens, confidence };
 }
+function hashPrompt(prompt) {
+  let hash = 2166136261;
+  for (let index = 0; index < prompt.length; index++) {
+    hash ^= prompt.charCodeAt(index);
+    hash = Math.imul(hash, 16777619) >>> 0;
+  }
+  return `${prompt.length}:${hash.toString(36)}`;
+}
 var analysisCache = /* @__PURE__ */ new Map();
 var TASK_TYPE_TAGS = {
   code: ["code", "instruction"],
@@ -14095,7 +14432,7 @@ var TaskAnalyzer = class {
    * Low confidence prompts fall back to a conservative mixed/moderate profile.
    */
   async analyze(prompt) {
-    const cacheKey = prompt.slice(0, 200);
+    const cacheKey = hashPrompt(prompt);
     const cached = analysisCache.get(cacheKey);
     if (cached) {
       this.lastProfile = cached;
@@ -14194,7 +14531,7 @@ var TaskAnalyzer = class {
     analysisCache.clear();
   }
 };
-var DEFAULT_STATS_FILE = path25.join(os6.homedir(), ".cascade", "model-perf.json");
+var DEFAULT_STATS_FILE = path26.join(os6.homedir(), ".cascade", "model-perf.json");
 var ModelPerformanceTracker = class {
   stats = /* @__PURE__ */ new Map();
   featureStats = /* @__PURE__ */ new Map();
@@ -14234,7 +14571,7 @@ var ModelPerformanceTracker = class {
   async save() {
     if (this.readOnly) return;
     try {
-      await fs5.mkdir(path25.dirname(this.statsFile), { recursive: true });
+      await fs5.mkdir(path26.dirname(this.statsFile), { recursive: true });
       const modelsObj = {};
       const featuresObj = {};
       for (const [key, stat] of this.stats) modelsObj[key] = stat;
@@ -14782,7 +15119,7 @@ Required capability: ${description.slice(0, 300)}`;
    *  any dangerous action, so a silently-reloaded tool can't act without approval. */
   async loadPersistedTools() {
     if (!this.workspacePath || !this.persistEnabled) return;
-    const file = path25.join(this.workspacePath, ".cascade", DYNAMIC_TOOLS_FILE);
+    const file = path26.join(this.workspacePath, ".cascade", DYNAMIC_TOOLS_FILE);
     try {
       const raw = await fs5.readFile(file, "utf-8");
       const specs = JSON.parse(raw);
@@ -14806,8 +15143,8 @@ Required capability: ${description.slice(0, 300)}`;
   }
   async persist() {
     if (!this.workspacePath || !this.persistEnabled) return;
-    const dir = path25.join(this.workspacePath, ".cascade");
-    const file = path25.join(dir, DYNAMIC_TOOLS_FILE);
+    const dir = path26.join(this.workspacePath, ".cascade");
+    const file = path26.join(dir, DYNAMIC_TOOLS_FILE);
     try {
       await fs5.mkdir(dir, { recursive: true });
       await fs5.writeFile(file, JSON.stringify(Array.from(this.specs.values()), null, 2), "utf-8");
@@ -14827,12 +15164,12 @@ var WorldStateDB = class {
   constructor(workspacePath, debugMode = false) {
     this.workspacePath = workspacePath;
     this.debugMode = debugMode;
-    const cascadeDir = path25.join(workspacePath, ".cascade");
-    if (!fs24.existsSync(cascadeDir)) {
-      fs24.mkdirSync(cascadeDir, { recursive: true });
+    const cascadeDir = path26.join(workspacePath, ".cascade");
+    if (!fs25.existsSync(cascadeDir)) {
+      fs25.mkdirSync(cascadeDir, { recursive: true });
     }
-    this.keyPath = path25.join(cascadeDir, "world_state.key");
-    this.dbPath = path25.join(cascadeDir, "world_state.db");
+    this.keyPath = path26.join(cascadeDir, "world_state.key");
+    this.dbPath = path26.join(cascadeDir, "world_state.db");
     this.initEncryptionKey();
     this.db = new Database(this.dbPath);
     this.db.pragma("journal_mode = WAL");
@@ -14889,11 +15226,11 @@ var WorldStateDB = class {
     ).run(e, r, row.encrypted_value, row.source_worker, row.timestamp, validTo, change);
   }
   initEncryptionKey() {
-    if (fs24.existsSync(this.keyPath)) {
-      this.encryptionKey = fs24.readFileSync(this.keyPath);
+    if (fs25.existsSync(this.keyPath)) {
+      this.encryptionKey = fs25.readFileSync(this.keyPath);
     } else {
       this.encryptionKey = crypto4.randomBytes(32);
-      fs24.writeFileSync(this.keyPath, this.encryptionKey);
+      fs25.writeFileSync(this.keyPath, this.encryptionKey);
     }
   }
   encrypt(text) {
@@ -15179,9 +15516,9 @@ var WorldStateDB = class {
   dumpDebugIfNeeded() {
     if (!this.debugMode) return;
     try {
-      const dumpPath = path25.join(os6.tmpdir(), "cascade_world_state_debug.json");
+      const dumpPath = path26.join(os6.tmpdir(), "cascade_world_state_debug.json");
       const entries = this.getAllEntries();
-      fs24.writeFileSync(dumpPath, JSON.stringify(entries, null, 2), "utf-8");
+      fs25.writeFileSync(dumpPath, JSON.stringify(entries, null, 2), "utf-8");
     } catch (err) {
       console.error("Failed to dump debug world state", err);
     }
@@ -15190,6 +15527,128 @@ var WorldStateDB = class {
     this.db.close();
   }
 };
+var RESUME_SCHEMA_VERSION = 1;
+var DEFAULT_MAX_CHECKPOINTS = 5;
+var DEFAULT_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1e3;
+var FILE_PATTERN = /^(\d+)-(.+)\.json$/;
+function safeId(taskId) {
+  const cleaned = taskId.replace(/[^A-Za-z0-9._-]/g, "_").replace(/\.{2,}/g, "_");
+  return cleaned.slice(0, 100) || "run";
+}
+function isCheckpoint(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const c = value;
+  return c.version === RESUME_SCHEMA_VERSION && typeof c.taskId === "string" && typeof c.prompt === "string" && typeof c.createdAt === "string" && typeof c.partialOutput === "string" && Array.isArray(c.completed);
+}
+var ResumeStore = class {
+  dir;
+  maxCheckpoints;
+  maxAgeMs;
+  now;
+  constructor(options) {
+    this.dir = options.dir;
+    this.maxCheckpoints = options.maxCheckpoints ?? DEFAULT_MAX_CHECKPOINTS;
+    this.maxAgeMs = options.maxAgeMs ?? DEFAULT_MAX_AGE_MS;
+    this.now = options.now ?? Date.now;
+  }
+  /**
+   * Persist a checkpoint and prune. Never throws: failing to save a resume file
+   * must not turn a recoverable stop into a crash, which would be a strictly
+   * worse outcome than the one this store exists to improve.
+   */
+  async save(checkpoint) {
+    try {
+      const timestamp = this.now();
+      const record = {
+        ...checkpoint,
+        version: RESUME_SCHEMA_VERSION,
+        createdAt: checkpoint.createdAt ?? new Date(timestamp).toISOString()
+      };
+      await promises.mkdir(this.dir, { recursive: true });
+      const finalPath = path26.join(this.dir, `${timestamp}-${safeId(record.taskId)}.json`);
+      const tempPath = `${finalPath}.${process.pid}.tmp`;
+      await promises.writeFile(tempPath, JSON.stringify(record, null, 2), "utf-8");
+      await promises.rename(tempPath, finalPath);
+      await this.prune();
+    } catch {
+    }
+  }
+  /** Valid, unexpired checkpoints, newest first. */
+  async list() {
+    let entries;
+    try {
+      entries = await promises.readdir(this.dir);
+    } catch {
+      return [];
+    }
+    const cutoff = this.now() - this.maxAgeMs;
+    const candidates = entries.map((name) => ({ name, match: FILE_PATTERN.exec(name) })).filter((e) => e.match !== null).map((e) => ({ name: e.name, timestamp: Number(e.match[1]) })).filter((e) => e.timestamp >= cutoff).sort((a, b) => b.timestamp - a.timestamp);
+    const checkpoints = [];
+    for (const candidate of candidates) {
+      try {
+        const raw = await promises.readFile(path26.join(this.dir, candidate.name), "utf-8");
+        const parsed = JSON.parse(raw);
+        if (isCheckpoint(parsed)) checkpoints.push(parsed);
+      } catch {
+        continue;
+      }
+    }
+    return checkpoints;
+  }
+  /** The most recent resumable run, or null. */
+  async latest() {
+    return (await this.list())[0] ?? null;
+  }
+  /**
+   * Load a checkpoint and delete it in the same step. Resuming twice from one
+   * checkpoint would re-run restored work, so consumption is part of reading.
+   */
+  async consume(taskId) {
+    const all = await this.list();
+    const target = taskId ? all.find((c) => c.taskId === taskId) : all[0];
+    if (!target) return null;
+    await this.delete(target.taskId);
+    return target;
+  }
+  /** Remove every checkpoint for a task id. */
+  async delete(taskId) {
+    try {
+      const entries = await promises.readdir(this.dir);
+      const wanted = safeId(taskId);
+      await Promise.all(entries.map(async (name) => {
+        const match = FILE_PATTERN.exec(name);
+        if (match?.[2] === wanted) {
+          await promises.rm(path26.join(this.dir, name), { force: true });
+        }
+      }));
+    } catch {
+    }
+  }
+  /** Drop expired checkpoints, then any beyond the newest `maxCheckpoints`. */
+  async prune() {
+    try {
+      const entries = await promises.readdir(this.dir);
+      const cutoff = this.now() - this.maxAgeMs;
+      const files = entries.map((name) => ({ name, match: FILE_PATTERN.exec(name) })).filter((e) => e.match !== null).map((e) => ({ name: e.name, timestamp: Number(e.match[1]) })).sort((a, b) => b.timestamp - a.timestamp);
+      const doomed = files.filter((f, index) => f.timestamp < cutoff || index >= this.maxCheckpoints);
+      const staleTemps = entries.filter((name) => name.endsWith(".tmp")).filter((name) => (Number(FILE_PATTERN.exec(name.replace(/\.\d+\.tmp$/, ".json"))?.[1]) || 0) < cutoff);
+      await Promise.all([...doomed.map((f) => f.name), ...staleTemps].map(
+        (name) => promises.rm(path26.join(this.dir, name), { force: true })
+      ));
+    } catch {
+    }
+  }
+};
+function summarizeCompleted(completed, perNodeChars = 500) {
+  if (!completed.length) return "";
+  const lines = completed.map((node) => {
+    const body = node.output.length > perNodeChars ? `${node.output.slice(0, perNodeChars)}\u2026` : node.output;
+    return `- [${node.status}] ${node.title}
+  ${body.replace(/\n/g, "\n  ")}`;
+  });
+  return `ALREADY COMPLETED in a previous attempt \u2014 do NOT redo these:
+${lines.join("\n")}`;
+}
 var ignore2 = ignoreFactory.default ?? ignoreFactory;
 var PrivacyPaths = class {
   localOnly;
@@ -15236,7 +15695,7 @@ var CascadeIgnore = class {
     ]);
   }
   async load(workspacePath) {
-    const filePath = path25.join(workspacePath, ".cascadeignore");
+    const filePath = path26.join(workspacePath, ".cascadeignore");
     try {
       const content = await fs5.readFile(filePath, "utf-8");
       const lines = content.split("\n").filter((l) => l.trim() && !l.startsWith("#"));
@@ -15247,7 +15706,7 @@ var CascadeIgnore = class {
   }
   isIgnored(filePath, workspacePath) {
     try {
-      const relative = workspacePath ? path25.relative(workspacePath, filePath) : filePath;
+      const relative = workspacePath ? path26.relative(workspacePath, filePath) : filePath;
       return this.ig.ignores(relative);
     } catch {
       return false;
@@ -15590,7 +16049,7 @@ var WorkspaceIndex = class {
   isIgnored;
   chunker;
   constructor(opts) {
-    this.root = path25.resolve(opts.root);
+    this.root = path26.resolve(opts.root);
     this.db = opts.db;
     this.namespace = opts.namespace ?? "code";
     this.extensions = new Set((opts.extensions ?? DEFAULT_EXTENSIONS).map((e) => e.replace(/^\./, "").toLowerCase()));
@@ -15622,14 +16081,14 @@ var WorkspaceIndex = class {
         return;
       }
       for (const entry of entries) {
-        const abs = path25.join(dir, entry.name);
+        const abs = path26.join(dir, entry.name);
         if (entry.isDirectory()) {
           if (HARD_SKIP_DIRS.has(entry.name) || this.isIgnored(abs)) continue;
           await walk(abs);
         } else if (entry.isFile()) {
-          const ext = path25.extname(entry.name).slice(1).toLowerCase();
+          const ext = path26.extname(entry.name).slice(1).toLowerCase();
           if (!this.extensions.has(ext) || this.isIgnored(abs)) continue;
-          out.push(path25.relative(this.root, abs));
+          out.push(path26.relative(this.root, abs));
         }
       }
     };
@@ -15659,7 +16118,7 @@ var WorkspaceIndex = class {
     const entries = [];
     for (const rel of rels) {
       try {
-        const abs = path25.join(this.root, rel);
+        const abs = path26.join(this.root, rel);
         const stat = await fs5.stat(abs);
         if (stat.size > this.maxFileBytes) continue;
         const buf = await fs5.readFile(abs);
@@ -16197,8 +16656,16 @@ var Cascade = class _Cascade extends EventEmitter {
   /** Orchestration decisions for the CURRENT run — cleared on each run(). */
   decisionLog = [];
   initialized = false;
-  /** Last task that stopped at the budget cap — powers /continue (resumeRun). */
+  /**
+   * Last interrupted task — powers /continue (resumeRun). Kept in memory as a
+   * fast path for the same-process case; the durable copy lives in `resumeStore`
+   * so a crash or an exit no longer throws away everything already finished.
+   */
   lastInterruptedRun;
+  /** Durable resume checkpoints. See core/orchestration/resume-store.ts. */
+  resumeStore;
+  /** Section results of the CURRENT run, so an interruption can checkpoint them. */
+  currentRunCompleted = [];
   initPromise;
   store;
   audit;
@@ -16231,10 +16698,16 @@ var Cascade = class _Cascade extends EventEmitter {
     this.toolRegistry = new ToolRegistry(this.config.tools, workspacePath);
     try {
       this.router.setDeadModelStore(new DeadModelStore(
-        fileDeadModelPersistence(path25.join(workspacePath, ".cascade", "dead-models.json"))
+        fileDeadModelPersistence(path26.join(workspacePath, ".cascade", "dead-models.json"))
       ));
     } catch {
     }
+    try {
+      this.resumeStore = new ResumeStore({
+        dir: path26.join(workspacePath, ".cascade", "resume")
+      });
+    } catch {
+    }
     this.multimodal = new MultimodalRegistry(
       (this.config.providers ?? []).map((p) => p.type)
     );
@@ -16319,8 +16792,8 @@ var Cascade = class _Cascade extends EventEmitter {
       this.emit("log", { level: "warn", message: "Code index enabled but no embeddings-capable provider is configured \u2014 skipping." });
       return;
     }
-    const dbPath = ci.dbPath || path25.join(this.workspacePath, ".cascade", "code-index.db");
-    fs24.mkdirSync(path25.dirname(dbPath), { recursive: true });
+    const dbPath = ci.dbPath || path26.join(this.workspacePath, ".cascade", "code-index.db");
+    fs25.mkdirSync(path26.dirname(dbPath), { recursive: true });
     const db = new Database(dbPath);
     db.pragma("journal_mode = WAL");
     const complete = chatCompleterFromProviders(this.config.providers);
@@ -16700,10 +17173,43 @@ ${input}` }],
   setFeedbackSource(source) {
     this.router.setFeedbackSource(source);
   }
-  /** True when a task stopped at the budget cap and can be resumed via /continue. */
+  /**
+   * Write a durable checkpoint for an interrupted run.
+   *
+   * Best-effort throughout: a run is already ending badly on every path that
+   * calls this, and failing to record a resume file must not make that ending
+   * worse. Nothing here is allowed to throw.
+   */
+  async checkpointRun(taskId, prompt, partialOutput, reason, detail) {
+    if (!this.currentRunCompleted.length && !partialOutput) return;
+    try {
+      await this.resumeStore?.save({
+        taskId,
+        prompt,
+        reason,
+        ...detail ? { detail } : {},
+        partialOutput,
+        completed: [...this.currentRunCompleted]
+      });
+    } catch {
+    }
+  }
+  /** True when a task can be resumed via /continue (this process or a previous one). */
   hasResumableRun() {
     return this.lastInterruptedRun != null;
   }
+  /**
+   * True when a checkpoint from ANY process is resumable. Async because the
+   * durable check touches disk; `hasResumableRun` remains the sync in-memory
+   * answer for callers already on a hot path.
+   */
+  async hasDurableResume() {
+    return await this.resumeStore?.latest() != null;
+  }
+  /** Interrupted runs available to resume, newest first. */
+  async listResumableRuns() {
+    return await this.resumeStore?.list() ?? [];
+  }
   /**
    * Raise the per-run token budget for a resume and return the continuation
    * prompt (or null when nothing is resumable). Consumes the interrupted-run
@@ -16714,22 +17220,54 @@ ${input}` }],
     const last = this.lastInterruptedRun;
     if (!last) return null;
     this.lastInterruptedRun = void 0;
-    const raised = opts.maxTokens ?? Math.round((this.config.budget?.maxTokensPerRun ?? 2e5) * 2);
+    this.raiseBudgetForResume(opts.maxTokens);
+    return this.buildResumePrompt(last.prompt, last.partialOutput, []);
+  }
+  /**
+   * Durable counterpart to prepareResume: recovers a run interrupted in ANY
+   * process, including one that crashed before it could return. Consumes the
+   * checkpoint, so the same finished work is never restored into two runs.
+   */
+  async prepareDurableResume(opts = {}) {
+    const checkpoint = await this.resumeStore?.consume(opts.taskId);
+    if (!checkpoint) return null;
+    this.lastInterruptedRun = void 0;
+    this.raiseBudgetForResume(opts.maxTokens);
+    return this.buildResumePrompt(checkpoint.prompt, checkpoint.partialOutput, checkpoint.completed);
+  }
+  /** A resume gets a bigger budget — the previous attempt exhausted the old one. */
+  raiseBudgetForResume(maxTokens) {
+    const raised = maxTokens ?? Math.round((this.config.budget?.maxTokensPerRun ?? 2e5) * 2);
     this.config = { ...this.config, budget: { ...this.config.budget, maxTokensPerRun: raised } };
     this.router.setMaxTokensPerRun(raised);
-    return `Continue and FINISH this task. A previous attempt was interrupted before completion; any files already created are on disk \u2014 build on them, do NOT recreate them. Complete only the remaining work.
-
-Original task: ${last.prompt}` + (last.partialOutput ? `
-
+  }
+  /**
+   * The resume prompt. Completed sections are named explicitly rather than
+   * gestured at: "do not recreate the files" is an instruction a planner can
+   * only guess at, whereas a list of what is already done, and what it produced,
+   * is something it can act on. That difference is the entire reason node
+   * results are kept — a re-plan that cannot see the finished work will plan the
+   * finished work again, and the user pays for it a second time.
+   */
+  buildResumePrompt(prompt, partialOutput, completed) {
+    const done = summarizeCompleted(completed);
+    return [
+      "Continue and FINISH this task. A previous attempt was interrupted before completion; any files already created are on disk \u2014 build on them, do NOT recreate them. Plan ONLY the remaining work.",
+      "",
+      `Original task: ${prompt}`,
+      done ? `
+${done}` : "",
+      partialOutput ? `
 Partial result so far:
-${last.partialOutput}` : "");
+${partialOutput}` : ""
+    ].filter(Boolean).join("\n");
   }
   /**
    * Resume the last budget-capped task with a raised budget (SDK/headless).
    * Returns null when there is nothing to resume.
    */
   async resumeRun(opts = {}) {
-    const prompt = this.prepareResume(opts);
+    const prompt = await this.prepareDurableResume(opts) ?? this.prepareResume(opts);
     if (!prompt) return null;
     return this.run({ prompt });
   }
@@ -17100,6 +17638,7 @@ ${prompt}` : prompt;
     const startMs = Date.now();
     const taskId = randomUUID();
     this.decisionLog = [];
+    this.currentRunCompleted = [];
     if (options.fastAnswer) {
       return this.runFastAnswer(options, startMs, taskId);
     }
@@ -17214,6 +17753,11 @@ ${prompt}` : prompt;
       });
       tier.on("log", (e) => this.emit("log", e));
       tier.on("tier:status", (e) => this.emit("tier:status", e));
+      tier.on("section:complete", (e) => {
+        if (e.status !== "COMPLETED" && e.status !== "PARTIAL") return;
+        this.currentRunCompleted.push(e);
+        this.emit("section:complete", e);
+      });
       tier.on("tool:call", (e) => this.emit("tool:call", e));
       tier.on("tool:result", (e) => this.emit("tool:result", e));
       tier.on("tool:approval-request", async (request) => {
@@ -17360,6 +17904,7 @@ _(incomplete: ${reasons.join("; ")})_` : partial;
       if (budgetInfo) throw new CascadeRouter.BudgetExceededError(budgetInfo.reason);
       const trip = runBreaker.reason();
       if (trip) {
+        await this.checkpointRun(taskId, options.prompt, finalOutput || "", "breaker", trip.message);
         finalOutput = [
           `\u26A0 **Run stopped early \u2014 ${trip.modelId} was failing every request.**`,
           "",
@@ -17379,6 +17924,13 @@ ${finalOutput}` : ""
           reason: err instanceof Error ? err.message : "Task cancelled",
           partialOutput: finalOutput || ""
         });
+        await this.checkpointRun(
+          taskId,
+          options.prompt,
+          finalOutput || "",
+          "cancelled",
+          err instanceof Error ? err.message : "Task cancelled"
+        );
         runError = null;
       } else if (err instanceof Error && err.name === "BudgetExceededError") {
         this.emit("run:budget-exceeded", {
@@ -17387,9 +17939,17 @@ ${finalOutput}` : ""
           partialOutput: finalOutput || ""
         });
         this.lastInterruptedRun = { prompt: options.prompt, partialOutput: finalOutput || "", taskId };
+        await this.checkpointRun(taskId, options.prompt, finalOutput || "", "budget", err.message);
         if (!finalOutput) finalOutput = `\u26A0 Stopped to avoid runaway cost: ${err.message}`;
         runError = null;
       } else {
+        await this.checkpointRun(
+          taskId,
+          options.prompt,
+          finalOutput || "",
+          "error",
+          err instanceof Error ? err.message : String(err)
+        );
         runError = err;
         throw err;
       }
@@ -17637,7 +18197,7 @@ var Keystore = class {
       const creds = await this.keytar.findCredentials(KEYTAR_SERVICE);
       this.cache = Object.fromEntries(creds.map((c) => [c.account, c.password]));
       this.backend = "keytar";
-      if (password && fs24.existsSync(this.storePath)) {
+      if (password && fs25.existsSync(this.storePath)) {
         try {
           const fileEntries = this.decryptFile(password);
           for (const [k, v] of Object.entries(fileEntries)) {
@@ -17656,7 +18216,7 @@ var Keystore = class {
         "Keystore unlock requires a password because the OS keychain (keytar) is not available on this system."
       );
     }
-    if (!fs24.existsSync(this.storePath)) {
+    if (!fs25.existsSync(this.storePath)) {
       const salt = crypto4.randomBytes(SALT_LEN);
       this.masterKey = this.deriveKey(password, salt);
       this.writeWithSalt({}, salt);
@@ -17670,7 +18230,7 @@ var Keystore = class {
   }
   /** Synchronous legacy unlock kept for AES-only environments. */
   unlockSync(password) {
-    if (!fs24.existsSync(this.storePath)) {
+    if (!fs25.existsSync(this.storePath)) {
       const salt = crypto4.randomBytes(SALT_LEN);
       this.masterKey = this.deriveKey(password, salt);
       this.writeWithSalt({}, salt);
@@ -17728,7 +18288,7 @@ var Keystore = class {
     }
   }
   decryptFile(password, knownSalt) {
-    if (!fs24.existsSync(this.storePath)) return {};
+    if (!fs25.existsSync(this.storePath)) return {};
     try {
       const { salt, ciphertext, iv, tag } = this.readRaw();
       const useSalt = knownSalt ?? salt;
@@ -17750,8 +18310,8 @@ var Keystore = class {
     const ciphertext = Buffer.concat([cipher.update(plaintext), cipher.final()]);
     const tag = cipher.getAuthTag();
     const out = Buffer.concat([raw.salt, iv, tag, ciphertext]);
-    fs24.mkdirSync(path25.dirname(this.storePath), { recursive: true });
-    fs24.writeFileSync(this.storePath, out, { mode: 384 });
+    fs25.mkdirSync(path26.dirname(this.storePath), { recursive: true });
+    fs25.writeFileSync(this.storePath, out, { mode: 384 });
   }
   writeWithSalt(data, salt) {
     if (!this.masterKey) throw new Error("writeWithSalt called before masterKey was set");
@@ -17761,11 +18321,11 @@ var Keystore = class {
     const ciphertext = Buffer.concat([cipher.update(plaintext), cipher.final()]);
     const tag = cipher.getAuthTag();
     const out = Buffer.concat([salt, iv, tag, ciphertext]);
-    fs24.mkdirSync(path25.dirname(this.storePath), { recursive: true });
-    fs24.writeFileSync(this.storePath, out, { mode: 384 });
+    fs25.mkdirSync(path26.dirname(this.storePath), { recursive: true });
+    fs25.writeFileSync(this.storePath, out, { mode: 384 });
   }
   readRaw() {
-    const buf = fs24.readFileSync(this.storePath);
+    const buf = fs25.readFileSync(this.storePath);
     let offset = 0;
     const salt = buf.subarray(offset, offset + SALT_LEN);
     offset += SALT_LEN;
@@ -17781,7 +18341,7 @@ var Keystore = class {
   }
 };
 async function loadCascadeMd(workspacePath) {
-  const filePath = path25.join(workspacePath, "CASCADE.md");
+  const filePath = path26.join(workspacePath, "CASCADE.md");
   try {
     const raw = await fs5.readFile(filePath, "utf-8");
     return parseCascadeMd(raw);
@@ -17812,7 +18372,7 @@ ${raw.trim()}`;
 var MemoryStore = class _MemoryStore {
   db;
   constructor(dbPath) {
-    fs24.mkdirSync(path25.dirname(dbPath), { recursive: true });
+    fs25.mkdirSync(path26.dirname(dbPath), { recursive: true });
     try {
       this.db = new Database(dbPath, { timeout: 5e3 });
       this.db.pragma("journal_mode = WAL");
@@ -18648,7 +19208,7 @@ Original error: ${err.message}`
   }
 };
 function credentialsPath(globalDir2) {
-  return path25.join(globalDir2, GLOBAL_CREDENTIALS_FILE);
+  return path26.join(globalDir2, GLOBAL_CREDENTIALS_FILE);
 }
 function providerKey(p) {
   if (p.type === "azure") {
@@ -18661,7 +19221,7 @@ function isPersistable(p) {
 }
 function loadGlobalCredentials(globalDir2) {
   try {
-    const raw = fs24.readFileSync(credentialsPath(globalDir2), "utf-8");
+    const raw = fs25.readFileSync(credentialsPath(globalDir2), "utf-8");
     const parsed = JSON.parse(raw);
     if (!Array.isArray(parsed.providers)) return [];
     return parsed.providers.filter(
@@ -18673,13 +19233,13 @@ function loadGlobalCredentials(globalDir2) {
 }
 function saveGlobalCredentials(globalDir2, providers) {
   const filePath = credentialsPath(globalDir2);
-  fs24.mkdirSync(globalDir2, { recursive: true, mode: 448 });
+  fs25.mkdirSync(globalDir2, { recursive: true, mode: 448 });
   const body = { version: 1, providers: providers.filter(isPersistable) };
   const tmp = `${filePath}.tmp`;
-  fs24.writeFileSync(tmp, JSON.stringify(body, null, 2), { encoding: "utf-8", mode: 384 });
-  fs24.renameSync(tmp, filePath);
+  fs25.writeFileSync(tmp, JSON.stringify(body, null, 2), { encoding: "utf-8", mode: 384 });
+  fs25.renameSync(tmp, filePath);
   try {
-    fs24.chmodSync(filePath, 384);
+    fs25.chmodSync(filePath, 384);
   } catch {
   }
 }
@@ -18714,7 +19274,7 @@ var ConfigManager = class {
   /** `globalDirOverride` exists for tests — never point it at the real home dir there. */
   constructor(workspacePath = process.cwd(), globalDirOverride) {
     this.workspacePath = workspacePath;
-    this.globalDir = globalDirOverride ?? path25.join(os6.homedir(), GLOBAL_CONFIG_DIR);
+    this.globalDir = globalDirOverride ?? path26.join(os6.homedir(), GLOBAL_CONFIG_DIR);
   }
   async load() {
     this.config = await this.loadConfig();
@@ -18728,8 +19288,8 @@ var ConfigManager = class {
     this.ignore = new CascadeIgnore();
     await this.ignore.load(this.workspacePath);
     this.cascadeMd = await loadCascadeMd(this.workspacePath);
-    this.keystore = new Keystore(path25.join(this.globalDir, GLOBAL_KEYSTORE_FILE));
-    this.store = new MemoryStore(path25.join(this.workspacePath, CASCADE_DB_FILE));
+    this.keystore = new Keystore(path26.join(this.globalDir, GLOBAL_KEYSTORE_FILE));
+    this.store = new MemoryStore(path26.join(this.workspacePath, CASCADE_DB_FILE));
     await this.injectEnvKeys();
     this.config.providers = mergeGlobalCredentials(this.config.providers, loadGlobalCredentials(this.globalDir));
     await this.ensureDefaultIdentity();
@@ -18754,8 +19314,8 @@ var ConfigManager = class {
     return this.workspacePath;
   }
   async save() {
-    const configPath = path25.join(this.workspacePath, CASCADE_CONFIG_FILE);
-    await fs5.mkdir(path25.dirname(configPath), { recursive: true });
+    const configPath = path26.join(this.workspacePath, CASCADE_CONFIG_FILE);
+    await fs5.mkdir(path26.dirname(configPath), { recursive: true });
     await fs5.writeFile(configPath, JSON.stringify(this.config, null, 2), "utf-8");
     try {
       saveGlobalCredentials(this.globalDir, this.config.providers);
@@ -18791,7 +19351,7 @@ var ConfigManager = class {
     return configProvider?.apiKey;
   }
   async loadConfig() {
-    const configPath = path25.join(this.workspacePath, CASCADE_CONFIG_FILE);
+    const configPath = path26.join(this.workspacePath, CASCADE_CONFIG_FILE);
     try {
       const raw = await fs5.readFile(configPath, "utf-8");
       return validateConfig(JSON.parse(raw));
@@ -19323,7 +19883,7 @@ function aggregateCostStats(sessions, opts = {}) {
 }
 
 // src/dashboard/server.ts
-var __dirname$1 = path25.dirname(fileURLToPath(import.meta.url));
+var __dirname$1 = path26.dirname(fileURLToPath(import.meta.url));
 var ORPHANED_ESCALATION_GRACE_MS = 3e4;
 var DashboardServer = class {
   app;
@@ -19603,14 +20163,14 @@ var DashboardServer = class {
    */
   persistConfig() {
     try {
-      const configPath = path25.join(this.workspacePath, CASCADE_CONFIG_FILE);
-      fs24.mkdirSync(path25.dirname(configPath), { recursive: true });
-      fs24.writeFileSync(configPath, JSON.stringify(this.config, null, 2), "utf-8");
+      const configPath = path26.join(this.workspacePath, CASCADE_CONFIG_FILE);
+      fs25.mkdirSync(path26.dirname(configPath), { recursive: true });
+      fs25.writeFileSync(configPath, JSON.stringify(this.config, null, 2), "utf-8");
     } catch (err) {
       console.warn(`[dashboard] Failed to persist config: ${err instanceof Error ? err.message : String(err)}`);
     }
     try {
-      saveGlobalCredentials(path25.join(os6.homedir(), GLOBAL_CONFIG_DIR), this.config.providers ?? []);
+      saveGlobalCredentials(path26.join(os6.homedir(), GLOBAL_CONFIG_DIR), this.config.providers ?? []);
     } catch (err) {
       console.warn(`[dashboard] Failed to sync global credentials: ${err instanceof Error ? err.message : String(err)}`);
     }
@@ -19625,15 +20185,15 @@ var DashboardServer = class {
   resolveDashboardSecret() {
     const fromConfig = this.config.dashboard.secret ?? process.env["CASCADE_DASHBOARD_SECRET"];
     if (fromConfig) return fromConfig;
-    const secretPath = path25.join(this.workspacePath, CASCADE_DASHBOARD_SECRET_FILE);
+    const secretPath = path26.join(this.workspacePath, CASCADE_DASHBOARD_SECRET_FILE);
     try {
-      if (fs24.existsSync(secretPath)) {
-        const existing = fs24.readFileSync(secretPath, "utf-8").trim();
+      if (fs25.existsSync(secretPath)) {
+        const existing = fs25.readFileSync(secretPath, "utf-8").trim();
         if (existing.length >= 16) return existing;
       }
       const generated = randomUUID();
-      fs24.mkdirSync(path25.dirname(secretPath), { recursive: true });
-      fs24.writeFileSync(secretPath, generated, { encoding: "utf-8", mode: 384 });
+      fs25.mkdirSync(path26.dirname(secretPath), { recursive: true });
+      fs25.writeFileSync(secretPath, generated, { encoding: "utf-8", mode: 384 });
       if (this.config.dashboard.auth) {
         console.warn(
           `Dashboard auth enabled with no secret configured; persisted a generated secret to ${secretPath}. Set CASCADE_DASHBOARD_SECRET or config.dashboard.secret to override.`
@@ -19660,7 +20220,7 @@ var DashboardServer = class {
   // ── Setup ─────────────────────────────────────
   getGlobalStore() {
     if (!this.globalStore) {
-      const globalDbPath = path25.join(os6.homedir(), GLOBAL_CONFIG_DIR, GLOBAL_RUNTIME_DB_FILE);
+      const globalDbPath = path26.join(os6.homedir(), GLOBAL_CONFIG_DIR, GLOBAL_RUNTIME_DB_FILE);
       this.globalStore = new MemoryStore(globalDbPath);
     }
     return this.globalStore;
@@ -20040,12 +20600,12 @@ ${prompt}`;
     }
   }
   watchRuntimeChanges() {
-    const workspaceDbPath = path25.join(this.workspacePath, CASCADE_DB_FILE);
-    const globalDbPath = path25.join(os6.homedir(), GLOBAL_CONFIG_DIR, GLOBAL_RUNTIME_DB_FILE);
+    const workspaceDbPath = path26.join(this.workspacePath, CASCADE_DB_FILE);
+    const globalDbPath = path26.join(os6.homedir(), GLOBAL_CONFIG_DIR, GLOBAL_RUNTIME_DB_FILE);
     const watchPaths = [workspaceDbPath, globalDbPath].filter((p, index, arr) => arr.indexOf(p) === index);
     for (const watchPath of watchPaths) {
-      if (!fs24.existsSync(watchPath)) continue;
-      fs24.watchFile(watchPath, { interval: 3e3 }, () => {
+      if (!fs25.existsSync(watchPath)) continue;
+      fs25.watchFile(watchPath, { interval: 3e3 }, () => {
         this.throttledBroadcast(watchPath === globalDbPath ? "global" : "workspace");
       });
     }
@@ -20167,7 +20727,7 @@ ${prompt}`;
       const sessionId = req.params.id;
       this.store.deleteSession(sessionId);
       this.store.deleteRuntimeSession(sessionId);
-      const globalDbPath = path25.join(os6.homedir(), GLOBAL_CONFIG_DIR, GLOBAL_RUNTIME_DB_FILE);
+      const globalDbPath = path26.join(os6.homedir(), GLOBAL_CONFIG_DIR, GLOBAL_RUNTIME_DB_FILE);
       const globalStore = new MemoryStore(globalDbPath);
       try {
         globalStore.deleteRuntimeSession(sessionId);
@@ -20260,7 +20820,7 @@ ${prompt}`;
     });
     this.app.delete("/api/sessions", auth2, (req, res) => {
       const body = req.body;
-      const globalDbPath = path25.join(os6.homedir(), GLOBAL_CONFIG_DIR, GLOBAL_RUNTIME_DB_FILE);
+      const globalDbPath = path26.join(os6.homedir(), GLOBAL_CONFIG_DIR, GLOBAL_RUNTIME_DB_FILE);
       if (body?.ids && Array.isArray(body.ids) && body.ids.length > 0) {
         const globalStore = new MemoryStore(globalDbPath);
         try {
@@ -20283,7 +20843,7 @@ ${prompt}`;
     });
     this.app.delete("/api/runtime", auth2, (_req, res) => {
       this.store.deleteAllRuntimeNodes();
-      const globalDbPath = path25.join(os6.homedir(), GLOBAL_CONFIG_DIR, GLOBAL_RUNTIME_DB_FILE);
+      const globalDbPath = path26.join(os6.homedir(), GLOBAL_CONFIG_DIR, GLOBAL_RUNTIME_DB_FILE);
       const globalStore = new MemoryStore(globalDbPath);
       try {
         globalStore.deleteAllRuntimeNodes();
@@ -20369,12 +20929,12 @@ ${prompt}`;
       if (body["tierLimits"]) this.config.tierLimits = { ...this.config.tierLimits, ...body["tierLimits"] };
       if (body["budget"]) this.config.budget = { ...this.config.budget, ...body["budget"] };
       try {
-        const configPath = path25.join(this.workspacePath, CASCADE_CONFIG_FILE);
-        const existing = fs24.existsSync(configPath) ? JSON.parse(fs24.readFileSync(configPath, "utf-8")) : {};
+        const configPath = path26.join(this.workspacePath, CASCADE_CONFIG_FILE);
+        const existing = fs25.existsSync(configPath) ? JSON.parse(fs25.readFileSync(configPath, "utf-8")) : {};
         const updated = { ...existing, tierLimits: this.config.tierLimits, budget: this.config.budget };
         const tmp = configPath + ".tmp";
-        fs24.writeFileSync(tmp, JSON.stringify(updated, null, 2), "utf-8");
-        fs24.renameSync(tmp, configPath);
+        fs25.writeFileSync(tmp, JSON.stringify(updated, null, 2), "utf-8");
+        fs25.renameSync(tmp, configPath);
         res.json({ ok: true });
       } catch (err) {
         res.status(500).json({ error: `Failed to save config: ${err instanceof Error ? err.message : String(err)}` });
@@ -20402,7 +20962,7 @@ ${prompt}`;
     this.app.get("/api/runtime", auth2, (req, res) => {
       const scope = req.query["scope"] ?? "workspace";
       if (scope === "global") {
-        const globalDbPath = path25.join(os6.homedir(), GLOBAL_CONFIG_DIR, GLOBAL_RUNTIME_DB_FILE);
+        const globalDbPath = path26.join(os6.homedir(), GLOBAL_CONFIG_DIR, GLOBAL_RUNTIME_DB_FILE);
         const globalStore = new MemoryStore(globalDbPath);
         try {
           res.json({
@@ -20743,13 +21303,13 @@ ${prompt}`;
         res.status(500).json({ error: err instanceof Error ? err.message : String(err) });
       }
     });
-    const prodPath = path25.resolve(__dirname$1, "../web/dist");
-    const devPath = path25.resolve(__dirname$1, "../../web/dist");
-    const webDistPath = fs24.existsSync(prodPath) ? prodPath : devPath;
-    if (fs24.existsSync(webDistPath)) {
+    const prodPath = path26.resolve(__dirname$1, "../web/dist");
+    const devPath = path26.resolve(__dirname$1, "../../web/dist");
+    const webDistPath = fs25.existsSync(prodPath) ? prodPath : devPath;
+    if (fs25.existsSync(webDistPath)) {
       this.app.use(express.static(webDistPath));
       this.app.get("*", (_req, res) => {
-        res.sendFile(path25.join(webDistPath, "index.html"));
+        res.sendFile(path26.join(webDistPath, "index.html"));
       });
     } else {
       this.app.get("/", (_req, res) => {
@@ -20936,14 +21496,14 @@ function planRetrieval(ctx) {
 }
 var CLOUD_SESSION_FILE = "cloud-session.json";
 function globalDir(homeDir = os6.homedir()) {
-  return path25.join(homeDir, GLOBAL_CONFIG_DIR);
+  return path26.join(homeDir, GLOBAL_CONFIG_DIR);
 }
 function cloudSessionPath(dir = globalDir()) {
-  return path25.join(dir, CLOUD_SESSION_FILE);
+  return path26.join(dir, CLOUD_SESSION_FILE);
 }
 function loadCloudSession(dir = globalDir()) {
   try {
-    const raw = fs24.readFileSync(cloudSessionPath(dir), "utf-8");
+    const raw = fs25.readFileSync(cloudSessionPath(dir), "utf-8");
     const parsed = JSON.parse(raw);
     if (!parsed?.refreshToken || !parsed?.serverUrl) return null;
     return parsed;
@@ -20952,17 +21512,17 @@ function loadCloudSession(dir = globalDir()) {
   }
 }
 function saveCloudSession(session, dir = globalDir()) {
-  fs24.mkdirSync(dir, { recursive: true, mode: 448 });
+  fs25.mkdirSync(dir, { recursive: true, mode: 448 });
   const file = cloudSessionPath(dir);
-  fs24.writeFileSync(file, JSON.stringify(session, null, 2), { mode: 384 });
+  fs25.writeFileSync(file, JSON.stringify(session, null, 2), { mode: 384 });
   try {
-    fs24.chmodSync(file, 384);
+    fs25.chmodSync(file, 384);
   } catch {
   }
 }
 function clearCloudSession(dir = globalDir()) {
   try {
-    fs24.rmSync(cloudSessionPath(dir));
+    fs25.rmSync(cloudSessionPath(dir));
   } catch {
   }
 }
@@ -21134,16 +21694,16 @@ var CloudClient = class _CloudClient {
     return (await this.refresh()).accessToken;
   }
   /** Authenticated request that refreshes once on a 401 (e.g. server-side revoke). */
-  async authed(path27, init = {}) {
-    const call = (token) => fetch(this.url(path27), { ...init, headers: { ...init.headers ?? {}, Authorization: `Bearer ${token}` } });
+  async authed(path28, init = {}) {
+    const call = (token) => fetch(this.url(path28), { ...init, headers: { ...init.headers ?? {}, Authorization: `Bearer ${token}` } });
     let res = await call(await this.accessToken());
     if (res.status === 401) res = await call((await this.refresh()).accessToken);
     if (!res.ok) throw new Error(`Request failed (${res.status}).`);
     const text = await res.text();
     return text ? JSON.parse(text) : {};
   }
-  authedGet(path27) {
-    return this.authed(path27);
+  authedGet(path28) {
+    return this.authed(path28);
   }
   async fetchMe(token) {
     const res = await fetch(this.url("/api/me"), { headers: { Authorization: `Bearer ${token}` } });
@@ -21480,6 +22040,6 @@ function applySyncBundle(bundle, config) {
   return next;
 }
 
-export { AZURE_BASE_MODELS, AZURE_BASE_URL_TEMPLATE, AuditLogger, CASCADE_AUDIT_FILE, CASCADE_CONFIG_DIR, CASCADE_CONFIG_FILE, CASCADE_DASHBOARD_SECRET_FILE, CASCADE_DB_FILE, CASCADE_IGNORE_FILE, CASCADE_KEYSTORE_FILE, CASCADE_MD_FILE, CASCADE_VERSION, CHARS_PER_TOKEN, COMPLEXITY_T2_COUNT, Cascade, CascadeCancelledError, CascadeIgnore, CascadeRouter, CascadeToolError, CloudClient, CodeSearchTool, ConfigManager, CurrentPageTool, DEFAULT_API_PORT, DEFAULT_APPROVAL_REQUIRED, DEFAULT_AUTO_SUMMARIZE_AT, DEFAULT_CLOUD_URL, DEFAULT_CONTEXT_LIMIT, DEFAULT_DASHBOARD_PORT, DEFAULT_MAX_SESSION_MESSAGES, DEFAULT_RETENTION_DAYS, DEFAULT_THEME, DOCUMENT_MIME, DashboardServer, FileMcpOAuthStore, GITHUB_MODELS_API_VERSION, GITHUB_MODELS_CATALOG_URL, GITHUB_MODELS_INFERENCE_URL, GLOBAL_CONFIG_DIR, GLOBAL_CREDENTIALS_FILE, GLOBAL_DB_FILE, GLOBAL_KEYSTORE_FILE, GLOBAL_RUNTIME_DB_FILE, GenerateDocumentTool, GraphRetriever, GraphSearchTool, HooksRunner, Keystore, LLMReranker, LM_STUDIO_BASE_URL, MAX_PAGE_TEXT_CHARS, MCP_TOOL_PREFIX, MODELS, McpClient, McpOAuthProvider, MemoryStore, OLLAMA_BASE_URL, OpenAICompatibleEmbedder, PROVIDER_DISPLAY_NAMES, Retriever, SqliteVectorStore, T1Administrator, T1_MODEL_PRIORITY, T2Manager, T2_MODEL_PRIORITY, T3Worker, T3_MODEL_PRIORITY, THEME_NAMES, TOOL_NAMES, TaskScheduler, Telemetry, ToolRegistry, VISION_MODEL_PRIORITY, WorkspaceIndex, applySyncBundle, azureModelForDeployment, beginMcpOAuth, buildDocumentTools, buildManifest, buildSessionTranscript, bytesToBase64, cagCharBudget, chartKind, chartToTableRows, chatCompleterFromProviders, chunkCode, chunkText2 as chunkText, completeMcpOAuth, connectMcpWithLoopbackOAuth, createCascade, decryptJSON as decryptSyncBlob, diffManifest, disambiguateMcpServerNames, discoverMcpAuthServer, discoverMcpTools, distillSessionFacts, embedderFromProviders, encryptJSON as encryptSyncBlob, extractCharts, fileExt, fileOAuthProvider, gatherSyncBundle, hashContent, heuristicCodeChunker, inferAzureBaseModel, inlineRuns, isDocumentFormat, isMcpToolName, matchImageLine, mcpServerPrefix, mcpToolName, nodeHttpFetch, parseBlocks, parseChartSpec, parseDelimited, parseRankOrder, parseSlide, planRetrieval, preferIpv4Host, reciprocalRankFusion, refreshMcpToken, removeMcpServerDenials, renderDocument, renderDocx, renderPptx, renderXlsx, runCascade, sessionWorthRemembering, sniffImage, splitSlides, streamCascade, stripInline, uniqueMcpServerName };
+export { AZURE_BASE_MODELS, AZURE_BASE_URL_TEMPLATE, AuditLogger, CASCADE_AUDIT_FILE, CASCADE_CONFIG_DIR, CASCADE_CONFIG_FILE, CASCADE_DASHBOARD_SECRET_FILE, CASCADE_DB_FILE, CASCADE_IGNORE_FILE, CASCADE_KEYSTORE_FILE, CASCADE_MD_FILE, CASCADE_VERSION, CHARS_PER_TOKEN, COMPLEXITY_T2_COUNT, Cascade, CascadeCancelledError, CascadeIgnore, CascadeRouter, CascadeToolError, CloudClient, CodeSearchTool, ConfigManager, CurrentPageTool, DEFAULT_API_PORT, DEFAULT_APPROVAL_REQUIRED, DEFAULT_AUTO_SUMMARIZE_AT, DEFAULT_CLOUD_URL, DEFAULT_CONTEXT_LIMIT, DEFAULT_DASHBOARD_PORT, DEFAULT_MAX_SESSION_MESSAGES, DEFAULT_RETENTION_DAYS, DEFAULT_THEME, DOCUMENT_MIME, DashboardServer, DependencyScheduler, FileMcpOAuthStore, GITHUB_MODELS_API_VERSION, GITHUB_MODELS_CATALOG_URL, GITHUB_MODELS_INFERENCE_URL, GLOBAL_CONFIG_DIR, GLOBAL_CREDENTIALS_FILE, GLOBAL_DB_FILE, GLOBAL_KEYSTORE_FILE, GLOBAL_RUNTIME_DB_FILE, GenerateDocumentTool, GraphRetriever, GraphSearchTool, HooksRunner, Keystore, LLMReranker, LM_STUDIO_BASE_URL, MAX_PAGE_TEXT_CHARS, MCP_TOOL_PREFIX, MODELS, McpClient, McpOAuthProvider, MemoryStore, OLLAMA_BASE_URL, OpenAICompatibleEmbedder, PROVIDER_DISPLAY_NAMES, RESUME_SCHEMA_VERSION, ResumeStore, Retriever, SqliteVectorStore, T1Administrator, T1_MODEL_PRIORITY, T2Manager, T2_MODEL_PRIORITY, T3Worker, T3_MODEL_PRIORITY, THEME_NAMES, TOOL_NAMES, TaskGraphValidationError, TaskScheduler, Telemetry, ToolRegistry, VISION_MODEL_PRIORITY, WorkspaceIndex, applySyncBundle, azureModelForDeployment, beginMcpOAuth, buildDocumentTools, buildManifest, buildSessionTranscript, bytesToBase64, cagCharBudget, chartKind, chartToTableRows, chatCompleterFromProviders, chunkCode, chunkText2 as chunkText, compileSectionGraph, compileSubtaskGraph, compileTaskGraph, completeMcpOAuth, connectMcpWithLoopbackOAuth, createCascade, decryptJSON as decryptSyncBlob, diffManifest, disambiguateMcpServerNames, discoverMcpAuthServer, discoverMcpTools, distillSessionFacts, embedderFromProviders, encryptJSON as encryptSyncBlob, evaluateAcceptance, extractCharts, failures, fileExt, fileOAuthProvider, gatherSyncBundle, hashContent, heuristicCodeChunker, inferAzureBaseModel, inlineRuns, isDocumentFormat, isMcpToolName, matchImageLine, mcpServerPrefix, mcpToolName, nodeHttpFetch, parseBlocks, parseChartSpec, parseDelimited, parseRankOrder, parseSlide, planRetrieval, preferIpv4Host, reciprocalRankFusion, refreshMcpToken, removeMcpServerDenials, renderDocument, renderDocx, renderPptx, renderXlsx, runCascade, sessionWorthRemembering, sniffImage, splitSlides, streamCascade, stripInline, summarizeCompleted, undecided, uniqueMcpServerName };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map