cascade-ai 0.12.23 → 0.13.1

package/dist/cli.js

@@ -6,20 +6,20 @@ import http, { createServer } from 'http';
 import https from 'https';
 import zlib from 'zlib';
 import { Readable } from 'stream';
+import Database2 from 'better-sqlite3';
+import path25 from 'path';
+import fs23 from 'fs';
+import os8 from 'os';
+import crypto, { randomUUID, timingSafeEqual } from 'crypto';
 import { render, Box, Text, useStdout, useApp, useInput, Static } from 'ink';
 import { Command } from 'commander';
 import React2, { useState, useReducer, useRef, useCallback, useEffect, useMemo } from 'react';
 import chalk9 from 'chalk';
 import dotenv from 'dotenv';
-import fs21 from 'fs';
-import path23 from 'path';
 import { fileURLToPath } from 'url';
 import fs9 from 'fs/promises';
-import os6 from 'os';
-import crypto, { randomUUID, timingSafeEqual } from 'crypto';
 import * as _ignoreModule from 'ignore';
 import _ignoreModule__default from 'ignore';
-import Database from 'better-sqlite3';
 import { z } from 'zod';
 import { exec, execFile, execSync, spawnSync } from 'child_process';
 import { jsxs, jsx, Fragment } from 'react/jsx-runtime';
