cascade-ai 0.67.0 → 0.69.0

package/dist/cli.cjs

@@ -9,8 +9,8 @@ var https = require('https');
 var zlib = require('zlib');
 var stream = require('stream');
 var Database2 = require('better-sqlite3');
-var path33 = require('path');
-var fs30 = require('fs');
+var path34 = require('path');
+var fs31 = require('fs');
 var os10 = require('os');
 var crypto = require('crypto');
 var ink = require('ink');
@@ -77,8 +77,8 @@ var http__default = /*#__PURE__*/_interopDefault(http);
 var https__default = /*#__PURE__*/_interopDefault(https);
 var zlib__default = /*#__PURE__*/_interopDefault(zlib);
 var Database2__default = /*#__PURE__*/_interopDefault(Database2);
-var path33__default = /*#__PURE__*/_interopDefault(path33);
-var fs30__default = /*#__PURE__*/_interopDefault(fs30);
+var path34__default = /*#__PURE__*/_interopDefault(path34);
+var fs31__default = /*#__PURE__*/_interopDefault(fs31);
 var os10__default = /*#__PURE__*/_interopDefault(os10);
 var crypto__default = /*#__PURE__*/_interopDefault(crypto);
 var React2__default = /*#__PURE__*/_interopDefault(React2);
@@ -1810,7 +1810,7 @@ var CASCADE_VERSION, CASCADE_CONFIG_FILE, CASCADE_DB_FILE, CASCADE_DASHBOARD_SEC
 var init_constants = __esm({
   "src/constants.ts"() {
     init_pricing();
-    CASCADE_VERSION = "0.67.0";
+    CASCADE_VERSION = "0.69.0";
     CASCADE_CONFIG_FILE = ".cascade/config.json";
     CASCADE_DB_FILE = ".cascade/memory.db";
     CASCADE_DASHBOARD_SECRET_FILE = ".cascade/dashboard-secret";
@@ -3932,12 +3932,12 @@ var init_audit_logger = __esm({
       constructor(workspacePath, debugMode = false) {
         this.workspacePath = workspacePath;
         this.debugMode = debugMode;
-        const cascadeDir = path33__default.default.join(workspacePath, ".cascade");
-        if (!fs30__default.default.existsSync(cascadeDir)) {
-          fs30__default.default.mkdirSync(cascadeDir, { recursive: true });
+        const cascadeDir = path34__default.default.join(workspacePath, ".cascade");
+        if (!fs31__default.default.existsSync(cascadeDir)) {
+          fs31__default.default.mkdirSync(cascadeDir, { recursive: true });
         }
-        this.keyPath = path33__default.default.join(cascadeDir, "audit_log.key");
-        this.dbPath = path33__default.default.join(cascadeDir, "audit_log.db");
+        this.keyPath = path34__default.default.join(cascadeDir, "audit_log.key");
+        this.dbPath = path34__default.default.join(cascadeDir, "audit_log.db");
         this.initEncryptionKey();
         this.db = new Database2__default.default(this.dbPath);
         this.db.pragma("journal_mode = WAL");
@@ -3967,11 +3967,11 @@ var init_audit_logger = __esm({
         return crypto__default.default.createHash("sha256").update(`${prevHash}|${timestamp}|${eventType}|${tierId}|${encryptedPayload}`).digest("hex");
       }
       initEncryptionKey() {
-        if (fs30__default.default.existsSync(this.keyPath)) {
-          this.encryptionKey = fs30__default.default.readFileSync(this.keyPath);
+        if (fs31__default.default.existsSync(this.keyPath)) {
+          this.encryptionKey = fs31__default.default.readFileSync(this.keyPath);
         } else {
           this.encryptionKey = crypto__default.default.randomBytes(32);
-          fs30__default.default.writeFileSync(this.keyPath, this.encryptionKey);
+          fs31__default.default.writeFileSync(this.keyPath, this.encryptionKey);
         }
       }
       encrypt(text) {
@@ -4049,9 +4049,9 @@ var init_audit_logger = __esm({
       dumpDebugIfNeeded() {
         if (!this.debugMode) return;
         try {
-          const dumpPath = path33__default.default.join(os10__default.default.tmpdir(), "cascade_audit_logs_debug.json");
+          const dumpPath = path34__default.default.join(os10__default.default.tmpdir(), "cascade_audit_logs_debug.json");
           const entries = this.getAllLogs();
-          fs30__default.default.writeFileSync(dumpPath, JSON.stringify(entries, null, 2), "utf-8");
+          fs31__default.default.writeFileSync(dumpPath, JSON.stringify(entries, null, 2), "utf-8");
         } catch (err) {
           console.error("Failed to dump debug audit logs", err);
         }
@@ -4106,7 +4106,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 && fs30__default.default.existsSync(this.storePath)) {
+      if (password && fs31__default.default.existsSync(this.storePath)) {
         try {
           const fileEntries = this.decryptFile(password);
           for (const [k, v] of Object.entries(fileEntries)) {
@@ -4125,7 +4125,7 @@ var Keystore = class {
         "Keystore unlock requires a password because the OS keychain (keytar) is not available on this system."
       );
     }
-    if (!fs30__default.default.existsSync(this.storePath)) {
+    if (!fs31__default.default.existsSync(this.storePath)) {
       const salt = crypto__default.default.randomBytes(SALT_LEN);
       this.masterKey = this.deriveKey(password, salt);
       this.writeWithSalt({}, salt);
@@ -4139,7 +4139,7 @@ var Keystore = class {
   }
   /** Synchronous legacy unlock kept for AES-only environments. */
   unlockSync(password) {
-    if (!fs30__default.default.existsSync(this.storePath)) {
+    if (!fs31__default.default.existsSync(this.storePath)) {
       const salt = crypto__default.default.randomBytes(SALT_LEN);
       this.masterKey = this.deriveKey(password, salt);
       this.writeWithSalt({}, salt);
@@ -4197,7 +4197,7 @@ var Keystore = class {
     }
   }
   decryptFile(password, knownSalt) {
-    if (!fs30__default.default.existsSync(this.storePath)) return {};
+    if (!fs31__default.default.existsSync(this.storePath)) return {};
     try {
       const { salt, ciphertext, iv, tag } = this.readRaw();
       const useSalt = knownSalt ?? salt;
@@ -4219,8 +4219,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]);
-    fs30__default.default.mkdirSync(path33__default.default.dirname(this.storePath), { recursive: true });
-    fs30__default.default.writeFileSync(this.storePath, out, { mode: 384 });
+    fs31__default.default.mkdirSync(path34__default.default.dirname(this.storePath), { recursive: true });
+    fs31__default.default.writeFileSync(this.storePath, out, { mode: 384 });
   }
   writeWithSalt(data, salt) {
     if (!this.masterKey) throw new Error("writeWithSalt called before masterKey was set");
@@ -4230,11 +4230,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]);
-    fs30__default.default.mkdirSync(path33__default.default.dirname(this.storePath), { recursive: true });
-    fs30__default.default.writeFileSync(this.storePath, out, { mode: 384 });
+    fs31__default.default.mkdirSync(path34__default.default.dirname(this.storePath), { recursive: true });
+    fs31__default.default.writeFileSync(this.storePath, out, { mode: 384 });
   }
   readRaw() {
-    const buf = fs30__default.default.readFileSync(this.storePath);
+    const buf = fs31__default.default.readFileSync(this.storePath);
     let offset = 0;
     const salt = buf.subarray(offset, offset + SALT_LEN);
     offset += SALT_LEN;
@@ -4267,7 +4267,7 @@ var CascadeIgnore = class {
     ]);
   }
   async load(workspacePath) {
-    const filePath = path33__default.default.join(workspacePath, ".cascadeignore");
+    const filePath = path34__default.default.join(workspacePath, ".cascadeignore");
     try {
       const content = await fs11__default.default.readFile(filePath, "utf-8");
       const lines = content.split("\n").filter((l) => l.trim() && !l.startsWith("#"));
@@ -4278,7 +4278,7 @@ var CascadeIgnore = class {
   }
   isIgnored(filePath, workspacePath) {
     try {
-      const relative = workspacePath ? path33__default.default.relative(workspacePath, filePath) : filePath;
+      const relative = workspacePath ? path34__default.default.relative(workspacePath, filePath) : filePath;
       return this.ig.ignores(relative);
     } catch {
       return false;
@@ -4289,7 +4289,7 @@ var CascadeIgnore = class {
   }
 };
 async function createDefaultIgnoreFile(workspacePath) {
-  const filePath = path33__default.default.join(workspacePath, ".cascadeignore");
+  const filePath = path34__default.default.join(workspacePath, ".cascadeignore");
   const content = `# .cascadeignore \u2014 Files Cascade agents cannot read or modify
 # Syntax identical to .gitignore
 
@@ -4319,7 +4319,7 @@ Thumbs.db
   await fs11__default.default.writeFile(filePath, content, "utf-8");
 }
 async function loadCascadeMd(workspacePath) {
-  const filePath = path33__default.default.join(workspacePath, "CASCADE.md");
+  const filePath = path34__default.default.join(workspacePath, "CASCADE.md");
   try {
     const raw = await fs11__default.default.readFile(filePath, "utf-8");
     return parseCascadeMd(raw);
@@ -4348,7 +4348,7 @@ ${raw.trim()}`;
   return { raw, sections, systemPrompt };
 }
 async function createDefaultCascadeMd(workspacePath) {
-  const filePath = path33__default.default.join(workspacePath, "CASCADE.md");
+  const filePath = path34__default.default.join(workspacePath, "CASCADE.md");
   const content = `# Cascade Project Instructions
 
 This file contains project-specific instructions for the Cascade AI agent.
@@ -4383,7 +4383,7 @@ List any areas the agent should not touch.
 var MemoryStore = class _MemoryStore {
   db;
   constructor(dbPath) {
-    fs30__default.default.mkdirSync(path33__default.default.dirname(dbPath), { recursive: true });
+    fs31__default.default.mkdirSync(path34__default.default.dirname(dbPath), { recursive: true });
     try {
       this.db = new Database2__default.default(dbPath, { timeout: 5e3 });
       this.db.pragma("journal_mode = WAL");
@@ -5635,7 +5635,7 @@ function validateConfig(raw) {
 // src/config/global-credentials.ts
 init_constants();
 function credentialsPath(globalDir2) {
-  return path33__default.default.join(globalDir2, GLOBAL_CREDENTIALS_FILE);
+  return path34__default.default.join(globalDir2, GLOBAL_CREDENTIALS_FILE);
 }
 function providerKey(p) {
   if (p.type === "azure") {
@@ -5648,7 +5648,7 @@ function isPersistable(p) {
 }
 function loadGlobalCredentials(globalDir2) {
   try {
-    const raw = fs30__default.default.readFileSync(credentialsPath(globalDir2), "utf-8");
+    const raw = fs31__default.default.readFileSync(credentialsPath(globalDir2), "utf-8");
     const parsed = JSON.parse(raw);
     if (!Array.isArray(parsed.providers)) return [];
     return parsed.providers.filter(
@@ -5660,13 +5660,13 @@ function loadGlobalCredentials(globalDir2) {
 }
 function saveGlobalCredentials(globalDir2, providers) {
   const filePath = credentialsPath(globalDir2);
-  fs30__default.default.mkdirSync(globalDir2, { recursive: true, mode: 448 });
+  fs31__default.default.mkdirSync(globalDir2, { recursive: true, mode: 448 });
   const body = { version: 1, providers: providers.filter(isPersistable) };
   const tmp = `${filePath}.tmp`;
-  fs30__default.default.writeFileSync(tmp, JSON.stringify(body, null, 2), { encoding: "utf-8", mode: 384 });
-  fs30__default.default.renameSync(tmp, filePath);
+  fs31__default.default.writeFileSync(tmp, JSON.stringify(body, null, 2), { encoding: "utf-8", mode: 384 });
+  fs31__default.default.renameSync(tmp, filePath);
   try {
-    fs30__default.default.chmodSync(filePath, 384);
+    fs31__default.default.chmodSync(filePath, 384);
   } catch {
   }
 }
@@ -5884,7 +5884,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 ?? path33__default.default.join(os10__default.default.homedir(), GLOBAL_CONFIG_DIR);
+    this.globalDir = globalDirOverride ?? path34__default.default.join(os10__default.default.homedir(), GLOBAL_CONFIG_DIR);
   }
   async load() {
     this.config = await this.loadConfig();
@@ -5898,8 +5898,8 @@ var ConfigManager = class {
     this.ignore = new CascadeIgnore();
     await this.ignore.load(this.workspacePath);
     this.cascadeMd = await loadCascadeMd(this.workspacePath);
-    this.keystore = new Keystore(path33__default.default.join(this.globalDir, GLOBAL_KEYSTORE_FILE));
-    this.store = new MemoryStore(path33__default.default.join(this.workspacePath, CASCADE_DB_FILE));
+    this.keystore = new Keystore(path34__default.default.join(this.globalDir, GLOBAL_KEYSTORE_FILE));
+    this.store = new MemoryStore(path34__default.default.join(this.workspacePath, CASCADE_DB_FILE));
     await this.injectEnvKeys();
     this.config.providers = mergeGlobalCredentials(this.config.providers, loadGlobalCredentials(this.globalDir));
     await this.ensureDefaultIdentity();
@@ -5924,8 +5924,8 @@ var ConfigManager = class {
     return this.workspacePath;
   }
   async save() {
-    const configPath = path33__default.default.join(this.workspacePath, CASCADE_CONFIG_FILE);
-    await fs11__default.default.mkdir(path33__default.default.dirname(configPath), { recursive: true });
+    const configPath = path34__default.default.join(this.workspacePath, CASCADE_CONFIG_FILE);
+    await fs11__default.default.mkdir(path34__default.default.dirname(configPath), { recursive: true });
     await fs11__default.default.writeFile(configPath, JSON.stringify(this.config, null, 2), "utf-8");
     try {
       saveGlobalCredentials(this.globalDir, this.config.providers);
@@ -5961,7 +5961,7 @@ var ConfigManager = class {
     return configProvider?.apiKey;
   }
   async loadConfig() {
-    const configPath = path33__default.default.join(this.workspacePath, CASCADE_CONFIG_FILE);
+    const configPath = path34__default.default.join(this.workspacePath, CASCADE_CONFIG_FILE);
     try {
       const raw = await fs11__default.default.readFile(configPath, "utf-8");
       return validateConfig(JSON.parse(raw));
@@ -6963,13 +6963,13 @@ var DeadModelStore = class {
 function fileDeadModelPersistence(filePath) {
   return {
     load() {
-      if (!fs30.existsSync(filePath)) return [];
-      const raw = JSON.parse(fs30.readFileSync(filePath, "utf-8"));
+      if (!fs31.existsSync(filePath)) return [];
+      const raw = JSON.parse(fs31.readFileSync(filePath, "utf-8"));
       return Array.isArray(raw) ? raw : [];
     },
     save(records) {
-      fs30.mkdirSync(path33.dirname(filePath), { recursive: true });
-      fs30.writeFileSync(filePath, JSON.stringify(records, null, 2));
+      fs31.mkdirSync(path34.dirname(filePath), { recursive: true });
+      fs31.writeFileSync(filePath, JSON.stringify(records, null, 2));
     }
   };
 }
@@ -7128,7 +7128,7 @@ init_pricing();
 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 = path33__default.default.join(os10__default.default.homedir(), GLOBAL_CONFIG_DIR, "benchmarks-cache.json");
+var DEFAULT_CACHE_FILE = path34__default.default.join(os10__default.default.homedir(), GLOBAL_CONFIG_DIR, "benchmarks-cache.json");
 function normalizeModelId2(id) {
   let s = id.toLowerCase();
   const slash = s.lastIndexOf("/");
@@ -7275,7 +7275,7 @@ var LiveDataProvider = class {
   }
   async saveCache() {
     try {
-      await fs11__default.default.mkdir(path33__default.default.dirname(this.opts.cacheFile), { recursive: true });
+      await fs11__default.default.mkdir(path34__default.default.dirname(this.opts.cacheFile), { recursive: true });
       const cache = {
         fetchedAt: this.fetchedAt,
         snapshot: this.snapshot ?? void 0,
@@ -8535,6 +8535,21 @@ var BaseTier = class extends EventEmitter__default.default {
    * which node (Cockpit node panel / Why panel).
    */
   servingModel;
+  /**
+   * This tier's identity IN THE TASK GRAPH — the section or subtask id the
+   * planner assigned — plus where it sat in the dependency order.
+   *
+   * `id` and `graphNodeId` are deliberately different id spaces, and both are
+   * needed. `id` identifies this tier INSTANCE ("T2_a1b2c3d4", minted per
+   * construction); `graphNodeId` identifies the WORK ("s1"), which is what
+   * dependency edges point at. Without the distinction a graph view cannot be
+   * drawn at all: `dependsOn` lists section ids, while every running tier
+   * reports a generated tier id, so every edge would name a node that never
+   * appears in the stream.
+   */
+  graphNodeId;
+  graphDependsOn;
+  graphWave;
   constructor(role, id, parentId) {
     super();
     this.role = role;
@@ -8546,6 +8561,33 @@ var BaseTier = class extends EventEmitter__default.default {
   setPresenter(on = true) {
     this.isPresenter = on;
   }
+  /**
+   * Record where this tier sits in the compiled task graph.
+   *
+   * Called by whichever tier scheduled this one: the id and edges are known at
+   * construction, the wave only once the scheduler reaches it, so the fields
+   * are set independently rather than all at once.
+   */
+  setGraphPosition(position) {
+    if (position.nodeId !== void 0) this.graphNodeId = position.nodeId;
+    if (position.dependsOn !== void 0) this.graphDependsOn = [...position.dependsOn];
+    if (position.wave !== void 0) this.graphWave = position.wave;
+  }
+  /**
+   * The graph fields, for spreading into a status payload.
+   *
+   * One helper rather than two literals because `tier:status` is emitted from
+   * two different call sites with two different payload shapes; adding a field
+   * to only one of them makes it arrive intermittently, which is worse for a
+   * consumer than never arriving at all.
+   */
+  graphFields() {
+    return {
+      nodeId: this.graphNodeId,
+      dependsOn: this.graphDependsOn ? [...this.graphDependsOn] : void 0,
+      waveId: this.graphWave
+    };
+  }
   getStatus() {
     return this.status;
   }
@@ -8560,7 +8602,8 @@ var BaseTier = class extends EventEmitter__default.default {
       status,
       timestamp,
       output,
-      model: this.servingModel
+      model: this.servingModel,
+      ...this.graphFields()
     };
     this.emit("status", event);
     this.emit("tier:status", event);
@@ -8600,7 +8643,8 @@ var BaseTier = class extends EventEmitter__default.default {
       progressPct: update.progressPct,
       timestamp,
       output: update.output,
-      model: this.servingModel
+      model: this.servingModel,
+      ...this.graphFields()
     });
   }
   buildMessage(type, to, payload) {
@@ -9068,6 +9112,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) {
@@ -9384,7 +9501,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);
@@ -9402,22 +9519,45 @@ 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 pendingAcceptance = undecided(acceptanceResults);
+      const testResult = await this.selfTest(assignment, output, pendingAcceptance);
       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;
-        const retest = await this.selfTest(assignment, output);
+        const retest = await this.selfTest(assignment, output, pendingAcceptance);
         passed.push(...retest.passed);
         if (retest.failed.length > 0) {
           failed.push(...retest.failed);
@@ -9721,8 +9861,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 (path38, content) => {
-          this.store?.addFileSnapshot(this.taskId, path38, content);
+        saveSnapshot: async (path39, content) => {
+          this.store?.addFileSnapshot(this.taskId, path39, content);
         },
         sendPeerSync: (to, syncType, content) => {
           this.peerBus?.send(this.id, to, syncType, this.assignment?.subtaskId ?? "", content);
@@ -9909,7 +10049,7 @@ ${assignment.expectedOutput}`;
     const { promisify: promisify4 } = await import('util');
     const execAsync3 = promisify4(exec3);
     for (const artifactPath of artifactPaths) {
-      const absolutePath = path33__default.default.resolve(process.cwd(), artifactPath);
+      const absolutePath = path34__default.default.resolve(process.cwd(), artifactPath);
       try {
         const stat = await fs11__default.default.stat(absolutePath);
         if (!stat.isFile()) {
@@ -9944,7 +10084,7 @@ ${assignment.expectedOutput}`;
           issues.push(`PDF artifact looks too small to be valid: ${artifactPath}`);
           continue;
         }
-        const ext = path33__default.default.extname(absolutePath).toLowerCase();
+        const ext = path34__default.default.extname(absolutePath).toLowerCase();
         try {
           if (ext === ".ts" || ext === ".tsx") {
             await execAsync3(`npx tsc --noEmit ${absolutePath}`, { timeout: 1e4 });
@@ -10030,14 +10170,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) => path34__default.default.resolve(process.cwd(), target);
+    return evaluateAcceptance(criteria, assignment.files ?? [], {
+      stat: async (target) => {
+        try {
+          const stat = await fs11__default.default.stat(resolve2(target));
+          return stat.isFile() ? { size: stat.size } : null;
+        } catch {
+          return null;
+        }
+      },
+      read: async (target) => {
+        try {
+          const content = await fs11__default.default.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}
@@ -10104,8 +10272,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}
@@ -10767,12 +10935,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.",
@@ -11106,6 +11482,7 @@ HIERARCHY CONTEXT: ${this.hierarchyContext}` : ""),
     for (const a of assignments) {
       const worker = new T3Worker(this.router, this.toolRegistry, this.id);
       if (this.store) worker.setStore(this.store, taskId);
+      worker.setGraphPosition({ nodeId: a.subtaskId, dependsOn: a.dependsOn ?? [] });
       worker.setPeerBus(this.t3PeerBus);
       if (this.permissionEscalator) worker.setPermissionEscalator(this.permissionEscalator);
       if (this.toolCreator) worker.setToolCreator(this.toolCreator);
@@ -11168,21 +11545,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;
@@ -11217,6 +11603,7 @@ HIERARCHY CONTEXT: ${this.hierarchyContext}` : ""),
         runnableIds.push(fallbackId);
       }
       wave++;
+      for (const id of runnableIds) workerMap.get(id)?.setGraphPosition({ wave });
       this.log(`Wave ${wave}: running ${runnableIds.length} subtask(s) in parallel`);
       this.sendStatusUpdate({
         progressPct: 20 + Math.min(wave * 10, 60),
@@ -11389,49 +11776,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);
@@ -11570,6 +11914,101 @@ HIERARCHY CONTEXT: ${this.hierarchyContext}` : ""),
 // src/core/tiers/t1-administrator.ts
 init_constants();
 
+// 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 policy = this.options.onUpstreamFailure ?? "continue";
+    const settled = /* @__PURE__ */ new Set();
+    const results = /* @__PURE__ */ new Map();
+    const blocked = /* @__PURE__ */ new Map();
+    const waves = [];
+    let wave = 0;
+    const blockDescendants = async (failedIds) => {
+      const rootsFor = /* @__PURE__ */ new Map();
+      const queue = [];
+      for (const rootId of failedIds) {
+        for (const childId of dependents.get(rootId) ?? []) queue.push({ id: childId, root: rootId });
+      }
+      while (queue.length > 0) {
+        const { id, root } = queue.shift();
+        if (settled.has(id)) continue;
+        const known = rootsFor.get(id);
+        if (known) {
+          if (!known.has(root)) known.add(root);
+          continue;
+        }
+        rootsFor.set(id, /* @__PURE__ */ new Set([root]));
+        for (const childId of dependents.get(id) ?? []) queue.push({ id: childId, root });
+      }
+      for (const node of nodes) {
+        const roots = rootsFor.get(node.id);
+        if (!roots || settled.has(node.id)) continue;
+        const causes = nodes.filter((n) => roots.has(n.id));
+        const blockedBy = causes.map((n) => n.id);
+        const blockedByTitles = causes.map((n) => n.title || n.id);
+        const record = {
+          blockedBy,
+          blockedByTitles,
+          reason: blockedByTitles.length === 1 ? `Required upstream work "${blockedByTitles[0]}" failed` : `Required upstream work ${blockedByTitles.map((t) => `"${t}"`).join(", ")} failed`
+        };
+        blocked.set(node.id, record);
+        settled.add(node.id);
+        await this.hooks.onNodeBlocked?.(node, record);
+      }
+    };
+    while (settled.size < nodes.length) {
+      const ready = nodes.filter((node) => !settled.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 outcomes = /* @__PURE__ */ new Map();
+      const runOne = async (node) => {
+        const result = await this.hooks.execute(node);
+        results.set(node.id, result);
+        settled.add(node.id);
+        const outcome = this.hooks.classify?.(node, result) ?? "succeeded";
+        outcomes.set(node.id, outcome);
+        if (outcome === "failed" && policy === "block") ; else {
+          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));
+      }
+      const failedThisWave = ready.filter((node) => outcomes.get(node.id) === "failed").map((node) => node.id);
+      if (policy === "block" && failedThisWave.length > 0) {
+        await blockDescendants(failedThisWave);
+      }
+      wave++;
+    }
+    return { results, waves, blocked };
+  }
+};
+
 // src/utils/json-extract.ts
 function extractFirstJsonObject(input) {
   if (!input) return null;
@@ -11641,7 +12080,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",
@@ -11667,6 +12106,9 @@ QUALITY RULES:
 
 ${generation}` : ""}`;
 }
+function producedOutput(result) {
+  return result.status === "COMPLETED" || result.status === "PARTIAL";
+}
 var T1Administrator = class extends BaseTier {
   router;
   toolRegistry;
@@ -11801,7 +12243,7 @@ Board guidance (must be followed in the plan): ${decision.note}`,
     let allT2Results = await this.dispatchT2Managers(plan.sections);
     let pass = 1;
     const maxReplanPasses = this.config.maxReplanPasses ?? 2;
-    const okCount = (rs) => rs.filter((r) => r.status === "COMPLETED" || r.status === "PARTIAL").length;
+    const okCount = (rs) => rs.filter(producedOutput).length;
     while (pass <= maxReplanPasses) {
       const reviewResult = await this.reviewT2Outputs(enrichedPrompt, plan, allT2Results);
       if (reviewResult.approved) {
@@ -11932,7 +12374,7 @@ In 3-5 terse bullets, flag the most important RISKS, GAPS, or over-/under-decomp
   /** Structured, grounded summary of what's already done — used to keep
    * corrective replan passes from re-emitting completed sections. */
   summarizeCompletedSections(results) {
-    const done = results.filter((r) => r.status === "COMPLETED" || r.status === "PARTIAL");
+    const done = results.filter(producedOutput);
     if (done.length === 0) return "";
     const lines = done.map((r) => `- "${r.sectionTitle}" [${r.status}]: ${(r.sectionSummary || "(no summary)").slice(0, 300)}`);
     return `ALREADY COMPLETED SECTIONS (do not redo these \u2014 plan only what's still missing):
@@ -12056,7 +12498,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) {
@@ -12073,6 +12519,7 @@ SPEC RULES \u2014 each subtask is a self-contained spec slice (workers execute f
       if (this.runBreaker) manager.setRunBreaker(this.runBreaker);
       if (this.escalationCallback) manager.setEscalationCallback(this.escalationCallback);
       manager.setHierarchyContext(`You are a T2 Manager for the section "${section.sectionTitle}". You are part of a COMPLEX task overseen by T1 Administrator.`);
+      manager.setGraphPosition({ nodeId: section.sectionId, dependsOn: section.dependsOn ?? [] });
       if (this.store) {
         manager.setStore(this.store);
       }
@@ -12168,118 +12615,162 @@ 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));
-    }
-    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 compiled = compileSectionGraph(sections);
+    for (const issue of compiled.issues) {
+      this.log(`\u26A0 Section graph: ${issue.message}`);
     }
-    const totalSections = sections.length;
+    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 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,
+      {
+        // The wave is the scheduler's own counter, and it is the only place the
+        // parallelism is visible: nodes sharing a wave ran at the same time.
+        // Stamped before the wave executes so the first status event a node
+        // emits already carries it.
+        onWaveStart: (nodes, wave) => {
+          for (const node of nodes) managers[node.ordinal]?.setGraphPosition({ wave });
+        },
+        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 = {
+        },
+        // PARTIAL is deliberately not a failure: a degraded-but-real section
+        // can still feed the one after it, and cancelling that work would cost
+        // the user more than letting it try.
+        // BLOCKED cannot reach here today — the scheduler settles blocked nodes
+        // through onNodeBlocked and never executes them, so classify only ever
+        // sees results that ran. It is listed anyway because the failure mode if
+        // that ever changes is silent and expensive: a blocked section would
+        // classify as 'succeeded' and release its own dependents, so work that
+        // should have been skipped would run and be billed.
+        classify: (_node, result) => result.status === "FAILED" || result.status === "BLOCKED" ? "failed" : "succeeded",
+        onNodeBlocked: (node, blockedInfo) => {
+          const section = node.payload;
+          this.log(`\u292B Skipped "${section.sectionTitle}" \u2014 ${blockedInfo.reason}`);
+          resultMap.set(node.id, {
             sectionId: section.sectionId,
             sectionTitle: section.sectionTitle,
-            status: "FAILED",
+            // BLOCKED, not FAILED. This section was never attempted — saying it
+            // failed reports a breakage that did not happen, and hides the one
+            // that did (the upstream section named below).
+            status: "BLOCKED",
             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);
+            issues: [
+              `${blockedInfo.reason}. This section was not attempted, so no tokens were spent on it.`
+            ],
+            blockedBy: { ids: [...blockedInfo.blockedBy], titles: [...blockedInfo.blockedByTitles] }
+          });
+          completedSections++;
+          this.sendStatusUpdate({
+            progressPct: 10 + Math.floor(completedSections / totalSections * 85),
+            currentAction: `Skipped: ${section.sectionTitle} (blocked by an upstream failure)`,
+            status: "IN_PROGRESS"
+          });
+          this.emit("tier:status", {
+            tierId: section.sectionId,
+            // A blocked section has no tier instance — it was never
+            // constructed — so its runtime id and its graph id are the same
+            // thing here. Emitting nodeId anyway keeps every node in the
+            // stream addressable in the graph's id space, which is what
+            // dependsOn edges point at.
+            nodeId: section.sectionId,
+            dependsOn: [...section.dependsOn ?? []],
+            role: "T2",
+            label: section.sectionTitle,
+            status: "BLOCKED",
+            blockedBy: [...blockedInfo.blockedByTitles],
+            output: blockedInfo.reason
+          });
+          this.emit("section:complete", {
+            id: node.id,
+            title: section.sectionTitle,
+            status: "BLOCKED",
+            blockedBy: [...blockedInfo.blockedByTitles],
+            output: ""
+          });
+        },
+        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",
+        // A section that declared `dependsOn` said it needs that section's
+        // output. Running it after the dependency failed produces a second
+        // failure, billed, whose cause is the first one — so don't.
+        onUpstreamFailure: "block"
       }
-    };
-    await executeWave();
+    );
+    await scheduler.run();
     return sections.map((s) => resultMap.get(s.sectionId)).filter(Boolean);
   }
   async compileFinalOutput(originalPrompt, plan, t2Results) {
-    const completedSections = t2Results.filter((r) => r.status !== "FAILED");
+    const completedSections = t2Results.filter(producedOutput);
     if (!completedSections.length) {
       const allIssues = [
         ...t2Results.flatMap((r) => r.issues ?? []),
@@ -12299,7 +12790,6 @@ ${r.sectionSummary}
 Outputs:
 ${r.t3Results.filter((t) => t.status === "COMPLETED").map((t) => `\u2022 ${typeof t.output === "string" ? t.output : JSON.stringify(t.output)}`).join("\n")}`).join("\n\n---\n\n");
     const openIssues = t2Results.flatMap((r) => r.issues).filter(Boolean);
-    t2Results.filter((r) => r.status === "FAILED" || r.status === "PARTIAL");
     const compilePrompt = `Compile a final, coherent response to the user's original request.
 
 Original request: ${originalPrompt}
@@ -12794,6 +13284,7 @@ Model: ${asset.modelId} \u2014 ${r.selected.reason}`;
 };
 var DEFAULT_VIDEO_SECONDS = 5;
 var MAX_VIDEO_SECONDS = 8;
+var MIN_VIDEO_SECONDS = 4;
 var GenerateVideoTool = class extends BaseTool {
   constructor(deps) {
     super();
@@ -12810,7 +13301,7 @@ var GenerateVideoTool = class extends BaseTool {
     type: "object",
     properties: {
       prompt: { type: "string", description: "What the video should show: subject, action, camera movement, style." },
-      seconds: { type: "number", description: `Clip length, 1-${MAX_VIDEO_SECONDS} seconds (default ${DEFAULT_VIDEO_SECONDS}). Billed per second \u2014 keep it short.` },
+      seconds: { type: "number", description: `Clip length, ${MIN_VIDEO_SECONDS}-${MAX_VIDEO_SECONDS} seconds (default ${DEFAULT_VIDEO_SECONDS}). Billed per second \u2014 keep it short.` },
       aspectRatio: { type: "string", description: 'Frame shape: "16:9" (default) or "9:16" for vertical.' },
       model: { type: "string", description: "Optional: force a specific video model." }
     },
@@ -12822,7 +13313,7 @@ var GenerateVideoTool = class extends BaseTool {
     const r = resolve(this.deps, "video", input["model"] ? String(input["model"]) : void 0);
     if (!r.ok) return r.error;
     const asked = typeof input["seconds"] === "number" ? input["seconds"] : DEFAULT_VIDEO_SECONDS;
-    const seconds = Math.max(1, Math.min(MAX_VIDEO_SECONDS, Math.round(asked)));
+    const seconds = Math.max(MIN_VIDEO_SECONDS, Math.min(MAX_VIDEO_SECONDS, Math.round(asked)));
     const asset = await generateVideo(
       r.selected.capability,
       r.cfg,
@@ -12839,7 +13330,7 @@ var GenerateVideoTool = class extends BaseTool {
     const location = await this.deps.sink(asset);
     const unit = r.selected.cost;
     const estimate = unit ? ` Estimated cost: $${(unit.amount * seconds).toFixed(2)} (${seconds}s x ${unit.label}).` : "";
-    const clamped = seconds !== Math.round(asked) ? ` Duration was clamped to ${seconds}s (max ${MAX_VIDEO_SECONDS}).` : "";
+    const clamped = seconds !== Math.round(asked) ? ` Duration was clamped to ${seconds}s (allowed ${MIN_VIDEO_SECONDS}-${MAX_VIDEO_SECONDS}).` : "";
     return `Video generated and saved to ${location}.
 Model: ${asset.modelId}.${estimate}${clamped}`;
   }
@@ -12908,16 +13399,16 @@ function resolveInWorkspace(workspaceRoot, input) {
   if (typeof input !== "string" || input.length === 0) {
     throw new WorkspaceSandboxError(String(input), workspaceRoot);
   }
-  const root = path33__default.default.resolve(workspaceRoot);
-  const abs = path33__default.default.isAbsolute(input) ? path33__default.default.resolve(input) : path33__default.default.resolve(root, input);
-  const rel = path33__default.default.relative(root, abs);
-  if (rel === "" || rel === ".") ; else if (rel.startsWith("..") || path33__default.default.isAbsolute(rel)) {
+  const root = path34__default.default.resolve(workspaceRoot);
+  const abs = path34__default.default.isAbsolute(input) ? path34__default.default.resolve(input) : path34__default.default.resolve(root, input);
+  const rel = path34__default.default.relative(root, abs);
+  if (rel === "" || rel === ".") ; else if (rel.startsWith("..") || path34__default.default.isAbsolute(rel)) {
     throw new WorkspaceSandboxError(input, root);
   }
   try {
-    const real = fs30__default.default.realpathSync(abs);
-    const realRel = path33__default.default.relative(root, real);
-    if (realRel !== "" && realRel !== "." && (realRel.startsWith("..") || path33__default.default.isAbsolute(realRel))) {
+    const real = fs31__default.default.realpathSync(abs);
+    const realRel = path34__default.default.relative(root, real);
+    if (realRel !== "" && realRel !== "." && (realRel.startsWith("..") || path34__default.default.isAbsolute(realRel))) {
       throw new WorkspaceSandboxError(input, root);
     }
   } catch (e) {
@@ -13570,7 +14061,7 @@ var GenerateDocumentTool = class extends BaseTool {
       }
     }
     const bytes = await renderDocument(ext, content, { name: filePath, loadImageBytes });
-    await fs11__default.default.mkdir(path33__default.default.dirname(absPath), { recursive: true });
+    await fs11__default.default.mkdir(path34__default.default.dirname(absPath), { recursive: true });
     await fs11__default.default.writeFile(absPath, bytes);
     const charts = countCharts(content);
     return [
@@ -13791,7 +14282,7 @@ var FileWriteTool = class extends BaseTool {
       } catch {
       }
     }
-    await fs11__default.default.mkdir(path33__default.default.dirname(absPath), { recursive: true });
+    await fs11__default.default.mkdir(path34__default.default.dirname(absPath), { recursive: true });
     await fs11__default.default.writeFile(absPath, content, "utf-8");
     return `Written ${content.length} characters to ${filePath}`;
   }
@@ -14289,7 +14780,7 @@ var ImageAnalyzeTool = class extends BaseTool {
 };
 async function fileToImageAttachment(filePath) {
   const data = await fs11__default.default.readFile(filePath);
-  const ext = path33__default.default.extname(filePath).toLowerCase();
+  const ext = path34__default.default.extname(filePath).toLowerCase();
   const mimeMap = {
     ".jpg": "image/jpeg",
     ".jpeg": "image/jpeg",
@@ -14323,14 +14814,14 @@ var PDFCreateTool = class extends BaseTool {
     const filePath = input["path"];
     const content = input["content"];
     const title = input["title"];
-    const dir = path33__default.default.dirname(filePath);
-    if (!fs30__default.default.existsSync(dir)) {
-      fs30__default.default.mkdirSync(dir, { recursive: true });
+    const dir = path34__default.default.dirname(filePath);
+    if (!fs31__default.default.existsSync(dir)) {
+      fs31__default.default.mkdirSync(dir, { recursive: true });
     }
     return new Promise((resolve2, reject) => {
       try {
         const doc = new PDFDocument__default.default({ margin: 50 });
-        const stream = fs30__default.default.createWriteStream(filePath);
+        const stream = fs31__default.default.createWriteStream(filePath);
         doc.pipe(stream);
         if (title) {
           doc.info["Title"] = title;
@@ -14408,22 +14899,22 @@ var CodeInterpreterTool = class extends BaseTool {
       }
       cmdPrefix = NODE_CMD;
     }
-    const tmpDir = path33__default.default.join(this.workspaceRoot, ".cascade", "tmp");
-    if (!fs30__default.default.existsSync(tmpDir)) {
-      fs30__default.default.mkdirSync(tmpDir, { recursive: true });
+    const tmpDir = path34__default.default.join(this.workspaceRoot, ".cascade", "tmp");
+    if (!fs31__default.default.existsSync(tmpDir)) {
+      fs31__default.default.mkdirSync(tmpDir, { recursive: true });
     }
     const extension = language === "python" ? "py" : "js";
     const fileName = `intp_${crypto.randomUUID().slice(0, 8)}.${extension}`;
-    const filePath = path33__default.default.join(tmpDir, fileName);
-    fs30__default.default.writeFileSync(filePath, code, "utf-8");
+    const filePath = path34__default.default.join(tmpDir, fileName);
+    fs31__default.default.writeFileSync(filePath, code, "utf-8");
     const execArgs = [filePath, ...args];
     return new Promise((resolve2) => {
       const startMs = Date.now();
       child_process.execFile(cmdPrefix, execArgs, { cwd: this.workspaceRoot, timeout: 3e4 }, (error, stdout, stderr) => {
         const duration = Date.now() - startMs;
         try {
-          if (fs30__default.default.existsSync(filePath)) {
-            fs30__default.default.unlinkSync(filePath);
+          if (fs31__default.default.existsSync(filePath)) {
+            fs31__default.default.unlinkSync(filePath);
           }
         } catch (cleanupErr) {
           console.error(`Failed to cleanup interpreter script ${filePath}:`, cleanupErr);
@@ -14735,7 +15226,7 @@ var GlobTool = class extends BaseTool {
   };
   async execute(input, _options) {
     const pattern = input["pattern"];
-    const searchPath = input["path"] ? path33__default.default.resolve(this.workspaceRoot, input["path"]) : this.workspaceRoot;
+    const searchPath = input["path"] ? path34__default.default.resolve(this.workspaceRoot, input["path"]) : this.workspaceRoot;
     const matches = await glob.glob(pattern, {
       cwd: searchPath,
       ignore: ["node_modules/**", ".git/**", "dist/**", "build/**"],
@@ -14748,7 +15239,7 @@ var GlobTool = class extends BaseTool {
     const withMtime = await Promise.all(
       matches.map(async (rel) => {
         try {
-          const stat = await fs11__default.default.stat(path33__default.default.join(searchPath, rel));
+          const stat = await fs11__default.default.stat(path34__default.default.join(searchPath, rel));
           return { rel, mtime: stat.mtimeMs };
         } catch {
           return { rel, mtime: 0 };
@@ -14797,7 +15288,7 @@ var GrepTool = class extends BaseTool {
   };
   async execute(input, _options) {
     const pattern = input["pattern"];
-    const searchPath = input["path"] ? path33__default.default.resolve(this.workspaceRoot, input["path"]) : this.workspaceRoot;
+    const searchPath = input["path"] ? path34__default.default.resolve(this.workspaceRoot, input["path"]) : this.workspaceRoot;
     const globPattern = input["glob"];
     const outputMode = input["output_mode"] ?? "content";
     const context = input["context"] ?? 0;
@@ -14851,12 +15342,12 @@ var GrepTool = class extends BaseTool {
         nodir: true
       });
     } catch {
-      files = [path33__default.default.relative(searchPath, searchPath) || "."];
+      files = [path34__default.default.relative(searchPath, searchPath) || "."];
     }
     const results = [];
     let totalCount = 0;
     for (const rel of files) {
-      const abs = path33__default.default.join(searchPath, rel);
+      const abs = path34__default.default.join(searchPath, rel);
       let content;
       try {
         content = await fs11__default.default.readFile(abs, "utf-8");
@@ -15243,10 +15734,10 @@ var ToolRegistry = class extends EventEmitter__default.default {
   }
   isIgnored(filePath) {
     if (!filePath) return false;
-    const abs = path33__default.default.resolve(this.workspaceRoot, filePath);
-    const rel = path33__default.default.relative(this.workspaceRoot, abs);
-    if (!rel || rel.startsWith("..") || path33__default.default.isAbsolute(rel)) return true;
-    const posixRel = rel.split(path33__default.default.sep).join("/");
+    const abs = path34__default.default.resolve(this.workspaceRoot, filePath);
+    const rel = path34__default.default.relative(this.workspaceRoot, abs);
+    if (!rel || rel.startsWith("..") || path34__default.default.isAbsolute(rel)) return true;
+    const posixRel = rel.split(path34__default.default.sep).join("/");
     return this.ignoreMatcher.ignores(posixRel);
   }
 };
@@ -15480,22 +15971,22 @@ var FileMcpOAuthStore = class {
   filePath;
   load() {
     try {
-      return JSON.parse(fs30__default.default.readFileSync(this.filePath, "utf-8"));
+      return JSON.parse(fs31__default.default.readFileSync(this.filePath, "utf-8"));
     } catch {
       return void 0;
     }
   }
   save(state) {
-    fs30__default.default.mkdirSync(path33__default.default.dirname(this.filePath), { recursive: true, mode: 448 });
-    fs30__default.default.writeFileSync(this.filePath, JSON.stringify(state, null, 2), { mode: 384 });
+    fs31__default.default.mkdirSync(path34__default.default.dirname(this.filePath), { recursive: true, mode: 448 });
+    fs31__default.default.writeFileSync(this.filePath, JSON.stringify(state, null, 2), { mode: 384 });
     try {
-      fs30__default.default.chmodSync(this.filePath, 384);
+      fs31__default.default.chmodSync(this.filePath, 384);
     } catch {
     }
   }
   clear() {
     try {
-      fs30__default.default.rmSync(this.filePath);
+      fs31__default.default.rmSync(this.filePath);
     } catch {
     }
   }
@@ -15958,6 +16449,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"],
@@ -15972,7 +16471,24 @@ var TaskAnalyzer = class {
   feedback;
   bias;
   lastProfile = null;
-  lastSelectedModels = /* @__PURE__ */ new Map();
+  /** Models chosen by the run currently in flight. Cleared when it completes. */
+  currentRunSelections = /* @__PURE__ */ new Map();
+  /**
+   * Immutable snapshot of the last COMPLETED run: its selections AND the task
+   * type they were chosen for.
+   *
+   * The task type has to travel WITH the selections. `lastProfile` is overwritten
+   * by the next analyze(), so if run B started before the user rated run A, A's
+   * models were credited under B's task type — teaching the router that a coding
+   * model is good at creative writing, from a rating that never said so.
+   *
+   * Explicit ratings arrive after the run finishes — rateLastRun() is by nature
+   * a reaction to a finished answer — but the run finalizer calls
+   * recordRunOutcome() first, and that used to clear the only map there was. So
+   * every explicit rating iterated an empty map, recorded nothing, and returned
+   * false: the 3x-weighted user signal never reached the tracker at all.
+   */
+  lastCompletedRun;
   constructor(tracker, bias = "balanced") {
     this.tracker = tracker;
     this.bias = bias;
@@ -16001,7 +16517,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;
@@ -16019,11 +16535,15 @@ var TaskAnalyzer = class {
    */
   async selectModel(prompt, tier, selector, opts) {
     const profile = await this.analyze(prompt);
+    const recordSelection = (model) => {
+      if (model) this.currentRunSelections.set(tier, model);
+      return model;
+    };
     if (profile.requiresVision) {
-      return selector.selectVisionModel();
+      return recordSelection(selector.selectVisionModel());
     }
     let candidates2 = selector.getCandidatesForTier(tier);
-    if (candidates2.length === 0) return selector.selectForTier(tier);
+    if (candidates2.length === 0) return recordSelection(selector.selectForTier(tier));
     if (opts?.requiresToolUse) {
       const toolCapable = candidates2.filter((m) => m.supportsToolUse !== false);
       if (toolCapable.length > 0) candidates2 = toolCapable;
@@ -16033,9 +16553,7 @@ var TaskAnalyzer = class {
       score: this.scoreModel(m, profile)
     }));
     scored.sort((a, b) => b.score - a.score);
-    const best = scored[0]?.model ?? selector.selectForTier(tier);
-    if (best) this.lastSelectedModels.set(tier, best);
-    return best;
+    return recordSelection(scored[0]?.model ?? selector.selectForTier(tier));
   }
   /**
    * Record the outcome of a completed run across all tiers that were selected
@@ -16044,25 +16562,38 @@ var TaskAnalyzer = class {
   recordRunOutcome(outcome, costByTier, contextTokens = 0) {
     if (!this.tracker || !this.lastProfile) return;
     const taskType = this.lastProfile.type;
-    for (const [tier, model] of this.lastSelectedModels) {
+    for (const [tier, model] of this.currentRunSelections) {
       const cost = costByTier[tier] ?? 0;
       this.tracker.record(model.id, taskType, outcome, 0, cost, contextTokens);
     }
-    this.lastSelectedModels.clear();
+    this.lastCompletedRun = { selections: new Map(this.currentRunSelections), taskType };
+    this.currentRunSelections.clear();
     void this.tracker.save();
   }
   /**
-   * Record an explicit user rating (good/bad) for the last run's selected models.
+   * Record an explicit user rating (good/bad) for the last COMPLETED run's models.
    * Explicit ratings carry 3× the weight of auto-detected outcomes.
-   * Does NOT clear lastSelectedModels — the auto record already did that.
+   *
+   * Reads the completed-run snapshot, not the in-flight map: by the time a user
+   * can rate an answer, the finalizer has already run and the in-flight map is
+   * empty.
+   *
+   * The snapshot is CONSUMED. recordExplicit() weights a rating 3x by recording
+   * three samples, so a double submit would inject six — a stutter on the
+   * button would count as two opinions. Consuming makes a second call a no-op
+   * that reports false, which is what "rate this run" should mean.
    */
   recordExplicitRating(rating) {
-    if (!this.tracker || !this.lastProfile) return false;
-    const taskType = this.lastProfile.type;
-    for (const [, model] of this.lastSelectedModels) {
-      this.tracker.recordExplicit(model.id, taskType, rating, 0);
-    }
-    return this.lastSelectedModels.size > 0;
+    const snapshot = this.lastCompletedRun;
+    if (!this.tracker || !snapshot || snapshot.selections.size === 0) return false;
+    const ratedModels = /* @__PURE__ */ new Set();
+    for (const [, model] of snapshot.selections) {
+      if (ratedModels.has(model.id)) continue;
+      ratedModels.add(model.id);
+      this.tracker.recordExplicit(model.id, snapshot.taskType, rating, 0);
+    }
+    this.lastCompletedRun = void 0;
+    return true;
   }
   scoreModel(model, profile) {
     const perf = this.tracker?.performanceScore(model.id, profile.type) ?? 0.5;
@@ -16103,7 +16634,7 @@ var TaskAnalyzer = class {
 
 // src/core/router/model-performance-tracker.ts
 init_pricing();
-var DEFAULT_STATS_FILE = path33__default.default.join(os10__default.default.homedir(), ".cascade", "model-perf.json");
+var DEFAULT_STATS_FILE = path34__default.default.join(os10__default.default.homedir(), ".cascade", "model-perf.json");
 var ModelPerformanceTracker = class {
   stats = /* @__PURE__ */ new Map();
   featureStats = /* @__PURE__ */ new Map();
@@ -16143,7 +16674,7 @@ var ModelPerformanceTracker = class {
   async save() {
     if (this.readOnly) return;
     try {
-      await fs11__default.default.mkdir(path33__default.default.dirname(this.statsFile), { recursive: true });
+      await fs11__default.default.mkdir(path34__default.default.dirname(this.statsFile), { recursive: true });
       const modelsObj = {};
       const featuresObj = {};
       for (const [key, stat] of this.stats) modelsObj[key] = stat;
@@ -16691,7 +17222,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 = path33__default.default.join(this.workspacePath, ".cascade", DYNAMIC_TOOLS_FILE);
+    const file = path34__default.default.join(this.workspacePath, ".cascade", DYNAMIC_TOOLS_FILE);
     try {
       const raw = await fs11__default.default.readFile(file, "utf-8");
       const specs = JSON.parse(raw);
@@ -16715,8 +17246,8 @@ Required capability: ${description.slice(0, 300)}`;
   }
   async persist() {
     if (!this.workspacePath || !this.persistEnabled) return;
-    const dir = path33__default.default.join(this.workspacePath, ".cascade");
-    const file = path33__default.default.join(dir, DYNAMIC_TOOLS_FILE);
+    const dir = path34__default.default.join(this.workspacePath, ".cascade");
+    const file = path34__default.default.join(dir, DYNAMIC_TOOLS_FILE);
     try {
       await fs11__default.default.mkdir(dir, { recursive: true });
       await fs11__default.default.writeFile(file, JSON.stringify(Array.from(this.specs.values()), null, 2), "utf-8");
@@ -16736,12 +17267,12 @@ var WorldStateDB = class {
   constructor(workspacePath, debugMode = false) {
     this.workspacePath = workspacePath;
     this.debugMode = debugMode;
-    const cascadeDir = path33__default.default.join(workspacePath, ".cascade");
-    if (!fs30__default.default.existsSync(cascadeDir)) {
-      fs30__default.default.mkdirSync(cascadeDir, { recursive: true });
+    const cascadeDir = path34__default.default.join(workspacePath, ".cascade");
+    if (!fs31__default.default.existsSync(cascadeDir)) {
+      fs31__default.default.mkdirSync(cascadeDir, { recursive: true });
     }
-    this.keyPath = path33__default.default.join(cascadeDir, "world_state.key");
-    this.dbPath = path33__default.default.join(cascadeDir, "world_state.db");
+    this.keyPath = path34__default.default.join(cascadeDir, "world_state.key");
+    this.dbPath = path34__default.default.join(cascadeDir, "world_state.db");
     this.initEncryptionKey();
     this.db = new Database2__default.default(this.dbPath);
     this.db.pragma("journal_mode = WAL");
@@ -16798,11 +17329,11 @@ var WorldStateDB = class {
     ).run(e, r, row.encrypted_value, row.source_worker, row.timestamp, validTo, change);
   }
   initEncryptionKey() {
-    if (fs30__default.default.existsSync(this.keyPath)) {
-      this.encryptionKey = fs30__default.default.readFileSync(this.keyPath);
+    if (fs31__default.default.existsSync(this.keyPath)) {
+      this.encryptionKey = fs31__default.default.readFileSync(this.keyPath);
     } else {
       this.encryptionKey = crypto__default.default.randomBytes(32);
-      fs30__default.default.writeFileSync(this.keyPath, this.encryptionKey);
+      fs31__default.default.writeFileSync(this.keyPath, this.encryptionKey);
     }
   }
   encrypt(text) {
@@ -17088,9 +17619,9 @@ var WorldStateDB = class {
   dumpDebugIfNeeded() {
     if (!this.debugMode) return;
     try {
-      const dumpPath = path33__default.default.join(os10__default.default.tmpdir(), "cascade_world_state_debug.json");
+      const dumpPath = path34__default.default.join(os10__default.default.tmpdir(), "cascade_world_state_debug.json");
       const entries = this.getAllEntries();
-      fs30__default.default.writeFileSync(dumpPath, JSON.stringify(entries, null, 2), "utf-8");
+      fs31__default.default.writeFileSync(dumpPath, JSON.stringify(entries, null, 2), "utf-8");
     } catch (err) {
       console.error("Failed to dump debug world state", err);
     }
@@ -17099,6 +17630,212 @@ 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$/;
+var CLAIM_SUFFIX = ".claimed";
+var DEFAULT_CLAIM_TIMEOUT_MS = 10 * 60 * 1e3;
+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;
+  claimTimeoutMs;
+  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;
+    this.claimTimeoutMs = options.claimTimeoutMs ?? DEFAULT_CLAIM_TIMEOUT_MS;
+  }
+  /**
+   * Persist a checkpoint and prune.
+   *
+   * Never throws — failing to save a resume file must not turn a recoverable
+   * stop into a crash — but DOES report whether the atomic rename landed.
+   * Callers decide whether an original claim is safe to discard based on that
+   * answer, so "I swallowed the error" and "the checkpoint is on disk" must not
+   * look alike to them.
+   *
+   * @returns true only when the checkpoint is durably on disk.
+   */
+  async save(checkpoint) {
+    try {
+      const timestamp = this.now();
+      const record = {
+        ...checkpoint,
+        version: RESUME_SCHEMA_VERSION,
+        createdAt: checkpoint.createdAt ?? new Date(timestamp).toISOString()
+      };
+      await fs31.promises.mkdir(this.dir, { recursive: true });
+      const finalPath = path34__default.default.join(this.dir, `${timestamp}-${safeId(record.taskId)}.json`);
+      const tempPath = `${finalPath}.${process.pid}.tmp`;
+      await fs31.promises.writeFile(tempPath, JSON.stringify(record, null, 2), "utf-8");
+      await fs31.promises.rename(tempPath, finalPath);
+      await this.prune();
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /** Valid, unexpired checkpoints, newest first. */
+  async list() {
+    let entries;
+    try {
+      entries = await fs31.promises.readdir(this.dir);
+    } catch {
+      return [];
+    }
+    const cutoff = this.now() - this.maxAgeMs;
+    const candidates2 = 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 candidates2) {
+      try {
+        const raw = await fs31.promises.readFile(path34__default.default.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;
+  }
+  /**
+   * Claim a checkpoint for a resume attempt.
+   *
+   * This used to DELETE the file and return it, which opened a window with no
+   * recovery record at all: between preparing the continuation and the resumed
+   * run writing its own checkpoint, a crash lost the only copy — and a crash is
+   * precisely what this store exists to survive. Deleting on read optimised for
+   * "never resume twice" at the cost of "never lose the work", which is the
+   * wrong trade for a recovery mechanism.
+   *
+   * Instead the file is RENAMED to `.claimed`, which still hides it from
+   * `list()` (so a concurrent resume cannot take the same work) but keeps it on
+   * disk. The caller then either `release`s it — restoring it for another
+   * attempt — or `settle`s it once the resumed run is safely under way. A claim
+   * abandoned by a dead process is reclaimed after `claimTimeoutMs`.
+   */
+  async claim(taskId) {
+    const all = await this.list();
+    const target = taskId ? all.find((c) => c.taskId === taskId) : all[0];
+    if (!target) return null;
+    try {
+      const entries = await fs31.promises.readdir(this.dir);
+      const wanted = safeId(target.taskId);
+      const source = entries.find((name) => FILE_PATTERN.exec(name)?.[2] === wanted);
+      if (!source) return null;
+      const claimId = `${this.now()}-${safeId(target.taskId)}`;
+      await fs31.promises.rename(path34__default.default.join(this.dir, source), path34__default.default.join(this.dir, `${claimId}${CLAIM_SUFFIX}`));
+      return { checkpoint: target, claimId };
+    } catch {
+      return null;
+    }
+  }
+  /** Give a claim back, so the work stays recoverable after a failed start. */
+  async release(claimId) {
+    try {
+      await fs31.promises.rename(
+        path34__default.default.join(this.dir, `${claimId}${CLAIM_SUFFIX}`),
+        path34__default.default.join(this.dir, `${claimId}.json`)
+      );
+    } catch {
+    }
+  }
+  /** Discard a claim for good — the resumed run has taken ownership. */
+  async settle(claimId) {
+    try {
+      await fs31.promises.rm(path34__default.default.join(this.dir, `${claimId}${CLAIM_SUFFIX}`), { force: true });
+    } catch {
+    }
+  }
+  /**
+   * Claim-and-discard in one step. Kept for callers that genuinely want the old
+   * semantics; prefer claim/settle so a crash mid-resume stays recoverable.
+   */
+  async consume(taskId) {
+    const claimed = await this.claim(taskId);
+    if (!claimed) return null;
+    await this.settle(claimed.claimId);
+    return claimed.checkpoint;
+  }
+  /**
+   * Return claims abandoned by a process that died mid-resume. Without this a
+   * crash between claim and settle would strand the checkpoint invisibly —
+   * trading one loss window for another.
+   */
+  async reclaimStale() {
+    let reclaimed = 0;
+    try {
+      const entries = await fs31.promises.readdir(this.dir);
+      const cutoff = this.now() - this.claimTimeoutMs;
+      for (const name of entries) {
+        if (!name.endsWith(CLAIM_SUFFIX)) continue;
+        const stamp2 = Number(/^(\d+)-/.exec(name)?.[1]);
+        if (!Number.isFinite(stamp2) || stamp2 >= cutoff) continue;
+        await fs31.promises.rename(
+          path34__default.default.join(this.dir, name),
+          path34__default.default.join(this.dir, `${name.slice(0, -CLAIM_SUFFIX.length)}.json`)
+        );
+        reclaimed++;
+      }
+    } catch {
+    }
+    return reclaimed;
+  }
+  /** Remove every checkpoint for a task id. */
+  async delete(taskId) {
+    try {
+      const entries = await fs31.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 fs31.promises.rm(path34__default.default.join(this.dir, name), { force: true });
+        }
+      }));
+    } catch {
+    }
+  }
+  /** Drop expired checkpoints, then any beyond the newest `maxCheckpoints`. */
+  async prune() {
+    try {
+      const entries = await fs31.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) => fs31.promises.rm(path34__default.default.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 ignore3 = _ignoreModule__namespace.default ?? _ignoreModule__namespace;
 var PrivacyPaths = class {
   localOnly;
@@ -17460,7 +18197,7 @@ var WorkspaceIndex = class {
   isIgnored;
   chunker;
   constructor(opts) {
-    this.root = path33__default.default.resolve(opts.root);
+    this.root = path34__default.default.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()));
@@ -17492,14 +18229,14 @@ var WorkspaceIndex = class {
         return;
       }
       for (const entry of entries) {
-        const abs = path33__default.default.join(dir, entry.name);
+        const abs = path34__default.default.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 = path33__default.default.extname(entry.name).slice(1).toLowerCase();
+          const ext = path34__default.default.extname(entry.name).slice(1).toLowerCase();
           if (!this.extensions.has(ext) || this.isIgnored(abs)) continue;
-          out.push(path33__default.default.relative(this.root, abs));
+          out.push(path34__default.default.relative(this.root, abs));
         }
       }
     };
@@ -17529,7 +18266,7 @@ var WorkspaceIndex = class {
     const entries = [];
     for (const rel of rels) {
       try {
-        const abs = path33__default.default.join(this.root, rel);
+        const abs = path34__default.default.join(this.root, rel);
         const stat = await fs11__default.default.stat(abs);
         if (stat.size > this.maxFileBytes) continue;
         const buf = await fs11__default.default.readFile(abs);
@@ -18067,8 +18804,35 @@ var Cascade = class _Cascade extends EventEmitter__default.default {
   /** 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;
+  /** Claim held by an in-flight resume, settled once the run owns the work. */
+  claimedResumeId;
+  /**
+   * Facts inherited from the checkpoint this run is resuming, so its own
+   * checkpoint is cumulative rather than only covering this attempt.
+   */
+  resumedFrom;
+  /** Whether THIS run persisted a checkpoint of its own. Drives settle-vs-release. */
+  wroteCheckpointThisRun = false;
+  /**
+   * Whether the run reached the end of its normal path.
+   *
+   * NOT the same as `runError == null`: the cancellation and budget handlers
+   * both null `runError` deliberately (an intentional stop is not a telemetry
+   * error) and the breaker path never sets it at all. Treating that as success
+   * meant an immediate cancel — no output, no replacement checkpoint — deleted
+   * the original claim and the finished sections with it.
+   */
+  completedNormally = false;
+  /** Section results of the CURRENT run, so an interruption can checkpoint them. */
+  currentRunCompleted = [];
   initPromise;
   store;
   audit;
@@ -18101,10 +18865,16 @@ var Cascade = class _Cascade extends EventEmitter__default.default {
     this.toolRegistry = new ToolRegistry(this.config.tools, workspacePath);
     try {
       this.router.setDeadModelStore(new DeadModelStore(
-        fileDeadModelPersistence(path33__default.default.join(workspacePath, ".cascade", "dead-models.json"))
+        fileDeadModelPersistence(path34__default.default.join(workspacePath, ".cascade", "dead-models.json"))
       ));
     } catch {
     }
+    try {
+      this.resumeStore = new ResumeStore({
+        dir: path34__default.default.join(workspacePath, ".cascade", "resume")
+      });
+    } catch {
+    }
     this.multimodal = new MultimodalRegistry(
       (this.config.providers ?? []).map((p) => p.type)
     );
@@ -18189,8 +18959,8 @@ var Cascade = class _Cascade extends EventEmitter__default.default {
       this.emit("log", { level: "warn", message: "Code index enabled but no embeddings-capable provider is configured \u2014 skipping." });
       return;
     }
-    const dbPath = ci.dbPath || path33__default.default.join(this.workspacePath, ".cascade", "code-index.db");
-    fs30__default.default.mkdirSync(path33__default.default.dirname(dbPath), { recursive: true });
+    const dbPath = ci.dbPath || path34__default.default.join(this.workspacePath, ".cascade", "code-index.db");
+    fs31__default.default.mkdirSync(path34__default.default.dirname(dbPath), { recursive: true });
     const db = new Database2__default.default(dbPath);
     db.pragma("journal_mode = WAL");
     const complete = chatCompleterFromProviders(this.config.providers);
@@ -18570,10 +19340,57 @@ ${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) {
+    const inherited = this.resumedFrom?.completed ?? [];
+    const merged = /* @__PURE__ */ new Map();
+    for (const node of inherited) merged.set(node.id, node);
+    for (const node of this.currentRunCompleted) {
+      const existing = merged.get(node.id);
+      if (existing?.status === "COMPLETED" && node.status !== "COMPLETED") continue;
+      merged.set(node.id, node);
+    }
+    const completed = [...merged.values()];
+    const canonicalPrompt = this.resumedFrom?.prompt ?? prompt;
+    const carriedPartial = partialOutput || (this.resumedFrom?.partialOutput ?? "");
+    if (!completed.length && !carriedPartial) return false;
+    try {
+      const saved = await this.resumeStore?.save({
+        taskId,
+        prompt: canonicalPrompt,
+        reason,
+        ...detail ? { detail } : {},
+        partialOutput: carriedPartial,
+        completed
+      });
+      this.wroteCheckpointThisRun = saved === true;
+      return saved === true;
+    } catch {
+      return false;
+    }
+  }
+  /** 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
@@ -18584,24 +19401,105 @@ ${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 = {}) {
+    await this.resumeStore?.reclaimStale();
+    const claimed = await this.resumeStore?.claim(opts.taskId);
+    if (!claimed) return null;
+    try {
+      this.lastInterruptedRun = void 0;
+      this.raiseBudgetForResume(opts.maxTokens);
+      const prompt = this.buildResumePrompt(
+        claimed.checkpoint.prompt,
+        claimed.checkpoint.partialOutput,
+        claimed.checkpoint.completed
+      );
+      this.resumedFrom = {
+        prompt: claimed.checkpoint.prompt,
+        completed: claimed.checkpoint.completed,
+        partialOutput: claimed.checkpoint.partialOutput
+      };
+      this.claimedResumeId = claimed.claimId;
+      return prompt;
+    } catch (err) {
+      await this.resumeStore?.release(claimed.claimId);
+      throw err;
+    }
+  }
+  /**
+   * Discard the claimed checkpoint once the resumed run has taken ownership of
+   * the work (it has produced its own checkpoint, or finished). Called by the
+   * run loop; safe to call when nothing is claimed.
+   */
+  async settleClaimedResume(succeeded) {
+    const claimId = this.claimedResumeId;
+    if (!claimId) return;
+    this.claimedResumeId = void 0;
+    if (succeeded || this.wroteCheckpointThisRun) {
+      await this.resumeStore?.settle(claimId);
+    } else {
+      await this.resumeStore?.release(claimId);
+    }
+  }
+  /**
+   * Hand back a claim taken by prepareDurableResume() when the caller never
+   * gets as far as run(). The REPL prepares the continuation and submits it
+   * separately, so a failure in between would otherwise strand the checkpoint
+   * for the whole lease timeout before reclaimStale() could recover it.
+   */
+  async releaseClaimedResume() {
+    const claimId = this.claimedResumeId;
+    if (!claimId) return;
+    this.claimedResumeId = void 0;
+    await this.resumeStore?.release(claimId);
+  }
+  /** 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 });
+    try {
+      return await this.run({ prompt });
+    } catch (err) {
+      await this.releaseClaimedResume();
+      throw err;
+    }
   }
   getWorkspacePath() {
     return this.workspacePath;
@@ -18970,6 +19868,10 @@ ${prompt}` : prompt;
     const startMs = Date.now();
     const taskId = crypto.randomUUID();
     this.decisionLog = [];
+    this.currentRunCompleted = [];
+    this.wroteCheckpointThisRun = false;
+    this.completedNormally = false;
+    if (!this.claimedResumeId) this.resumedFrom = void 0;
     if (options.fastAnswer) {
       return this.runFastAnswer(options, startMs, taskId);
     }
@@ -19084,6 +19986,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) => {
@@ -19230,6 +20137,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.**`,
           "",
@@ -19242,6 +20150,7 @@ _(incomplete: ${reasons.join("; ")})_` : partial;
 ${finalOutput}` : ""
         ].join("\n").trimEnd();
       }
+      this.completedNormally = trip == null;
     } catch (err) {
       if (err instanceof CascadeCancelledError || err instanceof Error && err.name === "AbortError" || options.signal?.aborted) {
         this.emit("run:cancelled", {
@@ -19249,6 +20158,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", {
@@ -19257,9 +20173,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;
       }
@@ -19268,6 +20192,10 @@ ${finalOutput}` : ""
         escalator.cancelAllPending();
       } catch {
       }
+      try {
+        await this.settleClaimedResume(this.completedNormally);
+      } catch {
+      }
       try {
         this.releasePendingEscalations();
       } catch {
@@ -19471,14 +20399,14 @@ ${finalOutput}` : ""
 init_constants();
 var CLOUD_SESSION_FILE = "cloud-session.json";
 function globalDir(homeDir = os10__default.default.homedir()) {
-  return path33__default.default.join(homeDir, GLOBAL_CONFIG_DIR);
+  return path34__default.default.join(homeDir, GLOBAL_CONFIG_DIR);
 }
 function cloudSessionPath(dir = globalDir()) {
-  return path33__default.default.join(dir, CLOUD_SESSION_FILE);
+  return path34__default.default.join(dir, CLOUD_SESSION_FILE);
 }
 function loadCloudSession(dir = globalDir()) {
   try {
-    const raw = fs30__default.default.readFileSync(cloudSessionPath(dir), "utf-8");
+    const raw = fs31__default.default.readFileSync(cloudSessionPath(dir), "utf-8");
     const parsed = JSON.parse(raw);
     if (!parsed?.refreshToken || !parsed?.serverUrl) return null;
     return parsed;
@@ -19487,17 +20415,17 @@ function loadCloudSession(dir = globalDir()) {
   }
 }
 function saveCloudSession(session, dir = globalDir()) {
-  fs30__default.default.mkdirSync(dir, { recursive: true, mode: 448 });
+  fs31__default.default.mkdirSync(dir, { recursive: true, mode: 448 });
   const file = cloudSessionPath(dir);
-  fs30__default.default.writeFileSync(file, JSON.stringify(session, null, 2), { mode: 384 });
+  fs31__default.default.writeFileSync(file, JSON.stringify(session, null, 2), { mode: 384 });
   try {
-    fs30__default.default.chmodSync(file, 384);
+    fs31__default.default.chmodSync(file, 384);
   } catch {
   }
 }
 function clearCloudSession(dir = globalDir()) {
   try {
-    fs30__default.default.rmSync(cloudSessionPath(dir));
+    fs31__default.default.rmSync(cloudSessionPath(dir));
   } catch {
   }
 }
@@ -19669,16 +20597,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(path38, init = {}) {
-    const call = (token) => fetch(this.url(path38), { ...init, headers: { ...init.headers ?? {}, Authorization: `Bearer ${token}` } });
+  async authed(path39, init = {}) {
+    const call = (token) => fetch(this.url(path39), { ...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(path38) {
-    return this.authed(path38);
+  authedGet(path39) {
+    return this.authed(path39);
   }
   async fetchMe(token) {
     const res = await fetch(this.url("/api/me"), { headers: { Authorization: `Bearer ${token}` } });
@@ -20458,7 +21386,8 @@ function AgentTreeInternal({
           ] }),
           node.status === "COMPLETED" && /* @__PURE__ */ jsxRuntime.jsx(ink.Text, { color: theme.colors.success, children: " \u2714" }),
           node.status === "FAILED" && /* @__PURE__ */ jsxRuntime.jsx(ink.Text, { color: theme.colors.error, children: " \u2718" }),
-          node.status === "ESCALATED" && /* @__PURE__ */ jsxRuntime.jsx(ink.Text, { color: theme.colors.warning, children: " \u25B2" })
+          node.status === "ESCALATED" && /* @__PURE__ */ jsxRuntime.jsx(ink.Text, { color: theme.colors.warning, children: " \u25B2" }),
+          node.status === "BLOCKED" && /* @__PURE__ */ jsxRuntime.jsx(ink.Text, { color: theme.colors.muted, children: " \u292B skipped" })
         ] }, `t2-${node.id}-${i}`);
       }
       if (row.type === "t3") {
@@ -20483,7 +21412,8 @@ function AgentTreeInternal({
             /* @__PURE__ */ jsxRuntime.jsx(Spinner__default.default, { type: "dots" })
           ] }),
           node.status === "COMPLETED" && /* @__PURE__ */ jsxRuntime.jsx(ink.Text, { color: theme.colors.success, children: " \u2714" }),
-          node.status === "FAILED" && /* @__PURE__ */ jsxRuntime.jsx(ink.Text, { color: theme.colors.error, children: " \u2718" })
+          node.status === "FAILED" && /* @__PURE__ */ jsxRuntime.jsx(ink.Text, { color: theme.colors.error, children: " \u2718" }),
+          node.status === "BLOCKED" && /* @__PURE__ */ jsxRuntime.jsx(ink.Text, { color: theme.colors.muted, children: " \u292B skipped" })
         ] }, `t3-${node.id}-${i}`);
       }
       return null;
@@ -21453,9 +22383,9 @@ function Repl({ config, workspacePath, themeName, initialPrompt, identityName, a
       }
     } catch {
     }
-    const configPath = path33__default.default.join(workspacePath, ".cascade", "config.json");
+    const configPath = path34__default.default.join(workspacePath, ".cascade", "config.json");
     try {
-      await fs11__default.default.mkdir(path33__default.default.dirname(configPath), { recursive: true });
+      await fs11__default.default.mkdir(path34__default.default.dirname(configPath), { recursive: true });
       await fs11__default.default.writeFile(configPath, JSON.stringify(config, null, 2), "utf-8");
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
@@ -21482,7 +22412,7 @@ function Repl({ config, workspacePath, themeName, initialPrompt, identityName, a
   }, []);
   const recordNodeEvent = React2.useCallback((event) => {
     const existing = treeNodesRef.current.get(event.tierId);
-    const node = { id: event.tierId, role: event.role ?? existing?.role ?? "T3", label: event.label ?? existing?.label ?? event.tierId, status: event.status ?? existing?.status ?? "IDLE", currentAction: event.currentAction ?? existing?.currentAction, progressPct: event.progressPct ?? existing?.progressPct, parentId: event.parentId ?? existing?.parentId, children: [] };
+    const node = { id: event.tierId, role: event.role ?? existing?.role ?? "T3", label: event.label ?? existing?.label ?? event.tierId, status: event.status ?? existing?.status ?? "IDLE", currentAction: event.currentAction ?? existing?.currentAction, progressPct: event.progressPct ?? existing?.progressPct, parentId: event.parentId ?? existing?.parentId, nodeId: event.nodeId ?? existing?.nodeId, dependsOn: event.dependsOn ?? existing?.dependsOn, waveId: event.waveId ?? existing?.waveId, blockedBy: event.blockedBy ?? existing?.blockedBy, children: [] };
     treeNodesRef.current.set(event.tierId, node);
     const store = storeRef.current;
     if (store) {
@@ -21507,9 +22437,9 @@ function Repl({ config, workspacePath, themeName, initialPrompt, identityName, a
       if (msg.includes("non-text parts")) return;
       originalLog(...args);
     };
-    const store = new MemoryStore(path33__default.default.join(workspacePath, CASCADE_DB_FILE));
+    const store = new MemoryStore(path34__default.default.join(workspacePath, CASCADE_DB_FILE));
     storeRef.current = store;
-    globalStoreRef.current = new MemoryStore(path33__default.default.join(os10__default.default.homedir(), GLOBAL_CONFIG_DIR, GLOBAL_RUNTIME_DB_FILE));
+    globalStoreRef.current = new MemoryStore(path34__default.default.join(os10__default.default.homedir(), GLOBAL_CONFIG_DIR, GLOBAL_RUNTIME_DB_FILE));
     const identityRows = store.listIdentities().map((i) => ({ id: i.id, name: i.name, isDefault: i.isDefault }));
     setIdentities(identityRows);
     let initialIdentityId = config.defaultIdentityId ?? identityRows.find((i) => i.isDefault)?.id ?? identityRows[0]?.id;
@@ -21577,7 +22507,7 @@ function Repl({ config, workspacePath, themeName, initialPrompt, identityName, a
       onThemeChange: (name) => setTheme(getTheme(name)),
       onExport: async (fmt) => {
         const stamp2 = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-        const exportPath = path33__default.default.join(workspacePath, `cascade-export-${stamp2}.${fmt === "json" ? "json" : "md"}`);
+        const exportPath = path34__default.default.join(workspacePath, `cascade-export-${stamp2}.${fmt === "json" ? "json" : "md"}`);
         if (fmt === "json") {
           await fs11__default.default.writeFile(exportPath, JSON.stringify({ sessionId: sessionIdRef.current, messages: state.messages }, null, 2), "utf-8");
         } else {
@@ -21819,11 +22749,21 @@ ${lastUser.content}`;
       onContinue: async (args) => {
         const cascade = cascadeRef.current;
         if (!cascade) return "Not ready yet.";
-        if (!cascade.hasResumableRun()) return "Nothing to continue \u2014 no task was stopped by the budget cap.";
+        if (state.isExecuting) {
+          return "A task is already running \u2014 wait for it to finish (or press Esc to stop it) before using /continue.";
+        }
         const n = args[0] ? parseInt(args[0].replace(/[^0-9]/g, ""), 10) : NaN;
-        const prompt = cascade.prepareResume(Number.isFinite(n) && n > 0 ? { maxTokens: n } : {});
-        if (!prompt) return "Nothing to continue.";
-        await handleSubmit(prompt);
+        const opts = Number.isFinite(n) && n > 0 ? { maxTokens: n } : {};
+        const prompt = await cascade.prepareDurableResume(opts) ?? cascade.prepareResume(opts);
+        if (!prompt) {
+          return "Nothing to continue \u2014 no interrupted task was found for this workspace.";
+        }
+        try {
+          await handleSubmit(prompt);
+        } catch (err) {
+          await cascade.releaseClaimedResume();
+          throw err;
+        }
         return "";
       }
     });
@@ -22475,7 +23415,7 @@ function stringifySlashOutput(val) {
 }
 async function searchSessionsAndMessages(query, workspacePath) {
   if (!query) return "Usage: /search <query>";
-  const dbPath = path33__default.default.join(workspacePath, CASCADE_DB_FILE);
+  const dbPath = path34__default.default.join(workspacePath, CASCADE_DB_FILE);
   try {
     await fs11__default.default.access(dbPath);
   } catch {
@@ -22509,7 +23449,7 @@ async function searchSessionsAndMessages(query, workspacePath) {
 async function diagnoseRuntime(config, workspacePath) {
   const providers = config.providers.map((p) => `${p.type}${p.apiKey ? " (key set)" : " (no key)"}`).join("\n");
   const models = [`T1: ${config.models.t1 ?? "default"}`, `T2: ${config.models.t2 ?? "default"}`, `T3: ${config.models.t3 ?? "default"}`].join("\n");
-  const store = new MemoryStore(path33__default.default.join(workspacePath, CASCADE_DB_FILE));
+  const store = new MemoryStore(path34__default.default.join(workspacePath, CASCADE_DB_FILE));
   try {
     const sessions2 = store.listSessions(void 0, 3);
     return [
@@ -22528,7 +23468,7 @@ async function diagnoseRuntime(config, workspacePath) {
 }
 async function showRecentLogs(args, workspacePath) {
   const limit = Number.parseInt(args[0] ?? "10", 10) || 10;
-  const store = new MemoryStore(path33__default.default.join(workspacePath, CASCADE_DB_FILE));
+  const store = new MemoryStore(path34__default.default.join(workspacePath, CASCADE_DB_FILE));
   try {
     const logs = store.listRuntimeNodeLogs(void 0, void 0, limit);
     if (!logs.length) return "No recent runtime logs.";
@@ -22540,7 +23480,7 @@ async function showRecentLogs(args, workspacePath) {
 async function loadSessionSnapshot(args, workspacePath) {
   const sessionId = args[0];
   if (!sessionId) return "Usage: /resume <sessionId>";
-  const store = new MemoryStore(path33__default.default.join(workspacePath, CASCADE_DB_FILE));
+  const store = new MemoryStore(path34__default.default.join(workspacePath, CASCADE_DB_FILE));
   try {
     const session = store.getSession(sessionId);
     if (!session) return `Session not found: ${sessionId}`;
@@ -22968,9 +23908,9 @@ function SetupWizard({ workspacePath, onComplete }) {
           ...anyAuto ? { cascadeAuto: true } : {}
         };
         const config = CascadeConfigSchema.parse(rawConfig);
-        const configDir = path33__default.default.join(workspacePath, ".cascade");
+        const configDir = path34__default.default.join(workspacePath, ".cascade");
         await fs11__default.default.mkdir(configDir, { recursive: true });
-        const configPath = path33__default.default.join(workspacePath, CASCADE_CONFIG_FILE);
+        const configPath = path34__default.default.join(workspacePath, CASCADE_CONFIG_FILE);
         await fs11__default.default.writeFile(configPath, JSON.stringify(config, null, 2), "utf-8");
         savedConfigRef.current = config;
         dispatchRef.current({ type: "GO_DONE" });
@@ -23312,14 +24252,14 @@ function printTelemetryBanner() {
 async function initCommand(workspacePath = process.cwd()) {
   const spin = ora__default.default({ text: "Initializing Cascade project\u2026", color: "magenta" }).start();
   try {
-    const configDir = path33__default.default.join(workspacePath, ".cascade");
+    const configDir = path34__default.default.join(workspacePath, ".cascade");
     await fs11__default.default.mkdir(configDir, { recursive: true });
-    const mdPath = path33__default.default.join(workspacePath, "CASCADE.md");
+    const mdPath = path34__default.default.join(workspacePath, "CASCADE.md");
     if (!await fileExists(mdPath)) {
       await createDefaultCascadeMd(workspacePath);
       spin.succeed(chalk7__default.default.green("Created CASCADE.md"));
     }
-    const ignorePath = path33__default.default.join(workspacePath, ".cascadeignore");
+    const ignorePath = path34__default.default.join(workspacePath, ".cascadeignore");
     if (!await fileExists(ignorePath)) {
       await createDefaultIgnoreFile(workspacePath);
       spin.succeed(chalk7__default.default.green("Created .cascadeignore"));
@@ -23328,7 +24268,7 @@ async function initCommand(workspacePath = process.cwd()) {
     console.log();
     console.log(chalk7__default.default.magenta("  \u25C8 Cascade AI \u2014 Project initialized"));
     console.log();
-    const configPath = path33__default.default.join(workspacePath, CASCADE_CONFIG_FILE);
+    const configPath = path34__default.default.join(workspacePath, CASCADE_CONFIG_FILE);
     if (await fileExists(configPath)) {
       console.log(chalk7__default.default.yellow("  .cascade/config.json already exists \u2014 launching wizard to reconfigure."));
       console.log();
@@ -23386,7 +24326,7 @@ function fromEnv(env) {
   return out;
 }
 async function fromClaudeCode(home) {
-  const file = path33__default.default.join(home, ".claude", ".credentials.json");
+  const file = path34__default.default.join(home, ".claude", ".credentials.json");
   const data = await readJson(file);
   if (!data) return [];
   const oauth = data["claudeAiOauth"];
@@ -23409,7 +24349,7 @@ async function fromClaudeCode(home) {
   return [];
 }
 async function fromCodex(home) {
-  const file = path33__default.default.join(home, ".codex", "auth.json");
+  const file = path34__default.default.join(home, ".codex", "auth.json");
   const data = await readJson(file);
   if (!data) return [];
   const apiKey = str(data["OPENAI_API_KEY"]);
@@ -23432,7 +24372,7 @@ async function fromCodex(home) {
   return [];
 }
 async function fromGemini(home) {
-  const file = path33__default.default.join(home, ".gemini", "oauth_creds.json");
+  const file = path34__default.default.join(home, ".gemini", "oauth_creds.json");
   const data = await readJson(file);
   const accessToken = str(data?.["access_token"]);
   if (!accessToken) return [];
@@ -23448,7 +24388,7 @@ async function fromGemini(home) {
 }
 async function fromCopilot(home) {
   for (const name of ["apps.json", "hosts.json"]) {
-    const file = path33__default.default.join(home, ".config", "github-copilot", name);
+    const file = path34__default.default.join(home, ".config", "github-copilot", name);
     const data = await readJson(file);
     if (!data) continue;
     for (const value of Object.values(data)) {
@@ -23502,7 +24442,7 @@ async function doctorCommand() {
   checks.push({
     label: "Cascade config",
     ok: true,
-    detail: `Loaded ${path33__default.default.join(process.cwd(), CASCADE_CONFIG_FILE)}`
+    detail: `Loaded ${path34__default.default.join(process.cwd(), CASCADE_CONFIG_FILE)}`
   });
   const providers = [
     { type: "anthropic", name: "Anthropic" },
@@ -23585,17 +24525,17 @@ async function doctorCommand() {
     const detail = c.detail ? chalk7__default.default.gray(` \u2014 ${c.detail}`) : "";
     console.log(`${icon}  ${label}${detail}`);
   }
-  const failures = checks.filter((c) => !c.ok);
+  const failures2 = checks.filter((c) => !c.ok);
   console.log();
-  if (failures.length === 0) {
+  if (failures2.length === 0) {
     console.log(chalk7__default.default.green("  All checks passed!\n"));
   } else {
-    const critical = failures.filter((c) => c.label.includes("Node") || c.label.includes("API key"));
+    const critical = failures2.filter((c) => c.label.includes("Node") || c.label.includes("API key"));
     if (critical.length) {
       console.log(chalk7__default.default.yellow(`  ${critical.length} issue(s) need attention.
 `));
     } else {
-      console.log(chalk7__default.default.gray(`  ${failures.length} optional item(s) not configured.
+      console.log(chalk7__default.default.gray(`  ${failures2.length} optional item(s) not configured.
 `));
     }
   }
@@ -23613,7 +24553,7 @@ async function checkEndpoint(url) {
   }
 }
 async function indexCommand(dirPath) {
-  const workspace = path33__default.default.resolve(dirPath || process.cwd());
+  const workspace = path34__default.default.resolve(dirPath || process.cwd());
   const cm = new ConfigManager(workspace);
   await cm.load();
   const config = cm.getConfig();
@@ -23624,8 +24564,8 @@ async function indexCommand(dirPath) {
     process.exitCode = 1;
     return;
   }
-  const dbPath = config.codeIndex?.dbPath || path33__default.default.join(workspace, ".cascade", "code-index.db");
-  fs30__default.default.mkdirSync(path33__default.default.dirname(dbPath), { recursive: true });
+  const dbPath = config.codeIndex?.dbPath || path34__default.default.join(workspace, ".cascade", "code-index.db");
+  fs31__default.default.mkdirSync(path34__default.default.dirname(dbPath), { recursive: true });
   const db = new Database2__default.default(dbPath);
   db.pragma("journal_mode = WAL");
   const complete = chatCompleterFromProviders(config.providers);
@@ -24114,7 +25054,7 @@ function openBrowser2(url) {
 }
 function storePathFor(name) {
   const safe = name.replace(/[^a-z0-9._-]/gi, "_").slice(0, 64) || "server";
-  return path33__default.default.join(os10__default.default.homedir(), ".cascade-ai", "mcp-oauth", `${safe}.json`);
+  return path34__default.default.join(os10__default.default.homedir(), ".cascade-ai", "mcp-oauth", `${safe}.json`);
 }
 function defaultName(url) {
   try {
@@ -24316,8 +25256,14 @@ var DashboardSocket = class {
   emitCascadeEvent(ev) {
     this.io.emit("cascade:event", ev);
   }
-  emitTierStatus(tierId, role, status, sessionId, action) {
-    const payload = { tierId, role, status, action, timestamp: (/* @__PURE__ */ new Date()).toISOString(), sessionId };
+  /**
+   * `extra` exists because this signature is positional: every field the tier
+   * emits that is not named here is silently dropped on this path, while the
+   * other two forwarders spread the whole event through. That asymmetry is how
+   * a field can reach the web dashboard from one code path and not another.
+   */
+  emitTierStatus(tierId, role, status, sessionId, action, extra) {
+    const payload = { tierId, role, status, action, timestamp: (/* @__PURE__ */ new Date()).toISOString(), sessionId, ...extra };
     this.io.emit("tier:status", payload);
     this.io.to(`session:${sessionId}`).emit("tier:status", payload);
   }
@@ -24616,7 +25562,7 @@ function aggregateCostStats(sessions2, opts = {}) {
 }
 
 // src/dashboard/server.ts
-var __dirname$1 = path33__default.default.dirname(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('cli.cjs', document.baseURI).href))));
+var __dirname$1 = path34__default.default.dirname(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('cli.cjs', document.baseURI).href))));
 var ORPHANED_ESCALATION_GRACE_MS = 3e4;
 var DashboardServer = class {
   app;
@@ -24896,14 +25842,14 @@ var DashboardServer = class {
    */
   persistConfig() {
     try {
-      const configPath = path33__default.default.join(this.workspacePath, CASCADE_CONFIG_FILE);
-      fs30__default.default.mkdirSync(path33__default.default.dirname(configPath), { recursive: true });
-      fs30__default.default.writeFileSync(configPath, JSON.stringify(this.config, null, 2), "utf-8");
+      const configPath = path34__default.default.join(this.workspacePath, CASCADE_CONFIG_FILE);
+      fs31__default.default.mkdirSync(path34__default.default.dirname(configPath), { recursive: true });
+      fs31__default.default.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(path33__default.default.join(os10__default.default.homedir(), GLOBAL_CONFIG_DIR), this.config.providers ?? []);
+      saveGlobalCredentials(path34__default.default.join(os10__default.default.homedir(), GLOBAL_CONFIG_DIR), this.config.providers ?? []);
     } catch (err) {
       console.warn(`[dashboard] Failed to sync global credentials: ${err instanceof Error ? err.message : String(err)}`);
     }
@@ -24918,15 +25864,15 @@ var DashboardServer = class {
   resolveDashboardSecret() {
     const fromConfig = this.config.dashboard.secret ?? process.env["CASCADE_DASHBOARD_SECRET"];
     if (fromConfig) return fromConfig;
-    const secretPath = path33__default.default.join(this.workspacePath, CASCADE_DASHBOARD_SECRET_FILE);
+    const secretPath = path34__default.default.join(this.workspacePath, CASCADE_DASHBOARD_SECRET_FILE);
     try {
-      if (fs30__default.default.existsSync(secretPath)) {
-        const existing = fs30__default.default.readFileSync(secretPath, "utf-8").trim();
+      if (fs31__default.default.existsSync(secretPath)) {
+        const existing = fs31__default.default.readFileSync(secretPath, "utf-8").trim();
         if (existing.length >= 16) return existing;
       }
       const generated = crypto.randomUUID();
-      fs30__default.default.mkdirSync(path33__default.default.dirname(secretPath), { recursive: true });
-      fs30__default.default.writeFileSync(secretPath, generated, { encoding: "utf-8", mode: 384 });
+      fs31__default.default.mkdirSync(path34__default.default.dirname(secretPath), { recursive: true });
+      fs31__default.default.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.`
@@ -24953,7 +25899,7 @@ var DashboardServer = class {
   // ── Setup ─────────────────────────────────────
   getGlobalStore() {
     if (!this.globalStore) {
-      const globalDbPath = path33__default.default.join(os10__default.default.homedir(), GLOBAL_CONFIG_DIR, GLOBAL_RUNTIME_DB_FILE);
+      const globalDbPath = path34__default.default.join(os10__default.default.homedir(), GLOBAL_CONFIG_DIR, GLOBAL_RUNTIME_DB_FILE);
       this.globalStore = new MemoryStore(globalDbPath);
     }
     return this.globalStore;
@@ -25333,12 +26279,12 @@ ${prompt}`;
     }
   }
   watchRuntimeChanges() {
-    const workspaceDbPath = path33__default.default.join(this.workspacePath, CASCADE_DB_FILE);
-    const globalDbPath = path33__default.default.join(os10__default.default.homedir(), GLOBAL_CONFIG_DIR, GLOBAL_RUNTIME_DB_FILE);
+    const workspaceDbPath = path34__default.default.join(this.workspacePath, CASCADE_DB_FILE);
+    const globalDbPath = path34__default.default.join(os10__default.default.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 (!fs30__default.default.existsSync(watchPath)) continue;
-      fs30__default.default.watchFile(watchPath, { interval: 3e3 }, () => {
+      if (!fs31__default.default.existsSync(watchPath)) continue;
+      fs31__default.default.watchFile(watchPath, { interval: 3e3 }, () => {
         this.throttledBroadcast(watchPath === globalDbPath ? "global" : "workspace");
       });
     }
@@ -25460,7 +26406,7 @@ ${prompt}`;
       const sessionId = req.params.id;
       this.store.deleteSession(sessionId);
       this.store.deleteRuntimeSession(sessionId);
-      const globalDbPath = path33__default.default.join(os10__default.default.homedir(), GLOBAL_CONFIG_DIR, GLOBAL_RUNTIME_DB_FILE);
+      const globalDbPath = path34__default.default.join(os10__default.default.homedir(), GLOBAL_CONFIG_DIR, GLOBAL_RUNTIME_DB_FILE);
       const globalStore = new MemoryStore(globalDbPath);
       try {
         globalStore.deleteRuntimeSession(sessionId);
@@ -25553,7 +26499,7 @@ ${prompt}`;
     });
     this.app.delete("/api/sessions", auth2, (req, res) => {
       const body = req.body;
-      const globalDbPath = path33__default.default.join(os10__default.default.homedir(), GLOBAL_CONFIG_DIR, GLOBAL_RUNTIME_DB_FILE);
+      const globalDbPath = path34__default.default.join(os10__default.default.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 {
@@ -25576,7 +26522,7 @@ ${prompt}`;
     });
     this.app.delete("/api/runtime", auth2, (_req, res) => {
       this.store.deleteAllRuntimeNodes();
-      const globalDbPath = path33__default.default.join(os10__default.default.homedir(), GLOBAL_CONFIG_DIR, GLOBAL_RUNTIME_DB_FILE);
+      const globalDbPath = path34__default.default.join(os10__default.default.homedir(), GLOBAL_CONFIG_DIR, GLOBAL_RUNTIME_DB_FILE);
       const globalStore = new MemoryStore(globalDbPath);
       try {
         globalStore.deleteAllRuntimeNodes();
@@ -25662,12 +26608,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 = path33__default.default.join(this.workspacePath, CASCADE_CONFIG_FILE);
-        const existing = fs30__default.default.existsSync(configPath) ? JSON.parse(fs30__default.default.readFileSync(configPath, "utf-8")) : {};
+        const configPath = path34__default.default.join(this.workspacePath, CASCADE_CONFIG_FILE);
+        const existing = fs31__default.default.existsSync(configPath) ? JSON.parse(fs31__default.default.readFileSync(configPath, "utf-8")) : {};
         const updated = { ...existing, tierLimits: this.config.tierLimits, budget: this.config.budget };
         const tmp = configPath + ".tmp";
-        fs30__default.default.writeFileSync(tmp, JSON.stringify(updated, null, 2), "utf-8");
-        fs30__default.default.renameSync(tmp, configPath);
+        fs31__default.default.writeFileSync(tmp, JSON.stringify(updated, null, 2), "utf-8");
+        fs31__default.default.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)}` });
@@ -25695,7 +26641,7 @@ ${prompt}`;
     this.app.get("/api/runtime", auth2, (req, res) => {
       const scope = req.query["scope"] ?? "workspace";
       if (scope === "global") {
-        const globalDbPath = path33__default.default.join(os10__default.default.homedir(), GLOBAL_CONFIG_DIR, GLOBAL_RUNTIME_DB_FILE);
+        const globalDbPath = path34__default.default.join(os10__default.default.homedir(), GLOBAL_CONFIG_DIR, GLOBAL_RUNTIME_DB_FILE);
         const globalStore = new MemoryStore(globalDbPath);
         try {
           res.json({
@@ -26036,13 +26982,13 @@ ${prompt}`;
         res.status(500).json({ error: err instanceof Error ? err.message : String(err) });
       }
     });
-    const prodPath = path33__default.default.resolve(__dirname$1, "../web/dist");
-    const devPath = path33__default.default.resolve(__dirname$1, "../../web/dist");
-    const webDistPath = fs30__default.default.existsSync(prodPath) ? prodPath : devPath;
-    if (fs30__default.default.existsSync(webDistPath)) {
+    const prodPath = path34__default.default.resolve(__dirname$1, "../web/dist");
+    const devPath = path34__default.default.resolve(__dirname$1, "../../web/dist");
+    const webDistPath = fs31__default.default.existsSync(prodPath) ? prodPath : devPath;
+    if (fs31__default.default.existsSync(webDistPath)) {
       this.app.use(express__default.default.static(webDistPath));
       this.app.get("*", (_req, res) => {
-        res.sendFile(path33__default.default.join(webDistPath, "index.html"));
+        res.sendFile(path34__default.default.join(webDistPath, "index.html"));
       });
     } else {
       this.app.get("/", (_req, res) => {
@@ -26063,7 +27009,7 @@ init_constants();
 async function dashboardCommand(config, workspacePath = process.cwd()) {
   const port = config.dashboard.port ?? DEFAULT_DASHBOARD_PORT;
   const spin = ora__default.default({ text: `Starting dashboard on port ${port}\u2026`, color: "magenta" }).start();
-  const store = new MemoryStore(path33__default.default.join(workspacePath, CASCADE_DB_FILE));
+  const store = new MemoryStore(path34__default.default.join(workspacePath, CASCADE_DB_FILE));
   const server = new DashboardServer(config, store, workspacePath);
   server.watchRuntimeChanges();
   const gThis = globalThis;
@@ -26095,7 +27041,7 @@ init_constants();
 function makeIdentityCommand(workspacePath = process.cwd()) {
   const identity = new commander.Command("identity").alias("id").description("Manage Cascade identities");
   identity.command("list").description("List all available identities").action(() => {
-    const store = new MemoryStore(path33__default.default.join(workspacePath, CASCADE_DB_FILE));
+    const store = new MemoryStore(path34__default.default.join(workspacePath, CASCADE_DB_FILE));
     try {
       const identities = store.listIdentities();
       console.log(chalk7__default.default.bold("\n  Identities:"));
@@ -26115,7 +27061,7 @@ function makeIdentityCommand(workspacePath = process.cwd()) {
     }
   });
   identity.command("create <name>").description("Create a new identity").option("-d, --desc <text>", "Description of the identity").option("-s, --system <text>", "System prompt").option("--default", "Set as default identity").action((name, options) => {
-    const store = new MemoryStore(path33__default.default.join(workspacePath, CASCADE_DB_FILE));
+    const store = new MemoryStore(path34__default.default.join(workspacePath, CASCADE_DB_FILE));
     try {
       if (options.default) {
         const existingDefault = store.getDefaultIdentity();
@@ -26141,7 +27087,7 @@ function makeIdentityCommand(workspacePath = process.cwd()) {
     }
   });
   identity.command("set-default <name>").description("Set an identity as default by name or ID").action((query) => {
-    const store = new MemoryStore(path33__default.default.join(workspacePath, CASCADE_DB_FILE));
+    const store = new MemoryStore(path34__default.default.join(workspacePath, CASCADE_DB_FILE));
     try {
       const identities = store.listIdentities();
       const match = identities.find((i) => i.id === query || i.name.toLowerCase() === query.toLowerCase());
@@ -26290,8 +27236,8 @@ async function exportCommand(options = {}) {
   let store;
   try {
     const workspacePath = options.workspacePath ?? process.cwd();
-    const workspaceDbPath = path33__default.default.join(workspacePath, CASCADE_DB_FILE);
-    const globalDbPath = path33__default.default.join(os10__default.default.homedir(), GLOBAL_CONFIG_DIR, GLOBAL_DB_FILE);
+    const workspaceDbPath = path34__default.default.join(workspacePath, CASCADE_DB_FILE);
+    const globalDbPath = path34__default.default.join(os10__default.default.homedir(), GLOBAL_CONFIG_DIR, GLOBAL_DB_FILE);
     let dbPath = globalDbPath;
     try {
       await fs11__default.default.access(workspaceDbPath);
@@ -26333,7 +27279,7 @@ async function exportCommand(options = {}) {
     const ext = format === "json" ? ".json" : ".md";
     const safeName = session.title.replace(/[^\w\s-]/g, "").replace(/\s+/g, "-").slice(0, 60);
     const defaultFile = `cascade-export-${safeName}${ext}`;
-    const outPath = options.output ? path33__default.default.resolve(options.output) : path33__default.default.join(process.cwd(), defaultFile);
+    const outPath = options.output ? path34__default.default.resolve(options.output) : path34__default.default.join(process.cwd(), defaultFile);
     await fs11__default.default.writeFile(outPath, content, "utf-8");
     spin.succeed(chalk7__default.default.green(`Exported to ${chalk7__default.default.white(outPath)}`));
     const messageCount = Array.isArray(session.messages) ? session.messages.length : 0;
@@ -26561,11 +27507,11 @@ async function statsCommand() {
 dotenv__default.default.config();
 function warnIfBuildIsStale() {
   try {
-    const here = path33__default.default.dirname(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('cli.cjs', document.baseURI).href))));
+    const here = path34__default.default.dirname(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('cli.cjs', document.baseURI).href))));
     for (const rel of ["..", "../.."]) {
-      const pkgPath = path33__default.default.join(here, rel, "package.json");
-      if (!fs30__default.default.existsSync(pkgPath)) continue;
-      const pkg = JSON.parse(fs30__default.default.readFileSync(pkgPath, "utf-8"));
+      const pkgPath = path34__default.default.join(here, rel, "package.json");
+      if (!fs31__default.default.existsSync(pkgPath)) continue;
+      const pkg = JSON.parse(fs31__default.default.readFileSync(pkgPath, "utf-8"));
       if (pkg.name !== "cascade-ai") continue;
       if (pkg.version && pkg.version !== CASCADE_VERSION) {
         console.error(