cascade-ai 0.66.1 → 0.67.0

package/dist/cli.js

@@ -7,8 +7,8 @@ import https from 'https';
 import zlib from 'zlib';
 import { Readable } from 'stream';
 import Database2 from 'better-sqlite3';
-import path32, { dirname } from 'path';
-import fs29, { mkdirSync, writeFileSync, existsSync, readFileSync } from 'fs';
+import path33, { dirname } from 'path';
+import fs30, { mkdirSync, writeFileSync, existsSync, readFileSync } from 'fs';
 import os10 from 'os';
 import crypto, { randomUUID, randomBytes, webcrypto, timingSafeEqual, createHash } from 'crypto';
 import { render, Box, Text, useStdout, useApp, useInput, Static } from 'ink';
@@ -17,7 +17,7 @@ import React2, { useState, useReducer, useRef, useCallback, useEffect, useMemo }
 import chalk7 from 'chalk';
 import dotenv from 'dotenv';
 import { fileURLToPath } from 'url';
-import fs10 from 'fs/promises';
+import fs11 from 'fs/promises';
 import * as _ignoreModule from 'ignore';
 import _ignoreModule__default from 'ignore';
 import { z } from 'zod';
@@ -1757,7 +1757,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.66.1";
+    CASCADE_VERSION = "0.67.0";
     CASCADE_CONFIG_FILE = ".cascade/config.json";
     CASCADE_DB_FILE = ".cascade/memory.db";
     CASCADE_DASHBOARD_SECRET_FILE = ".cascade/dashboard-secret";