@@ -58,7 +58,7 @@ var __export = (target, all) => {
 var CASCADE_VERSION, CASCADE_CONFIG_FILE, CASCADE_DB_FILE, CASCADE_DASHBOARD_SECRET_FILE, GLOBAL_CONFIG_DIR, GLOBAL_DB_FILE, GLOBAL_KEYSTORE_FILE, GLOBAL_RUNTIME_DB_FILE, DEFAULT_DASHBOARD_PORT, DEFAULT_CONTEXT_LIMIT, DEFAULT_AUTO_SUMMARIZE_AT, MODELS, T1_MODEL_PRIORITY, T2_MODEL_PRIORITY, T3_MODEL_PRIORITY, VISION_MODEL_PRIORITY, COMPLEXITY_T2_COUNT, THEME_NAMES, DEFAULT_THEME, OLLAMA_BASE_URL, LM_STUDIO_BASE_URL, AZURE_BASE_URL_TEMPLATE, TOOL_NAMES, DEFAULT_APPROVAL_REQUIRED;
 var init_constants = __esm({
   "src/constants.ts"() {
-    CASCADE_VERSION = "0.12.23";
+    CASCADE_VERSION = "0.13.1";
     CASCADE_CONFIG_FILE = ".cascade/config.json";
     CASCADE_DB_FILE = ".cascade/memory.db";
     CASCADE_DASHBOARD_SECRET_FILE = ".cascade/dashboard-secret";
@@ -1525,6 +1525,149 @@ var init_openai_compatible = __esm({
   }
 });
 
+// src/core/audit/audit-logger.ts
+var audit_logger_exports = {};
+__export(audit_logger_exports, {
+  AuditLogger: () => AuditLogger2
+});
+var AuditLogger2;
+var init_audit_logger = __esm({
+  "src/core/audit/audit-logger.ts"() {
+    AuditLogger2 = class {
+      constructor(workspacePath, debugMode = false) {
+        this.workspacePath = workspacePath;
+        this.debugMode = debugMode;
+        const cascadeDir = path25.join(workspacePath, ".cascade");
+        if (!fs23.existsSync(cascadeDir)) {
+          fs23.mkdirSync(cascadeDir, { recursive: true });
+        }
+        this.keyPath = path25.join(cascadeDir, "audit_log.key");
+        this.dbPath = path25.join(cascadeDir, "audit_log.db");
+        this.initEncryptionKey();
+        this.db = new Database2(this.dbPath);
+        this.db.pragma("journal_mode = WAL");
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS audit_logs (
+        id TEXT PRIMARY KEY,
+        timestamp TEXT NOT NULL,
+        event_type TEXT NOT NULL,
+        tier_id TEXT NOT NULL,
+        encrypted_payload TEXT NOT NULL,
+        prev_hash TEXT NOT NULL DEFAULT '',
+        hash TEXT NOT NULL DEFAULT ''
+      )
+    `);
+        const cols = this.db.pragma("table_info(audit_logs)").map((c) => c.name);
+        if (!cols.includes("prev_hash")) this.db.exec(`ALTER TABLE audit_logs ADD COLUMN prev_hash TEXT NOT NULL DEFAULT ''`);
+        if (!cols.includes("hash")) this.db.exec(`ALTER TABLE audit_logs ADD COLUMN hash TEXT NOT NULL DEFAULT ''`);
+      }
+      workspacePath;
+      debugMode;
+      db;
+      keyPath;
+      dbPath;
+      encryptionKey;
+      /** SHA-256 link over everything that identifies an entry, chained to the previous entry's hash. */
+      chainHash(prevHash, timestamp, eventType, tierId, encryptedPayload) {
+        return crypto.createHash("sha256").update(`${prevHash}|${timestamp}|${eventType}|${tierId}|${encryptedPayload}`).digest("hex");
+      }
+      initEncryptionKey() {
+        if (fs23.existsSync(this.keyPath)) {
+          this.encryptionKey = fs23.readFileSync(this.keyPath);
+        } else {
+          this.encryptionKey = crypto.randomBytes(32);
+          fs23.writeFileSync(this.keyPath, this.encryptionKey);
+        }
+      }
+      encrypt(text) {
+        const iv = crypto.randomBytes(16);
+        const cipher = crypto.createCipheriv("aes-256-gcm", this.encryptionKey, iv);
+        let encrypted = cipher.update(text, "utf8", "hex");
+        encrypted += cipher.final("hex");
+        const authTag = cipher.getAuthTag().toString("hex");
+        return `${iv.toString("hex")}:${authTag}:${encrypted}`;
+      }
+      decrypt(text) {
+        const parts = text.split(":");
+        if (parts.length !== 3) throw new Error("Invalid encrypted payload format");
+        const [ivHex, authTagHex, encryptedHex] = parts;
+        const iv = Buffer.from(ivHex, "hex");
+        const authTag = Buffer.from(authTagHex, "hex");
+        const decipher = crypto.createDecipheriv("aes-256-gcm", this.encryptionKey, iv);
+        decipher.setAuthTag(authTag);
+        let decrypted = decipher.update(encryptedHex, "hex", "utf8");
+        decrypted += decipher.final("utf8");
+        return decrypted;
+      }
+      logEvent(eventType, tierId, payloadObj) {
+        const id = crypto.randomUUID();
+        const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+        const payload = JSON.stringify(payloadObj);
+        const encryptedPayload = this.encrypt(payload);
+        const last = this.db.prepare("SELECT hash FROM audit_logs ORDER BY rowid DESC LIMIT 1").get();
+        const prevHash = last?.hash ?? "";
+        const hash = this.chainHash(prevHash, timestamp, eventType, tierId, encryptedPayload);
+        const stmt = this.db.prepare("INSERT INTO audit_logs (id, timestamp, event_type, tier_id, encrypted_payload, prev_hash, hash) VALUES (?, ?, ?, ?, ?, ?, ?)");
+        stmt.run(id, timestamp, eventType, tierId, encryptedPayload, prevHash, hash);
+        this.dumpDebugIfNeeded();
+        return id;
+      }
+      /**
+       * Recompute the whole hash chain in insertion (rowid) order. Any edited,
+       * removed, or reordered row makes every later hash mismatch. Rows written
+       * before the chain existed (empty hash) fail verification too — integrity
+       * can only be claimed for chained history.
+       */
+      verifyChain() {
+        const rows = this.db.prepare(
+          "SELECT rowid, timestamp, event_type, tier_id, encrypted_payload, prev_hash, hash FROM audit_logs ORDER BY rowid ASC"
+        ).all();
+        let prevHash = "";
+        for (const row of rows) {
+          const expected = this.chainHash(prevHash, row.timestamp, row.event_type, row.tier_id, row.encrypted_payload);
+          if (row.prev_hash !== prevHash || row.hash !== expected) {
+            return { ok: false, entries: rows.length, firstBadRow: row.rowid };
+          }
+          prevHash = row.hash;
+        }
+        return { ok: true, entries: rows.length };
+      }
+      getAllLogs() {
+        const stmt = this.db.prepare("SELECT id, timestamp, event_type, tier_id, encrypted_payload FROM audit_logs ORDER BY timestamp ASC");
+        const rows = stmt.all();
+        return rows.map((row) => {
+          let payload = "";
+          try {
+            payload = this.decrypt(row.encrypted_payload);
+          } catch (err) {
+            payload = '{"error":"[Decryption Failed - Payload Corrupted]"}';
+          }
+          return {
+            id: row.id,
+            timestamp: row.timestamp,
+            eventType: row.event_type,
+            tierId: row.tier_id,
+            payload
+          };
+        });
+      }
+      dumpDebugIfNeeded() {
+        if (!this.debugMode) return;
+        try {
+          const dumpPath = path25.join(os8.tmpdir(), "cascade_audit_logs_debug.json");
+          const entries = this.getAllLogs();
+          fs23.writeFileSync(dumpPath, JSON.stringify(entries, null, 2), "utf-8");
+        } catch (err) {
+          console.error("Failed to dump debug audit logs", err);
+        }
+      }
+      close() {
+        this.db.close();
+      }
+    };
+  }
+});
+
 // src/cli/index.ts
 init_constants();
 var ALGORITHM = "aes-256-gcm";
@@ -1568,7 +1711,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 && fs21.existsSync(this.storePath)) {
+      if (password && fs23.existsSync(this.storePath)) {
         try {
           const fileEntries = this.decryptFile(password);
           for (const [k, v] of Object.entries(fileEntries)) {
@@ -1587,7 +1730,7 @@ var Keystore = class {
         "Keystore unlock requires a password because the OS keychain (keytar) is not available on this system."
       );
     }
-    if (!fs21.existsSync(this.storePath)) {
+    if (!fs23.existsSync(this.storePath)) {
       const salt = crypto.randomBytes(SALT_LEN);
       this.masterKey = this.deriveKey(password, salt);
       this.writeWithSalt({}, salt);
@@ -1601,7 +1744,7 @@ var Keystore = class {
   }
   /** Synchronous legacy unlock kept for AES-only environments. */
   unlockSync(password) {
-    if (!fs21.existsSync(this.storePath)) {
+    if (!fs23.existsSync(this.storePath)) {
       const salt = crypto.randomBytes(SALT_LEN);
       this.masterKey = this.deriveKey(password, salt);
       this.writeWithSalt({}, salt);
@@ -1659,7 +1802,7 @@ var Keystore = class {
     }
   }
   decryptFile(password, knownSalt) {
-    if (!fs21.existsSync(this.storePath)) return {};
+    if (!fs23.existsSync(this.storePath)) return {};
     try {
       const { salt, ciphertext, iv, tag } = this.readRaw();
       const useSalt = knownSalt ?? salt;
@@ -1681,8 +1824,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]);
-    fs21.mkdirSync(path23.dirname(this.storePath), { recursive: true });
-    fs21.writeFileSync(this.storePath, out, { mode: 384 });
+    fs23.mkdirSync(path25.dirname(this.storePath), { recursive: true });
+    fs23.writeFileSync(this.storePath, out, { mode: 384 });
   }
   writeWithSalt(data, salt) {
     if (!this.masterKey) throw new Error("writeWithSalt called before masterKey was set");
@@ -1692,11 +1835,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]);
-    fs21.mkdirSync(path23.dirname(this.storePath), { recursive: true });
-    fs21.writeFileSync(this.storePath, out, { mode: 384 });
+    fs23.mkdirSync(path25.dirname(this.storePath), { recursive: true });
+    fs23.writeFileSync(this.storePath, out, { mode: 384 });
   }
   readRaw() {
-    const buf = fs21.readFileSync(this.storePath);
+    const buf = fs23.readFileSync(this.storePath);
     let offset = 0;
     const salt = buf.subarray(offset, offset + SALT_LEN);
     offset += SALT_LEN;
@@ -1729,7 +1872,7 @@ var CascadeIgnore = class {
     ]);
   }
   async load(workspacePath) {
-    const filePath = path23.join(workspacePath, ".cascadeignore");
+    const filePath = path25.join(workspacePath, ".cascadeignore");
     try {
       const content = await fs9.readFile(filePath, "utf-8");
       const lines = content.split("\n").filter((l) => l.trim() && !l.startsWith("#"));
@@ -1740,7 +1883,7 @@ var CascadeIgnore = class {
   }
   isIgnored(filePath, workspacePath) {
     try {
-      const relative = workspacePath ? path23.relative(workspacePath, filePath) : filePath;
+      const relative = workspacePath ? path25.relative(workspacePath, filePath) : filePath;
       return this.ig.ignores(relative);
     } catch {
       return false;
@@ -1751,7 +1894,7 @@ var CascadeIgnore = class {
   }
 };
 async function createDefaultIgnoreFile(workspacePath) {
-  const filePath = path23.join(workspacePath, ".cascadeignore");
+  const filePath = path25.join(workspacePath, ".cascadeignore");
   const content = `# .cascadeignore \u2014 Files Cascade agents cannot read or modify
 # Syntax identical to .gitignore
 
@@ -1781,7 +1924,7 @@ Thumbs.db
   await fs9.writeFile(filePath, content, "utf-8");
 }
 async function loadCascadeMd(workspacePath) {
-  const filePath = path23.join(workspacePath, "CASCADE.md");
+  const filePath = path25.join(workspacePath, "CASCADE.md");
   try {
     const raw = await fs9.readFile(filePath, "utf-8");
     return parseCascadeMd(raw);
@@ -1810,7 +1953,7 @@ ${raw.trim()}`;
   return { raw, sections, systemPrompt };
 }
 async function createDefaultCascadeMd(workspacePath) {
-  const filePath = path23.join(workspacePath, "CASCADE.md");
+  const filePath = path25.join(workspacePath, "CASCADE.md");
   const content = `# Cascade Project Instructions
 
 This file contains project-specific instructions for the Cascade AI agent.
@@ -1845,9 +1988,9 @@ List any areas the agent should not touch.
 var MemoryStore = class _MemoryStore {
   db;
   constructor(dbPath) {
-    fs21.mkdirSync(path23.dirname(dbPath), { recursive: true });
+    fs23.mkdirSync(path25.dirname(dbPath), { recursive: true });
     try {
-      this.db = new Database(dbPath, { timeout: 5e3 });
+      this.db = new Database2(dbPath, { timeout: 5e3 });
       this.db.pragma("journal_mode = WAL");
       this.db.pragma("foreign_keys = ON");
       this.db.pragma("synchronous = NORMAL");
@@ -2692,7 +2835,8 @@ var WorkspaceConfigSchema = z.object({
   cascadeMdPath: z.string().default("CASCADE.md"),
   configPath: z.string().default(".cascade/config.json"),
   keystorePath: z.string().default(".cascade/keystore.enc"),
-  auditLogPath: z.string().default(".cascade/audit.log")
+  auditLogPath: z.string().default(".cascade/audit.log"),
+  debugWorldState: z.boolean().default(false)
 });
 var CascadeConfigSchema = z.object({
   version: z.literal("1.0").default("1.0"),
@@ -2837,6 +2981,14 @@ var CascadeConfigSchema = z.object({
    *   'parallel' / 'sequential' — force it.
    */
   t3Execution: z.enum(["auto", "parallel", "sequential"]).default("auto"),
+  /**
+   * Per-path privacy tiers. A subtask touching a `local-only` path is forced
+   * onto LOCAL models (never cloud) and its raw output is withheld from the
+   * tiers above. Patterns use .gitignore syntax, like .cascadeignore.
+   */
+  privacy: z.object({
+    paths: z.array(z.object({ pattern: z.string().min(1), policy: z.enum(["local-only"]) })).default([])
+  }).optional(),
   /**
    * T3→T2 reinforcement: when enabled, a worker that discovers its subtask should
    * fan out can call the `request_workers` tool to have its T2 manager spawn
@@ -2886,15 +3038,15 @@ var ConfigManager = class {
   globalDir;
   constructor(workspacePath = process.cwd()) {
     this.workspacePath = workspacePath;
-    this.globalDir = path23.join(os6.homedir(), GLOBAL_CONFIG_DIR);
+    this.globalDir = path25.join(os8.homedir(), GLOBAL_CONFIG_DIR);
   }
   async load() {
     this.config = await this.loadConfig();
     this.ignore = new CascadeIgnore();
     await this.ignore.load(this.workspacePath);
     this.cascadeMd = await loadCascadeMd(this.workspacePath);
-    this.keystore = new Keystore(path23.join(this.globalDir, GLOBAL_KEYSTORE_FILE));
-    this.store = new MemoryStore(path23.join(this.workspacePath, CASCADE_DB_FILE));
+    this.keystore = new Keystore(path25.join(this.globalDir, GLOBAL_KEYSTORE_FILE));
+    this.store = new MemoryStore(path25.join(this.workspacePath, CASCADE_DB_FILE));
     await this.injectEnvKeys();
     await this.ensureDefaultIdentity();
   }
@@ -2917,8 +3069,8 @@ var ConfigManager = class {
     return this.workspacePath;
   }
   async save() {
-    const configPath = path23.join(this.workspacePath, CASCADE_CONFIG_FILE);
-    await fs9.mkdir(path23.dirname(configPath), { recursive: true });
+    const configPath = path25.join(this.workspacePath, CASCADE_CONFIG_FILE);
+    await fs9.mkdir(path25.dirname(configPath), { recursive: true });
     await fs9.writeFile(configPath, JSON.stringify(this.config, null, 2), "utf-8");
   }
   async updateConfig(updates) {
@@ -2942,7 +3094,7 @@ var ConfigManager = class {
     return configProvider?.apiKey;
   }
   async loadConfig() {
-    const configPath = path23.join(this.workspacePath, CASCADE_CONFIG_FILE);
+    const configPath = path25.join(this.workspacePath, CASCADE_CONFIG_FILE);
     try {
       const raw = await fs9.readFile(configPath, "utf-8");
       return validateConfig(JSON.parse(raw));
@@ -3821,7 +3973,7 @@ init_constants();
 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 = path23.join(os6.homedir(), GLOBAL_CONFIG_DIR, "benchmarks-cache.json");
+var DEFAULT_CACHE_FILE = path25.join(os8.homedir(), GLOBAL_CONFIG_DIR, "benchmarks-cache.json");
 function normalizeModelId(id) {
   let s = id.toLowerCase();
   const slash = s.lastIndexOf("/");
@@ -3936,7 +4088,7 @@ var LiveDataProvider = class {
   }
   async saveCache() {
     try {
-      await fs9.mkdir(path23.dirname(this.opts.cacheFile), { recursive: true });
+      await fs9.mkdir(path25.dirname(this.opts.cacheFile), { recursive: true });
       const cache = {
         fetchedAt: this.fetchedAt,
         snapshot: this.snapshot ?? void 0,
@@ -4066,7 +4218,8 @@ var CascadeRouter = class _CascadeRouter extends EventEmitter {
     costByTier: {},
     tokensByTier: {},
     inputTokensByTier: {},
-    outputTokensByTier: {}
+    outputTokensByTier: {},
+    costByFeature: {}
   };
   tierModels = /* @__PURE__ */ new Map();
   config;
@@ -4088,6 +4241,9 @@ var CascadeRouter = class _CascadeRouter extends EventEmitter {
   tpmLimiter;
   localQueue;
   taskAnalyzer;
+  worldStateDB;
+  privacyPaths;
+  guidanceQueue;
   liveData;
   /** Snapshot of configured/default tier models, taken before Cascade Auto overrides them. */
   originalTierModels;
@@ -4245,7 +4401,17 @@ var CascadeRouter = class _CascadeRouter extends EventEmitter {
     if (options.model && !requireVision) {
       this.ensureProvider(options.model, this.config.providers);
     }
-    const model = requireVision ? this.selector.selectVisionModel() : options.model ?? this.tierModels.get(tier);
+    let model = requireVision ? this.selector.selectVisionModel() : options.model ?? this.tierModels.get(tier);
+    if (options.forceLocal && model && !this.isPrivateModel(model)) {
+      const localModel = this.selector.getAllAvailableModels().find((m) => this.isPrivateModel(m));
+      if (!localModel) {
+        throw new Error(
+          "privacy.paths: this subtask touches a local-only path but no LOCAL model is available. Configure Ollama or an OpenAI-compatible endpoint on a loopback/private host, or remove the privacy policy."
+        );
+      }
+      this.ensureProvider(localModel, this.config.providers);
+      model = localModel;
+    }
     if (!model) throw new Error(`No model available for tier ${tier}`);
     const provider = this.getProvider(model);
     if (!provider) throw new Error(`No provider for model ${model.id}`);
@@ -4317,7 +4483,7 @@ var CascadeRouter = class _CascadeRouter extends EventEmitter {
       if (!result || typeof result.content !== "string" || !result.usage) {
         throw new Error(`Provider ${model.provider}:${model.id} returned an invalid generation result.`);
       }
-      this.recordStats(tier, model, result.usage);
+      this.recordStats(tier, model, result.usage, options.featureTag);
       this.failover.recordSuccess(model.provider);
       return result;
     } catch (err) {
@@ -4422,6 +4588,42 @@ var CascadeRouter = class _CascadeRouter extends EventEmitter {
   setTaskAnalyzer(analyzer) {
     this.taskAnalyzer = analyzer;
   }
+  setWorldStateDB(db) {
+    this.worldStateDB = db;
+  }
+  getWorldStateDB() {
+    return this.worldStateDB;
+  }
+  setPrivacyPaths(paths) {
+    this.privacyPaths = paths;
+  }
+  getPrivacyPaths() {
+    return this.privacyPaths;
+  }
+  setGuidanceQueue(queue) {
+    this.guidanceQueue = queue;
+  }
+  getGuidanceQueue() {
+    return this.guidanceQueue;
+  }
+  /**
+   * "Private" = inference never leaves the user's machine/network: Ollama
+   * models (isLocal), or an OpenAI-compatible endpoint (e.g. llama.cpp, vLLM,
+   * LM Studio) whose configured host is loopback or a private range. A cloud
+   * OpenAI-compatible endpoint (public host) does NOT qualify.
+   */
+  isPrivateModel(model) {
+    if (model.isLocal) return true;
+    if (model.provider !== "openai-compatible") return false;
+    const baseUrl = this.config?.providers?.find((p) => p.type === "openai-compatible")?.baseUrl;
+    if (!baseUrl) return false;
+    try {
+      const host = new URL(baseUrl).hostname.toLowerCase();
+      return host === "localhost" || host === "127.0.0.1" || host === "::1" || host === "[::1]" || /^10\./.test(host) || /^192\.168\./.test(host) || /^172\.(1[6-9]|2\d|3[01])\./.test(host) || host.endsWith(".local");
+    } catch {
+      return false;
+    }
+  }
   /**
    * Cascade Auto per-subtask routing: pick the benchmark-best model for a
    * specific subtask's text, scoped to the tier's eligible candidates. Returns
@@ -4445,7 +4647,8 @@ var CascadeRouter = class _CascadeRouter extends EventEmitter {
       costByTier: { ...this.stats.costByTier },
       tokensByTier: { ...this.stats.tokensByTier },
       inputTokensByTier: { ...this.stats.inputTokensByTier },
-      outputTokensByTier: { ...this.stats.outputTokensByTier }
+      outputTokensByTier: { ...this.stats.outputTokensByTier },
+      costByFeature: { ...this.stats.costByFeature }
     };
   }
   /**
@@ -4495,7 +4698,8 @@ var CascadeRouter = class _CascadeRouter extends EventEmitter {
       costByTier: {},
       tokensByTier: {},
       inputTokensByTier: {},
-      outputTokensByTier: {}
+      outputTokensByTier: {},
+      costByFeature: {}
     };
     this.sessionCostUsd = 0;
     this.budgetState = "ok";
@@ -4661,7 +4865,7 @@ var CascadeRouter = class _CascadeRouter extends EventEmitter {
     }
     return void 0;
   }
-  recordStats(tier, model, usage) {
+  recordStats(tier, model, usage, featureTag) {
     this.stats.totalTokens += usage.totalTokens;
     this.stats.totalCostUsd += usage.estimatedCostUsd;
     this.sessionCostUsd += usage.estimatedCostUsd;
@@ -4671,6 +4875,9 @@ var CascadeRouter = class _CascadeRouter extends EventEmitter {
     this.stats.tokensByTier[tier] = (this.stats.tokensByTier[tier] ?? 0) + usage.totalTokens;
     this.stats.inputTokensByTier[tier] = (this.stats.inputTokensByTier[tier] ?? 0) + usage.inputTokens;
     this.stats.outputTokensByTier[tier] = (this.stats.outputTokensByTier[tier] ?? 0) + usage.outputTokens;
+    if (featureTag) {
+      this.stats.costByFeature[featureTag] = (this.stats.costByFeature[featureTag] ?? 0) + usage.estimatedCostUsd;
+    }
     this.runTokens += usage.totalTokens;
     this.runCostUsd += usage.estimatedCostUsd;
     this.updateBudgetState();
@@ -5208,6 +5415,8 @@ var T3Worker = class extends BaseTier {
   toolRegistry;
   context;
   assignment;
+  /** True when this subtask matched a privacy.paths local-only pattern. */
+  localOnlyMatch = false;
   peerSyncBuffer = [];
   store;
   audit;
@@ -5263,6 +5472,11 @@ var T3Worker = class extends BaseTier {
     this.taskId = taskId;
     this.setLabel(assignment.subtaskTitle);
     this.setStatus("ACTIVE");
+    const privacy = this.router.getPrivacyPaths?.();
+    this.localOnlyMatch = !!privacy?.hasPolicies() && privacy.anyLocalOnly(this.extractArtifactPaths(assignment));
+    if (this.localOnlyMatch) {
+      this.log("Privacy: subtask touches a local-only path \u2014 forcing a private model; raw output will be withheld upstream.");
+    }
     this.tools = this.toolRegistry.getToolDefinitions();
     if (this.reinforcementDepth === 0 && this.router.getReinforcementsConfig?.()?.enabled) {
       this.tools = [...this.tools, {
@@ -5393,9 +5607,17 @@ Now execute your subtask using this context where relevant.`
       }
       const reflectCfg = this.router.getReflectionConfig?.() ?? { enabled: false, maxRounds: 1 };
       if (reflectCfg.enabled) {
-        this.sendStatusUpdate({ progressPct: 85, currentAction: "Reflecting on output", status: "IN_PROGRESS" });
+        this.sendStatusUpdate({ progressPct: 85, currentAction: "Reflecting on output via T2-Critic", status: "IN_PROGRESS" });
         output = await this.reflectAndImprove(assignment, output, reflectCfg.maxRounds);
       }
+      const db = this.router.getWorldStateDB?.();
+      if (db) {
+        try {
+          db.addEntry(this.id, `Completed: ${assignment.subtaskTitle}. Output length: ${output.length} chars.`);
+        } catch (e) {
+          this.log("Failed to write to World State DB");
+        }
+      }
       this.setStatus("COMPLETED", output);
       this.sendStatusUpdate({ progressPct: 100, currentAction: "Subtask complete", status: "IN_PROGRESS", output });
       this.peerBus?.publish(this.id, assignment.subtaskId, output, "COMPLETED");
@@ -5468,6 +5690,16 @@ Now execute your subtask using this context where relevant.`
     while (iterations < MAX_ITERATIONS) {
       iterations++;
       this.throwIfCancelled();
+      const guidance = this.router.getGuidanceQueue?.()?.drain(this.id) ?? [];
+      for (const g of guidance) {
+        this.log(`User intervention received: ${g.text}`);
+        this.sendStatusUpdate({ progressPct: 50, currentAction: "Applying user intervention", status: "IN_PROGRESS" });
+        await this.context.addMessage({
+          role: "user",
+          content: `USER INTERVENTION (mid-run steering \u2014 follow this over prior instructions where they conflict):
+${g.text}`
+        });
+      }
       const options = {
         messages: this.context.getMessages(),
         systemPrompt: this.systemPromptOverride + systemPrompt + (this.hierarchyContext ? `
@@ -5476,7 +5708,9 @@ HIERARCHY CONTEXT: ${this.hierarchyContext}` : "") + textToolSuffix,
         // Don't pass tools array when model can't use them natively
         tools: useTextTools ? void 0 : tools.length ? tools : void 0,
         maxTokens: 4096,
-        ...subtaskModel ? { model: subtaskModel } : {}
+        ...subtaskModel ? { model: subtaskModel } : {},
+        featureTag: this.assignment?.sectionTitle,
+        ...this.localOnlyMatch ? { forceLocal: true } : {}
       };
       const result = await this.router.generate(
         "T3",
@@ -5640,8 +5874,8 @@ HIERARCHY CONTEXT: ${this.hierarchyContext}` : "") + textToolSuffix,
         tierId: this.id,
         sessionId: this.taskId,
         requireApproval: false,
-        saveSnapshot: async (path28, content) => {
-          this.store?.addFileSnapshot(this.taskId, path28, content);
+        saveSnapshot: async (path30, content) => {
+          this.store?.addFileSnapshot(this.taskId, path30, content);
         },
         sendPeerSync: (to, syncType, content) => {
           this.peerBus?.send(this.id, to, syncType, this.assignment?.subtaskId ?? "", content);
@@ -5811,7 +6045,7 @@ ${assignment.expectedOutput}`;
     const { promisify: promisify4 } = await import('util');
     const execAsync3 = promisify4(exec3);
     for (const artifactPath of artifactPaths) {
-      const absolutePath = path23.resolve(process.cwd(), artifactPath);
+      const absolutePath = path25.resolve(process.cwd(), artifactPath);
       try {
         const stat = await fs9.stat(absolutePath);
         if (!stat.isFile()) {
@@ -5832,7 +6066,7 @@ ${assignment.expectedOutput}`;
           issues.push(`PDF artifact looks too small to be valid: ${artifactPath}`);
           continue;
         }
-        const ext = path23.extname(absolutePath).toLowerCase();
+        const ext = path25.extname(absolutePath).toLowerCase();
         try {
           if (ext === ".ts" || ext === ".tsx") {
             await execAsync3(`npx tsc --noEmit ${absolutePath}`, { timeout: 1e4 });
@@ -5861,30 +6095,35 @@ ${stdout}`);
    * needed. Best-effort: any parse/error just keeps the current output.
    */
   async reflectAndImprove(assignment, output, maxRounds) {
-    const sys = this.systemPromptOverride + (this.hierarchyContext ? `
-
-HIERARCHY CONTEXT: ${this.hierarchyContext}` : "");
     let current = output;
-    for (let round = 0; round < Math.max(1, maxRounds); round++) {
-      try {
-        const verdict = await this.router.generate("T3", {
+    try {
+      for (let round = 0; round < Math.max(1, maxRounds); round++) {
+        const verdictResult = await this.router.generate("T2", {
           messages: [{
             role: "user",
-            content: `Does this output FULLY achieve the goal \u2014 not just the literal task, but the intent behind it?
+            content: `You are an independent critic reviewing another worker's output against its assignment.
 
-Goal / expected: ${assignment.expectedOutput}
+Goal: ${assignment.expectedOutput}
 Subtask: ${assignment.description}
-
-Output:
+Current Output:
 ${current}
 
-Reply with ONLY JSON: {"sufficient": true|false, "notes": "what is weak or missing if not sufficient"}`
+Is this output sufficient and correct? Respond with ONLY a JSON object:
+{"sufficient": true|false, "notes": "what is wrong or missing if false"}`
           }],
-          systemPrompt: sys,
-          maxTokens: 400
+          systemPrompt: "You are a T2-Critic reviewing a T3 Worker's output. Judge strictly against the stated goal.",
+          maxTokens: 400,
+          signal: this.signal,
+          featureTag: assignment.sectionTitle,
+          ...this.localOnlyMatch ? { forceLocal: true } : {}
         });
-        const parsed = JSON.parse(/\{[\s\S]*\}/.exec(verdict.content)?.[0] ?? "{}");
-        if (parsed.sufficient !== false) break;
+        const match = /\{[\s\S]*\}/.exec(verdictResult.content);
+        const parsed = match ? JSON.parse(match[0]) : { sufficient: true };
+        if (parsed.sufficient !== false) {
+          this.log("T2-Critic approved output.");
+          break;
+        }
+        this.log(`T2-Critic rejected output: ${parsed.notes}`);
         const improved = await this.router.generate("T3", {
           messages: [{
             role: "user",
@@ -5896,16 +6135,20 @@ Goal / expected: ${assignment.expectedOutput}
 Current output:
 ${current}`
           }],
-          systemPrompt: sys,
-          maxTokens: 4096
+          systemPrompt: this.systemPromptOverride + (this.hierarchyContext ? `
+
+HIERARCHY CONTEXT: ${this.hierarchyContext}` : ""),
+          maxTokens: 4096,
+          featureTag: assignment.sectionTitle,
+          ...this.localOnlyMatch ? { forceLocal: true } : {}
         });
         const next = (improved.content ?? "").trim();
         if (!next) break;
         current = next;
         this.log("Reflection: revised output for better goal alignment.");
-      } catch {
-        break;
       }
+    } catch (e) {
+      this.log(`T2-Critic reflection failed: ${e}`);
     }
     return current;
   }
@@ -5926,7 +6169,9 @@ Reply with JSON: { "completeness": "pass"|"fail", "correctness": "pass"|"fail",
       maxTokens: 500,
       systemPrompt: this.systemPromptOverride + (this.hierarchyContext ? `
 
-HIERARCHY CONTEXT: ${this.hierarchyContext}` : "")
+HIERARCHY CONTEXT: ${this.hierarchyContext}` : ""),
+      featureTag: assignment.sectionTitle,
+      ...this.localOnlyMatch ? { forceLocal: true } : {}
     });
     try {
       const jsonMatch = /\{[\s\S]*\}/.exec(testResult.content);
@@ -6021,6 +6266,7 @@ Begin execution now.`;
       issues,
       peerSyncsUsed: this.peerSyncBuffer.map((m) => m.fromId),
       correctionAttempts,
+      localOnly: this.localOnlyMatch || void 0,
       reinforcements: this.pendingReinforcements.length ? this.pendingReinforcements : void 0
     };
   }
@@ -6312,6 +6558,42 @@ var PeerBus = class extends EventEmitter {
   }
 };
 
+// src/core/audit/redaction.ts
+var RedactionLayer = class {
+  // Regexes for common secrets/PII
+  static RULES = [
+    // IPv4 addresses (basic approximation)
+    { pattern: /\b(?:\d{1,3}\.){3}\d{1,3}\b/g, replacement: "[REDACTED_IP]" },
+    // Generic API keys/Secrets (looks like a long random hex or b64 string preceded by key/secret/token)
+    { pattern: /(?:\b(?:api_key|apikey|secret|token|password|bearer|auth|authorization)\b[^a-zA-Z0-9_]{1,4})([a-zA-Z0-9_\-\.]{16,})/gi, replacement: "$1[REDACTED_SECRET]" },
+    // Email addresses
+    { pattern: /\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,7}\b/g, replacement: "[REDACTED_EMAIL]" },
+    // Phone numbers (simplistic)
+    { pattern: /\b(?:\+\d{1,3}[- ]?)?\(?\d{3}\)?[- ]?\d{3}[- ]?\d{4}\b/g, replacement: "[REDACTED_PHONE]" },
+    // AWS Access Key ID
+    { pattern: /\b(AKIA[0-9A-Z]{16})\b/g, replacement: "[REDACTED_AWS_AK]" }
+  ];
+  /**
+   * Applies all redaction rules to the input string.
+   */
+  static redact(text) {
+    if (!text) return text;
+    let redacted = text;
+    for (const rule of this.RULES) {
+      if (rule.pattern.test(redacted)) {
+        rule.pattern.lastIndex = 0;
+        redacted = redacted.replace(rule.pattern, (match, p1, offset, str2) => {
+          if (p1 && match.includes(p1) && p1 !== match) {
+            return match.replace(p1, rule.replacement.replace("$1", ""));
+          }
+          return rule.replacement;
+        });
+      }
+    }
+    return redacted;
+  }
+};
+
 // src/core/tiers/t2-manager.ts
 var T2_SYSTEM_PROMPT = `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.
@@ -6540,7 +6822,8 @@ HIERARCHY CONTEXT: ${this.hierarchyContext}` : ""),
     try {
       const jsonMatch = /\[[\s\S]*\]/.exec(result.content);
       if (!jsonMatch) throw new Error("No JSON array found");
-      return JSON.parse(jsonMatch[0]);
+      const parsed = JSON.parse(jsonMatch[0]);
+      return parsed.map((a) => ({ ...a, sectionTitle: assignment.sectionTitle }));
     } catch {
       return [{
         subtaskId: randomUUID(),
@@ -6550,6 +6833,8 @@ HIERARCHY CONTEXT: ${this.hierarchyContext}` : ""),
         constraints: assignment.constraints,
         peerT3Ids: [],
         parentT2: this.id,
+        sectionTitle: assignment.sectionTitle,
+        dependsOn: [],
         executionMode: "parallel"
       }];
     }
@@ -6669,6 +6954,14 @@ HIERARCHY CONTEXT: ${this.hierarchyContext}` : ""),
         const assignment = sanitizedAssignments.find((a) => a.subtaskId === id);
         const worker = workerMap.get(id);
         const result = await worker.execute(assignment, taskId, waveSignal);
+        if (result.localOnly) {
+          result.output = `[local-only path \u2014 output withheld by privacy policy; status: ${result.status}; checks passed: ${result.testResults.passed.length}/${result.testResults.checksRun.length || 0}]`;
+        } else {
+          if (typeof result.output === "string" && result.output) {
+            result.output = RedactionLayer.redact(result.output);
+          }
+        }
+        if (result.issues) result.issues = result.issues.map((i) => RedactionLayer.redact(i));
         resultMap.set(id, result);
         return result;
       };
@@ -7301,10 +7594,15 @@ In 3-5 terse bullets, flag the most important RISKS, GAPS, or over-/under-decomp
     }
   }
   async decomposeTask(prompt, systemContext) {
+    const db = this.router.getWorldStateDB?.();
+    const worldStateContext = db ? `
+
+PROJECT WORLD STATE (Current architecture and recent changes):
+${db.getFormattedState()}` : "";
     const contextSection = systemContext ? `
 Project context:
 ${systemContext}` : "";
-    const decompositionPrompt = `Analyze this task and create an execution plan.${contextSection}
+    const decompositionPrompt = `Analyze this task and create an execution plan.${contextSection}${worldStateContext}
 
     Task: ${prompt}
 
@@ -7792,16 +8090,16 @@ function resolveInWorkspace(workspaceRoot, input) {
   if (typeof input !== "string" || input.length === 0) {
     throw new WorkspaceSandboxError(String(input), workspaceRoot);
   }
-  const root = path23.resolve(workspaceRoot);
-  const abs = path23.isAbsolute(input) ? path23.resolve(input) : path23.resolve(root, input);
-  const rel = path23.relative(root, abs);
-  if (rel === "" || rel === ".") ; else if (rel.startsWith("..") || path23.isAbsolute(rel)) {
+  const root = path25.resolve(workspaceRoot);
+  const abs = path25.isAbsolute(input) ? path25.resolve(input) : path25.resolve(root, input);
+  const rel = path25.relative(root, abs);
+  if (rel === "" || rel === ".") ; else if (rel.startsWith("..") || path25.isAbsolute(rel)) {
     throw new WorkspaceSandboxError(input, root);
   }
   try {
-    const real = fs21.realpathSync(abs);
-    const realRel = path23.relative(root, real);
-    if (realRel !== "" && realRel !== "." && (realRel.startsWith("..") || path23.isAbsolute(realRel))) {
+    const real = fs23.realpathSync(abs);
+    const realRel = path25.relative(root, real);
+    if (realRel !== "" && realRel !== "." && (realRel.startsWith("..") || path25.isAbsolute(realRel))) {
       throw new WorkspaceSandboxError(input, root);
     }
   } catch (e) {
@@ -7862,7 +8160,7 @@ var FileWriteTool = class extends BaseTool {
       } catch {
       }
     }
-    await fs9.mkdir(path23.dirname(absPath), { recursive: true });
+    await fs9.mkdir(path25.dirname(absPath), { recursive: true });
     await fs9.writeFile(absPath, content, "utf-8");
     return `Written ${content.length} characters to ${filePath}`;
   }
@@ -8360,7 +8658,7 @@ var ImageAnalyzeTool = class extends BaseTool {
 };
 async function fileToImageAttachment(filePath) {
   const data = await fs9.readFile(filePath);
-  const ext = path23.extname(filePath).toLowerCase();
+  const ext = path25.extname(filePath).toLowerCase();
   const mimeMap = {
     ".jpg": "image/jpeg",
     ".jpeg": "image/jpeg",
@@ -8394,14 +8692,14 @@ var PDFCreateTool = class extends BaseTool {
     const filePath = input["path"];
     const content = input["content"];
     const title = input["title"];
-    const dir = path23.dirname(filePath);
-    if (!fs21.existsSync(dir)) {
-      fs21.mkdirSync(dir, { recursive: true });
+    const dir = path25.dirname(filePath);
+    if (!fs23.existsSync(dir)) {
+      fs23.mkdirSync(dir, { recursive: true });
     }
     return new Promise((resolve, reject) => {
       try {
         const doc = new PDFDocument({ margin: 50 });
-        const stream = fs21.createWriteStream(filePath);
+        const stream = fs23.createWriteStream(filePath);
         doc.pipe(stream);
         if (title) {
           doc.info["Title"] = title;
@@ -8479,22 +8777,22 @@ var CodeInterpreterTool = class extends BaseTool {
       }
       cmdPrefix = NODE_CMD;
     }
-    const tmpDir = path23.join(this.workspaceRoot, ".cascade", "tmp");
-    if (!fs21.existsSync(tmpDir)) {
-      fs21.mkdirSync(tmpDir, { recursive: true });
+    const tmpDir = path25.join(this.workspaceRoot, ".cascade", "tmp");
+    if (!fs23.existsSync(tmpDir)) {
+      fs23.mkdirSync(tmpDir, { recursive: true });
     }
     const extension = language === "python" ? "py" : "js";
     const fileName = `intp_${randomUUID().slice(0, 8)}.${extension}`;
-    const filePath = path23.join(tmpDir, fileName);
-    fs21.writeFileSync(filePath, code, "utf-8");
+    const filePath = path25.join(tmpDir, fileName);
+    fs23.writeFileSync(filePath, code, "utf-8");
     const execArgs = [filePath, ...args];
     return new Promise((resolve) => {
       const startMs = Date.now();
       execFile(cmdPrefix, execArgs, { cwd: this.workspaceRoot, timeout: 3e4 }, (error, stdout, stderr) => {
         const duration = Date.now() - startMs;
         try {
-          if (fs21.existsSync(filePath)) {
-            fs21.unlinkSync(filePath);
+          if (fs23.existsSync(filePath)) {
+            fs23.unlinkSync(filePath);
           }
         } catch (cleanupErr) {
           console.error(`Failed to cleanup interpreter script ${filePath}:`, cleanupErr);
@@ -8773,7 +9071,7 @@ var GlobTool = class extends BaseTool {
   };
   async execute(input, _options) {
     const pattern = input["pattern"];
-    const searchPath = input["path"] ? path23.resolve(this.workspaceRoot, input["path"]) : this.workspaceRoot;
+    const searchPath = input["path"] ? path25.resolve(this.workspaceRoot, input["path"]) : this.workspaceRoot;
     const matches = await glob(pattern, {
       cwd: searchPath,
       ignore: ["node_modules/**", ".git/**", "dist/**", "build/**"],
@@ -8786,7 +9084,7 @@ var GlobTool = class extends BaseTool {
     const withMtime = await Promise.all(
       matches.map(async (rel) => {
         try {
-          const stat = await fs9.stat(path23.join(searchPath, rel));
+          const stat = await fs9.stat(path25.join(searchPath, rel));
           return { rel, mtime: stat.mtimeMs };
         } catch {
           return { rel, mtime: 0 };
@@ -8835,7 +9133,7 @@ var GrepTool = class extends BaseTool {
   };
   async execute(input, _options) {
     const pattern = input["pattern"];
-    const searchPath = input["path"] ? path23.resolve(this.workspaceRoot, input["path"]) : this.workspaceRoot;
+    const searchPath = input["path"] ? path25.resolve(this.workspaceRoot, input["path"]) : this.workspaceRoot;
     const globPattern = input["glob"];
     const outputMode = input["output_mode"] ?? "content";
     const context = input["context"] ?? 0;
@@ -8889,12 +9187,12 @@ var GrepTool = class extends BaseTool {
         nodir: true
       });
     } catch {
-      files = [path23.relative(searchPath, searchPath) || "."];
+      files = [path25.relative(searchPath, searchPath) || "."];
     }
     const results = [];
     let totalCount = 0;
     for (const rel of files) {
-      const abs = path23.join(searchPath, rel);
+      const abs = path25.join(searchPath, rel);
       let content;
       try {
         content = await fs9.readFile(abs, "utf-8");
@@ -9256,10 +9554,10 @@ var ToolRegistry = class extends EventEmitter {
   }
   isIgnored(filePath) {
     if (!filePath) return false;
-    const abs = path23.resolve(this.workspaceRoot, filePath);
-    const rel = path23.relative(this.workspaceRoot, abs);
-    if (!rel || rel.startsWith("..") || path23.isAbsolute(rel)) return true;
-    const posixRel = rel.split(path23.sep).join("/");
+    const abs = path25.resolve(this.workspaceRoot, filePath);
+    const rel = path25.relative(this.workspaceRoot, abs);
+    if (!rel || rel.startsWith("..") || path25.isAbsolute(rel)) return true;
+    const posixRel = rel.split(path25.sep).join("/");
     return this.ignoreMatcher.ignores(posixRel);
   }
 };
@@ -9376,6 +9674,9 @@ var McpClient = class _McpClient {
     return this.clients.has(serverName);
   }
 };
+
+// src/core/cascade.ts
+init_audit_logger();
 var SAFE_TOOLS = /* @__PURE__ */ new Set([
   "file_read",
   "file_list",
@@ -9759,9 +10060,10 @@ var TaskAnalyzer = class {
     analysisCache.clear();
   }
 };
-var DEFAULT_STATS_FILE = path23.join(os6.homedir(), ".cascade", "model-perf.json");
+var DEFAULT_STATS_FILE = path25.join(os8.homedir(), ".cascade", "model-perf.json");
 var ModelPerformanceTracker = class {
   stats = /* @__PURE__ */ new Map();
+  featureStats = /* @__PURE__ */ new Map();
   statsFile;
   loaded = false;
   constructor(statsFile = DEFAULT_STATS_FILE) {
@@ -9773,18 +10075,29 @@ var ModelPerformanceTracker = class {
     try {
       const raw = await fs9.readFile(this.statsFile, "utf-8");
       const parsed = JSON.parse(raw);
-      for (const [key, stat] of Object.entries(parsed)) {
-        this.stats.set(key, stat);
+      if (parsed.models) {
+        for (const [key, stat] of Object.entries(parsed.models)) this.stats.set(key, stat);
+      } else {
+        for (const [key, stat] of Object.entries(parsed)) {
+          if (stat && typeof stat === "object" && typeof stat.successCount === "number") {
+            this.stats.set(key, stat);
+          }
+        }
+      }
+      if (parsed.features) {
+        for (const [key, stat] of Object.entries(parsed.features)) this.featureStats.set(key, stat);
       }
     } catch {
     }
   }
   async save() {
     try {
-      await fs9.mkdir(path23.dirname(this.statsFile), { recursive: true });
-      const obj = {};
-      for (const [key, stat] of this.stats) obj[key] = stat;
-      await fs9.writeFile(this.statsFile, JSON.stringify(obj, null, 2), "utf-8");
+      await fs9.mkdir(path25.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;
+      await fs9.writeFile(this.statsFile, JSON.stringify({ models: modelsObj, features: featuresObj }, null, 2), "utf-8");
     } catch {
     }
   }
@@ -9805,6 +10118,13 @@ var ModelPerformanceTracker = class {
       sampleCount: s.sampleCount + 1
     });
   }
+  recordFeatureCost(featureTag, costUsd) {
+    const s = this.featureStats.get(featureTag) ?? { totalCostUsd: 0, runCount: 0 };
+    this.featureStats.set(featureTag, {
+      totalCostUsd: s.totalCostUsd + costUsd,
+      runCount: s.runCount + 1
+    });
+  }
   /**
    * Record an explicit user rating (good/bad). Counts as 3 automatic samples
    * so user feedback carries significantly more weight than auto-detected outcomes.
@@ -9819,6 +10139,9 @@ var ModelPerformanceTracker = class {
   getAll() {
     return new Map(this.stats);
   }
+  getAllFeatures() {
+    return new Map(this.featureStats);
+  }
   /**
    * Returns 0.05–1.0; defaults to 0.5 (neutral prior) when no history exists.
    * High retry counts penalise the score.
@@ -10183,7 +10506,7 @@ Required capability: ${description.slice(0, 300)}`;
    *  any dangerous action, so a silently-reloaded tool can't act without approval. */
   async loadPersistedTools() {
     if (!this.workspacePath || !this.persistEnabled) return;
-    const file = path23.join(this.workspacePath, ".cascade", DYNAMIC_TOOLS_FILE);
+    const file = path25.join(this.workspacePath, ".cascade", DYNAMIC_TOOLS_FILE);
     try {
       const raw = await fs9.readFile(file, "utf-8");
       const specs = JSON.parse(raw);
@@ -10207,8 +10530,8 @@ Required capability: ${description.slice(0, 300)}`;
   }
   async persist() {
     if (!this.workspacePath || !this.persistEnabled) return;
-    const dir = path23.join(this.workspacePath, ".cascade");
-    const file = path23.join(dir, DYNAMIC_TOOLS_FILE);
+    const dir = path25.join(this.workspacePath, ".cascade");
+    const file = path25.join(dir, DYNAMIC_TOOLS_FILE);
     try {
       await fs9.mkdir(dir, { recursive: true });
       await fs9.writeFile(file, JSON.stringify(Array.from(this.specs.values()), null, 2), "utf-8");
@@ -10221,6 +10544,166 @@ Required capability: ${description.slice(0, 300)}`;
     return Array.from(this.specs.keys());
   }
 };
+var WorldStateDB = class {
+  constructor(workspacePath, debugMode = false) {
+    this.workspacePath = workspacePath;
+    this.debugMode = debugMode;
+    const cascadeDir = path25.join(workspacePath, ".cascade");
+    if (!fs23.existsSync(cascadeDir)) {
+      fs23.mkdirSync(cascadeDir, { recursive: true });
+    }
+    this.keyPath = path25.join(cascadeDir, "world_state.key");
+    this.dbPath = path25.join(cascadeDir, "world_state.db");
+    this.initEncryptionKey();
+    this.db = new Database2(this.dbPath);
+    this.db.pragma("journal_mode = WAL");
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS world_state (
+        id TEXT PRIMARY KEY,
+        timestamp TEXT NOT NULL,
+        worker_id TEXT NOT NULL,
+        encrypted_payload TEXT NOT NULL
+      )
+    `);
+  }
+  workspacePath;
+  debugMode;
+  db;
+  keyPath;
+  dbPath;
+  encryptionKey;
+  initEncryptionKey() {
+    if (fs23.existsSync(this.keyPath)) {
+      this.encryptionKey = fs23.readFileSync(this.keyPath);
+    } else {
+      this.encryptionKey = crypto.randomBytes(32);
+      fs23.writeFileSync(this.keyPath, this.encryptionKey);
+    }
+  }
+  encrypt(text) {
+    const iv = crypto.randomBytes(16);
+    const cipher = crypto.createCipheriv("aes-256-gcm", this.encryptionKey, iv);
+    let encrypted = cipher.update(text, "utf8", "hex");
+    encrypted += cipher.final("hex");
+    const authTag = cipher.getAuthTag().toString("hex");
+    return `${iv.toString("hex")}:${authTag}:${encrypted}`;
+  }
+  decrypt(text) {
+    const parts = text.split(":");
+    if (parts.length !== 3) throw new Error("Invalid encrypted payload format");
+    const [ivHex, authTagHex, encryptedHex] = parts;
+    const iv = Buffer.from(ivHex, "hex");
+    const authTag = Buffer.from(authTagHex, "hex");
+    const decipher = crypto.createDecipheriv("aes-256-gcm", this.encryptionKey, iv);
+    decipher.setAuthTag(authTag);
+    let decrypted = decipher.update(encryptedHex, "hex", "utf8");
+    decrypted += decipher.final("utf8");
+    return decrypted;
+  }
+  addEntry(workerId, summary) {
+    const id = crypto.randomUUID();
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const payload = JSON.stringify({ summary });
+    const encryptedPayload = this.encrypt(payload);
+    const stmt = this.db.prepare("INSERT INTO world_state (id, timestamp, worker_id, encrypted_payload) VALUES (?, ?, ?, ?)");
+    stmt.run(id, timestamp, workerId, encryptedPayload);
+    this.dumpDebugIfNeeded();
+    return id;
+  }
+  getAllEntries() {
+    const stmt = this.db.prepare("SELECT id, timestamp, worker_id, encrypted_payload FROM world_state ORDER BY timestamp ASC");
+    const rows = stmt.all();
+    return rows.map((row) => {
+      try {
+        const decrypted = this.decrypt(row.encrypted_payload);
+        const parsed = JSON.parse(decrypted);
+        return {
+          id: row.id,
+          timestamp: row.timestamp,
+          workerId: row.worker_id,
+          summary: parsed.summary
+        };
+      } catch (err) {
+        return {
+          id: row.id,
+          timestamp: row.timestamp,
+          workerId: row.worker_id,
+          summary: "[Decryption Failed - Payload Corrupted]"
+        };
+      }
+    });
+  }
+  getFormattedState() {
+    const entries = this.getAllEntries();
+    if (entries.length === 0) return "World State is currently empty.";
+    return entries.map((e, idx) => `[${e.timestamp}] Step ${idx + 1} (${e.workerId}): ${e.summary}`).join("\n");
+  }
+  dumpDebugIfNeeded() {
+    if (!this.debugMode) return;
+    try {
+      const dumpPath = path25.join(os8.tmpdir(), "cascade_world_state_debug.json");
+      const entries = this.getAllEntries();
+      fs23.writeFileSync(dumpPath, JSON.stringify(entries, null, 2), "utf-8");
+    } catch (err) {
+      console.error("Failed to dump debug world state", err);
+    }
+  }
+  close() {
+    this.db.close();
+  }
+};
+var ignore3 = _ignoreModule.default ?? _ignoreModule;
+var PrivacyPaths = class {
+  localOnly;
+  hasRules;
+  constructor(policies = []) {
+    this.localOnly = ignore3();
+    const patterns = policies.filter((p) => p.policy === "local-only").map((p) => p.pattern);
+    if (patterns.length) this.localOnly.add(patterns);
+    this.hasRules = patterns.length > 0;
+  }
+  /** True when any privacy rules are configured at all (cheap short-circuit). */
+  hasPolicies() {
+    return this.hasRules;
+  }
+  /** True when the given workspace-relative path falls under a local-only policy. */
+  isLocalOnly(relativePath) {
+    if (!this.hasRules || !relativePath) return false;
+    try {
+      return this.localOnly.ignores(relativePath.replace(/^\.?\//, ""));
+    } catch {
+      return false;
+    }
+  }
+  /** True when ANY of the given paths falls under a local-only policy. */
+  anyLocalOnly(relativePaths) {
+    return relativePaths.some((p) => this.isLocalOnly(p));
+  }
+};
+
+// src/core/steering/guidance.ts
+var GuidanceQueue = class {
+  entries = [];
+  /** Per-consumer read cursor so a broadcast entry reaches each worker once. */
+  cursors = /* @__PURE__ */ new Map();
+  push(text, nodeId) {
+    const entry = { text, nodeId, timestamp: (/* @__PURE__ */ new Date()).toISOString() };
+    this.entries.push(entry);
+    return entry;
+  }
+  /**
+   * New entries for this consumer since its last drain, filtered to entries
+   * that target it (or target everyone). Advances the consumer's cursor.
+   */
+  drain(consumerId) {
+    const from = this.cursors.get(consumerId) ?? 0;
+    this.cursors.set(consumerId, this.entries.length);
+    return this.entries.slice(from).filter((e) => !e.nodeId || consumerId === e.nodeId || consumerId.startsWith(e.nodeId));
+  }
+  get size() {
+    return this.entries.length;
+  }
+};
 
 // src/core/cascade.ts
 var Cascade = class _Cascade extends EventEmitter {
@@ -10240,6 +10723,9 @@ var Cascade = class _Cascade extends EventEmitter {
   taskAnalyzer;
   perfTracker;
   toolCreator;
+  worldStateDB;
+  encryptedAuditLogger;
+  guidanceQueue;
   workspacePath;
   constructor(config, workspacePath, store) {
     super();
@@ -10261,6 +10747,23 @@ var Cascade = class _Cascade extends EventEmitter {
     });
     this.toolRegistry = new ToolRegistry(this.config.tools, 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);
+    this.encryptedAuditLogger = new AuditLogger2(this.workspacePath, this.config.workspace?.debugWorldState ?? false);
+    const privacyPolicies = this.config.privacy?.paths ?? [];
+    if (privacyPolicies.length) this.router.setPrivacyPaths(new PrivacyPaths(privacyPolicies));
+    this.guidanceQueue = new GuidanceQueue();
+    this.router.setGuidanceQueue(this.guidanceQueue);
+  }
+  /**
+   * Live intervention: inject a user correction into the running hierarchy.
+   * Every active T3 worker (or only the one matching `nodeId`) picks it up at
+   * the top of its next agent-loop iteration as a USER INTERVENTION message.
+   */
+  injectGuidance(text, nodeId) {
+    const entry = this.guidanceQueue.push(text, nodeId);
+    this.encryptedAuditLogger?.logEvent("user_guidance", nodeId ?? "*", { text });
+    this.emit("guidance:injected", entry);
   }
   initOptionalFeatures() {
     if (this.config.cascadeAuto === true) {
@@ -10423,6 +10926,12 @@ ${last.partialOutput}` : "");
     if (!prompt) return null;
     return this.run({ prompt });
   }
+  getWorkspacePath() {
+    return this.workspacePath;
+  }
+  getWorldStateDB() {
+    return this.worldStateDB;
+  }
   /**
    * Record an explicit user rating for the last completed run.
    * Explicit ratings carry 3× the weight of auto-detected outcomes so user
@@ -10509,6 +11018,11 @@ ${last.partialOutput}` : "");
       }
       this.initOptionalFeatures();
       if (this.toolCreator) await this.toolCreator.loadPersistedTools();
+      if (this.encryptedAuditLogger) {
+        this.on("tool:call", (e) => this.encryptedAuditLogger.logEvent("tool_call", e.tierId || "unknown", e));
+        this.on("tool:result", (e) => this.encryptedAuditLogger.logEvent("tool_result", e.tierId || "unknown", e));
+        this.on("tier:status", (e) => this.encryptedAuditLogger.logEvent("tier_status", e.tierId || "unknown", e));
+      }
       this.initialized = true;
     })();
     try {
@@ -10934,6 +11448,7 @@ ${prompt}` : prompt;
       durationMs,
       costByTier: stats.costByTier,
       tokensByTier: stats.tokensByTier,
+      costByFeature: stats.costByFeature,
       costPercentByTier: this.router.getTierCostPercentages()
     };
   }
@@ -11183,6 +11698,30 @@ var SlashCommandRegistry = class {
         return { output: out || "File changes rolled back.", handled: true };
       }
     });
+    this.register({
+      command: "/steer",
+      description: "Steer a running task: /steer <correction for the active workers>",
+      args: ["<guidance>"],
+      handler: async (args, ctx) => {
+        const output = await ctx.onSteer(args);
+        return { output, handled: true };
+      }
+    });
+    this.register({
+      command: "/audit",
+      description: "Verify the tamper-evident audit log (hash chain integrity)",
+      handler: async (_args, ctx) => {
+        const { AuditLogger: AuditLogger3 } = await Promise.resolve().then(() => (init_audit_logger(), audit_logger_exports));
+        const logger = new AuditLogger3(ctx.workspacePath);
+        try {
+          const v = logger.verifyChain();
+          const output = v.ok ? `\u2714 Audit log intact \u2014 ${v.entries} entr${v.entries === 1 ? "y" : "ies"}, hash chain verified.` : `\u2718 Audit log FAILED verification at row ${v.firstBadRow} of ${v.entries} \u2014 entries at or after that row were modified, removed, or predate the hash chain.`;
+          return { output, handled: true };
+        } finally {
+          logger.close();
+        }
+      }
+    });
     this.register({
       command: "/branch",
       description: "Fork current session into parallel branches",
@@ -11830,7 +12369,8 @@ function CostTracker({
   tokensByTier,
   compact = false,
   savedUsd = 0,
-  savedPct = 0
+  savedPct = 0,
+  costByFeature
 }) {
   const hasTierCost = costByTier && Object.keys(costByTier).length > 0;
   const savingsLine = savedUsd > 0 ? `Saved $${savedUsd.toFixed(4)} (${savedPct}%) vs. running every call on T1` : null;
@@ -11929,6 +12469,16 @@ function CostTracker({
           ] }, tier);
         })
       ] })
+    ] }),
+    costByFeature && Object.keys(costByFeature).length > 0 && /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginTop: 1, children: [
+      /* @__PURE__ */ jsx(Text, { color: theme.colors.muted, children: "By feature/section:" }),
+      Object.entries(costByFeature).map(([feature, cost]) => /* @__PURE__ */ jsxs(Box, { marginLeft: 2, children: [
+        /* @__PURE__ */ jsx(Box, { width: 30, children: /* @__PURE__ */ jsx(Text, { color: theme.colors.secondary, wrap: "truncate-end", children: feature }) }),
+        /* @__PURE__ */ jsxs(Text, { color: theme.colors.success, children: [
+          "$",
+          cost.toFixed(6)
+        ] })
+      ] }, feature))
     ] })
   ] });
 }
@@ -12342,7 +12892,7 @@ function replReducer(state, action) {
     case "SET_TREE":
       return { ...state, agentTree: action.tree };
     case "UPDATE_COST":
-      return { ...state, totalTokens: action.tokens, totalCostUsd: action.costUsd, callsByProvider: action.byProvider, callsByTier: action.byTier, costByTier: action.costByTier, tokensByTier: action.tokensByTier, savedUsd: action.savedUsd, savedPct: action.savedPct };
+      return { ...state, totalTokens: action.tokens, totalCostUsd: action.costUsd, callsByProvider: action.byProvider, callsByTier: action.byTier, costByTier: action.costByTier, tokensByTier: action.tokensByTier, costByFeature: action.costByFeature, savedUsd: action.savedUsd, savedPct: action.savedPct };
     case "SET_APPROVAL":
       return { ...state, approvalRequest: action.request };
     case "SET_EXECUTING":
@@ -12356,7 +12906,7 @@ function replReducer(state, action) {
     case "TOGGLE_COMMS":
       return { ...state, showComms: !state.showComms };
     case "CLEAR":
-      return { ...state, messages: [], agentTree: null, streamBuffer: "", totalTokens: 0, totalCostUsd: 0, callsByProvider: {}, callsByTier: {}, costByTier: {}, tokensByTier: {}, savedUsd: 0, savedPct: 0, peerEvents: [], activeTool: null };
+      return { ...state, messages: [], agentTree: null, streamBuffer: "", totalTokens: 0, totalCostUsd: 0, callsByProvider: {}, callsByTier: {}, costByTier: {}, tokensByTier: {}, costByFeature: {}, savedUsd: 0, savedPct: 0, peerEvents: [], activeTool: null };
     case "CLEAR_TREE":
       return { ...state, agentTree: null };
     case "TOGGLE_COST":
@@ -12405,7 +12955,7 @@ function Repl({ config, workspacePath, themeName, initialPrompt, identityName, a
   const [slashIndex, setSlashIndex] = useState(0);
   const [identities, setIdentities] = useState([]);
   const [currentIdentityId, setCurrentIdentityId] = useState(config.defaultIdentityId);
-  const [state, dispatch] = useReducer(replReducer, { messages: [], agentTree: null, isStreaming: false, isExecuting: false, streamBuffer: "", totalTokens: 0, totalCostUsd: 0, callsByProvider: {}, callsByTier: {}, costByTier: {}, tokensByTier: {}, savedUsd: 0, savedPct: 0, peerEvents: [], showComms: true, approvalRequest: null, showCost: false, showDetails: false, error: null, activeTool: null });
+  const [state, dispatch] = useReducer(replReducer, { messages: [], agentTree: null, isStreaming: false, isExecuting: false, streamBuffer: "", totalTokens: 0, totalCostUsd: 0, callsByProvider: {}, callsByTier: {}, costByTier: {}, tokensByTier: {}, costByFeature: {}, savedUsd: 0, savedPct: 0, peerEvents: [], showComms: true, approvalRequest: null, showCost: false, showDetails: false, error: null, activeTool: null });
   const [isShowingModels, setIsShowingModels] = useState(false);
   const [planApprovalRequest, setPlanApprovalRequest] = useState(null);
   const [historyOffset, setHistoryOffset] = useState(0);
@@ -12474,9 +13024,9 @@ function Repl({ config, workspacePath, themeName, initialPrompt, identityName, a
       }
     } catch {
     }
-    const configPath = path23.join(workspacePath, ".cascade", "config.json");
+    const configPath = path25.join(workspacePath, ".cascade", "config.json");
     try {
-      await fs9.mkdir(path23.dirname(configPath), { recursive: true });
+      await fs9.mkdir(path25.dirname(configPath), { recursive: true });
       await fs9.writeFile(configPath, JSON.stringify(config, null, 2), "utf-8");
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
@@ -12528,9 +13078,9 @@ function Repl({ config, workspacePath, themeName, initialPrompt, identityName, a
       if (msg.includes("non-text parts")) return;
       originalLog(...args);
     };
-    const store = new MemoryStore(path23.join(workspacePath, CASCADE_DB_FILE));
+    const store = new MemoryStore(path25.join(workspacePath, CASCADE_DB_FILE));
     storeRef.current = store;
-    globalStoreRef.current = new MemoryStore(path23.join(os6.homedir(), GLOBAL_CONFIG_DIR, GLOBAL_RUNTIME_DB_FILE));
+    globalStoreRef.current = new MemoryStore(path25.join(os8.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;
@@ -12593,7 +13143,7 @@ function Repl({ config, workspacePath, themeName, initialPrompt, identityName, a
       onThemeChange: (name) => setTheme(getTheme(name)),
       onExport: async (fmt) => {
         const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-        const exportPath = path23.join(workspacePath, `cascade-export-${stamp}.${fmt === "json" ? "json" : "md"}`);
+        const exportPath = path25.join(workspacePath, `cascade-export-${stamp}.${fmt === "json" ? "json" : "md"}`);
         if (fmt === "json") {
           await fs9.writeFile(exportPath, JSON.stringify({ sessionId: sessionIdRef.current, messages: state.messages }, null, 2), "utf-8");
         } else {
@@ -12617,6 +13167,14 @@ ${msg.content}`).join("\n\n");
         }
         return `Restored ${snapshots.length} files to their initial session state.`;
       },
+      onSteer: (args) => {
+        const text = args.join(" ").trim();
+        if (!text) return "Usage: /steer <correction for the active workers>";
+        const cascade = cascadeRef.current;
+        if (!cascade) return "No active Cascade instance.";
+        cascade.injectGuidance(text);
+        return "Guidance queued \u2014 active workers apply it on their next step. (No task running? It applies to the next run's workers.)";
+      },
       onBranch: async () => {
         const store = storeRef.current;
         if (!store) return;
@@ -12935,7 +13493,7 @@ ${lastUser.content}`;
       if (lastTool !== null) dispatch({ type: "SET_ACTIVE_TOOL", toolName: lastTool });
       const stats = cascade.getRouter().getStats();
       const savings = cascade.getRouter().getDelegationSavings();
-      dispatch({ type: "UPDATE_COST", tokens: stats.totalTokens, costUsd: stats.totalCostUsd, byProvider: stats.callsByProvider, byTier: stats.callsByTier, costByTier: stats.costByTier, tokensByTier: stats.tokensByTier, savedUsd: savings.savedUsd, savedPct: savings.savedPct });
+      dispatch({ type: "UPDATE_COST", tokens: stats.totalTokens, costUsd: stats.totalCostUsd, byProvider: stats.callsByProvider, byTier: stats.callsByTier, costByTier: stats.costByTier, tokensByTier: stats.tokensByTier, costByFeature: stats.costByFeature, savedUsd: savings.savedUsd, savedPct: savings.savedPct });
       statusThrottleTimeout = null;
     };
     cascade.on("tier:root", onRoot);
@@ -13027,7 +13585,7 @@ ${lastUser.content}`;
       flushPeerEvents();
       const stats = cascade.getRouter().getStats();
       const savings = cascade.getRouter().getDelegationSavings();
-      dispatch({ type: "UPDATE_COST", tokens: stats.totalTokens, costUsd: stats.totalCostUsd, byProvider: stats.callsByProvider, byTier: stats.callsByTier, costByTier: stats.costByTier, tokensByTier: stats.tokensByTier, savedUsd: savings.savedUsd, savedPct: savings.savedPct });
+      dispatch({ type: "UPDATE_COST", tokens: stats.totalTokens, costUsd: stats.totalCostUsd, byProvider: stats.callsByProvider, byTier: stats.callsByTier, costByTier: stats.costByTier, tokensByTier: stats.tokensByTier, costByFeature: stats.costByFeature, savedUsd: savings.savedUsd, savedPct: savings.savedPct });
       dispatch({ type: "COMMIT_STREAM", finalText: result.output, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
       persistMessage("assistant", result.output, (/* @__PURE__ */ new Date()).toISOString());
       const receipt = formatRunReceipt(result, stats.totalCostUsd, savings);
@@ -13312,7 +13870,7 @@ ${lastUser.content}`;
     ),
     adaptiveMode === "wide" && state.showComms && liveBudget.commsMaxEvents > 0 && /* @__PURE__ */ jsx(PeerFeed, { events: state.peerEvents, theme, maxRows: liveBudget.commsMaxEvents }),
     adaptiveMode === "wide" && state.showDetails && liveBudget.showTimeline && /* @__PURE__ */ jsx(TimelinePanel, { nodes: [...treeNodesRef.current.values()], theme, currentIndex: timelineIndex, onChangeIndex: setTimelineIndex }),
-    adaptiveMode !== "narrow" && state.showCost && /* @__PURE__ */ jsx(CostTracker, { theme, totalTokens: state.totalTokens, totalCostUsd: state.totalCostUsd, callsByProvider: state.callsByProvider, callsByTier: state.callsByTier, costByTier: state.costByTier, tokensByTier: state.tokensByTier, compact: liveBudget.costCompact, savedUsd: state.savedUsd, savedPct: state.savedPct }),
+    adaptiveMode !== "narrow" && state.showCost && /* @__PURE__ */ jsx(CostTracker, { theme, totalTokens: state.totalTokens, totalCostUsd: state.totalCostUsd, callsByProvider: state.callsByProvider, callsByTier: state.callsByTier, costByTier: state.costByTier, tokensByTier: state.tokensByTier, costByFeature: state.costByFeature, compact: liveBudget.costCompact, savedUsd: state.savedUsd, savedPct: state.savedPct }),
     liveBudget.collapsed && (state.showCost || state.showDetails || state.agentTree != null) && /* @__PURE__ */ jsx(Text, { color: theme.colors.muted, dimColor: true, children: "  \u25B8 panels collapsed (small terminal)" }),
     state.approvalRequest && /* @__PURE__ */ jsx(ApprovalPrompt, { request: state.approvalRequest, theme, onDecision: (decision) => {
       dispatch({ type: "SET_APPROVAL", request: null });
@@ -13481,7 +14039,7 @@ function stringifySlashOutput(val) {
 }
 async function searchSessionsAndMessages(query, workspacePath) {
   if (!query) return "Usage: /search <query>";
-  const dbPath = path23.join(workspacePath, CASCADE_DB_FILE);
+  const dbPath = path25.join(workspacePath, CASCADE_DB_FILE);
   try {
     await fs9.access(dbPath);
   } catch {
@@ -13515,7 +14073,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(path23.join(workspacePath, CASCADE_DB_FILE));
+  const store = new MemoryStore(path25.join(workspacePath, CASCADE_DB_FILE));
   try {
     const sessions = store.listSessions(void 0, 3);
     return [
@@ -13534,7 +14092,7 @@ async function diagnoseRuntime(config, workspacePath) {
 }
 async function showRecentLogs(args, workspacePath) {
   const limit = Number.parseInt(args[0] ?? "10", 10) || 10;
-  const store = new MemoryStore(path23.join(workspacePath, CASCADE_DB_FILE));
+  const store = new MemoryStore(path25.join(workspacePath, CASCADE_DB_FILE));
   try {
     const logs = store.listRuntimeNodeLogs(void 0, void 0, limit);
     if (!logs.length) return "No recent runtime logs.";
@@ -13546,7 +14104,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(path23.join(workspacePath, CASCADE_DB_FILE));
+  const store = new MemoryStore(path25.join(workspacePath, CASCADE_DB_FILE));
   try {
     const session = store.getSession(sessionId);
     if (!session) return `Session not found: ${sessionId}`;
@@ -13966,9 +14524,9 @@ function SetupWizard({ workspacePath, onComplete }) {
           ...anyAuto ? { cascadeAuto: true } : {}
         };
         const config = CascadeConfigSchema.parse(rawConfig);
-        const configDir = path23.join(workspacePath, ".cascade");
+        const configDir = path25.join(workspacePath, ".cascade");
         await fs9.mkdir(configDir, { recursive: true });
-        const configPath = path23.join(workspacePath, CASCADE_CONFIG_FILE);
+        const configPath = path25.join(workspacePath, CASCADE_CONFIG_FILE);
         await fs9.writeFile(configPath, JSON.stringify(config, null, 2), "utf-8");
         savedConfigRef.current = config;
         dispatchRef.current({ type: "GO_DONE" });
@@ -14290,14 +14848,14 @@ function printTelemetryBanner() {
 async function initCommand(workspacePath = process.cwd()) {
   const spin = ora({ text: "Initializing Cascade project\u2026", color: "magenta" }).start();
   try {
-    const configDir = path23.join(workspacePath, ".cascade");
+    const configDir = path25.join(workspacePath, ".cascade");
     await fs9.mkdir(configDir, { recursive: true });
-    const mdPath = path23.join(workspacePath, "CASCADE.md");
+    const mdPath = path25.join(workspacePath, "CASCADE.md");
     if (!await fileExists(mdPath)) {
       await createDefaultCascadeMd(workspacePath);
       spin.succeed(chalk9.green("Created CASCADE.md"));
     }
-    const ignorePath = path23.join(workspacePath, ".cascadeignore");
+    const ignorePath = path25.join(workspacePath, ".cascadeignore");
     if (!await fileExists(ignorePath)) {
       await createDefaultIgnoreFile(workspacePath);
       spin.succeed(chalk9.green("Created .cascadeignore"));
@@ -14306,7 +14864,7 @@ async function initCommand(workspacePath = process.cwd()) {
     console.log();
     console.log(chalk9.magenta("  \u25C8 Cascade AI \u2014 Project initialized"));
     console.log();
-    const configPath = path23.join(workspacePath, CASCADE_CONFIG_FILE);
+    const configPath = path25.join(workspacePath, CASCADE_CONFIG_FILE);
     if (await fileExists(configPath)) {
       console.log(chalk9.yellow("  .cascade/config.json already exists \u2014 launching wizard to reconfigure."));
       console.log();
@@ -14364,7 +14922,7 @@ function fromEnv(env) {
   return out;
 }
 async function fromClaudeCode(home) {
-  const file = path23.join(home, ".claude", ".credentials.json");
+  const file = path25.join(home, ".claude", ".credentials.json");
   const data = await readJson(file);
   if (!data) return [];
   const oauth = data["claudeAiOauth"];
@@ -14387,7 +14945,7 @@ async function fromClaudeCode(home) {
   return [];
 }
 async function fromCodex(home) {
-  const file = path23.join(home, ".codex", "auth.json");
+  const file = path25.join(home, ".codex", "auth.json");
   const data = await readJson(file);
   if (!data) return [];
   const apiKey = str(data["OPENAI_API_KEY"]);
@@ -14410,7 +14968,7 @@ async function fromCodex(home) {
   return [];
 }
 async function fromGemini(home) {
-  const file = path23.join(home, ".gemini", "oauth_creds.json");
+  const file = path25.join(home, ".gemini", "oauth_creds.json");
   const data = await readJson(file);
   const accessToken = str(data?.["access_token"]);
   if (!accessToken) return [];
@@ -14426,7 +14984,7 @@ async function fromGemini(home) {
 }
 async function fromCopilot(home) {
   for (const name of ["apps.json", "hosts.json"]) {
-    const file = path23.join(home, ".config", "github-copilot", name);
+    const file = path25.join(home, ".config", "github-copilot", name);
     const data = await readJson(file);
     if (!data) continue;
     for (const value of Object.values(data)) {
@@ -14447,7 +15005,7 @@ async function fromCopilot(home) {
   return [];
 }
 async function discoverCredentials(opts = {}) {
-  const home = opts.homeDir ?? os6.homedir();
+  const home = opts.homeDir ?? os8.homedir();
   const env = opts.env ?? process.env;
   const groups = await Promise.all([
     Promise.resolve(fromEnv(env)),
@@ -14480,7 +15038,7 @@ async function doctorCommand() {
   checks.push({
     label: "Cascade config",
     ok: true,
-    detail: `Loaded ${path23.join(process.cwd(), CASCADE_CONFIG_FILE)}`
+    detail: `Loaded ${path25.join(process.cwd(), CASCADE_CONFIG_FILE)}`
   });
   const providers = [
     { type: "anthropic", name: "Anthropic" },
@@ -14759,6 +15317,24 @@ var DashboardSocket = class {
       });
     });
   }
+  onSessionHalt(callback) {
+    this.io.on("connection", (socket) => {
+      socket.on("session:halt", (payload) => {
+        if (typeof payload?.sessionId === "string") {
+          callback(payload.sessionId);
+        }
+      });
+    });
+  }
+  onSessionSteer(callback) {
+    this.io.on("connection", (socket) => {
+      socket.on("session:steer", (payload) => {
+        if (typeof payload?.message === "string" && payload.message.trim()) {
+          callback(payload.message.trim(), payload.sessionId, payload.nodeId);
+        }
+      });
+    });
+  }
   onConfigUpdate(callback) {
     this.io.on("connection", (socket) => {
       socket.on("config:update", (payload) => {
@@ -14793,7 +15369,7 @@ var DashboardSocket = class {
 
 // src/dashboard/server.ts
 init_constants();
-var __dirname$1 = path23.dirname(fileURLToPath(import.meta.url));
+var __dirname$1 = path25.dirname(fileURLToPath(import.meta.url));
 var DashboardServer = class {
   app;
   httpServer;
@@ -14804,6 +15380,13 @@ var DashboardServer = class {
   globalStore = null;
   broadcastTimer = null;
   activeSessions = /* @__PURE__ */ new Map();
+  activeControllers = /* @__PURE__ */ new Map();
+  /**
+   * Run taskIds per chat session — file snapshots are keyed by the run's
+   * taskId (see t3-worker saveSnapshot), so session rollback needs the list
+   * of runs the session performed in this server's lifetime.
+   */
+  sessionTaskIds = /* @__PURE__ */ new Map();
   port;
   host;
   workspacePath;
@@ -14864,6 +15447,8 @@ var DashboardServer = class {
     });
     this.socket.onCascadeRun(async (prompt, model, socketId, requestedSessionId) => {
       const sessionId = requestedSessionId ?? randomUUID();
+      const abortController = new AbortController();
+      this.activeControllers.set(sessionId, abortController);
       const runPrompt = requestedSessionId ? this.buildContinuationPrompt(sessionId, prompt) : prompt;
       const title = this.persistRunStart(sessionId, prompt);
       const cfg = model !== "auto" ? { ...this.config, models: { ...this.config.models, t1: model } } : this.config;
@@ -14882,7 +15467,8 @@ var DashboardServer = class {
         this.socket.emitPeerMessage(e);
       });
       try {
-        const result = await cascade.run({ prompt: runPrompt });
+        const result = await cascade.run({ prompt: runPrompt, signal: abortController.signal });
+        this.recordSessionTask(sessionId, result.taskId);
         this.persistRunEnd(sessionId, title, prompt, result.output, "COMPLETED");
         this.socket.emitToSocket(socketId, "session:complete", { sessionId, result });
         this.socket.broadcast("cost:update", {
@@ -14899,6 +15485,16 @@ var DashboardServer = class {
         });
       } finally {
         this.activeSessions.delete(sessionId);
+        this.activeControllers.delete(sessionId);
+      }
+    });
+    this.socket.onSessionHalt((sessionId) => {
+      this.activeControllers.get(sessionId)?.abort();
+    });
+    this.socket.onSessionSteer((message, sessionId, nodeId) => {
+      const steered = this.steerSessions(message, sessionId, nodeId);
+      if (steered > 0) {
+        this.socket.broadcast("session:message-injected", { sessionId, nodeId, message, steered, requestedAt: (/* @__PURE__ */ new Date()).toISOString() });
       }
     });
   }
@@ -14946,9 +15542,9 @@ var DashboardServer = class {
    */
   persistConfig() {
     try {
-      const configPath = path23.join(this.workspacePath, CASCADE_CONFIG_FILE);
-      fs21.mkdirSync(path23.dirname(configPath), { recursive: true });
-      fs21.writeFileSync(configPath, JSON.stringify(this.config, null, 2), "utf-8");
+      const configPath = path25.join(this.workspacePath, CASCADE_CONFIG_FILE);
+      fs23.mkdirSync(path25.dirname(configPath), { recursive: true });
+      fs23.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)}`);
     }
@@ -14963,15 +15559,15 @@ var DashboardServer = class {
   resolveDashboardSecret() {
     const fromConfig = this.config.dashboard.secret ?? process.env["CASCADE_DASHBOARD_SECRET"];
     if (fromConfig) return fromConfig;
-    const secretPath = path23.join(this.workspacePath, CASCADE_DASHBOARD_SECRET_FILE);
+    const secretPath = path25.join(this.workspacePath, CASCADE_DASHBOARD_SECRET_FILE);
     try {
-      if (fs21.existsSync(secretPath)) {
-        const existing = fs21.readFileSync(secretPath, "utf-8").trim();
+      if (fs23.existsSync(secretPath)) {
+        const existing = fs23.readFileSync(secretPath, "utf-8").trim();
         if (existing.length >= 16) return existing;
       }
       const generated = randomUUID();
-      fs21.mkdirSync(path23.dirname(secretPath), { recursive: true });
-      fs21.writeFileSync(secretPath, generated, { encoding: "utf-8", mode: 384 });
+      fs23.mkdirSync(path25.dirname(secretPath), { recursive: true });
+      fs23.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.`
@@ -14998,7 +15594,7 @@ var DashboardServer = class {
   // ── Setup ─────────────────────────────────────
   getGlobalStore() {
     if (!this.globalStore) {
-      const globalDbPath = path23.join(os6.homedir(), GLOBAL_CONFIG_DIR, GLOBAL_RUNTIME_DB_FILE);
+      const globalDbPath = path25.join(os8.homedir(), GLOBAL_CONFIG_DIR, GLOBAL_RUNTIME_DB_FILE);
       this.globalStore = new MemoryStore(globalDbPath);
     }
     return this.globalStore;
@@ -15046,6 +15642,21 @@ var DashboardServer = class {
     }
     this.persistRuntimeRow(sessionId, title, status, latestPrompt);
   }
+  /**
+   * Route steering text into running Cascade instances. Targets the given
+   * session, or every active session when none is specified (the desktop
+   * usually has exactly one run in flight). Returns how many were reached.
+   */
+  steerSessions(message, sessionId, nodeId) {
+    const targets = sessionId ? [this.activeSessions.get(sessionId)].filter((c) => !!c) : [...this.activeSessions.values()];
+    for (const cascade of targets) cascade.injectGuidance(message, nodeId);
+    return targets.length;
+  }
+  recordSessionTask(sessionId, taskId) {
+    const list = this.sessionTaskIds.get(sessionId) ?? [];
+    list.push(taskId);
+    this.sessionTaskIds.set(sessionId, list);
+  }
   persistRuntimeRow(sessionId, title, status, latestPrompt) {
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const row = { sessionId, title, workspacePath: this.workspacePath, status, startedAt: now, updatedAt: now, latestPrompt, isGlobal: false };
@@ -15139,12 +15750,12 @@ ${prompt}`;
     }
   }
   watchRuntimeChanges() {
-    const workspaceDbPath = path23.join(this.workspacePath, CASCADE_DB_FILE);
-    const globalDbPath = path23.join(os6.homedir(), GLOBAL_CONFIG_DIR, GLOBAL_RUNTIME_DB_FILE);
+    const workspaceDbPath = path25.join(this.workspacePath, CASCADE_DB_FILE);
+    const globalDbPath = path25.join(os8.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 (!fs21.existsSync(watchPath)) continue;
-      fs21.watchFile(watchPath, { interval: 3e3 }, () => {
+      if (!fs23.existsSync(watchPath)) continue;
+      fs23.watchFile(watchPath, { interval: 3e3 }, () => {
         this.throttledBroadcast(watchPath === globalDbPath ? "global" : "workspace");
       });
     }
@@ -15252,7 +15863,8 @@ ${prompt}`;
         res.status(400).json({ error: "message is required and must be a string" });
         return;
       }
-      const payload = { sessionId, nodeId, message, requestedAt: (/* @__PURE__ */ new Date()).toISOString() };
+      const steered = this.steerSessions(message, sessionId, nodeId);
+      const payload = { sessionId, nodeId, message, steered, requestedAt: (/* @__PURE__ */ new Date()).toISOString() };
       this.socket.broadcast("session:message-injected", payload);
       if (sessionId) this.socket.broadcastToRoom(`session:${sessionId}`, "session:message-injected", payload);
       res.json({ success: true, ...payload });
@@ -15274,7 +15886,7 @@ ${prompt}`;
       const sessionId = req.params.id;
       this.store.deleteSession(sessionId);
       this.store.deleteRuntimeSession(sessionId);
-      const globalDbPath = path23.join(os6.homedir(), GLOBAL_CONFIG_DIR, GLOBAL_RUNTIME_DB_FILE);
+      const globalDbPath = path25.join(os8.homedir(), GLOBAL_CONFIG_DIR, GLOBAL_RUNTIME_DB_FILE);
       const globalStore = new MemoryStore(globalDbPath);
       try {
         globalStore.deleteRuntimeSession(sessionId);
@@ -15286,9 +15898,34 @@ ${prompt}`;
       this.socket.broadcast("runtime:refresh", { scope: "global" });
       res.json({ ok: true });
     });
+    this.app.post("/api/sessions/:id/rollback", auth, mutationLimiter, async (req, res) => {
+      const sessionId = req.params.id;
+      const taskIds = this.sessionTaskIds.get(sessionId) ?? [];
+      if (!taskIds.length) {
+        res.json({ ok: true, restored: 0, message: "No file snapshots recorded for this session in the current app run." });
+        return;
+      }
+      const toRestore = /* @__PURE__ */ new Map();
+      for (const taskId of taskIds) {
+        for (const { filePath, content } of this.store.getLatestFileSnapshots(taskId)) {
+          if (!toRestore.has(filePath)) toRestore.set(filePath, content);
+        }
+      }
+      const { writeFile } = await import('fs/promises');
+      let restored = 0;
+      for (const [filePath, content] of toRestore) {
+        try {
+          await writeFile(filePath, content, "utf-8");
+          restored++;
+        } catch (err) {
+          console.warn(`[dashboard] rollback restore failed: ${filePath}`, err);
+        }
+      }
+      res.json({ ok: true, restored });
+    });
     this.app.delete("/api/sessions", auth, (req, res) => {
       const body = req.body;
-      const globalDbPath = path23.join(os6.homedir(), GLOBAL_CONFIG_DIR, GLOBAL_RUNTIME_DB_FILE);
+      const globalDbPath = path25.join(os8.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 {
@@ -15311,7 +15948,7 @@ ${prompt}`;
     });
     this.app.delete("/api/runtime", auth, (_req, res) => {
       this.store.deleteAllRuntimeNodes();
-      const globalDbPath = path23.join(os6.homedir(), GLOBAL_CONFIG_DIR, GLOBAL_RUNTIME_DB_FILE);
+      const globalDbPath = path25.join(os8.homedir(), GLOBAL_CONFIG_DIR, GLOBAL_RUNTIME_DB_FILE);
       const globalStore = new MemoryStore(globalDbPath);
       try {
         globalStore.deleteAllRuntimeNodes();
@@ -15362,6 +15999,19 @@ ${prompt}`;
       this.store.deleteIdentity(req.params.id);
       res.json({ ok: true });
     });
+    this.app.get("/api/audit/verify", auth, async (_req, res) => {
+      try {
+        const { AuditLogger: AuditLogger3 } = await Promise.resolve().then(() => (init_audit_logger(), audit_logger_exports));
+        const logger = new AuditLogger3(this.workspacePath);
+        try {
+          res.json(logger.verifyChain());
+        } finally {
+          logger.close();
+        }
+      } catch (err) {
+        res.status(500).json({ error: err instanceof Error ? err.message : String(err) });
+      }
+    });
     this.app.get("/api/audit/:sessionId", auth, (req, res) => {
       const log = this.store.getAuditLog(req.params.sessionId);
       res.json(log);
@@ -15384,12 +16034,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 = path23.join(this.workspacePath, CASCADE_CONFIG_FILE);
-        const existing = fs21.existsSync(configPath) ? JSON.parse(fs21.readFileSync(configPath, "utf-8")) : {};
+        const configPath = path25.join(this.workspacePath, CASCADE_CONFIG_FILE);
+        const existing = fs23.existsSync(configPath) ? JSON.parse(fs23.readFileSync(configPath, "utf-8")) : {};
         const updated = { ...existing, tierLimits: this.config.tierLimits, budget: this.config.budget };
         const tmp = configPath + ".tmp";
-        fs21.writeFileSync(tmp, JSON.stringify(updated, null, 2), "utf-8");
-        fs21.renameSync(tmp, configPath);
+        fs23.writeFileSync(tmp, JSON.stringify(updated, null, 2), "utf-8");
+        fs23.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)}` });
@@ -15417,7 +16067,7 @@ ${prompt}`;
     this.app.get("/api/runtime", auth, (req, res) => {
       const scope = req.query["scope"] ?? "workspace";
       if (scope === "global") {
-        const globalDbPath = path23.join(os6.homedir(), GLOBAL_CONFIG_DIR, GLOBAL_RUNTIME_DB_FILE);
+        const globalDbPath = path25.join(os8.homedir(), GLOBAL_CONFIG_DIR, GLOBAL_RUNTIME_DB_FILE);
         const globalStore = new MemoryStore(globalDbPath);
         try {
           res.json({
@@ -15467,6 +16117,7 @@ ${prompt}`;
         });
         try {
           const result = await cascade.run({ prompt: runPrompt, identityId: body.identityId });
+          this.recordSessionTask(sessionId, result.taskId);
           this.persistRunEnd(sessionId, title, prompt, result.output, "COMPLETED");
           this.socket.broadcast("cost:update", {
             sessionId,
@@ -15497,13 +16148,13 @@ ${prompt}`;
         }))
       });
     });
-    const prodPath = path23.resolve(__dirname$1, "../web/dist");
-    const devPath = path23.resolve(__dirname$1, "../../web/dist");
-    const webDistPath = fs21.existsSync(prodPath) ? prodPath : devPath;
-    if (fs21.existsSync(webDistPath)) {
+    const prodPath = path25.resolve(__dirname$1, "../web/dist");
+    const devPath = path25.resolve(__dirname$1, "../../web/dist");
+    const webDistPath = fs23.existsSync(prodPath) ? prodPath : devPath;
+    if (fs23.existsSync(webDistPath)) {
       this.app.use(express.static(webDistPath));
       this.app.get("*", (_req, res) => {
-        res.sendFile(path23.join(webDistPath, "index.html"));
+        res.sendFile(path25.join(webDistPath, "index.html"));
       });
     } else {
       this.app.get("/", (_req, res) => {
@@ -15524,7 +16175,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(path23.join(workspacePath, CASCADE_DB_FILE));
+  const store = new MemoryStore(path25.join(workspacePath, CASCADE_DB_FILE));
   const server = new DashboardServer(config, store, workspacePath);
   server.watchRuntimeChanges();
   const gThis = globalThis;
@@ -15556,7 +16207,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(path23.join(workspacePath, CASCADE_DB_FILE));
+    const store = new MemoryStore(path25.join(workspacePath, CASCADE_DB_FILE));
     try {
       const identities = store.listIdentities();
       console.log(chalk9.bold("\n  Identities:"));
@@ -15576,7 +16227,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(path23.join(workspacePath, CASCADE_DB_FILE));
+    const store = new MemoryStore(path25.join(workspacePath, CASCADE_DB_FILE));
     try {
       if (options.default) {
         const existingDefault = store.getDefaultIdentity();
@@ -15602,7 +16253,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(path23.join(workspacePath, CASCADE_DB_FILE));
+    const store = new MemoryStore(path25.join(workspacePath, CASCADE_DB_FILE));
     try {
       const identities = store.listIdentities();
       const match = identities.find((i) => i.id === query || i.name.toLowerCase() === query.toLowerCase());
@@ -15730,8 +16381,8 @@ async function exportCommand(options = {}) {
   let store;
   try {
     const workspacePath = options.workspacePath ?? process.cwd();
-    const workspaceDbPath = path23.join(workspacePath, CASCADE_DB_FILE);
-    const globalDbPath = path23.join(os6.homedir(), GLOBAL_CONFIG_DIR, GLOBAL_DB_FILE);
+    const workspaceDbPath = path25.join(workspacePath, CASCADE_DB_FILE);
+    const globalDbPath = path25.join(os8.homedir(), GLOBAL_CONFIG_DIR, GLOBAL_DB_FILE);
     let dbPath = globalDbPath;
     try {
       await fs9.access(workspaceDbPath);
@@ -15773,7 +16424,7 @@ async function exportCommand(options = {}) {
     const ext = format === "json" ? ".json" : ".md";
     const safeName = session.title.replace(/[^\w\s-]/g, "").replace(/\s+/g, "-").slice(0, 60);
     const defaultFile = `cascade-export-${safeName}${ext}`;
-    const outPath = options.output ? path23.resolve(options.output) : path23.join(process.cwd(), defaultFile);
+    const outPath = options.output ? path25.resolve(options.output) : path25.join(process.cwd(), defaultFile);
     await fs9.writeFile(outPath, content, "utf-8");
     spin.succeed(chalk9.green(`Exported to ${chalk9.white(outPath)}`));
     const messageCount = Array.isArray(session.messages) ? session.messages.length : 0;
@@ -16001,11 +16652,11 @@ async function statsCommand() {
 dotenv.config();
 function warnIfBuildIsStale() {
   try {
-    const here = path23.dirname(fileURLToPath(import.meta.url));
+    const here = path25.dirname(fileURLToPath(import.meta.url));
     for (const rel of ["..", "../.."]) {
-      const pkgPath = path23.join(here, rel, "package.json");
-      if (!fs21.existsSync(pkgPath)) continue;
-      const pkg = JSON.parse(fs21.readFileSync(pkgPath, "utf-8"));
+      const pkgPath = path25.join(here, rel, "package.json");
+      if (!fs23.existsSync(pkgPath)) continue;
+      const pkg = JSON.parse(fs23.readFileSync(pkgPath, "utf-8"));
       if (pkg.name !== "cascade-ai") continue;
       if (pkg.version && pkg.version !== CASCADE_VERSION) {
         console.error(