@@ -3879,12 +3879,12 @@ var init_audit_logger = __esm({
       constructor(workspacePath, debugMode = false) {
         this.workspacePath = workspacePath;
         this.debugMode = debugMode;
-        const cascadeDir = path32.join(workspacePath, ".cascade");
-        if (!fs29.existsSync(cascadeDir)) {
-          fs29.mkdirSync(cascadeDir, { recursive: true });
+        const cascadeDir = path33.join(workspacePath, ".cascade");
+        if (!fs30.existsSync(cascadeDir)) {
+          fs30.mkdirSync(cascadeDir, { recursive: true });
         }
-        this.keyPath = path32.join(cascadeDir, "audit_log.key");
-        this.dbPath = path32.join(cascadeDir, "audit_log.db");
+        this.keyPath = path33.join(cascadeDir, "audit_log.key");
+        this.dbPath = path33.join(cascadeDir, "audit_log.db");
         this.initEncryptionKey();
         this.db = new Database2(this.dbPath);
         this.db.pragma("journal_mode = WAL");
@@ -3914,11 +3914,11 @@ var init_audit_logger = __esm({
         return crypto.createHash("sha256").update(`${prevHash}|${timestamp}|${eventType}|${tierId}|${encryptedPayload}`).digest("hex");
       }
       initEncryptionKey() {
-        if (fs29.existsSync(this.keyPath)) {
-          this.encryptionKey = fs29.readFileSync(this.keyPath);
+        if (fs30.existsSync(this.keyPath)) {
+          this.encryptionKey = fs30.readFileSync(this.keyPath);
         } else {
           this.encryptionKey = crypto.randomBytes(32);
-          fs29.writeFileSync(this.keyPath, this.encryptionKey);
+          fs30.writeFileSync(this.keyPath, this.encryptionKey);
         }
       }
       encrypt(text) {
@@ -3996,9 +3996,9 @@ var init_audit_logger = __esm({
       dumpDebugIfNeeded() {
         if (!this.debugMode) return;
         try {
-          const dumpPath = path32.join(os10.tmpdir(), "cascade_audit_logs_debug.json");
+          const dumpPath = path33.join(os10.tmpdir(), "cascade_audit_logs_debug.json");
           const entries = this.getAllLogs();
-          fs29.writeFileSync(dumpPath, JSON.stringify(entries, null, 2), "utf-8");
+          fs30.writeFileSync(dumpPath, JSON.stringify(entries, null, 2), "utf-8");
         } catch (err) {
           console.error("Failed to dump debug audit logs", err);
         }
@@ -4053,7 +4053,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 && fs29.existsSync(this.storePath)) {
+      if (password && fs30.existsSync(this.storePath)) {
         try {
           const fileEntries = this.decryptFile(password);
           for (const [k, v] of Object.entries(fileEntries)) {
@@ -4072,7 +4072,7 @@ var Keystore = class {
         "Keystore unlock requires a password because the OS keychain (keytar) is not available on this system."
       );
     }
-    if (!fs29.existsSync(this.storePath)) {
+    if (!fs30.existsSync(this.storePath)) {
       const salt = crypto.randomBytes(SALT_LEN);
       this.masterKey = this.deriveKey(password, salt);
       this.writeWithSalt({}, salt);
@@ -4086,7 +4086,7 @@ var Keystore = class {
   }
   /** Synchronous legacy unlock kept for AES-only environments. */
   unlockSync(password) {
-    if (!fs29.existsSync(this.storePath)) {
+    if (!fs30.existsSync(this.storePath)) {
       const salt = crypto.randomBytes(SALT_LEN);
       this.masterKey = this.deriveKey(password, salt);
       this.writeWithSalt({}, salt);
@@ -4144,7 +4144,7 @@ var Keystore = class {
     }
   }
   decryptFile(password, knownSalt) {
-    if (!fs29.existsSync(this.storePath)) return {};
+    if (!fs30.existsSync(this.storePath)) return {};
     try {
       const { salt, ciphertext, iv, tag } = this.readRaw();
       const useSalt = knownSalt ?? salt;
@@ -4166,8 +4166,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]);
-    fs29.mkdirSync(path32.dirname(this.storePath), { recursive: true });
-    fs29.writeFileSync(this.storePath, out, { mode: 384 });
+    fs30.mkdirSync(path33.dirname(this.storePath), { recursive: true });
+    fs30.writeFileSync(this.storePath, out, { mode: 384 });
   }
   writeWithSalt(data, salt) {
     if (!this.masterKey) throw new Error("writeWithSalt called before masterKey was set");
@@ -4177,11 +4177,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]);
-    fs29.mkdirSync(path32.dirname(this.storePath), { recursive: true });
-    fs29.writeFileSync(this.storePath, out, { mode: 384 });
+    fs30.mkdirSync(path33.dirname(this.storePath), { recursive: true });
+    fs30.writeFileSync(this.storePath, out, { mode: 384 });
   }
   readRaw() {
-    const buf = fs29.readFileSync(this.storePath);
+    const buf = fs30.readFileSync(this.storePath);
     let offset = 0;
     const salt = buf.subarray(offset, offset + SALT_LEN);
     offset += SALT_LEN;
@@ -4214,9 +4214,9 @@ var CascadeIgnore = class {
     ]);
   }
   async load(workspacePath) {
-    const filePath = path32.join(workspacePath, ".cascadeignore");
+    const filePath = path33.join(workspacePath, ".cascadeignore");
     try {
-      const content = await fs10.readFile(filePath, "utf-8");
+      const content = await fs11.readFile(filePath, "utf-8");
       const lines = content.split("\n").filter((l) => l.trim() && !l.startsWith("#"));
       this.ig.add(lines);
       this.loaded = true;
@@ -4225,7 +4225,7 @@ var CascadeIgnore = class {
   }
   isIgnored(filePath, workspacePath) {
     try {
-      const relative = workspacePath ? path32.relative(workspacePath, filePath) : filePath;
+      const relative = workspacePath ? path33.relative(workspacePath, filePath) : filePath;
       return this.ig.ignores(relative);
     } catch {
       return false;
@@ -4236,7 +4236,7 @@ var CascadeIgnore = class {
   }
 };
 async function createDefaultIgnoreFile(workspacePath) {
-  const filePath = path32.join(workspacePath, ".cascadeignore");
+  const filePath = path33.join(workspacePath, ".cascadeignore");
   const content = `# .cascadeignore \u2014 Files Cascade agents cannot read or modify
 # Syntax identical to .gitignore
 
@@ -4263,12 +4263,12 @@ build/
 .DS_Store
 Thumbs.db
 `;
-  await fs10.writeFile(filePath, content, "utf-8");
+  await fs11.writeFile(filePath, content, "utf-8");
 }
 async function loadCascadeMd(workspacePath) {
-  const filePath = path32.join(workspacePath, "CASCADE.md");
+  const filePath = path33.join(workspacePath, "CASCADE.md");
   try {
-    const raw = await fs10.readFile(filePath, "utf-8");
+    const raw = await fs11.readFile(filePath, "utf-8");
     return parseCascadeMd(raw);
   } catch {
     return null;
@@ -4295,7 +4295,7 @@ ${raw.trim()}`;
   return { raw, sections, systemPrompt };
 }
 async function createDefaultCascadeMd(workspacePath) {
-  const filePath = path32.join(workspacePath, "CASCADE.md");
+  const filePath = path33.join(workspacePath, "CASCADE.md");
   const content = `# Cascade Project Instructions
 
 This file contains project-specific instructions for the Cascade AI agent.
@@ -4325,12 +4325,12 @@ All tools are allowed unless specified otherwise.
 
 List any areas the agent should not touch.
 `;
-  await fs10.writeFile(filePath, content, "utf-8");
+  await fs11.writeFile(filePath, content, "utf-8");
 }
 var MemoryStore = class _MemoryStore {
   db;
   constructor(dbPath) {
-    fs29.mkdirSync(path32.dirname(dbPath), { recursive: true });
+    fs30.mkdirSync(path33.dirname(dbPath), { recursive: true });
     try {
       this.db = new Database2(dbPath, { timeout: 5e3 });
       this.db.pragma("journal_mode = WAL");
@@ -5582,7 +5582,7 @@ function validateConfig(raw) {
 // src/config/global-credentials.ts
 init_constants();
 function credentialsPath(globalDir2) {
-  return path32.join(globalDir2, GLOBAL_CREDENTIALS_FILE);
+  return path33.join(globalDir2, GLOBAL_CREDENTIALS_FILE);
 }
 function providerKey(p) {
   if (p.type === "azure") {
@@ -5595,7 +5595,7 @@ function isPersistable(p) {
 }
 function loadGlobalCredentials(globalDir2) {
   try {
-    const raw = fs29.readFileSync(credentialsPath(globalDir2), "utf-8");
+    const raw = fs30.readFileSync(credentialsPath(globalDir2), "utf-8");
     const parsed = JSON.parse(raw);
     if (!Array.isArray(parsed.providers)) return [];
     return parsed.providers.filter(
@@ -5607,13 +5607,13 @@ function loadGlobalCredentials(globalDir2) {
 }
 function saveGlobalCredentials(globalDir2, providers) {
   const filePath = credentialsPath(globalDir2);
-  fs29.mkdirSync(globalDir2, { recursive: true, mode: 448 });
+  fs30.mkdirSync(globalDir2, { recursive: true, mode: 448 });
   const body = { version: 1, providers: providers.filter(isPersistable) };
   const tmp = `${filePath}.tmp`;
-  fs29.writeFileSync(tmp, JSON.stringify(body, null, 2), { encoding: "utf-8", mode: 384 });
-  fs29.renameSync(tmp, filePath);
+  fs30.writeFileSync(tmp, JSON.stringify(body, null, 2), { encoding: "utf-8", mode: 384 });
+  fs30.renameSync(tmp, filePath);
   try {
-    fs29.chmodSync(filePath, 384);
+    fs30.chmodSync(filePath, 384);
   } catch {
   }
 }
@@ -5831,7 +5831,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 ?? path32.join(os10.homedir(), GLOBAL_CONFIG_DIR);
+    this.globalDir = globalDirOverride ?? path33.join(os10.homedir(), GLOBAL_CONFIG_DIR);
   }
   async load() {
     this.config = await this.loadConfig();
@@ -5845,8 +5845,8 @@ var ConfigManager = class {
     this.ignore = new CascadeIgnore();
     await this.ignore.load(this.workspacePath);
     this.cascadeMd = await loadCascadeMd(this.workspacePath);
-    this.keystore = new Keystore(path32.join(this.globalDir, GLOBAL_KEYSTORE_FILE));
-    this.store = new MemoryStore(path32.join(this.workspacePath, CASCADE_DB_FILE));
+    this.keystore = new Keystore(path33.join(this.globalDir, GLOBAL_KEYSTORE_FILE));
+    this.store = new MemoryStore(path33.join(this.workspacePath, CASCADE_DB_FILE));
     await this.injectEnvKeys();
     this.config.providers = mergeGlobalCredentials(this.config.providers, loadGlobalCredentials(this.globalDir));
     await this.ensureDefaultIdentity();
@@ -5871,9 +5871,9 @@ var ConfigManager = class {
     return this.workspacePath;
   }
   async save() {
-    const configPath = path32.join(this.workspacePath, CASCADE_CONFIG_FILE);
-    await fs10.mkdir(path32.dirname(configPath), { recursive: true });
-    await fs10.writeFile(configPath, JSON.stringify(this.config, null, 2), "utf-8");
+    const configPath = path33.join(this.workspacePath, CASCADE_CONFIG_FILE);
+    await fs11.mkdir(path33.dirname(configPath), { recursive: true });
+    await fs11.writeFile(configPath, JSON.stringify(this.config, null, 2), "utf-8");
     try {
       saveGlobalCredentials(this.globalDir, this.config.providers);
     } catch (err) {
@@ -5908,9 +5908,9 @@ var ConfigManager = class {
     return configProvider?.apiKey;
   }
   async loadConfig() {
-    const configPath = path32.join(this.workspacePath, CASCADE_CONFIG_FILE);
+    const configPath = path33.join(this.workspacePath, CASCADE_CONFIG_FILE);
     try {
-      const raw = await fs10.readFile(configPath, "utf-8");
+      const raw = await fs11.readFile(configPath, "utf-8");
       return validateConfig(JSON.parse(raw));
     } catch (err) {
       if (err.code === "ENOENT") {
@@ -7075,7 +7075,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 = path32.join(os10.homedir(), GLOBAL_CONFIG_DIR, "benchmarks-cache.json");
+var DEFAULT_CACHE_FILE = path33.join(os10.homedir(), GLOBAL_CONFIG_DIR, "benchmarks-cache.json");
 function normalizeModelId2(id) {
   let s = id.toLowerCase();
   const slash = s.lastIndexOf("/");
@@ -7110,7 +7110,7 @@ var LiveDataProvider = class {
     if (this.loaded) return;
     this.loaded = true;
     try {
-      const raw = await fs10.readFile(this.opts.cacheFile, "utf-8");
+      const raw = await fs11.readFile(this.opts.cacheFile, "utf-8");
       const cache = JSON.parse(raw);
       if (cache.snapshot?.families) {
         this.snapshot = cache.snapshot;
@@ -7222,14 +7222,14 @@ var LiveDataProvider = class {
   }
   async saveCache() {
     try {
-      await fs10.mkdir(path32.dirname(this.opts.cacheFile), { recursive: true });
+      await fs11.mkdir(path33.dirname(this.opts.cacheFile), { recursive: true });
       const cache = {
         fetchedAt: this.fetchedAt,
         snapshot: this.snapshot ?? void 0,
         prices: Object.fromEntries(this.prices),
         capabilities: Object.fromEntries(this.capabilities)
       };
-      await fs10.writeFile(this.opts.cacheFile, JSON.stringify(cache, null, 2), "utf-8");
+      await fs11.writeFile(this.opts.cacheFile, JSON.stringify(cache, null, 2), "utf-8");
     } catch {
     }
   }
@@ -9049,7 +9049,16 @@ var KNOWN_TOOLS = [
   "glob",
   "grep",
   "web_fetch",
-  "generate_image"
+  // Every media tool buildMediaTools can register, not just the image one.
+  // Omitting three of the four meant a run whose ONLY tools were media ones
+  // (a video-generation subtask on an account with no file/web tools) counted
+  // as "no tools registered" and dropped all tool guidance — the worker was
+  // then told nothing about using tools at all, and wrote the video as prose.
+  "generate_image",
+  "generate_video",
+  "generate_speech",
+  "transcribe_audio",
+  "generate_document"
 ];
 var PROVIDER_BACKED_TOOLS = /* @__PURE__ */ new Set([
   "generate_image",
@@ -9066,19 +9075,55 @@ function buildWorkerRules(has) {
     canWriteFiles && "- If the task asks for a file or artifact, you must actually create it in the workspace, verify that it exists, and inspect it before claiming success.",
     has("web_search") && '- Use the "web_search" tool to find current information, documentation, news, or general web data.',
     has("pdf_create") && '- Use the "pdf_create" tool for PDF requests.',
+    // A .docx/.pptx/.xlsx is a ZIP of OOXML parts, not text with a suffix.
+    // file_write does exactly what it promises — writes the model's characters
+    // verbatim — so without this rule the worker "wrote" a Word document that
+    // Word correctly reported as corrupted. Stated as an explicit prohibition
+    // on the tool it would otherwise reach for, because "use generate_document"
+    // alone competes with a file_write habit the model already has.
+    has("generate_document") && '- For a Word (.docx), PowerPoint (.pptx) or Excel (.xlsx) deliverable you MUST call the "generate_document" tool and NEVER "file_write" or "run_code" \u2014 those formats are ZIP archives of XML, so text written straight to the path opens as a corrupted file. Pass the target path plus the source: Markdown for .docx, Markdown slides separated by --- rules for .pptx (each slide starts with a heading), CSV for .xlsx.',
+    // The alternative to this rule is not "a worse chart" — it is a paragraph
+    // describing a chart that does not exist, which is what real decks came
+    // back with. A `chart:` block is checkable, carries the exact numbers, and
+    // becomes a genuine editable PowerPoint chart object.
+    has("generate_document") && '- For any data-driven visualization (a chart, graph, trend, breakdown or comparison of numbers), emit a fenced ```chart:bar block \u2014 also chart:line, chart:pie, chart:doughnut, chart:area, chart:scatter \u2014 whose body is an optional "title: ..." line followed by CSV: a header row of "<category label>,<series name>,<series name>", then one row per category. In a PowerPoint deliverable that becomes a REAL, editable chart carrying your exact numbers; in Word and Excel the same block keeps every value as a table or worksheet. Never write prose describing a chart in place of emitting one.',
     // Without this the model "writes the image" as prose — a bracketed
     // description sitting in the deck where the picture should be — even with a
     // working image model registered. Naming the reference syntax matters as
     // much as naming the tool: a generated image nobody embeds is still a
-    // missing image.
+    // missing image. It also has to say the reference must stand ALONE on its
+    // line, because only a standalone reference is parsed as a picture (see
+    // core/documents/blocks.ts matchImageLine) — one embedded mid-sentence
+    // silently degrades to caption text.
     //
-    // Scoped to PowerPoint/Word specifically: those are the only exporters
-    // that actually embed a Markdown image reference (cloud/web/exporters.ts
-    // toPptx/toDocx). PDF and plain-text/Markdown deliverables flatten a
-    // reference straight to caption text — telling the model to call
-    // generate_image for THOSE just pays for an image nobody ever sees.
-    has("generate_image") && '- When a slide deck (PowerPoint) or Word document deliverable calls for a decorative image or illustration, you MUST call the "generate_image" tool and then reference its result using Markdown image syntax: ![description](location), where "location" is exactly the string the tool reported back. NEVER write a text placeholder or a bracketed description such as [image: a cat] in its place. Do NOT use "generate_image" for a chart, graph, or diagram that must show exact data (numbers, axes, labels) \u2014 an image model cannot guarantee those values are correct, so render that data as a Markdown table instead. For any OTHER deliverable format (PDF, plain text, code, etc.) do NOT call "generate_image" \u2014 those cannot embed the result, so describe the visual in words instead.',
-    has("run_code") && '- Use the "run_code" tool for any file types (Excel, Zip, csv, etc.) or complex processing not covered by other tools. Always cleanup after code execution.',
+    // Scoped to PowerPoint/Word specifically: those are the only renderers that
+    // actually embed a Markdown image reference. PDF and plain-text/Markdown
+    // deliverables flatten a reference straight to caption text — telling the
+    // model to call generate_image for THOSE just pays for an image nobody
+    // ever sees.
+    has("generate_image") && // Supersedes the earlier wording of this same rule: it now names the
+    // standalone-line parser constraint, says to generate BEFORE writing the
+    // document, and points data-driven visuals at a ```chart: block rather
+    // than a Markdown table, which is only the right advice now that chart
+    // blocks render as real chart objects.
+    '- When a slide deck (PowerPoint) or Word document deliverable calls for a decorative image, photo or illustration, you MUST call the "generate_image" tool \u2014 once per image the deliverable needs, BEFORE you write the document \u2014 and then put each result on a line of its OWN using Markdown image syntax: ![description](location), where "location" is exactly the string the tool reported back. A reference inside a sentence stays prose and no picture appears. NEVER write a text placeholder or a bracketed description such as [image: a cat] in its place, and never state that an image is included when you did not generate one. Do NOT use "generate_image" for a chart, graph or diagram that must show exact data (numbers, axes, labels) \u2014 an image model cannot guarantee those values are correct; emit a ```chart: block instead. For any OTHER deliverable format (PDF, plain text, code, etc.) do NOT call "generate_image" \u2014 those cannot embed the result, so describe the visual in words instead.',
+    // The other half of image reliability, and the half no amount of
+    // instruction-tightening could fix: generate_image only exists when an
+    // OpenAI or Gemini key is configured (multimodal/registry.ts CAPABILITIES).
+    // With neither, the model was never given a choice — and a model that
+    // doesn't know that writes "[illustration of a cat]" and moves on. Said out
+    // loud, up front, so the fallback is a real chart or honest prose.
+    !has("generate_image") && (has("generate_document") || canWriteFiles) && "- No image-generation model is available on this run, so there is NO tool that can draw a picture. Do not emit a Markdown image reference, a bracketed placeholder such as [image: a cat], or any claim that an illustration is included. If the request needs a data visualization use a ```chart: block, which needs no image model; otherwise describe the visual in words and say plainly that no image could be generated.",
+    // The video counterpart of the image rule above, and the fix for the
+    // reported "it writes scripts forever and never makes the video" run. The
+    // failure mode is identical — the model narrates the deliverable instead of
+    // producing it — but the stakes are not: a video subtask that ends in prose
+    // has burned the whole pre-production plan for nothing. Unlike the image
+    // rule this is NOT scoped to a document format, because the clip itself is
+    // the deliverable rather than an illustration inside one, and the reference
+    // syntax is a plain link: Markdown image syntax does not embed a video.
+    has("generate_video") && '- When the subtask deliverable is a video, you MUST call the "generate_video" tool \u2014 that call IS the deliverable, and the subtask is not done until it has returned. NEVER deliver the video as prose, a script, a storyboard, or a bracketed placeholder such as [video: a cat skating], and NEVER claim a video exists unless the tool reported a location for it. Call it exactly ONCE: it is billed per second of output and renders for minutes, so a second call charges the user again. Then report the location string the tool returned VERBATIM as your result, referencing it as [description](location) if it goes inside a document. If the tool reports a failure or a timeout, report that failure verbatim and stop \u2014 do NOT call it again, and do NOT substitute a written description of a video that was never made.',
+    has("run_code") && `- Use the "run_code" tool for data processing, archives, and file formats not covered by a dedicated tool. ${has("generate_document") ? 'Do NOT use it to build a .docx, .pptx or .xlsx \u2014 "generate_document" already produces those correctly. ' : ""}${has("pdf_create") ? 'Do NOT use it to build a PDF \u2014 "pdf_create" does that. ' : ""}Always cleanup after code execution.`,
     "- If you are not making meaningful progress, stop and escalate rather than looping or padding the response.",
     has("peer_message") && '- Use the "peer_message" tool to communicate with other T3 workers if your tasks have dependencies or shared state. You can send updates or wait for signals.',
     hasAnyTool && "- Only use tools directly relevant to THIS subtask. Do not reach for an unrelated connected-service action (e.g. creating, deleting, or modifying a repository, issue, or PR; sending a message) unless the subtask explicitly calls for it.",
@@ -9089,13 +9134,34 @@ function buildWorkerRules(has) {
 Rules:
 ${rules.filter((r) => r !== false).join("\n")}`;
 }
-var ARTIFACT_TOOLS = /* @__PURE__ */ new Set(["file_write", "file_edit", "shell"]);
+var ARTIFACT_TOOLS = /* @__PURE__ */ new Set(["file_write", "file_edit", "shell", "generate_document"]);
+var ARTIFACT_FILE_RE = /\b[\w./-]+\.(pdf|md|html|txt|json|csv|py|js|ts|tsx|jsx|docx?|pptx?|xlsx?|png|jpg|jpeg|svg|gif)\b/i;
 function shouldRequireArtifact(assignment, toolNames) {
   if (!toolNames.some((n) => ARTIFACT_TOOLS.has(n))) return false;
   if (assignment?.files?.length) return true;
   const haystack = `${assignment?.description ?? ""}
 ${assignment?.expectedOutput ?? ""}`;
-  return /\b[\w./-]+\.(pdf|md|html|txt|json|csv|py|js|ts|tsx|jsx|docx?|png|jpg|jpeg|svg|gif)\b/i.test(haystack) || /save (?:a|the)? file|create (?:a|the)? file|write (?:a|the)? file/i.test(haystack);
+  return ARTIFACT_FILE_RE.test(haystack) || /save (?:a|the)? file|create (?:a|the)? file|write (?:a|the)? file/i.test(haystack);
+}
+var VISUAL_REQUEST_RE = /\b(image|images|picture|pictures|photo|photos|illustration|illustrations|visual|visuals|visualisation|visualization|visualizations|chart|charts|graph|graphs|plot|plots|diagram|diagrams|infographic)\b/i;
+var IMAGE_REF_RE = /!\[[^\]]*\]\([^)]+\)/;
+var CHART_BLOCK_RE = /^\s*```+\s*chart\s*:/im;
+function missingVisualEvidence(assignment, output, calledTools, toolNames) {
+  const canVisualize = toolNames.includes("generate_image") || toolNames.includes("generate_document");
+  if (!canVisualize) return null;
+  const haystack = `${assignment?.description ?? ""}
+${assignment?.expectedOutput ?? ""}`;
+  if (!VISUAL_REQUEST_RE.test(haystack)) return null;
+  if (calledTools.includes("generate_image") || calledTools.includes("generate_document")) return null;
+  if (IMAGE_REF_RE.test(output) || CHART_BLOCK_RE.test(output)) return null;
+  const options = [];
+  if (toolNames.includes("generate_image")) {
+    options.push('call "generate_image" and reference the result on its own line as ![description](location)');
+  }
+  if (toolNames.includes("generate_document")) {
+    options.push("emit a fenced ```chart:bar (or chart:line / chart:pie) block whose body is CSV, for anything data-driven");
+  }
+  return `The subtask asks for a visual, but the output contains no embedded image and no chart block \u2014 only prose. ${options.join(", or ")}. Describing a picture is not producing one.`;
 }
 var T3Worker = class extends BaseTier {
   router;
@@ -9276,6 +9342,18 @@ Now execute your subtask using this context where relevant.`
           return this.buildResult("ESCALATED", output, { checksRun, passed, failed }, issues, correctionAttempts);
         }
       }
+      const visualIssue = missingVisualEvidence(
+        assignment,
+        output,
+        toolCalls.map((t) => t.name),
+        this.tools.map((t) => t.name)
+      );
+      if (visualIssue) {
+        correctionAttempts = 1;
+        issues.push(visualIssue);
+        this.sendStatusUpdate({ progressPct: 68, currentAction: "Verifying requested visuals", status: "IN_PROGRESS" });
+        output = await this.correctOutput(output, [visualIssue]);
+      }
       this.sendStatusUpdate({ progressPct: 70, currentAction: "Self-testing output", status: "IN_PROGRESS" });
       const testResult = await this.selfTest(assignment, output);
       checksRun.push(...testResult.checksRun);
@@ -9590,8 +9668,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 (path37, content) => {
-          this.store?.addFileSnapshot(this.taskId, path37, content);
+        saveSnapshot: async (path38, content) => {
+          this.store?.addFileSnapshot(this.taskId, path38, content);
         },
         sendPeerSync: (to, syncType, content) => {
           this.peerBus?.send(this.id, to, syncType, this.assignment?.subtaskId ?? "", content);
@@ -9620,6 +9698,12 @@ HIERARCHY CONTEXT: ${this.hierarchyContext}` : "") + textToolSuffix,
       if (isTaggedSystemic || isProviderBacked && classifyProviderError(err).systemic) {
         throw new CriticalToolError(errMsg, tc.name);
       }
+      if (isProviderBacked) {
+        throw new CriticalToolError(
+          `${tc.name} failed and was not retried \u2014 media generation is billed per attempt, so Cascade stops on the first failure instead of paying for a second. Reason: ${errMsg}`,
+          tc.name
+        );
+      }
       return await this.adaptiveFallback(tc, `Tool error: ${errMsg}`);
     }
   }
@@ -9629,6 +9713,14 @@ HIERARCHY CONTEXT: ${this.hierarchyContext}` : "") + textToolSuffix,
    *   1. Find a semantically similar registered tool and retry with same input
    *   2. Synthesize a new tool via ToolCreator (if available) and run it
    *   3. Return the original error so the agent loop can decide what to do next
+   *
+   * Scoped to CHEAP, task-scoped failures — the class of problem it was built
+   * for is a wrong or missing tool name, where a name-similar sibling plausibly
+   * does the same job for the same (near-zero) cost. PROVIDER_BACKED_TOOLS never
+   * reach it: their siblings are keyword-similar but semantically different
+   * (generate_image is not a stand-in for generate_video), and every attempt —
+   * theirs, or a synthesized replacement's — is separately billed. See the
+   * fast-fail branch in executeTool().
    */
   async adaptiveFallback(tc, originalError) {
     const altTool = this.findAlternativeTool(tc.name);
@@ -9753,7 +9845,7 @@ ${assignment.expectedOutput}`;
     const declared = (assignment.files ?? []).map((f) => f.trim()).filter((f) => f.includes("."));
     const haystack = `${assignment.description}
 ${assignment.expectedOutput}`;
-    const matches = haystack.match(/\b[\w./-]+\.(pdf|md|html|txt|json|csv|py|js|ts|tsx|jsx|docx?|png|jpg|jpeg|svg|gif)\b/gi) ?? [];
+    const matches = haystack.match(new RegExp(ARTIFACT_FILE_RE.source, "gi")) ?? [];
     return [.../* @__PURE__ */ new Set([...declared, ...matches.map((m) => m.trim())])];
   }
   async verifyArtifacts(assignment) {
@@ -9764,9 +9856,9 @@ ${assignment.expectedOutput}`;
     const { promisify: promisify4 } = await import('util');
     const execAsync3 = promisify4(exec3);
     for (const artifactPath of artifactPaths) {
-      const absolutePath = path32.resolve(process.cwd(), artifactPath);
+      const absolutePath = path33.resolve(process.cwd(), artifactPath);
       try {
-        const stat = await fs10.stat(absolutePath);
+        const stat = await fs11.stat(absolutePath);
         if (!stat.isFile()) {
           issues.push(`Expected artifact is not a file: ${artifactPath}`);
           continue;
@@ -9775,8 +9867,22 @@ ${assignment.expectedOutput}`;
           issues.push(`Artifact is empty: ${artifactPath}`);
           continue;
         }
-        if (!/\.pdf$/i.test(artifactPath)) {
-          const content = await fs10.readFile(absolutePath, "utf-8");
+        if (/\.(docx|pptx|xlsx)$/i.test(artifactPath)) {
+          const head = Buffer.alloc(4);
+          const fh = await fs11.open(absolutePath, "r");
+          try {
+            await fh.read(head, 0, 4, 0);
+          } finally {
+            await fh.close();
+          }
+          if (head.toString("latin1") !== "PK") {
+            issues.push(
+              `${artifactPath} is not a valid Office file \u2014 it must be written with the generate_document tool, which renders the real OOXML archive. Plain text saved under that extension opens as corrupted.`
+            );
+            continue;
+          }
+        } else if (!/\.pdf$/i.test(artifactPath)) {
+          const content = await fs11.readFile(absolutePath, "utf-8");
           if (!content.trim()) {
             issues.push(`Artifact content is empty: ${artifactPath}`);
             continue;
@@ -9785,7 +9891,7 @@ ${assignment.expectedOutput}`;
           issues.push(`PDF artifact looks too small to be valid: ${artifactPath}`);
           continue;
         }
-        const ext = path32.extname(absolutePath).toLowerCase();
+        const ext = path33.extname(absolutePath).toLowerCase();
         try {
           if (ext === ".ts" || ext === ".tsx") {
             await execAsync3(`npx tsc --noEmit ${absolutePath}`, { timeout: 1e4 });
@@ -10381,15 +10487,245 @@ _(incomplete: ${t2Result.issues.join("; ")})_`;
   return output;
 }
 
+// src/core/multimodal/registry.ts
+init_pricing();
+var CAPABILITIES = [
+  // ── Image ──
+  {
+    modality: "image",
+    provider: "openai",
+    modelId: "dall-e-3",
+    api: "openai-images"
+  },
+  {
+    // Was `imagen-4.0-generate-001` on `:predict`, which now 404s for new keys
+    // ("no longer available to new users") — Imagen's :predict API is deprecated
+    // and shuts down 2026-08-17. Google's own migration path is this model on
+    // the ordinary generateContent endpoint, so the fix was never another Imagen
+    // id: the whole request/response SHAPE changes, which is why `api` moved to
+    // 'gemini-generate-content' rather than just the modelId moving.
+    // https://ai.google.dev/gemini-api/docs/imagen
+    modality: "image",
+    provider: "gemini",
+    modelId: "gemini-2.5-flash-image",
+    api: "gemini-generate-content"
+  },
+  // ── Speech (text → audio) ──
+  {
+    modality: "speech",
+    provider: "openai",
+    modelId: "tts-1",
+    api: "openai-speech"
+  },
+  {
+    // The only quality claim in this table that needs no leaderboard: OpenAI
+    // ships these as the same voice at two fidelities and charges double for
+    // this one. That is the vendor's own ordering, not an inference.
+    modality: "speech",
+    provider: "openai",
+    modelId: "tts-1-hd",
+    api: "openai-speech",
+    quality: 70,
+    qualityBasis: "OpenAI's own hd variant of tts-1, priced 2x"
+  },
+  // ── Transcription (audio → text) ──
+  {
+    modality: "transcription",
+    provider: "openai",
+    modelId: "whisper-1",
+    api: "openai-transcriptions"
+  },
+  // ── Video ──
+  {
+    // Long-running: submit returns an operation name, the video lands minutes
+    // later, and the bytes come from a short-lived signed URL. generate.ts owns
+    // that polling loop; the registry only records the shape via `api`.
+    //
+    // `veo-3.1-generate-001` (no "-preview") is VERTEX AI's id for this model,
+    // not the Gemini Developer API's — this file calls
+    // generativelanguage.googleapis.com (see generate.ts), which 404s on it:
+    // "models/veo-3.1-generate-001 is not found for API version v1beta". On the
+    // Gemini API specifically, Veo 3.1 is still preview-only, so the correct id
+    // there is `veo-3.1-generate-preview`.
+    // https://ai.google.dev/gemini-api/docs/veo
+    modality: "video",
+    provider: "gemini",
+    modelId: "veo-3.1-generate-preview",
+    api: "gemini-predict-lro"
+  }
+];
+function capabilityCost(cap) {
+  const match = findPricing(cap.modelId, cap.provider, {
+    fallbackProviders: cap.provider === "gemini" ? ["vertex"] : []
+  });
+  const rate = match?.entry.rates?.[0];
+  if (!rate) return null;
+  const unitLabel = {
+    per_image: "per image",
+    per_second: "per second of video",
+    per_character: "per character",
+    per_audio_minute: "per audio minute"
+  };
+  const unit = unitLabel[rate.unit] ?? rate.unit;
+  const amount = rate.amount;
+  const shown = amount < 1e-3 ? amount.toExponential(2) : amount.toFixed(4);
+  return { label: `$${shown} ${unit}`, amount, unit };
+}
+function explainChoice(c, cost, modality, isBest) {
+  const priced = cost ? ` ${cost.label}.` : "";
+  if (c.quality !== void 0) {
+    return isBest ? `${c.modelId} (${c.provider}) \u2014 ranked highest for ${modality}: ${c.qualityBasis}.${priced}` : `${c.modelId} (${c.provider}) \u2014 ranked alternative for ${modality}: ${c.qualityBasis}.${priced}`;
+  }
+  const noRanking = ". No published quality ranking is applied for this modality, so this is a cost choice, not a quality one.";
+  return isBest ? `${c.modelId} (${c.provider}) \u2014 cheapest usable ${modality} model` + (cost ? ` at ${cost.label}` : "") + noRanking : `${c.modelId} (${c.provider}) \u2014 alternative usable ${modality} model` + (cost ? ` at ${cost.label}` : "") + noRanking;
+}
+var MultimodalRegistry = class {
+  /** Provider types the user has actually configured a key for. */
+  available;
+  constructor(availableProviders) {
+    this.available = new Set(availableProviders);
+  }
+  /** Every capability whose provider is configured AND which Cascade can call. */
+  usable(modality) {
+    return CAPABILITIES.filter(
+      (c) => !c.unsupported && this.available.has(c.provider) && (!modality || c.modality === modality)
+    );
+  }
+  /** Modalities this account can actually generate right now. */
+  availableModalities() {
+    return [...new Set(this.usable().map((c) => c.modality))];
+  }
+  /**
+   * Every usable capability for a modality, best first.
+   *
+   * Ranked models beat unranked ones, then higher quality, then lower unit
+   * price. An explicit `preferModel` is moved to the head when it is usable —
+   * the user naming a model is a stronger signal than any prior.
+   *
+   * `select()` is just the head of this list. The TAIL is the point: a systemic
+   * provider failure (dead key, 404, exhausted quota) is scoped to one
+   * provider+model, so "this model cannot draw" is not the same fact as "this
+   * account cannot draw". A caller holding the ordered alternatives can try the
+   * next provider instead of aborting the whole run — see generate-media.ts.
+   */
+  rank(modality, opts = {}) {
+    const scored = this.usable(modality).map((c) => ({ c, cost: capabilityCost(c) })).sort((a, b) => {
+      const qa = a.c.quality ?? -1;
+      const qb = b.c.quality ?? -1;
+      if (qa !== qb) return qb - qa;
+      const pa = a.cost?.amount ?? Number.POSITIVE_INFINITY;
+      const pb = b.cost?.amount ?? Number.POSITIVE_INFINITY;
+      return pa - pb;
+    });
+    const results = scored.map(({ c, cost }, i) => ({
+      capability: c,
+      cost,
+      reason: explainChoice(c, cost, modality, i === 0)
+    }));
+    if (opts.preferModel) {
+      const i = results.findIndex((r) => r.capability.modelId === opts.preferModel);
+      if (i > -1) {
+        const [wanted] = results.splice(i, 1);
+        results.unshift({ ...wanted, reason: `Requested explicitly: ${wanted.capability.modelId}.` });
+      }
+    }
+    return results;
+  }
+  /**
+   * Pick a model for a modality — the best usable one, or null if there is none.
+   */
+  select(modality, opts = {}) {
+    return this.rank(modality, opts)[0] ?? null;
+  }
+  /**
+   * A plain-language account of what this account can and cannot generate —
+   * including the things it cannot, and why.
+   *
+   * This is the USER-facing inventory (model ids and unit prices), keyed on
+   * which providers are configured. It is deliberately NOT what the planner
+   * reads: see `describeGenerationForPlanner()` below for that, and the note
+   * there for why the two cannot be the same string.
+   */
+  describe() {
+    const lines = [];
+    const usable = this.usable();
+    if (usable.length) {
+      lines.push("Generation models available on your configured providers:");
+      for (const modality of ["image", "speech", "transcription", "video"]) {
+        const forModality = usable.filter((c) => c.modality === modality);
+        if (!forModality.length) continue;
+        const shown = forModality.map((c) => {
+          const cost = capabilityCost(c);
+          return `${c.modelId}${cost ? ` (${cost.label})` : ""}`;
+        });
+        lines.push(`  ${modality}: ${shown.join(", ")}`);
+      }
+    } else {
+      lines.push("No generation models are available \u2014 none of your configured providers offers one.");
+    }
+    const blocked = CAPABILITIES.filter((c) => c.unsupported && this.available.has(c.provider));
+    for (const c of blocked) {
+      lines.push(`  ${c.modality}: ${c.modelId} exists on your account but is not callable. ${c.unsupported}`);
+    }
+    lines.push(
+      "  music: no supported provider exposes a music-generation API, so Cascade cannot generate music."
+    );
+    return lines.join("\n");
+  }
+};
+var PLANNER_FACTS = [
+  { tool: "generate_image", modality: "image", shape: "one call returns one finished image" },
+  { tool: "generate_speech", modality: "speech", shape: "one call returns one finished audio file" },
+  {
+    tool: "generate_video",
+    modality: "video",
+    shape: "one call returns one finished clip, after rendering for 1-3 minutes (Cascade stops waiting at 8)"
+  },
+  {
+    tool: "transcribe_audio",
+    modality: "transcription",
+    shape: "one call returns the transcript of one audio file"
+  }
+];
+function plannerPriceNote(modality) {
+  const costs = CAPABILITIES.filter((c) => c.modality === modality && !c.unsupported).map((c) => capabilityCost(c)).filter((c) => c !== null);
+  if (!costs.length) return "";
+  const labels = new Set(costs.map((c) => c.label));
+  if (labels.size === 1) return ` Billed ${costs[0].label}.`;
+  const units = new Set(costs.map((c) => c.unit));
+  return units.size === 1 ? ` Billed ${[...units][0]}.` : "";
+}
+function describeGenerationForPlanner(has) {
+  const present = PLANNER_FACTS.filter((f) => has(f.tool));
+  if (!present.length) return "";
+  const lines = ["MEDIA GENERATION \u2014 the only generation tools this run can call:"];
+  for (const f of present) {
+    lines.push(`- "${f.tool}" (${f.modality}): ${f.shape}.${plannerPriceNote(f.modality)}`);
+  }
+  lines.push(
+    "Each one is a single ATOMIC tool call, made by ONE T3 worker, that produces the finished file. It is never a multi-step pipeline, and no worker can satisfy it by describing the result in words.",
+    "No other modality has a tool here \u2014 never plan a step that generates music, 3D or anything not listed above."
+  );
+  if (has("generate_video")) {
+    lines.push(
+      'VIDEO PLANS MUST END IN THE TOOL CALL. Creative pre-production \u2014 a script, a shot list, direction notes \u2014 is expected and worth planning, but it is NOT the video. Any plan that involves video MUST contain exactly ONE subtask whose deliverable is the "generate_video" call itself; it MUST be the last subtask on that path (dependsOn the pre-production ones), and nothing after it may be required to produce the clip. Never end a video plan on a script, a storyboard or a review step. Never split one clip across several "generate_video" subtasks, and never plan a render \u2192 critique \u2192 re-render loop: every render is billed again and takes minutes.'
+    );
+  }
+  return lines.join("\n");
+}
+
 // src/core/tiers/t2-manager.ts
-function buildT2SystemPrompt(hasPeerMessage) {
+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.",
     'If subtasks have dependencies, you can specify "executionMode": "sequential" for the section.',
-    hasPeerMessage && '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."
-  ].filter((l) => l !== false).join("\n");
+    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.",
+    generation && `
+${generation}`
+  ].filter((l) => l !== false && l !== "").join("\n");
 }
 var T2Manager = class extends BaseTier {
   router;
@@ -10686,7 +11022,7 @@ Return ONLY the JSON array.`;
     const messages = [{ role: "user", content: prompt }];
     const result = await this.router.generate("T2", {
       messages,
-      systemPrompt: this.systemPromptOverride + buildT2SystemPrompt(this.toolRegistry.hasTool("peer_message")) + (this.hierarchyContext ? `
+      systemPrompt: this.systemPromptOverride + buildT2SystemPrompt((name) => this.toolRegistry.hasTool(name)) + (this.hierarchyContext ? `
 
 HIERARCHY CONTEXT: ${this.hierarchyContext}` : ""),
       maxTokens: 2e3,
@@ -11239,6 +11575,7 @@ function isStrongKeywordOverlap(a = [], b = []) {
 }
 function buildT1SystemPrompt(has) {
   const canWriteArtifacts = has("file_write") || has("file_edit") || has("run_code") || has("pdf_create");
+  const generation = describeGenerationForPlanner(has);
   const rules = [
     "- Simple \u2192 1 T3, Moderate \u2192 2-3 T2s, Complex \u2192 3-5 T2s, Highly Complex \u2192 5+ T2s",
     "- Return ONLY valid JSON \u2014 no other text",
@@ -11273,7 +11610,9 @@ DEPENDENCY GUIDANCE:
 QUALITY RULES:
 - Each section must have a clear, testable "expectedOutput" so T2 knows when it is done.
 - Do NOT create trivial sections that only move files or print summaries \u2014 fold those into adjacent sections.
-- If the plan would naturally produce fewer than 2 independent sections, prefer Moderate routing (single T2).`;
+- If the plan would naturally produce fewer than 2 independent sections, prefer Moderate routing (single T2).${generation ? `
+
+${generation}` : ""}`;
 }
 var T1Administrator = class extends BaseTier {
   router;
@@ -11935,225 +12274,42 @@ Instructions:
   }
   /**
    * T1-level permission evaluator.
-   * Uses T1's model with full task context.
-   * Returns null only when the model explicitly says UNSURE (triggers user prompt).
-   */
-  async evaluatePermissionAtT1(req) {
-    const prompt = `You are T1 Administrator. Overall task goal:
-${this.taskGoal}
-
-A T3 Worker (inside section "${req.sectionContext}") wants to:
-Tool: ${req.toolName}
-Target: ${JSON.stringify(req.input)}
-Reason: ${req.subtaskContext}
-
-T2 Manager was uncertain about this. Given the overall task goal, should this be allowed?
-Reply with exactly one word: YES, NO, or UNSURE.
-(UNSURE = escalate to the human user for a final decision.)`;
-    try {
-      const result = await this.router.generate("T1", {
-        messages: [{ role: "user", content: prompt }],
-        systemPrompt: this.systemPromptOverride + "You are a T1 Administrator evaluating permissions.",
-        maxTokens: 10,
-        temperature: 0
-      });
-      const answer = result.content.trim().toUpperCase();
-      const verdict = answer.includes("YES") ? "approve" : answer.includes("NO") ? "deny" : "unsure";
-      (req.trail ??= []).push({ tier: "T1", verdict, reason: `T1: ${verdict === "approve" ? "consistent with overall task goal" : verdict === "deny" ? "not consistent with overall task goal" : "unsure"}` });
-      return null;
-    } catch {
-      (req.trail ??= []).push({ tier: "T1", verdict: "unsure", reason: "T1 evaluation failed" });
-      return null;
-    }
-  }
-};
-
-// src/core/cascade.ts
-init_cost();
-
-// src/core/multimodal/registry.ts
-init_pricing();
-var CAPABILITIES = [
-  // ── Image ──
-  {
-    modality: "image",
-    provider: "openai",
-    modelId: "dall-e-3",
-    api: "openai-images"
-  },
-  {
-    // Was `imagen-4.0-generate-001` on `:predict`, which now 404s for new keys
-    // ("no longer available to new users") — Imagen's :predict API is deprecated
-    // and shuts down 2026-08-17. Google's own migration path is this model on
-    // the ordinary generateContent endpoint, so the fix was never another Imagen
-    // id: the whole request/response SHAPE changes, which is why `api` moved to
-    // 'gemini-generate-content' rather than just the modelId moving.
-    // https://ai.google.dev/gemini-api/docs/imagen
-    modality: "image",
-    provider: "gemini",
-    modelId: "gemini-2.5-flash-image",
-    api: "gemini-generate-content"
-  },
-  // ── Speech (text → audio) ──
-  {
-    modality: "speech",
-    provider: "openai",
-    modelId: "tts-1",
-    api: "openai-speech"
-  },
-  {
-    // The only quality claim in this table that needs no leaderboard: OpenAI
-    // ships these as the same voice at two fidelities and charges double for
-    // this one. That is the vendor's own ordering, not an inference.
-    modality: "speech",
-    provider: "openai",
-    modelId: "tts-1-hd",
-    api: "openai-speech",
-    quality: 70,
-    qualityBasis: "OpenAI's own hd variant of tts-1, priced 2x"
-  },
-  // ── Transcription (audio → text) ──
-  {
-    modality: "transcription",
-    provider: "openai",
-    modelId: "whisper-1",
-    api: "openai-transcriptions"
-  },
-  // ── Video ──
-  {
-    // Long-running: submit returns an operation name, the video lands minutes
-    // later, and the bytes come from a short-lived signed URL. generate.ts owns
-    // that polling loop; the registry only records the shape via `api`.
-    //
-    // `veo-3.1-generate-001` (no "-preview") is VERTEX AI's id for this model,
-    // not the Gemini Developer API's — this file calls
-    // generativelanguage.googleapis.com (see generate.ts), which 404s on it:
-    // "models/veo-3.1-generate-001 is not found for API version v1beta". On the
-    // Gemini API specifically, Veo 3.1 is still preview-only, so the correct id
-    // there is `veo-3.1-generate-preview`.
-    // https://ai.google.dev/gemini-api/docs/veo
-    modality: "video",
-    provider: "gemini",
-    modelId: "veo-3.1-generate-preview",
-    api: "gemini-predict-lro"
-  }
-];
-function capabilityCost(cap) {
-  const match = findPricing(cap.modelId, cap.provider, {
-    fallbackProviders: cap.provider === "gemini" ? ["vertex"] : []
-  });
-  const rate = match?.entry.rates?.[0];
-  if (!rate) return null;
-  const unitLabel = {
-    per_image: "per image",
-    per_second: "per second of video",
-    per_character: "per character",
-    per_audio_minute: "per audio minute"
-  };
-  const unit = unitLabel[rate.unit] ?? rate.unit;
-  const amount = rate.amount;
-  const shown = amount < 1e-3 ? amount.toExponential(2) : amount.toFixed(4);
-  return { label: `$${shown} ${unit}`, amount, unit };
-}
-function explainChoice(c, cost, modality, isBest) {
-  const priced = cost ? ` ${cost.label}.` : "";
-  if (c.quality !== void 0) {
-    return isBest ? `${c.modelId} (${c.provider}) \u2014 ranked highest for ${modality}: ${c.qualityBasis}.${priced}` : `${c.modelId} (${c.provider}) \u2014 ranked alternative for ${modality}: ${c.qualityBasis}.${priced}`;
-  }
-  const noRanking = ". No published quality ranking is applied for this modality, so this is a cost choice, not a quality one.";
-  return isBest ? `${c.modelId} (${c.provider}) \u2014 cheapest usable ${modality} model` + (cost ? ` at ${cost.label}` : "") + noRanking : `${c.modelId} (${c.provider}) \u2014 alternative usable ${modality} model` + (cost ? ` at ${cost.label}` : "") + noRanking;
-}
-var MultimodalRegistry = class {
-  /** Provider types the user has actually configured a key for. */
-  available;
-  constructor(availableProviders) {
-    this.available = new Set(availableProviders);
-  }
-  /** Every capability whose provider is configured AND which Cascade can call. */
-  usable(modality) {
-    return CAPABILITIES.filter(
-      (c) => !c.unsupported && this.available.has(c.provider) && (!modality || c.modality === modality)
-    );
-  }
-  /** Modalities this account can actually generate right now. */
-  availableModalities() {
-    return [...new Set(this.usable().map((c) => c.modality))];
-  }
-  /**
-   * Every usable capability for a modality, best first.
-   *
-   * Ranked models beat unranked ones, then higher quality, then lower unit
-   * price. An explicit `preferModel` is moved to the head when it is usable —
-   * the user naming a model is a stronger signal than any prior.
-   *
-   * `select()` is just the head of this list. The TAIL is the point: a systemic
-   * provider failure (dead key, 404, exhausted quota) is scoped to one
-   * provider+model, so "this model cannot draw" is not the same fact as "this
-   * account cannot draw". A caller holding the ordered alternatives can try the
-   * next provider instead of aborting the whole run — see generate-media.ts.
-   */
-  rank(modality, opts = {}) {
-    const scored = this.usable(modality).map((c) => ({ c, cost: capabilityCost(c) })).sort((a, b) => {
-      const qa = a.c.quality ?? -1;
-      const qb = b.c.quality ?? -1;
-      if (qa !== qb) return qb - qa;
-      const pa = a.cost?.amount ?? Number.POSITIVE_INFINITY;
-      const pb = b.cost?.amount ?? Number.POSITIVE_INFINITY;
-      return pa - pb;
-    });
-    const results = scored.map(({ c, cost }, i) => ({
-      capability: c,
-      cost,
-      reason: explainChoice(c, cost, modality, i === 0)
-    }));
-    if (opts.preferModel) {
-      const i = results.findIndex((r) => r.capability.modelId === opts.preferModel);
-      if (i > -1) {
-        const [wanted] = results.splice(i, 1);
-        results.unshift({ ...wanted, reason: `Requested explicitly: ${wanted.capability.modelId}.` });
-      }
-    }
-    return results;
-  }
-  /**
-   * Pick a model for a modality — the best usable one, or null if there is none.
-   */
-  select(modality, opts = {}) {
-    return this.rank(modality, opts)[0] ?? null;
-  }
-  /**
-   * A plain-language account of what this account can and cannot generate —
-   * including the things it cannot, and why. The planner sees this, so being
-   * candid here is what stops it inventing a `generate_music` call.
-   */
-  describe() {
-    const lines = [];
-    const usable = this.usable();
-    if (usable.length) {
-      lines.push("Generation models available on your configured providers:");
-      for (const modality of ["image", "speech", "transcription", "video"]) {
-        const forModality = usable.filter((c) => c.modality === modality);
-        if (!forModality.length) continue;
-        const shown = forModality.map((c) => {
-          const cost = capabilityCost(c);
-          return `${c.modelId}${cost ? ` (${cost.label})` : ""}`;
-        });
-        lines.push(`  ${modality}: ${shown.join(", ")}`);
-      }
-    } else {
-      lines.push("No generation models are available \u2014 none of your configured providers offers one.");
-    }
-    const blocked = CAPABILITIES.filter((c) => c.unsupported && this.available.has(c.provider));
-    for (const c of blocked) {
-      lines.push(`  ${c.modality}: ${c.modelId} exists on your account but is not callable. ${c.unsupported}`);
+   * Uses T1's model with full task context.
+   * Returns null only when the model explicitly says UNSURE (triggers user prompt).
+   */
+  async evaluatePermissionAtT1(req) {
+    const prompt = `You are T1 Administrator. Overall task goal:
+${this.taskGoal}
+
+A T3 Worker (inside section "${req.sectionContext}") wants to:
+Tool: ${req.toolName}
+Target: ${JSON.stringify(req.input)}
+Reason: ${req.subtaskContext}
+
+T2 Manager was uncertain about this. Given the overall task goal, should this be allowed?
+Reply with exactly one word: YES, NO, or UNSURE.
+(UNSURE = escalate to the human user for a final decision.)`;
+    try {
+      const result = await this.router.generate("T1", {
+        messages: [{ role: "user", content: prompt }],
+        systemPrompt: this.systemPromptOverride + "You are a T1 Administrator evaluating permissions.",
+        maxTokens: 10,
+        temperature: 0
+      });
+      const answer = result.content.trim().toUpperCase();
+      const verdict = answer.includes("YES") ? "approve" : answer.includes("NO") ? "deny" : "unsure";
+      (req.trail ??= []).push({ tier: "T1", verdict, reason: `T1: ${verdict === "approve" ? "consistent with overall task goal" : verdict === "deny" ? "not consistent with overall task goal" : "unsure"}` });
+      return null;
+    } catch {
+      (req.trail ??= []).push({ tier: "T1", verdict: "unsure", reason: "T1 evaluation failed" });
+      return null;
     }
-    lines.push(
-      "  music: no supported provider exposes a music-generation API, so Cascade cannot generate music."
-    );
-    return lines.join("\n");
   }
 };
 
+// src/core/cascade.ts
+init_cost();
+
 // src/tools/base.ts
 var BaseTool = class {
   workspaceRoot = process.cwd();
@@ -12174,10 +12330,17 @@ var BaseTool = class {
 
 // src/core/multimodal/generate.ts
 var DEFAULT_TIMEOUT_MS = 12e4;
+var GenerationGaveUpError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "GenerationGaveUpError";
+  }
+};
 async function callProvider(fn, modelId) {
   try {
     return await fn();
   } catch (err) {
+    if (err instanceof GenerationGaveUpError) throw err;
     const classified = classifyProviderError(err);
     throw new Error(describeProviderError(classified, modelId));
   }
@@ -12375,8 +12538,8 @@ async function generateVideo(cap, cfg, req, signal, onProgress) {
       onProgress?.("Still rendering\u2026");
     }
     if (!operation.done) {
-      throw new Error(
-        `Video was still rendering after ${Math.round(VIDEO_TIMEOUT_MS / 6e4)} minutes. It may still complete on the provider side, but Cascade stopped waiting.`
+      throw new GenerationGaveUpError(
+        `${cap.modelId} timed out after ${Math.round(VIDEO_TIMEOUT_MS / 6e4)} minutes \u2014 no video was produced. Cascade stopped waiting; the render may still finish on the provider side, but nothing was saved. Try again with a shorter clip or a simpler prompt.`
       );
     }
     if (operation.error?.message) throw new Error(operation.error.message);
@@ -12682,6 +12845,700 @@ function buildMediaTools(deps, readFile) {
   if (modalities.has("transcription") && readFile) tools.push(new TranscribeAudioTool(deps, readFile));
   return tools;
 }
+var WorkspaceSandboxError = class extends Error {
+  constructor(attempted, workspaceRoot) {
+    super(`Refusing access to "${attempted}" \u2014 outside workspace root "${workspaceRoot}".`);
+    this.name = "WorkspaceSandboxError";
+  }
+};
+function resolveInWorkspace(workspaceRoot, input) {
+  if (typeof input !== "string" || input.length === 0) {
+    throw new WorkspaceSandboxError(String(input), workspaceRoot);
+  }
+  const root = path33.resolve(workspaceRoot);
+  const abs = path33.isAbsolute(input) ? path33.resolve(input) : path33.resolve(root, input);
+  const rel = path33.relative(root, abs);
+  if (rel === "" || rel === ".") ; else if (rel.startsWith("..") || path33.isAbsolute(rel)) {
+    throw new WorkspaceSandboxError(input, root);
+  }
+  try {
+    const real = fs30.realpathSync(abs);
+    const realRel = path33.relative(root, real);
+    if (realRel !== "" && realRel !== "." && (realRel.startsWith("..") || path33.isAbsolute(realRel))) {
+      throw new WorkspaceSandboxError(input, root);
+    }
+  } catch (e) {
+    if (e instanceof WorkspaceSandboxError) throw e;
+  }
+  return abs;
+}
+
+// src/core/documents/blocks.ts
+function fileExt(name) {
+  const base = name.split(/[\\/]/).pop() ?? name;
+  const dot = base.lastIndexOf(".");
+  return dot > 0 ? base.slice(dot + 1).toLowerCase() : "";
+}
+function parseDelimited(text, name = "") {
+  const delim = fileExt(name) === "tsv" || text.indexOf("	") !== -1 && text.indexOf(",") === -1 ? "	" : ",";
+  const rows = [];
+  let row = [];
+  let cell = "";
+  let quoted = false;
+  for (let i = 0; i < text.length; i++) {
+    const ch = text[i];
+    if (quoted) {
+      if (ch === '"') {
+        if (text[i + 1] === '"') {
+          cell += '"';
+          i++;
+        } else quoted = false;
+      } else cell += ch;
+    } else if (ch === '"') {
+      quoted = true;
+    } else if (ch === delim) {
+      row.push(cell);
+      cell = "";
+    } else if (ch === "\n") {
+      row.push(cell);
+      rows.push(row);
+      row = [];
+      cell = "";
+    } else if (ch === "\r") ; else {
+      cell += ch;
+    }
+    if (rows.length > 5e3) break;
+  }
+  if (cell !== "" || row.length) {
+    row.push(cell);
+    rows.push(row);
+  }
+  return rows.filter((r) => r.length > 1 || (r[0] ?? "") !== "");
+}
+var CHART_ALIASES = {
+  bar: "bar",
+  column: "bar",
+  bars: "bar",
+  barchart: "bar",
+  horizontalbar: "bar",
+  line: "line",
+  lines: "line",
+  linechart: "line",
+  pie: "pie",
+  piechart: "pie",
+  doughnut: "doughnut",
+  donut: "doughnut",
+  area: "area",
+  areachart: "area",
+  scatter: "scatter",
+  xy: "scatter"
+};
+function chartKind(raw) {
+  return CHART_ALIASES[raw.trim().toLowerCase().replace(/[\s_-]/g, "")] ?? null;
+}
+function toNumber(cell) {
+  const cleaned = cell.replace(/[$£€¥,\s%]/g, "").replace(/^\((.*)\)$/, "-$1");
+  const n = Number.parseFloat(cleaned);
+  return Number.isFinite(n) ? n : 0;
+}
+function parseChartSpec(kind, body) {
+  const lines = body.replace(/\r\n/g, "\n").split("\n");
+  let title;
+  while (lines.length && !lines[0].trim()) lines.shift();
+  const titleMatch = lines[0]?.match(/^\s*title\s*:\s*(.+)$/i);
+  if (titleMatch) {
+    title = titleMatch[1].trim();
+    lines.shift();
+  }
+  const rows = parseDelimited(lines.join("\n").trim());
+  if (rows.length < 2) return null;
+  const header = rows[0].map((c) => c.trim());
+  if (header.length < 2) return null;
+  const dataRows = rows.slice(1).filter((r) => r.some((c) => c.trim() !== ""));
+  if (!dataRows.length) return null;
+  const categories = dataRows.map((r, i) => (r[0] ?? "").trim() || `Item ${i + 1}`);
+  const series = header.slice(1).map((name, col2) => ({
+    name: name || `Series ${col2 + 1}`,
+    values: dataRows.map((r) => toNumber((r[col2 + 1] ?? "").trim()))
+  }));
+  if (!series.length) return null;
+  return {
+    kind,
+    ...title ? { title } : {},
+    categoryName: header[0] || "Category",
+    categories,
+    series
+  };
+}
+function chartToTableRows(spec) {
+  return [
+    [spec.categoryName, ...spec.series.map((s) => s.name)],
+    ...spec.categories.map((cat, i) => [cat, ...spec.series.map((s) => String(s.values[i] ?? 0))])
+  ];
+}
+function parseBlocks(md) {
+  const out = [];
+  const lines = md.replace(/\r\n/g, "\n").split("\n");
+  let i = 0;
+  let ordinal = 0;
+  const reset = () => {
+    ordinal = 0;
+  };
+  while (i < lines.length) {
+    const line = lines[i] ?? "";
+    const fence = line.match(/^```+\s*(.*)$/);
+    if (fence) {
+      const info = (fence[1] ?? "").trim();
+      i++;
+      const code = [];
+      while (i < lines.length && !/^```/.test(lines[i] ?? "")) {
+        code.push(lines[i] ?? "");
+        i++;
+      }
+      i++;
+      const chartInfo = info.match(/^chart\s*:\s*(.+)$/i);
+      const kind = chartInfo ? chartKind(chartInfo[1]) : null;
+      const spec = kind ? parseChartSpec(kind, code.join("\n")) : null;
+      out.push(spec ? { t: "chart", spec } : { t: "code", lines: code });
+      reset();
+      continue;
+    }
+    if (!line.trim()) {
+      i++;
+      reset();
+      continue;
+    }
+    const h = line.match(/^(#{1,6})\s+(.*)$/);
+    if (h) {
+      out.push({ t: "heading", level: h[1].length, text: h[2] });
+      i++;
+      reset();
+      continue;
+    }
+    if (/^\s*([-*_])\s*(\1\s*){2,}$/.test(line)) {
+      out.push({ t: "hr" });
+      i++;
+      reset();
+      continue;
+    }
+    const li = line.match(/^(\s*)([-*+]|\d+[.)])\s+(.*)$/);
+    if (li) {
+      const ordered = /\d/.test(li[2]);
+      ordinal = ordered ? ordinal + 1 : 0;
+      out.push({ t: "bullet", ordered, index: ordered ? ordinal : 0, text: li[3] });
+      i++;
+      continue;
+    }
+    if (/^>\s?/.test(line)) {
+      out.push({ t: "quote", text: line.replace(/^>\s?/, "") });
+      i++;
+      reset();
+      continue;
+    }
+    if (/^\|.*\|/.test(line)) {
+      const rows = [];
+      while (i < lines.length && /^\|.*\|/.test(lines[i] ?? "")) {
+        const r = lines[i];
+        if (!/^\|[\s:|-]+\|?\s*$/.test(r)) rows.push(r.replace(/^\||\|\s*$/g, "").split("|").map((c) => c.trim()));
+        i++;
+      }
+      out.push({ t: "table", rows });
+      reset();
+      continue;
+    }
+    out.push({ t: "para", text: line });
+    i++;
+    reset();
+  }
+  return out;
+}
+var IMAGE_LINE = /^!\[([^\]]*)\]\(([^)]+)\)$/;
+function matchImageLine(s) {
+  const m = s.trim().match(IMAGE_LINE);
+  return m ? { alt: m[1].trim(), url: m[2].trim() } : null;
+}
+function sniffImage(b) {
+  const dv = new DataView(b.buffer, b.byteOffset, b.byteLength);
+  if (b.length > 24 && b[0] === 137 && b[1] === 80 && b[2] === 78 && b[3] === 71) {
+    return { type: "png", mime: "image/png", width: dv.getUint32(16), height: dv.getUint32(20) };
+  }
+  if (b.length > 10 && b[0] === 71 && b[1] === 73 && b[2] === 70) {
+    return { type: "gif", mime: "image/gif", width: dv.getUint16(6, true), height: dv.getUint16(8, true) };
+  }
+  if (b.length > 26 && b[0] === 66 && b[1] === 77) {
+    return { type: "bmp", mime: "image/bmp", width: Math.abs(dv.getInt32(18, true)), height: Math.abs(dv.getInt32(22, true)) };
+  }
+  if (b.length > 4 && b[0] === 255 && b[1] === 216) {
+    let i = 2;
+    while (i + 9 < b.length) {
+      if (b[i] !== 255) {
+        i++;
+        continue;
+      }
+      const marker = b[i + 1];
+      if (marker >= 192 && marker <= 207 && marker !== 196 && marker !== 200 && marker !== 204) {
+        return { type: "jpg", mime: "image/jpeg", height: dv.getUint16(i + 5), width: dv.getUint16(i + 7) };
+      }
+      i += 2 + dv.getUint16(i + 2);
+    }
+  }
+  return null;
+}
+function bytesToBase64(bytes) {
+  const g = globalThis;
+  if (g.Buffer) return g.Buffer.from(bytes).toString("base64");
+  const CHUNK = 32768;
+  let binary = "";
+  for (let i = 0; i < bytes.length; i += CHUNK) {
+    binary += String.fromCharCode(...bytes.subarray(i, i + CHUNK));
+  }
+  return g.btoa(binary);
+}
+function stripInline(s) {
+  return s.replace(/\*\*(.+?)\*\*/g, "$1").replace(/(^|[^*])\*(?!\s)(.+?)\*/g, "$1$2").replace(/`([^`]+)`/g, "$1").replace(/\[(.+?)\]\((.+?)\)/g, "$1 ($2)");
+}
+function inlineRuns(text) {
+  const acc = [];
+  const re = /(\*\*[^*]+\*\*|`[^`]+`|\[[^\]]{1,500}\]\([^)]{1,2000}\)|\*[^*\s][^*]*\*)/g;
+  let last = 0;
+  let m;
+  while ((m = re.exec(text)) !== null) {
+    if (m.index > last) acc.push({ text: text.slice(last, m.index) });
+    const tok = m[0];
+    if (tok.startsWith("**")) acc.push({ text: tok.slice(2, -2), bold: true });
+    else if (tok.startsWith("`")) acc.push({ text: tok.slice(1, -1), code: true });
+    else if (tok.startsWith("[")) {
+      const l = tok.match(/\[([^\]]{1,500})\]\(([^)]{1,2000})\)/);
+      acc.push({ text: l ? `${l[1]} (${l[2]})` : tok });
+    } else acc.push({ text: tok.slice(1, -1), italic: true });
+    last = re.lastIndex;
+  }
+  if (last < text.length) acc.push({ text: text.slice(last) });
+  return acc.length ? acc : [{ text }];
+}
+function splitSlides(md) {
+  const norm = md.replace(/\r\n/g, "\n").trim();
+  let chunks = norm.split(/\n\s*-{3,}\s*\n/);
+  if (chunks.length === 1) {
+    const lines = norm.split("\n");
+    const sections = [];
+    let cur = [];
+    for (const ln of lines) {
+      if (/^#{1,2}\s+/.test(ln) && cur.some((l) => l.trim())) {
+        sections.push(cur.join("\n"));
+        cur = [];
+      }
+      cur.push(ln);
+    }
+    if (cur.length) sections.push(cur.join("\n"));
+    if (sections.length > 1) chunks = sections;
+  }
+  return chunks.map(parseSlide).filter((s) => s.title || s.body.length || s.images.length || s.charts.length);
+}
+function parseSlide(chunk) {
+  let title = "";
+  const body = [];
+  const images = [];
+  const charts = [];
+  const lines = chunk.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const raw = lines[i] ?? "";
+    const fence = raw.match(/^[ \t]*```+[ \t]*chart[ \t]*:(.*)/i);
+    if (fence) {
+      const kind = chartKind(fence[1]);
+      const bodyLines = [];
+      i++;
+      while (i < lines.length && !/^\s*```/.test(lines[i] ?? "")) {
+        bodyLines.push(lines[i] ?? "");
+        i++;
+      }
+      const spec = kind ? parseChartSpec(kind, bodyLines.join("\n")) : null;
+      if (spec) charts.push(spec);
+      else for (const bl of bodyLines) if (bl.trim()) body.push(stripInline(bl.trim()));
+      continue;
+    }
+    const line = raw.trim();
+    if (!line) continue;
+    const h = line.match(/^#{1,6}[ \t]+(.*)/);
+    if (h) {
+      if (!title) title = stripInline(h[1]);
+      else body.push(stripInline(h[1]));
+      continue;
+    }
+    const img = matchImageLine(line);
+    if (img) {
+      images.push(img);
+      continue;
+    }
+    const li = line.match(/^([-*+]|\d+[.)])[ \t]+(.*)/);
+    if (li) {
+      const bulletImg = matchImageLine(li[2]);
+      if (bulletImg) {
+        images.push(bulletImg);
+        continue;
+      }
+      body.push(stripInline(li[2]));
+      continue;
+    }
+    if (/^>\s?/.test(line)) {
+      body.push(stripInline(line.replace(/^>\s?/, "")));
+      continue;
+    }
+    body.push(stripInline(line));
+  }
+  return { title, body, images, charts };
+}
+function extractCharts(source) {
+  const lines = source.replace(/\r\n/g, "\n").split("\n");
+  const charts = [];
+  const rest = [];
+  for (let i = 0; i < lines.length; i++) {
+    const fence = lines[i].match(/^[ \t]*```+[ \t]*chart[ \t]*:(.*)/i);
+    if (!fence) {
+      rest.push(lines[i]);
+      continue;
+    }
+    const kind = chartKind(fence[1]);
+    const body = [];
+    i++;
+    while (i < lines.length && !/^\s*```/.test(lines[i] ?? "")) {
+      body.push(lines[i] ?? "");
+      i++;
+    }
+    const spec = kind ? parseChartSpec(kind, body.join("\n")) : null;
+    if (spec) charts.push(spec);
+    else rest.push(...body);
+  }
+  return { charts, rest: rest.join("\n") };
+}
+
+// src/core/documents/render.ts
+function isDocumentFormat(ext) {
+  return ext === "docx" || ext === "pptx" || ext === "xlsx";
+}
+async function loadImage(ref, load) {
+  if (!load) return null;
+  try {
+    const bytes = await load(ref.url);
+    if (!bytes || !bytes.length) return null;
+    const info = sniffImage(bytes);
+    if (!info || info.width <= 0 || info.height <= 0) return null;
+    return { ...info, bytes, alt: ref.alt };
+  } catch {
+    return null;
+  }
+}
+async function renderXlsx(source, opts = {}) {
+  const XLSX = await import('xlsx');
+  const { charts, rest } = extractCharts(source);
+  const name = opts.name ?? "";
+  const rows = parseDelimited(rest, name.toLowerCase().endsWith(".tsv") ? "x.tsv" : "x.csv");
+  const wb = XLSX.utils.book_new();
+  XLSX.utils.book_append_sheet(wb, XLSX.utils.aoa_to_sheet(rows.length ? rows : [[""]]), "Sheet1");
+  const used = /* @__PURE__ */ new Set(["Sheet1"]);
+  charts.forEach((spec, i) => {
+    const base = (spec.title || `Chart ${i + 1}`).replace(/[:\\/?*[\]]/g, " ").trim().slice(0, 28) || `Chart ${i + 1}`;
+    let sheetName = base;
+    let n = 2;
+    while (used.has(sheetName)) sheetName = `${base} ${n++}`.slice(0, 31);
+    used.add(sheetName);
+    const aoa = [
+      [spec.categoryName, ...spec.series.map((s) => s.name)],
+      ...spec.categories.map((cat, r) => [cat, ...spec.series.map((s) => s.values[r] ?? 0)])
+    ];
+    XLSX.utils.book_append_sheet(wb, XLSX.utils.aoa_to_sheet(aoa), sheetName);
+  });
+  return new Uint8Array(XLSX.write(wb, { type: "array", bookType: "xlsx" }));
+}
+var DOCX_MAX_W = 600;
+var DOCX_MAX_H = 864;
+async function renderDocx(md, opts = {}) {
+  const d = await import('docx');
+  const {
+    Document,
+    Packer,
+    Paragraph,
+    TextRun,
+    ImageRun,
+    HeadingLevel,
+    Table,
+    TableRow,
+    TableCell,
+    WidthType,
+    BorderStyle,
+    AlignmentType
+  } = d;
+  const HEADINGS = [
+    HeadingLevel.HEADING_1,
+    HeadingLevel.HEADING_2,
+    HeadingLevel.HEADING_3,
+    HeadingLevel.HEADING_4,
+    HeadingLevel.HEADING_5,
+    HeadingLevel.HEADING_6
+  ];
+  const runs = (text) => inlineRuns(text).map((r) => new TextRun({
+    text: r.text,
+    ...r.bold ? { bold: true } : {},
+    ...r.italic ? { italics: true } : {},
+    ...r.code ? { font: "Courier New" } : {}
+  }));
+  const tableOf = (rows) => new Table({
+    width: { size: 100, type: WidthType.PERCENTAGE },
+    rows: rows.map((r) => new TableRow({
+      children: r.map((c) => new TableCell({ children: [new Paragraph({ children: runs(c) })] }))
+    }))
+  });
+  const imageParagraph = (img) => {
+    const scale = Math.min(1, DOCX_MAX_W / img.width, DOCX_MAX_H / img.height);
+    return new Paragraph({
+      children: [new ImageRun({
+        type: img.type,
+        data: img.bytes,
+        transformation: { width: Math.round(img.width * scale), height: Math.round(img.height * scale) },
+        ...img.alt ? { altText: { name: img.alt, description: img.alt, title: img.alt } } : {}
+      })]
+    });
+  };
+  const asImage = async (text) => {
+    const ref = matchImageLine(text);
+    return ref ? await loadImage(ref, opts.loadImageBytes) : null;
+  };
+  const children = [];
+  for (const b of parseBlocks(md)) {
+    switch (b.t) {
+      case "heading":
+        children.push(new Paragraph({ heading: HEADINGS[Math.min(b.level, 6) - 1], children: runs(b.text) }));
+        break;
+      case "para": {
+        const img = await asImage(b.text);
+        children.push(img ? imageParagraph(img) : new Paragraph({ children: runs(b.text) }));
+        break;
+      }
+      case "bullet": {
+        const img = await asImage(b.text);
+        children.push(img ? imageParagraph(img) : new Paragraph({
+          children: runs(b.text),
+          ...b.ordered ? { numbering: { reference: "ol", level: 0 } } : { bullet: { level: 0 } }
+        }));
+        break;
+      }
+      case "code":
+        for (const cl of b.lines) {
+          children.push(new Paragraph({ children: [new TextRun({ text: cl || " ", font: "Courier New", size: 18 })] }));
+        }
+        break;
+      case "quote":
+        children.push(new Paragraph({ indent: { left: 360 }, children: [new TextRun({ text: stripInline(b.text), italics: true })] }));
+        break;
+      case "table":
+        children.push(tableOf(b.rows));
+        break;
+      case "chart":
+        if (b.spec.title) {
+          children.push(new Paragraph({ children: [new TextRun({ text: b.spec.title, bold: true })] }));
+        }
+        children.push(tableOf(chartToTableRows(b.spec)));
+        break;
+      case "hr":
+        children.push(new Paragraph({
+          children: [],
+          border: { bottom: { color: "CCCCCC", space: 1, style: BorderStyle.SINGLE, size: 6 } }
+        }));
+        break;
+    }
+  }
+  const doc = new Document({
+    numbering: {
+      config: [{ reference: "ol", levels: [{ level: 0, format: "decimal", text: "%1.", alignment: AlignmentType.START }] }]
+    },
+    sections: [{ children: children.length ? children : [new Paragraph({ children: [new TextRun("")] })] }]
+  });
+  return new Uint8Array(await Packer.toArrayBuffer(doc));
+}
+function pptxConstructor(mod) {
+  let c = mod;
+  for (let i = 0; i < 3 && c && typeof c !== "function"; i++) c = c.default;
+  if (typeof c !== "function") throw new Error("pptxgenjs did not export a constructor.");
+  return c;
+}
+var SLIDE_H = 7.5;
+var CONTENT_X = 0.6;
+var CONTENT_W = 12.1;
+var CONTENT_BOTTOM = 0.4;
+async function renderPptx(md, opts = {}) {
+  const PptxGen = pptxConstructor(await import('pptxgenjs'));
+  const pptx = new PptxGen();
+  pptx.layout = "LAYOUT_WIDE";
+  const CHART_TYPES = {
+    bar: pptx.ChartType["bar"],
+    line: pptx.ChartType["line"],
+    pie: pptx.ChartType["pie"],
+    doughnut: pptx.ChartType["doughnut"],
+    area: pptx.ChartType["area"],
+    scatter: pptx.ChartType["scatter"]
+  };
+  const slides = splitSlides(md);
+  const blank = { title: "", body: [""], images: [], charts: [] };
+  for (const s of slides.length ? slides : [blank]) {
+    const slide = pptx.addSlide();
+    if (s.title) slide.addText(s.title, { x: 0.5, y: 0.35, w: 12.3, h: 0.9, fontSize: 28, bold: true, color: "1F2937" });
+    const top = s.title ? 1.5 : 0.5;
+    const pics = (await Promise.all(s.images.map((r) => loadImage(r, opts.loadImageBytes)))).filter((p) => p !== null);
+    const visuals = [
+      ...s.charts.map((spec) => ({ kind: "chart", spec })),
+      ...pics.map((img) => ({ kind: "image", img }))
+    ];
+    const bodyH = visuals.length ? 2.2 : 5.4;
+    if (s.body.length) {
+      slide.addText(
+        s.body.map((t) => ({ text: t, options: { bullet: true, breakLine: true } })),
+        { x: CONTENT_X, y: top, w: CONTENT_W, h: bodyH, fontSize: 16, color: "374151", valign: "top" }
+      );
+    }
+    if (visuals.length) {
+      const y = top + (s.body.length ? bodyH + 0.2 : 0);
+      const h = Math.max(1, SLIDE_H - CONTENT_BOTTOM - y);
+      const gap = 0.3;
+      const w = (CONTENT_W - gap * (visuals.length - 1)) / visuals.length;
+      visuals.forEach((v, i) => {
+        const x = CONTENT_X + i * (w + gap);
+        if (v.kind === "image") {
+          slide.addImage({
+            data: `data:${v.img.mime};base64,${bytesToBase64(v.img.bytes)}`,
+            x,
+            y,
+            w,
+            h,
+            // 'contain' keeps the aspect ratio inside the box — a stretched
+            // render looks worse than a smaller correct one.
+            sizing: { type: "contain", w, h },
+            ...v.img.alt ? { altText: v.img.alt } : {}
+          });
+        } else {
+          slide.addChart(CHART_TYPES[v.spec.kind], chartData(v.spec), {
+            x,
+            y,
+            w,
+            h,
+            showLegend: v.spec.series.length > 1 || v.spec.kind === "pie" || v.spec.kind === "doughnut",
+            legendPos: "b",
+            showTitle: !!v.spec.title,
+            ...v.spec.title ? { title: v.spec.title } : {},
+            showValue: v.spec.kind === "pie" || v.spec.kind === "doughnut"
+          });
+        }
+      });
+    }
+  }
+  return new Uint8Array(await pptx.write({ outputType: "arraybuffer" }));
+}
+function chartData(spec) {
+  const series = spec.kind === "pie" || spec.kind === "doughnut" ? spec.series.slice(0, 1) : spec.series;
+  return series.map((s) => ({ name: s.name, labels: spec.categories, values: s.values }));
+}
+async function renderDocument(format, source, opts = {}) {
+  if (format === "docx") return renderDocx(source, opts);
+  if (format === "pptx") return renderPptx(source, opts);
+  return renderXlsx(source, opts);
+}
+
+// src/tools/generate-document.ts
+var SOURCE_HINT = {
+  docx: "Markdown",
+  pptx: "Markdown slides (separate slides with a --- rule; each slide starts with a heading)",
+  xlsx: "CSV (one header row, then data rows)"
+};
+var GenerateDocumentTool = class extends BaseTool {
+  /**
+   * `readFile` is injected so the image loader is testable and so a host with a
+   * different workspace (not plain disk) can supply its own reader.
+   */
+  constructor(readFile = async (p) => new Uint8Array(await fs11.readFile(p))) {
+    super();
+    this.readFile = readFile;
+  }
+  readFile;
+  name = "generate_document";
+  description = "Create a REAL Microsoft Office file (.docx Word, .pptx PowerPoint, .xlsx Excel) in the workspace. You write the SOURCE and this tool renders the actual binary: Markdown for .docx, Markdown slides (separated by --- rules) for .pptx, CSV for .xlsx. ALWAYS use this instead of file_write for those three extensions \u2014 file_write stores your text verbatim, which Office reports as a corrupted file. Supports embedded images (reference a generated image as ![alt](path-the-image-tool-returned) on its own line) and real, data-accurate charts (a ```chart:bar / chart:line / chart:pie fenced block whose body is CSV). Use pdf_create for PDFs.";
+  inputSchema = {
+    type: "object",
+    properties: {
+      path: {
+        type: "string",
+        description: "Where to write the file, relative to the workspace root. The extension decides the format: .docx, .pptx or .xlsx."
+      },
+      content: {
+        type: "string",
+        description: 'The document source. Markdown for .docx; Markdown slides separated by --- rules for .pptx (each slide starts with a heading); CSV for .xlsx. A standalone ![alt](path) line embeds that image. A fenced ```chart:bar (or chart:line, chart:pie, chart:area, chart:doughnut, chart:scatter) block whose body is CSV \u2014 an optional "title: \u2026" line, then a header row of "<category>,<series1>,<series2>", then data rows \u2014 becomes a real chart.'
+      },
+      format: {
+        type: "string",
+        description: 'Optional override: "docx", "pptx" or "xlsx". Normally inferred from the path extension.'
+      }
+    },
+    required: ["path", "content"]
+  };
+  isDangerous() {
+    return true;
+  }
+  async execute(input, options) {
+    const filePath = String(input["path"] ?? "").trim();
+    if (!filePath) return 'Provide a "path" for the document, e.g. "report.docx".';
+    const content = typeof input["content"] === "string" ? input["content"] : "";
+    if (!content.trim()) return 'Provide "content" \u2014 the Markdown (docx/pptx) or CSV (xlsx) source for the document.';
+    const requested = String(input["format"] ?? "").trim().toLowerCase().replace(/^\./, "");
+    const ext = requested || fileExt(filePath);
+    if (!isDocumentFormat(ext)) {
+      return `generate_document renders .docx, .pptx and .xlsx. "${filePath}" is not one of those \u2014 use pdf_create for a PDF, or file_write for a text file.`;
+    }
+    const absPath = resolveInWorkspace(this.workspaceRoot, filePath);
+    const embedded = [];
+    const skipped = [];
+    const loadImageBytes = async (url) => {
+      if (/^(https?|ftp):\/\//i.test(url)) {
+        skipped.push(`${url} (remote URL \u2014 download it into the workspace first)`);
+        return null;
+      }
+      const local = url.replace(/^file:\/\//i, "").split("?")[0].split("#")[0];
+      try {
+        const bytes2 = await this.readFile(resolveInWorkspace(this.workspaceRoot, decodeURIComponent(local)));
+        embedded.push(local);
+        return bytes2;
+      } catch {
+        skipped.push(`${local} (not found in the workspace)`);
+        return null;
+      }
+    };
+    if (options.saveSnapshot) {
+      try {
+        const old = await fs11.readFile(absPath, "utf-8");
+        await options.saveSnapshot(absPath, old);
+      } catch {
+      }
+    }
+    const bytes = await renderDocument(ext, content, { name: filePath, loadImageBytes });
+    await fs11.mkdir(path33.dirname(absPath), { recursive: true });
+    await fs11.writeFile(absPath, bytes);
+    const charts = countCharts(content);
+    return [
+      `Wrote a real ${LABEL[ext]} file to ${filePath} (${bytes.length} bytes) from ${SOURCE_HINT[ext]}.`,
+      embedded.length ? `Embedded ${embedded.length} image(s): ${embedded.join(", ")}.` : "",
+      // Named, not counted: a dropped image is the failure the user actually
+      // notices, and the model can only fix it if it is told which reference died.
+      skipped.length ? `Could NOT embed ${skipped.length} image reference(s): ${skipped.join("; ")}.` : "",
+      charts && ext === "pptx" ? `Rendered ${charts} chart block(s) as real, editable PowerPoint charts.` : "",
+      charts && ext === "docx" ? `Rendered ${charts} chart block(s) as data tables \u2014 Word documents cannot hold a native chart object.` : "",
+      charts && ext === "xlsx" ? `Wrote ${charts} chart block(s) onto their own worksheets as real rows the user can chart in Excel.` : ""
+    ].filter(Boolean).join("\n");
+  }
+};
+var LABEL = { docx: "Word", pptx: "PowerPoint", xlsx: "Excel" };
+function countCharts(source) {
+  return (source.match(/^\s*```+\s*chart\s*:/gim) ?? []).length;
+}
+function buildDocumentTools(readFile) {
+  return readFile ? [new GenerateDocumentTool(readFile)] : [];
+}
 
 // src/core/run-breaker.ts
 var DEFAULT_FAILURE_THRESHOLD = 3;
@@ -12830,35 +13687,6 @@ ${[e.stdout, e.stderr].filter(Boolean).join("\n").trim()}`;
     }
   }
 };
-var WorkspaceSandboxError = class extends Error {
-  constructor(attempted, workspaceRoot) {
-    super(`Refusing access to "${attempted}" \u2014 outside workspace root "${workspaceRoot}".`);
-    this.name = "WorkspaceSandboxError";
-  }
-};
-function resolveInWorkspace(workspaceRoot, input) {
-  if (typeof input !== "string" || input.length === 0) {
-    throw new WorkspaceSandboxError(String(input), workspaceRoot);
-  }
-  const root = path32.resolve(workspaceRoot);
-  const abs = path32.isAbsolute(input) ? path32.resolve(input) : path32.resolve(root, input);
-  const rel = path32.relative(root, abs);
-  if (rel === "" || rel === ".") ; else if (rel.startsWith("..") || path32.isAbsolute(rel)) {
-    throw new WorkspaceSandboxError(input, root);
-  }
-  try {
-    const real = fs29.realpathSync(abs);
-    const realRel = path32.relative(root, real);
-    if (realRel !== "" && realRel !== "." && (realRel.startsWith("..") || path32.isAbsolute(realRel))) {
-      throw new WorkspaceSandboxError(input, root);
-    }
-  } catch (e) {
-    if (e instanceof WorkspaceSandboxError) throw e;
-  }
-  return abs;
-}
-
-// src/tools/file.ts
 var FileReadTool = class extends BaseTool {
   name = "file_read";
   description = "Read the contents of a file. Returns the file content as a string.";
@@ -12876,7 +13704,7 @@ var FileReadTool = class extends BaseTool {
     const absPath = resolveInWorkspace(this.workspaceRoot, filePath);
     const offset = input["offset"] ?? 1;
     const limit = input["limit"];
-    const content = await fs10.readFile(absPath, "utf-8");
+    const content = await fs11.readFile(absPath, "utf-8");
     const lines = content.split("\n");
     const start = Math.max(0, offset - 1);
     const end = limit ? start + limit : lines.length;
@@ -12905,13 +13733,13 @@ var FileWriteTool = class extends BaseTool {
     const content = input["content"];
     if (options.saveSnapshot) {
       try {
-        const oldContent = await fs10.readFile(absPath, "utf-8");
+        const oldContent = await fs11.readFile(absPath, "utf-8");
         await options.saveSnapshot(absPath, oldContent);
       } catch {
       }
     }
-    await fs10.mkdir(path32.dirname(absPath), { recursive: true });
-    await fs10.writeFile(absPath, content, "utf-8");
+    await fs11.mkdir(path33.dirname(absPath), { recursive: true });
+    await fs11.writeFile(absPath, content, "utf-8");
     return `Written ${content.length} characters to ${filePath}`;
   }
 };
@@ -12937,7 +13765,7 @@ var FileEditTool = class extends BaseTool {
     const oldString = input["old_string"];
     const newString = input["new_string"];
     const replaceAll = input["replace_all"] ?? false;
-    const rawContent = await fs10.readFile(absPath, "utf-8");
+    const rawContent = await fs11.readFile(absPath, "utf-8");
     if (options.saveSnapshot) {
       await options.saveSnapshot(absPath, rawContent);
     }
@@ -12949,7 +13777,7 @@ var FileEditTool = class extends BaseTool {
       );
     }
     const updated = replaceAll ? content.split(normalizedOld).join(newString) : content.replace(normalizedOld, newString);
-    await fs10.writeFile(absPath, updated, "utf-8");
+    await fs11.writeFile(absPath, updated, "utf-8");
     const count = replaceAll ? content.split(normalizedOld).length - 1 : 1;
     return `Replaced ${count} occurrence(s) in ${filePath}`;
   }
@@ -12972,12 +13800,12 @@ var FileDeleteTool = class extends BaseTool {
     const absPath = resolveInWorkspace(this.workspaceRoot, filePath);
     if (options.saveSnapshot) {
       try {
-        const oldContent = await fs10.readFile(absPath, "utf-8");
+        const oldContent = await fs11.readFile(absPath, "utf-8");
         await options.saveSnapshot(absPath, oldContent);
       } catch {
       }
     }
-    await fs10.rm(absPath, { recursive: false });
+    await fs11.rm(absPath, { recursive: false });
     return `Deleted ${filePath}`;
   }
 };
@@ -12994,7 +13822,7 @@ var FileListTool = class extends BaseTool {
   async execute(input, _options) {
     const inputPath = input["path"] || ".";
     const absPath = resolveInWorkspace(this.workspaceRoot, inputPath);
-    const entries = await fs10.readdir(absPath, { withFileTypes: true });
+    const entries = await fs11.readdir(absPath, { withFileTypes: true });
     return entries.map((e) => `${e.isDirectory() ? "[DIR] " : "      "}${e.name}`).join("\n") || "(empty directory)";
   }
 };
@@ -13407,8 +14235,8 @@ var ImageAnalyzeTool = class extends BaseTool {
   }
 };
 async function fileToImageAttachment(filePath) {
-  const data = await fs10.readFile(filePath);
-  const ext = path32.extname(filePath).toLowerCase();
+  const data = await fs11.readFile(filePath);
+  const ext = path33.extname(filePath).toLowerCase();
   const mimeMap = {
     ".jpg": "image/jpeg",
     ".jpeg": "image/jpeg",
@@ -13442,14 +14270,14 @@ var PDFCreateTool = class extends BaseTool {
     const filePath = input["path"];
     const content = input["content"];
     const title = input["title"];
-    const dir = path32.dirname(filePath);
-    if (!fs29.existsSync(dir)) {
-      fs29.mkdirSync(dir, { recursive: true });
+    const dir = path33.dirname(filePath);
+    if (!fs30.existsSync(dir)) {
+      fs30.mkdirSync(dir, { recursive: true });
     }
     return new Promise((resolve2, reject) => {
       try {
         const doc = new PDFDocument({ margin: 50 });
-        const stream = fs29.createWriteStream(filePath);
+        const stream = fs30.createWriteStream(filePath);
         doc.pipe(stream);
         if (title) {
           doc.info["Title"] = title;
@@ -13527,22 +14355,22 @@ var CodeInterpreterTool = class extends BaseTool {
       }
       cmdPrefix = NODE_CMD;
     }
-    const tmpDir = path32.join(this.workspaceRoot, ".cascade", "tmp");
-    if (!fs29.existsSync(tmpDir)) {
-      fs29.mkdirSync(tmpDir, { recursive: true });
+    const tmpDir = path33.join(this.workspaceRoot, ".cascade", "tmp");
+    if (!fs30.existsSync(tmpDir)) {
+      fs30.mkdirSync(tmpDir, { recursive: true });
     }
     const extension = language === "python" ? "py" : "js";
     const fileName = `intp_${randomUUID().slice(0, 8)}.${extension}`;
-    const filePath = path32.join(tmpDir, fileName);
-    fs29.writeFileSync(filePath, code, "utf-8");
+    const filePath = path33.join(tmpDir, fileName);
+    fs30.writeFileSync(filePath, code, "utf-8");
     const execArgs = [filePath, ...args];
     return new Promise((resolve2) => {
       const startMs = Date.now();
       execFile(cmdPrefix, execArgs, { cwd: this.workspaceRoot, timeout: 3e4 }, (error, stdout, stderr) => {
         const duration = Date.now() - startMs;
         try {
-          if (fs29.existsSync(filePath)) {
-            fs29.unlinkSync(filePath);
+          if (fs30.existsSync(filePath)) {
+            fs30.unlinkSync(filePath);
           }
         } catch (cleanupErr) {
           console.error(`Failed to cleanup interpreter script ${filePath}:`, cleanupErr);
@@ -13854,7 +14682,7 @@ var GlobTool = class extends BaseTool {
   };
   async execute(input, _options) {
     const pattern = input["pattern"];
-    const searchPath = input["path"] ? path32.resolve(this.workspaceRoot, input["path"]) : this.workspaceRoot;
+    const searchPath = input["path"] ? path33.resolve(this.workspaceRoot, input["path"]) : this.workspaceRoot;
     const matches = await glob(pattern, {
       cwd: searchPath,
       ignore: ["node_modules/**", ".git/**", "dist/**", "build/**"],
@@ -13867,7 +14695,7 @@ var GlobTool = class extends BaseTool {
     const withMtime = await Promise.all(
       matches.map(async (rel) => {
         try {
-          const stat = await fs10.stat(path32.join(searchPath, rel));
+          const stat = await fs11.stat(path33.join(searchPath, rel));
           return { rel, mtime: stat.mtimeMs };
         } catch {
           return { rel, mtime: 0 };
@@ -13916,7 +14744,7 @@ var GrepTool = class extends BaseTool {
   };
   async execute(input, _options) {
     const pattern = input["pattern"];
-    const searchPath = input["path"] ? path32.resolve(this.workspaceRoot, input["path"]) : this.workspaceRoot;
+    const searchPath = input["path"] ? path33.resolve(this.workspaceRoot, input["path"]) : this.workspaceRoot;
     const globPattern = input["glob"];
     const outputMode = input["output_mode"] ?? "content";
     const context = input["context"] ?? 0;
@@ -13970,15 +14798,15 @@ var GrepTool = class extends BaseTool {
         nodir: true
       });
     } catch {
-      files = [path32.relative(searchPath, searchPath) || "."];
+      files = [path33.relative(searchPath, searchPath) || "."];
     }
     const results = [];
     let totalCount = 0;
     for (const rel of files) {
-      const abs = path32.join(searchPath, rel);
+      const abs = path33.join(searchPath, rel);
       let content;
       try {
-        content = await fs10.readFile(abs, "utf-8");
+        content = await fs11.readFile(abs, "utf-8");
       } catch {
         continue;
       }
@@ -14362,10 +15190,10 @@ var ToolRegistry = class extends EventEmitter {
   }
   isIgnored(filePath) {
     if (!filePath) return false;
-    const abs = path32.resolve(this.workspaceRoot, filePath);
-    const rel = path32.relative(this.workspaceRoot, abs);
-    if (!rel || rel.startsWith("..") || path32.isAbsolute(rel)) return true;
-    const posixRel = rel.split(path32.sep).join("/");
+    const abs = path33.resolve(this.workspaceRoot, filePath);
+    const rel = path33.relative(this.workspaceRoot, abs);
+    if (!rel || rel.startsWith("..") || path33.isAbsolute(rel)) return true;
+    const posixRel = rel.split(path33.sep).join("/");
     return this.ignoreMatcher.ignores(posixRel);
   }
 };
@@ -14599,22 +15427,22 @@ var FileMcpOAuthStore = class {
   filePath;
   load() {
     try {
-      return JSON.parse(fs29.readFileSync(this.filePath, "utf-8"));
+      return JSON.parse(fs30.readFileSync(this.filePath, "utf-8"));
     } catch {
       return void 0;
     }
   }
   save(state) {
-    fs29.mkdirSync(path32.dirname(this.filePath), { recursive: true, mode: 448 });
-    fs29.writeFileSync(this.filePath, JSON.stringify(state, null, 2), { mode: 384 });
+    fs30.mkdirSync(path33.dirname(this.filePath), { recursive: true, mode: 448 });
+    fs30.writeFileSync(this.filePath, JSON.stringify(state, null, 2), { mode: 384 });
     try {
-      fs29.chmodSync(this.filePath, 384);
+      fs30.chmodSync(this.filePath, 384);
     } catch {
     }
   }
   clear() {
     try {
-      fs29.rmSync(this.filePath);
+      fs30.rmSync(this.filePath);
     } catch {
     }
   }
@@ -15222,7 +16050,7 @@ var TaskAnalyzer = class {
 
 // src/core/router/model-performance-tracker.ts
 init_pricing();
-var DEFAULT_STATS_FILE = path32.join(os10.homedir(), ".cascade", "model-perf.json");
+var DEFAULT_STATS_FILE = path33.join(os10.homedir(), ".cascade", "model-perf.json");
 var ModelPerformanceTracker = class {
   stats = /* @__PURE__ */ new Map();
   featureStats = /* @__PURE__ */ new Map();
@@ -15242,7 +16070,7 @@ var ModelPerformanceTracker = class {
     if (this.loaded) return;
     this.loaded = true;
     try {
-      const raw = await fs10.readFile(this.statsFile, "utf-8");
+      const raw = await fs11.readFile(this.statsFile, "utf-8");
       const parsed = JSON.parse(raw);
       if (parsed.models) {
         for (const [key, stat] of Object.entries(parsed.models)) this.stats.set(key, stat);
@@ -15262,15 +16090,15 @@ var ModelPerformanceTracker = class {
   async save() {
     if (this.readOnly) return;
     try {
-      await fs10.mkdir(path32.dirname(this.statsFile), { recursive: true });
+      await fs11.mkdir(path33.dirname(this.statsFile), { recursive: true });
       const modelsObj = {};
       const featuresObj = {};
       for (const [key, stat] of this.stats) modelsObj[key] = stat;
       for (const [key, stat] of this.featureStats) featuresObj[key] = stat;
       const json = JSON.stringify({ models: modelsObj, features: featuresObj }, null, 2);
       const tmp = `${this.statsFile}.${process.pid}.${Date.now()}.tmp`;
-      await fs10.writeFile(tmp, json, "utf-8");
-      await fs10.rename(tmp, this.statsFile);
+      await fs11.writeFile(tmp, json, "utf-8");
+      await fs11.rename(tmp, this.statsFile);
     } catch {
     }
   }
@@ -15810,9 +16638,9 @@ 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 = path32.join(this.workspacePath, ".cascade", DYNAMIC_TOOLS_FILE);
+    const file = path33.join(this.workspacePath, ".cascade", DYNAMIC_TOOLS_FILE);
     try {
-      const raw = await fs10.readFile(file, "utf-8");
+      const raw = await fs11.readFile(file, "utf-8");
       const specs = JSON.parse(raw);
       if (!Array.isArray(specs)) return;
       let loaded = 0;
@@ -15834,11 +16662,11 @@ Required capability: ${description.slice(0, 300)}`;
   }
   async persist() {
     if (!this.workspacePath || !this.persistEnabled) return;
-    const dir = path32.join(this.workspacePath, ".cascade");
-    const file = path32.join(dir, DYNAMIC_TOOLS_FILE);
+    const dir = path33.join(this.workspacePath, ".cascade");
+    const file = path33.join(dir, DYNAMIC_TOOLS_FILE);
     try {
-      await fs10.mkdir(dir, { recursive: true });
-      await fs10.writeFile(file, JSON.stringify(Array.from(this.specs.values()), null, 2), "utf-8");
+      await fs11.mkdir(dir, { recursive: true });
+      await fs11.writeFile(file, JSON.stringify(Array.from(this.specs.values()), null, 2), "utf-8");
     } catch (err) {
       this.log(`[tool-creator] Failed to persist tools: ${err instanceof Error ? err.message : String(err)}`);
     }
@@ -15855,12 +16683,12 @@ var WorldStateDB = class {
   constructor(workspacePath, debugMode = false) {
     this.workspacePath = workspacePath;
     this.debugMode = debugMode;
-    const cascadeDir = path32.join(workspacePath, ".cascade");
-    if (!fs29.existsSync(cascadeDir)) {
-      fs29.mkdirSync(cascadeDir, { recursive: true });
+    const cascadeDir = path33.join(workspacePath, ".cascade");
+    if (!fs30.existsSync(cascadeDir)) {
+      fs30.mkdirSync(cascadeDir, { recursive: true });
     }
-    this.keyPath = path32.join(cascadeDir, "world_state.key");
-    this.dbPath = path32.join(cascadeDir, "world_state.db");
+    this.keyPath = path33.join(cascadeDir, "world_state.key");
+    this.dbPath = path33.join(cascadeDir, "world_state.db");
     this.initEncryptionKey();
     this.db = new Database2(this.dbPath);
     this.db.pragma("journal_mode = WAL");
@@ -15917,11 +16745,11 @@ var WorldStateDB = class {
     ).run(e, r, row.encrypted_value, row.source_worker, row.timestamp, validTo, change);
   }
   initEncryptionKey() {
-    if (fs29.existsSync(this.keyPath)) {
-      this.encryptionKey = fs29.readFileSync(this.keyPath);
+    if (fs30.existsSync(this.keyPath)) {
+      this.encryptionKey = fs30.readFileSync(this.keyPath);
     } else {
       this.encryptionKey = crypto.randomBytes(32);
-      fs29.writeFileSync(this.keyPath, this.encryptionKey);
+      fs30.writeFileSync(this.keyPath, this.encryptionKey);
     }
   }
   encrypt(text) {
@@ -16207,9 +17035,9 @@ var WorldStateDB = class {
   dumpDebugIfNeeded() {
     if (!this.debugMode) return;
     try {
-      const dumpPath = path32.join(os10.tmpdir(), "cascade_world_state_debug.json");
+      const dumpPath = path33.join(os10.tmpdir(), "cascade_world_state_debug.json");
       const entries = this.getAllEntries();
-      fs29.writeFileSync(dumpPath, JSON.stringify(entries, null, 2), "utf-8");
+      fs30.writeFileSync(dumpPath, JSON.stringify(entries, null, 2), "utf-8");
     } catch (err) {
       console.error("Failed to dump debug world state", err);
     }
@@ -16579,7 +17407,7 @@ var WorkspaceIndex = class {
   isIgnored;
   chunker;
   constructor(opts) {
-    this.root = path32.resolve(opts.root);
+    this.root = path33.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()));
@@ -16606,19 +17434,19 @@ var WorkspaceIndex = class {
     const walk = async (dir) => {
       let entries;
       try {
-        entries = await fs10.readdir(dir, { withFileTypes: true });
+        entries = await fs11.readdir(dir, { withFileTypes: true });
       } catch {
         return;
       }
       for (const entry of entries) {
-        const abs = path32.join(dir, entry.name);
+        const abs = path33.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 = path32.extname(entry.name).slice(1).toLowerCase();
+          const ext = path33.extname(entry.name).slice(1).toLowerCase();
           if (!this.extensions.has(ext) || this.isIgnored(abs)) continue;
-          out.push(path32.relative(this.root, abs));
+          out.push(path33.relative(this.root, abs));
         }
       }
     };
@@ -16648,10 +17476,10 @@ var WorkspaceIndex = class {
     const entries = [];
     for (const rel of rels) {
       try {
-        const abs = path32.join(this.root, rel);
-        const stat = await fs10.stat(abs);
+        const abs = path33.join(this.root, rel);
+        const stat = await fs11.stat(abs);
         if (stat.size > this.maxFileBytes) continue;
-        const buf = await fs10.readFile(abs);
+        const buf = await fs11.readFile(abs);
         if (buf.includes(0)) continue;
         entries.push({ path: rel, hash: hashContent(buf), text: buf.toString("utf8") });
       } catch {
@@ -17220,7 +18048,7 @@ var Cascade = class _Cascade extends EventEmitter {
     this.toolRegistry = new ToolRegistry(this.config.tools, workspacePath);
     try {
       this.router.setDeadModelStore(new DeadModelStore(
-        fileDeadModelPersistence(path32.join(workspacePath, ".cascade", "dead-models.json"))
+        fileDeadModelPersistence(path33.join(workspacePath, ".cascade", "dead-models.json"))
       ));
     } catch {
     }
@@ -17228,6 +18056,7 @@ var Cascade = class _Cascade extends EventEmitter {
       (this.config.providers ?? []).map((p) => p.type)
     );
     this.registerMediaTools(workspacePath);
+    this.registerDocumentTools(workspacePath);
     this.telemetry = config.telemetry?.enabled ? new Telemetry(config.telemetry, config.telemetry.distinctId ?? "anonymous") : noopTelemetry;
     this.worldStateDB = new WorldStateDB(this.workspacePath, this.config.workspace?.debugWorldState ?? false);
     this.router.setWorldStateDB(this.worldStateDB);
@@ -17307,8 +18136,8 @@ var Cascade = class _Cascade extends EventEmitter {
       this.emit("log", { level: "warn", message: "Code index enabled but no embeddings-capable provider is configured \u2014 skipping." });
       return;
     }
-    const dbPath = ci.dbPath || path32.join(this.workspacePath, ".cascade", "code-index.db");
-    fs29.mkdirSync(path32.dirname(dbPath), { recursive: true });
+    const dbPath = ci.dbPath || path33.join(this.workspacePath, ".cascade", "code-index.db");
+    fs30.mkdirSync(path33.dirname(dbPath), { recursive: true });
     const db = new Database2(dbPath);
     db.pragma("journal_mode = WAL");
     const complete = chatCompleterFromProviders(this.config.providers);
@@ -17648,6 +18477,35 @@ ${input}` }],
       this.toolRegistry.register(tool);
     }
   }
+  /**
+   * Register `generate_document` where there is a real workspace to write into.
+   *
+   * A `.docx`/`.pptx`/`.xlsx` is a ZIP of OOXML parts, so `file_write` — which
+   * does exactly what it says and writes the model's text verbatim — produced
+   * files Word/Excel/PowerPoint correctly reported as corrupted. This tool owns
+   * the conversion (see tools/generate-document.ts for why it isn't folded into
+   * file_write).
+   *
+   * Registered OUTSIDE `enabledTools` for the same reason the media tools are:
+   * that allowlist is a blast-radius control for tools that reach the machine
+   * or the network, and this one only writes the artifact the user asked for,
+   * into the workspace the run already owns. `disabledTools` still removes it.
+   * A host with no filesystem (the cloud) has its own browser-side exporter and
+   * simply never reaches this path — `buildDocumentTools` returns nothing
+   * without a file reader, mirroring `transcribe_audio`.
+   */
+  registerDocumentTools(workspacePath) {
+    const denied = new Set(this.config.tools?.disabledTools ?? []);
+    const tools = buildDocumentTools(async (p) => {
+      const fsp = await import('fs/promises');
+      return new Uint8Array(await fsp.readFile(p));
+    });
+    for (const tool of tools) {
+      if (denied.has(tool.name)) continue;
+      tool.setWorkspaceRoot(workspacePath);
+      this.toolRegistry.register(tool);
+    }
+  }
   /**
    * Supply per-model thumbs-up/down counts so Auto routing can weigh how models
    * have actually performed for this user, on top of public benchmarks.
@@ -18560,14 +19418,14 @@ ${finalOutput}` : ""
 init_constants();
 var CLOUD_SESSION_FILE = "cloud-session.json";
 function globalDir(homeDir = os10.homedir()) {
-  return path32.join(homeDir, GLOBAL_CONFIG_DIR);
+  return path33.join(homeDir, GLOBAL_CONFIG_DIR);
 }
 function cloudSessionPath(dir = globalDir()) {
-  return path32.join(dir, CLOUD_SESSION_FILE);
+  return path33.join(dir, CLOUD_SESSION_FILE);
 }
 function loadCloudSession(dir = globalDir()) {
   try {
-    const raw = fs29.readFileSync(cloudSessionPath(dir), "utf-8");
+    const raw = fs30.readFileSync(cloudSessionPath(dir), "utf-8");
     const parsed = JSON.parse(raw);
     if (!parsed?.refreshToken || !parsed?.serverUrl) return null;
     return parsed;
@@ -18576,17 +19434,17 @@ function loadCloudSession(dir = globalDir()) {
   }
 }
 function saveCloudSession(session, dir = globalDir()) {
-  fs29.mkdirSync(dir, { recursive: true, mode: 448 });
+  fs30.mkdirSync(dir, { recursive: true, mode: 448 });
   const file = cloudSessionPath(dir);
-  fs29.writeFileSync(file, JSON.stringify(session, null, 2), { mode: 384 });
+  fs30.writeFileSync(file, JSON.stringify(session, null, 2), { mode: 384 });
   try {
-    fs29.chmodSync(file, 384);
+    fs30.chmodSync(file, 384);
   } catch {
   }
 }
 function clearCloudSession(dir = globalDir()) {
   try {
-    fs29.rmSync(cloudSessionPath(dir));
+    fs30.rmSync(cloudSessionPath(dir));
   } catch {
   }
 }
@@ -18758,16 +19616,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(path37, init = {}) {
-    const call = (token) => fetch(this.url(path37), { ...init, headers: { ...init.headers ?? {}, Authorization: `Bearer ${token}` } });
+  async authed(path38, init = {}) {
+    const call = (token) => fetch(this.url(path38), { ...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(path37) {
-    return this.authed(path37);
+  authedGet(path38) {
+    return this.authed(path38);
   }
   async fetchMe(token) {
     const res = await fetch(this.url("/api/me"), { headers: { Authorization: `Bearer ${token}` } });
@@ -20542,10 +21400,10 @@ function Repl({ config, workspacePath, themeName, initialPrompt, identityName, a
       }
     } catch {
     }
-    const configPath = path32.join(workspacePath, ".cascade", "config.json");
+    const configPath = path33.join(workspacePath, ".cascade", "config.json");
     try {
-      await fs10.mkdir(path32.dirname(configPath), { recursive: true });
-      await fs10.writeFile(configPath, JSON.stringify(config, null, 2), "utf-8");
+      await fs11.mkdir(path33.dirname(configPath), { recursive: true });
+      await fs11.writeFile(configPath, JSON.stringify(config, null, 2), "utf-8");
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
       dispatch({
@@ -20596,9 +21454,9 @@ function Repl({ config, workspacePath, themeName, initialPrompt, identityName, a
       if (msg.includes("non-text parts")) return;
       originalLog(...args);
     };
-    const store = new MemoryStore(path32.join(workspacePath, CASCADE_DB_FILE));
+    const store = new MemoryStore(path33.join(workspacePath, CASCADE_DB_FILE));
     storeRef.current = store;
-    globalStoreRef.current = new MemoryStore(path32.join(os10.homedir(), GLOBAL_CONFIG_DIR, GLOBAL_RUNTIME_DB_FILE));
+    globalStoreRef.current = new MemoryStore(path33.join(os10.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;
@@ -20666,14 +21524,14 @@ 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 = path32.join(workspacePath, `cascade-export-${stamp2}.${fmt === "json" ? "json" : "md"}`);
+        const exportPath = path33.join(workspacePath, `cascade-export-${stamp2}.${fmt === "json" ? "json" : "md"}`);
         if (fmt === "json") {
-          await fs10.writeFile(exportPath, JSON.stringify({ sessionId: sessionIdRef.current, messages: state.messages }, null, 2), "utf-8");
+          await fs11.writeFile(exportPath, JSON.stringify({ sessionId: sessionIdRef.current, messages: state.messages }, null, 2), "utf-8");
         } else {
           const markdown = state.messages.map((msg) => `## ${msg.role.toUpperCase()} \u2014 ${msg.timestamp}
 
 ${msg.content}`).join("\n\n");
-          await fs10.writeFile(exportPath, markdown, "utf-8");
+          await fs11.writeFile(exportPath, markdown, "utf-8");
         }
       },
       onRollback: async () => {
@@ -20683,7 +21541,7 @@ ${msg.content}`).join("\n\n");
         if (!snapshots.length) return "No file snapshots found for this session.";
         for (const { filePath, content } of snapshots) {
           try {
-            await fs10.writeFile(filePath, content, "utf-8");
+            await fs11.writeFile(filePath, content, "utf-8");
           } catch (err) {
             console.error(`Restore failed: ${filePath}`, err);
           }
@@ -21564,9 +22422,9 @@ function stringifySlashOutput(val) {
 }
 async function searchSessionsAndMessages(query, workspacePath) {
   if (!query) return "Usage: /search <query>";
-  const dbPath = path32.join(workspacePath, CASCADE_DB_FILE);
+  const dbPath = path33.join(workspacePath, CASCADE_DB_FILE);
   try {
-    await fs10.access(dbPath);
+    await fs11.access(dbPath);
   } catch {
     return "No database found. Start a conversation first.";
   }
@@ -21598,7 +22456,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(path32.join(workspacePath, CASCADE_DB_FILE));
+  const store = new MemoryStore(path33.join(workspacePath, CASCADE_DB_FILE));
   try {
     const sessions2 = store.listSessions(void 0, 3);
     return [
@@ -21617,7 +22475,7 @@ async function diagnoseRuntime(config, workspacePath) {
 }
 async function showRecentLogs(args, workspacePath) {
   const limit = Number.parseInt(args[0] ?? "10", 10) || 10;
-  const store = new MemoryStore(path32.join(workspacePath, CASCADE_DB_FILE));
+  const store = new MemoryStore(path33.join(workspacePath, CASCADE_DB_FILE));
   try {
     const logs = store.listRuntimeNodeLogs(void 0, void 0, limit);
     if (!logs.length) return "No recent runtime logs.";
@@ -21629,7 +22487,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(path32.join(workspacePath, CASCADE_DB_FILE));
+  const store = new MemoryStore(path33.join(workspacePath, CASCADE_DB_FILE));
   try {
     const session = store.getSession(sessionId);
     if (!session) return `Session not found: ${sessionId}`;
@@ -22057,10 +22915,10 @@ function SetupWizard({ workspacePath, onComplete }) {
           ...anyAuto ? { cascadeAuto: true } : {}
         };
         const config = CascadeConfigSchema.parse(rawConfig);
-        const configDir = path32.join(workspacePath, ".cascade");
-        await fs10.mkdir(configDir, { recursive: true });
-        const configPath = path32.join(workspacePath, CASCADE_CONFIG_FILE);
-        await fs10.writeFile(configPath, JSON.stringify(config, null, 2), "utf-8");
+        const configDir = path33.join(workspacePath, ".cascade");
+        await fs11.mkdir(configDir, { recursive: true });
+        const configPath = path33.join(workspacePath, CASCADE_CONFIG_FILE);
+        await fs11.writeFile(configPath, JSON.stringify(config, null, 2), "utf-8");
         savedConfigRef.current = config;
         dispatchRef.current({ type: "GO_DONE" });
       } catch (err) {
@@ -22401,14 +23259,14 @@ function printTelemetryBanner() {
 async function initCommand(workspacePath = process.cwd()) {
   const spin = ora({ text: "Initializing Cascade project\u2026", color: "magenta" }).start();
   try {
-    const configDir = path32.join(workspacePath, ".cascade");
-    await fs10.mkdir(configDir, { recursive: true });
-    const mdPath = path32.join(workspacePath, "CASCADE.md");
+    const configDir = path33.join(workspacePath, ".cascade");
+    await fs11.mkdir(configDir, { recursive: true });
+    const mdPath = path33.join(workspacePath, "CASCADE.md");
     if (!await fileExists(mdPath)) {
       await createDefaultCascadeMd(workspacePath);
       spin.succeed(chalk7.green("Created CASCADE.md"));
     }
-    const ignorePath = path32.join(workspacePath, ".cascadeignore");
+    const ignorePath = path33.join(workspacePath, ".cascadeignore");
     if (!await fileExists(ignorePath)) {
       await createDefaultIgnoreFile(workspacePath);
       spin.succeed(chalk7.green("Created .cascadeignore"));
@@ -22417,7 +23275,7 @@ async function initCommand(workspacePath = process.cwd()) {
     console.log();
     console.log(chalk7.magenta("  \u25C8 Cascade AI \u2014 Project initialized"));
     console.log();
-    const configPath = path32.join(workspacePath, CASCADE_CONFIG_FILE);
+    const configPath = path33.join(workspacePath, CASCADE_CONFIG_FILE);
     if (await fileExists(configPath)) {
       console.log(chalk7.yellow("  .cascade/config.json already exists \u2014 launching wizard to reconfigure."));
       console.log();
@@ -22436,7 +23294,7 @@ async function initCommand(workspacePath = process.cwd()) {
 }
 async function fileExists(p) {
   try {
-    await fs10.access(p);
+    await fs11.access(p);
     return true;
   } catch {
     return false;
@@ -22448,7 +23306,7 @@ init_constants();
 var TOS_WARNING = "Reusing this subscription token outside its own CLI may violate the vendor\u2019s terms of service.";
 async function readJson(file) {
   try {
-    const raw = await fs10.readFile(file, "utf-8");
+    const raw = await fs11.readFile(file, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -22475,7 +23333,7 @@ function fromEnv(env) {
   return out;
 }
 async function fromClaudeCode(home) {
-  const file = path32.join(home, ".claude", ".credentials.json");
+  const file = path33.join(home, ".claude", ".credentials.json");
   const data = await readJson(file);
   if (!data) return [];
   const oauth = data["claudeAiOauth"];
@@ -22498,7 +23356,7 @@ async function fromClaudeCode(home) {
   return [];
 }
 async function fromCodex(home) {
-  const file = path32.join(home, ".codex", "auth.json");
+  const file = path33.join(home, ".codex", "auth.json");
   const data = await readJson(file);
   if (!data) return [];
   const apiKey = str(data["OPENAI_API_KEY"]);
@@ -22521,7 +23379,7 @@ async function fromCodex(home) {
   return [];
 }
 async function fromGemini(home) {
-  const file = path32.join(home, ".gemini", "oauth_creds.json");
+  const file = path33.join(home, ".gemini", "oauth_creds.json");
   const data = await readJson(file);
   const accessToken = str(data?.["access_token"]);
   if (!accessToken) return [];
@@ -22537,7 +23395,7 @@ async function fromGemini(home) {
 }
 async function fromCopilot(home) {
   for (const name of ["apps.json", "hosts.json"]) {
-    const file = path32.join(home, ".config", "github-copilot", name);
+    const file = path33.join(home, ".config", "github-copilot", name);
     const data = await readJson(file);
     if (!data) continue;
     for (const value of Object.values(data)) {
@@ -22591,7 +23449,7 @@ async function doctorCommand() {
   checks.push({
     label: "Cascade config",
     ok: true,
-    detail: `Loaded ${path32.join(process.cwd(), CASCADE_CONFIG_FILE)}`
+    detail: `Loaded ${path33.join(process.cwd(), CASCADE_CONFIG_FILE)}`
   });
   const providers = [
     { type: "anthropic", name: "Anthropic" },
@@ -22702,7 +23560,7 @@ async function checkEndpoint(url) {
   }
 }
 async function indexCommand(dirPath) {
-  const workspace = path32.resolve(dirPath || process.cwd());
+  const workspace = path33.resolve(dirPath || process.cwd());
   const cm = new ConfigManager(workspace);
   await cm.load();
   const config = cm.getConfig();
@@ -22713,8 +23571,8 @@ async function indexCommand(dirPath) {
     process.exitCode = 1;
     return;
   }
-  const dbPath = config.codeIndex?.dbPath || path32.join(workspace, ".cascade", "code-index.db");
-  fs29.mkdirSync(path32.dirname(dbPath), { recursive: true });
+  const dbPath = config.codeIndex?.dbPath || path33.join(workspace, ".cascade", "code-index.db");
+  fs30.mkdirSync(path33.dirname(dbPath), { recursive: true });
   const db = new Database2(dbPath);
   db.pragma("journal_mode = WAL");
   const complete = chatCompleterFromProviders(config.providers);
@@ -23203,7 +24061,7 @@ function openBrowser2(url) {
 }
 function storePathFor(name) {
   const safe = name.replace(/[^a-z0-9._-]/gi, "_").slice(0, 64) || "server";
-  return path32.join(os10.homedir(), ".cascade-ai", "mcp-oauth", `${safe}.json`);
+  return path33.join(os10.homedir(), ".cascade-ai", "mcp-oauth", `${safe}.json`);
 }
 function defaultName(url) {
   try {
@@ -23705,7 +24563,7 @@ function aggregateCostStats(sessions2, opts = {}) {
 }
 
 // src/dashboard/server.ts
-var __dirname$1 = path32.dirname(fileURLToPath(import.meta.url));
+var __dirname$1 = path33.dirname(fileURLToPath(import.meta.url));
 var ORPHANED_ESCALATION_GRACE_MS = 3e4;
 var DashboardServer = class {
   app;
@@ -23985,14 +24843,14 @@ var DashboardServer = class {
    */
   persistConfig() {
     try {
-      const configPath = path32.join(this.workspacePath, CASCADE_CONFIG_FILE);
-      fs29.mkdirSync(path32.dirname(configPath), { recursive: true });
-      fs29.writeFileSync(configPath, JSON.stringify(this.config, null, 2), "utf-8");
+      const configPath = path33.join(this.workspacePath, CASCADE_CONFIG_FILE);
+      fs30.mkdirSync(path33.dirname(configPath), { recursive: true });
+      fs30.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(path32.join(os10.homedir(), GLOBAL_CONFIG_DIR), this.config.providers ?? []);
+      saveGlobalCredentials(path33.join(os10.homedir(), GLOBAL_CONFIG_DIR), this.config.providers ?? []);
     } catch (err) {
       console.warn(`[dashboard] Failed to sync global credentials: ${err instanceof Error ? err.message : String(err)}`);
     }
@@ -24007,15 +24865,15 @@ var DashboardServer = class {
   resolveDashboardSecret() {
     const fromConfig = this.config.dashboard.secret ?? process.env["CASCADE_DASHBOARD_SECRET"];
     if (fromConfig) return fromConfig;
-    const secretPath = path32.join(this.workspacePath, CASCADE_DASHBOARD_SECRET_FILE);
+    const secretPath = path33.join(this.workspacePath, CASCADE_DASHBOARD_SECRET_FILE);
     try {
-      if (fs29.existsSync(secretPath)) {
-        const existing = fs29.readFileSync(secretPath, "utf-8").trim();
+      if (fs30.existsSync(secretPath)) {
+        const existing = fs30.readFileSync(secretPath, "utf-8").trim();
         if (existing.length >= 16) return existing;
       }
       const generated = randomUUID();
-      fs29.mkdirSync(path32.dirname(secretPath), { recursive: true });
-      fs29.writeFileSync(secretPath, generated, { encoding: "utf-8", mode: 384 });
+      fs30.mkdirSync(path33.dirname(secretPath), { recursive: true });
+      fs30.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.`
@@ -24042,7 +24900,7 @@ var DashboardServer = class {
   // ── Setup ─────────────────────────────────────
   getGlobalStore() {
     if (!this.globalStore) {
-      const globalDbPath = path32.join(os10.homedir(), GLOBAL_CONFIG_DIR, GLOBAL_RUNTIME_DB_FILE);
+      const globalDbPath = path33.join(os10.homedir(), GLOBAL_CONFIG_DIR, GLOBAL_RUNTIME_DB_FILE);
       this.globalStore = new MemoryStore(globalDbPath);
     }
     return this.globalStore;
@@ -24422,12 +25280,12 @@ ${prompt}`;
     }
   }
   watchRuntimeChanges() {
-    const workspaceDbPath = path32.join(this.workspacePath, CASCADE_DB_FILE);
-    const globalDbPath = path32.join(os10.homedir(), GLOBAL_CONFIG_DIR, GLOBAL_RUNTIME_DB_FILE);
+    const workspaceDbPath = path33.join(this.workspacePath, CASCADE_DB_FILE);
+    const globalDbPath = path33.join(os10.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 (!fs29.existsSync(watchPath)) continue;
-      fs29.watchFile(watchPath, { interval: 3e3 }, () => {
+      if (!fs30.existsSync(watchPath)) continue;
+      fs30.watchFile(watchPath, { interval: 3e3 }, () => {
         this.throttledBroadcast(watchPath === globalDbPath ? "global" : "workspace");
       });
     }
@@ -24549,7 +25407,7 @@ ${prompt}`;
       const sessionId = req.params.id;
       this.store.deleteSession(sessionId);
       this.store.deleteRuntimeSession(sessionId);
-      const globalDbPath = path32.join(os10.homedir(), GLOBAL_CONFIG_DIR, GLOBAL_RUNTIME_DB_FILE);
+      const globalDbPath = path33.join(os10.homedir(), GLOBAL_CONFIG_DIR, GLOBAL_RUNTIME_DB_FILE);
       const globalStore = new MemoryStore(globalDbPath);
       try {
         globalStore.deleteRuntimeSession(sessionId);
@@ -24642,7 +25500,7 @@ ${prompt}`;
     });
     this.app.delete("/api/sessions", auth2, (req, res) => {
       const body = req.body;
-      const globalDbPath = path32.join(os10.homedir(), GLOBAL_CONFIG_DIR, GLOBAL_RUNTIME_DB_FILE);
+      const globalDbPath = path33.join(os10.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 {
@@ -24665,7 +25523,7 @@ ${prompt}`;
     });
     this.app.delete("/api/runtime", auth2, (_req, res) => {
       this.store.deleteAllRuntimeNodes();
-      const globalDbPath = path32.join(os10.homedir(), GLOBAL_CONFIG_DIR, GLOBAL_RUNTIME_DB_FILE);
+      const globalDbPath = path33.join(os10.homedir(), GLOBAL_CONFIG_DIR, GLOBAL_RUNTIME_DB_FILE);
       const globalStore = new MemoryStore(globalDbPath);
       try {
         globalStore.deleteAllRuntimeNodes();
@@ -24751,12 +25609,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 = path32.join(this.workspacePath, CASCADE_CONFIG_FILE);
-        const existing = fs29.existsSync(configPath) ? JSON.parse(fs29.readFileSync(configPath, "utf-8")) : {};
+        const configPath = path33.join(this.workspacePath, CASCADE_CONFIG_FILE);
+        const existing = fs30.existsSync(configPath) ? JSON.parse(fs30.readFileSync(configPath, "utf-8")) : {};
         const updated = { ...existing, tierLimits: this.config.tierLimits, budget: this.config.budget };
         const tmp = configPath + ".tmp";
-        fs29.writeFileSync(tmp, JSON.stringify(updated, null, 2), "utf-8");
-        fs29.renameSync(tmp, configPath);
+        fs30.writeFileSync(tmp, JSON.stringify(updated, null, 2), "utf-8");
+        fs30.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)}` });
@@ -24784,7 +25642,7 @@ ${prompt}`;
     this.app.get("/api/runtime", auth2, (req, res) => {
       const scope = req.query["scope"] ?? "workspace";
       if (scope === "global") {
-        const globalDbPath = path32.join(os10.homedir(), GLOBAL_CONFIG_DIR, GLOBAL_RUNTIME_DB_FILE);
+        const globalDbPath = path33.join(os10.homedir(), GLOBAL_CONFIG_DIR, GLOBAL_RUNTIME_DB_FILE);
         const globalStore = new MemoryStore(globalDbPath);
         try {
           res.json({
@@ -25125,13 +25983,13 @@ ${prompt}`;
         res.status(500).json({ error: err instanceof Error ? err.message : String(err) });
       }
     });
-    const prodPath = path32.resolve(__dirname$1, "../web/dist");
-    const devPath = path32.resolve(__dirname$1, "../../web/dist");
-    const webDistPath = fs29.existsSync(prodPath) ? prodPath : devPath;
-    if (fs29.existsSync(webDistPath)) {
+    const prodPath = path33.resolve(__dirname$1, "../web/dist");
+    const devPath = path33.resolve(__dirname$1, "../../web/dist");
+    const webDistPath = fs30.existsSync(prodPath) ? prodPath : devPath;
+    if (fs30.existsSync(webDistPath)) {
       this.app.use(express.static(webDistPath));
       this.app.get("*", (_req, res) => {
-        res.sendFile(path32.join(webDistPath, "index.html"));
+        res.sendFile(path33.join(webDistPath, "index.html"));
       });
     } else {
       this.app.get("/", (_req, res) => {
@@ -25152,7 +26010,7 @@ init_constants();
 async function dashboardCommand(config, workspacePath = process.cwd()) {
   const port = config.dashboard.port ?? DEFAULT_DASHBOARD_PORT;
   const spin = ora({ text: `Starting dashboard on port ${port}\u2026`, color: "magenta" }).start();
-  const store = new MemoryStore(path32.join(workspacePath, CASCADE_DB_FILE));
+  const store = new MemoryStore(path33.join(workspacePath, CASCADE_DB_FILE));
   const server = new DashboardServer(config, store, workspacePath);
   server.watchRuntimeChanges();
   const gThis = globalThis;
@@ -25184,7 +26042,7 @@ init_constants();
 function makeIdentityCommand(workspacePath = process.cwd()) {
   const identity = new Command("identity").alias("id").description("Manage Cascade identities");
   identity.command("list").description("List all available identities").action(() => {
-    const store = new MemoryStore(path32.join(workspacePath, CASCADE_DB_FILE));
+    const store = new MemoryStore(path33.join(workspacePath, CASCADE_DB_FILE));
     try {
       const identities = store.listIdentities();
       console.log(chalk7.bold("\n  Identities:"));
@@ -25204,7 +26062,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(path32.join(workspacePath, CASCADE_DB_FILE));
+    const store = new MemoryStore(path33.join(workspacePath, CASCADE_DB_FILE));
     try {
       if (options.default) {
         const existingDefault = store.getDefaultIdentity();
@@ -25230,7 +26088,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(path32.join(workspacePath, CASCADE_DB_FILE));
+    const store = new MemoryStore(path33.join(workspacePath, CASCADE_DB_FILE));
     try {
       const identities = store.listIdentities();
       const match = identities.find((i) => i.id === query || i.name.toLowerCase() === query.toLowerCase());
@@ -25379,11 +26237,11 @@ async function exportCommand(options = {}) {
   let store;
   try {
     const workspacePath = options.workspacePath ?? process.cwd();
-    const workspaceDbPath = path32.join(workspacePath, CASCADE_DB_FILE);
-    const globalDbPath = path32.join(os10.homedir(), GLOBAL_CONFIG_DIR, GLOBAL_DB_FILE);
+    const workspaceDbPath = path33.join(workspacePath, CASCADE_DB_FILE);
+    const globalDbPath = path33.join(os10.homedir(), GLOBAL_CONFIG_DIR, GLOBAL_DB_FILE);
     let dbPath = globalDbPath;
     try {
-      await fs10.access(workspaceDbPath);
+      await fs11.access(workspaceDbPath);
       dbPath = workspaceDbPath;
     } catch {
     }
@@ -25422,8 +26280,8 @@ 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 ? path32.resolve(options.output) : path32.join(process.cwd(), defaultFile);
-    await fs10.writeFile(outPath, content, "utf-8");
+    const outPath = options.output ? path33.resolve(options.output) : path33.join(process.cwd(), defaultFile);
+    await fs11.writeFile(outPath, content, "utf-8");
     spin.succeed(chalk7.green(`Exported to ${chalk7.white(outPath)}`));
     const messageCount = Array.isArray(session.messages) ? session.messages.length : 0;
     console.log();
@@ -25650,11 +26508,11 @@ async function statsCommand() {
 dotenv.config();
 function warnIfBuildIsStale() {
   try {
-    const here = path32.dirname(fileURLToPath(import.meta.url));
+    const here = path33.dirname(fileURLToPath(import.meta.url));
     for (const rel of ["..", "../.."]) {
-      const pkgPath = path32.join(here, rel, "package.json");
-      if (!fs29.existsSync(pkgPath)) continue;
-      const pkg = JSON.parse(fs29.readFileSync(pkgPath, "utf-8"));
+      const pkgPath = path33.join(here, rel, "package.json");
+      if (!fs30.existsSync(pkgPath)) continue;
+      const pkg = JSON.parse(fs30.readFileSync(pkgPath, "utf-8"));
       if (pkg.name !== "cascade-ai") continue;
       if (pkg.version && pkg.version !== CASCADE_VERSION) {
         console.error(