cascade-ai 0.12.23 → 0.13.1

package/dist/index.cjs

@@ -1,7 +1,11 @@
 'use strict';
 
+var Database = require('better-sqlite3');
+var path20 = require('path');
+var fs19 = require('fs');
+var os6 = require('os');
+var crypto3 = require('crypto');
 var EventEmitter = require('events');
-var crypto = require('crypto');
 var glob = require('glob');
 var Anthropic = require('@anthropic-ai/sdk');
 var OpenAI = require('openai');
@@ -12,12 +16,9 @@ var https = require('https');
 var zlib = require('zlib');
 var stream = require('stream');
 var fs4 = require('fs/promises');
-var path18 = require('path');
-var os4 = require('os');
 var ignoreFactory = require('ignore');
 var child_process = require('child_process');
 var util = require('util');
-var fs17 = require('fs');
 var simpleGit = require('simple-git');
 var PDFDocument = require('pdfkit');
 var dns2 = require('dns/promises');
@@ -26,7 +27,6 @@ var index_js = require('@modelcontextprotocol/sdk/client/index.js');
 var stdio_js = require('@modelcontextprotocol/sdk/client/stdio.js');
 var zod = require('zod');
 var worker_threads = require('worker_threads');
-var Database = require('better-sqlite3');
 var url = require('url');
 var express = require('express');
 var rateLimit = require('express-rate-limit');
@@ -57,8 +57,12 @@ function _interopNamespace(e) {
   return Object.freeze(n);
 }
 
+var Database__default = /*#__PURE__*/_interopDefault(Database);
+var path20__default = /*#__PURE__*/_interopDefault(path20);
+var fs19__default = /*#__PURE__*/_interopDefault(fs19);
+var os6__default = /*#__PURE__*/_interopDefault(os6);
+var crypto3__default = /*#__PURE__*/_interopDefault(crypto3);
 var EventEmitter__default = /*#__PURE__*/_interopDefault(EventEmitter);
-var crypto__default = /*#__PURE__*/_interopDefault(crypto);
 var Anthropic__default = /*#__PURE__*/_interopDefault(Anthropic);
 var OpenAI__default = /*#__PURE__*/_interopDefault(OpenAI);
 var dns__default = /*#__PURE__*/_interopDefault(dns);
@@ -66,14 +70,10 @@ var http__default = /*#__PURE__*/_interopDefault(http);
 var https__default = /*#__PURE__*/_interopDefault(https);
 var zlib__default = /*#__PURE__*/_interopDefault(zlib);
 var fs4__default = /*#__PURE__*/_interopDefault(fs4);
-var path18__default = /*#__PURE__*/_interopDefault(path18);
-var os4__default = /*#__PURE__*/_interopDefault(os4);
 var ignoreFactory__namespace = /*#__PURE__*/_interopNamespace(ignoreFactory);
-var fs17__default = /*#__PURE__*/_interopDefault(fs17);
 var PDFDocument__default = /*#__PURE__*/_interopDefault(PDFDocument);
 var dns2__default = /*#__PURE__*/_interopDefault(dns2);
 var net__default = /*#__PURE__*/_interopDefault(net);
-var Database__default = /*#__PURE__*/_interopDefault(Database);
 var express__default = /*#__PURE__*/_interopDefault(express);
 var rateLimit__default = /*#__PURE__*/_interopDefault(rateLimit);
 var bcrypt__default = /*#__PURE__*/_interopDefault(bcrypt);
@@ -82,10 +82,161 @@ var jwt__default = /*#__PURE__*/_interopDefault(jwt);
 var cron__default = /*#__PURE__*/_interopDefault(cron);
 
 // Cascade AI — Multi-tier AI Orchestration System
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 
+// 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 = path20__default.default.join(workspacePath, ".cascade");
+        if (!fs19__default.default.existsSync(cascadeDir)) {
+          fs19__default.default.mkdirSync(cascadeDir, { recursive: true });
+        }
+        this.keyPath = path20__default.default.join(cascadeDir, "audit_log.key");
+        this.dbPath = path20__default.default.join(cascadeDir, "audit_log.db");
+        this.initEncryptionKey();
+        this.db = new Database__default.default(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 crypto3__default.default.createHash("sha256").update(`${prevHash}|${timestamp}|${eventType}|${tierId}|${encryptedPayload}`).digest("hex");
+      }
+      initEncryptionKey() {
+        if (fs19__default.default.existsSync(this.keyPath)) {
+          this.encryptionKey = fs19__default.default.readFileSync(this.keyPath);
+        } else {
+          this.encryptionKey = crypto3__default.default.randomBytes(32);
+          fs19__default.default.writeFileSync(this.keyPath, this.encryptionKey);
+        }
+      }
+      encrypt(text) {
+        const iv = crypto3__default.default.randomBytes(16);
+        const cipher = crypto3__default.default.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 = crypto3__default.default.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 = crypto3__default.default.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 = path20__default.default.join(os6__default.default.tmpdir(), "cascade_audit_logs_debug.json");
+          const entries = this.getAllLogs();
+          fs19__default.default.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/constants.ts
-var CASCADE_VERSION = "0.12.23";
+var CASCADE_VERSION = "0.13.1";
 var CASCADE_CONFIG_DIR = ".cascade";
 var CASCADE_MD_FILE = "CASCADE.md";
 var CASCADE_IGNORE_FILE = ".cascadeignore";
@@ -2017,7 +2168,7 @@ function computeDelegationSavings(stats, t1Model) {
 var DEFAULT_SNAPSHOT_URL = "https://raw.githubusercontent.com/Varun-SV/Cascade-AI/main/src/core/router/benchmark-data.json";
 var OPENROUTER_MODELS_URL = "https://openrouter.ai/api/v1/models";
 var FETCH_TIMEOUT_MS = 8e3;
-var DEFAULT_CACHE_FILE = path18__default.default.join(os4__default.default.homedir(), GLOBAL_CONFIG_DIR, "benchmarks-cache.json");
+var DEFAULT_CACHE_FILE = path20__default.default.join(os6__default.default.homedir(), GLOBAL_CONFIG_DIR, "benchmarks-cache.json");
 function normalizeModelId(id) {
   let s = id.toLowerCase();
   const slash = s.lastIndexOf("/");
@@ -2132,7 +2283,7 @@ var LiveDataProvider = class {
   }
   async saveCache() {
     try {
-      await fs4__default.default.mkdir(path18__default.default.dirname(this.opts.cacheFile), { recursive: true });
+      await fs4__default.default.mkdir(path20__default.default.dirname(this.opts.cacheFile), { recursive: true });
       const cache = {
         fetchedAt: this.fetchedAt,
         snapshot: this.snapshot ?? void 0,
@@ -2262,7 +2413,8 @@ var CascadeRouter = class _CascadeRouter extends EventEmitter__default.default {
     costByTier: {},
     tokensByTier: {},
     inputTokensByTier: {},
-    outputTokensByTier: {}
+    outputTokensByTier: {},
+    costByFeature: {}
   };
   tierModels = /* @__PURE__ */ new Map();
   config;
@@ -2284,6 +2436,9 @@ var CascadeRouter = class _CascadeRouter extends EventEmitter__default.default {
   tpmLimiter;
   localQueue;
   taskAnalyzer;
+  worldStateDB;
+  privacyPaths;
+  guidanceQueue;
   liveData;
   /** Snapshot of configured/default tier models, taken before Cascade Auto overrides them. */
   originalTierModels;
@@ -2441,7 +2596,17 @@ var CascadeRouter = class _CascadeRouter extends EventEmitter__default.default {
     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}`);
@@ -2513,7 +2678,7 @@ var CascadeRouter = class _CascadeRouter extends EventEmitter__default.default {
       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) {
@@ -2618,6 +2783,42 @@ var CascadeRouter = class _CascadeRouter extends EventEmitter__default.default {
   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
@@ -2641,7 +2842,8 @@ var CascadeRouter = class _CascadeRouter extends EventEmitter__default.default {
       costByTier: { ...this.stats.costByTier },
       tokensByTier: { ...this.stats.tokensByTier },
       inputTokensByTier: { ...this.stats.inputTokensByTier },
-      outputTokensByTier: { ...this.stats.outputTokensByTier }
+      outputTokensByTier: { ...this.stats.outputTokensByTier },
+      costByFeature: { ...this.stats.costByFeature }
     };
   }
   /**
@@ -2691,7 +2893,8 @@ var CascadeRouter = class _CascadeRouter extends EventEmitter__default.default {
       costByTier: {},
       tokensByTier: {},
       inputTokensByTier: {},
-      outputTokensByTier: {}
+      outputTokensByTier: {},
+      costByFeature: {}
     };
     this.sessionCostUsd = 0;
     this.budgetState = "ok";
@@ -2857,7 +3060,7 @@ var CascadeRouter = class _CascadeRouter extends EventEmitter__default.default {
     }
     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;
@@ -2867,6 +3070,9 @@ var CascadeRouter = class _CascadeRouter extends EventEmitter__default.default {
     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();
@@ -2966,7 +3172,7 @@ var BaseTier = class extends EventEmitter__default.default {
   constructor(role, id, parentId) {
     super();
     this.role = role;
-    this.id = id ?? `${role}_${crypto.randomUUID().slice(0, 8)}`;
+    this.id = id ?? `${role}_${crypto3.randomUUID().slice(0, 8)}`;
     this.parentId = parentId;
     this.label = this.id;
   }
@@ -3217,7 +3423,7 @@ var AuditLogger = class {
   logAt(level, tierId, action, details) {
     if (!this.shouldLog(level)) return;
     const entry = {
-      id: crypto.randomUUID(),
+      id: crypto3.randomUUID(),
       sessionId: this.sessionId,
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
       tierId,
@@ -3403,6 +3609,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;
@@ -3458,6 +3666,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, {
@@ -3588,9 +3801,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");
@@ -3663,6 +3884,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 ? `
@@ -3671,7 +3902,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",
@@ -3835,8 +4068,8 @@ HIERARCHY CONTEXT: ${this.hierarchyContext}` : "") + textToolSuffix,
         tierId: this.id,
         sessionId: this.taskId,
         requireApproval: false,
-        saveSnapshot: async (path19, content) => {
-          this.store?.addFileSnapshot(this.taskId, path19, content);
+        saveSnapshot: async (path21, content) => {
+          this.store?.addFileSnapshot(this.taskId, path21, content);
         },
         sendPeerSync: (to, syncType, content) => {
           this.peerBus?.send(this.id, to, syncType, this.assignment?.subtaskId ?? "", content);
@@ -4006,7 +4239,7 @@ ${assignment.expectedOutput}`;
     const { promisify: promisify4 } = await import('util');
     const execAsync2 = promisify4(exec2);
     for (const artifactPath of artifactPaths) {
-      const absolutePath = path18__default.default.resolve(process.cwd(), artifactPath);
+      const absolutePath = path20__default.default.resolve(process.cwd(), artifactPath);
       try {
         const stat = await fs4__default.default.stat(absolutePath);
         if (!stat.isFile()) {
@@ -4027,7 +4260,7 @@ ${assignment.expectedOutput}`;
           issues.push(`PDF artifact looks too small to be valid: ${artifactPath}`);
           continue;
         }
-        const ext = path18__default.default.extname(absolutePath).toLowerCase();
+        const ext = path20__default.default.extname(absolutePath).toLowerCase();
         try {
           if (ext === ".ts" || ext === ".tsx") {
             await execAsync2(`npx tsc --noEmit ${absolutePath}`, { timeout: 1e4 });
@@ -4056,30 +4289,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",
@@ -4091,16 +4329,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;
   }
@@ -4121,7 +4363,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);
@@ -4216,6 +4460,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
     };
   }
@@ -4507,6 +4752,42 @@ var PeerBus = class extends EventEmitter__default.default {
   }
 };
 
+// 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, str) => {
+          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.
@@ -4735,16 +5016,19 @@ 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: crypto.randomUUID(),
+        subtaskId: crypto3.randomUUID(),
         subtaskTitle: assignment.sectionTitle,
         description: assignment.description,
         expectedOutput: assignment.expectedOutput,
         constraints: assignment.constraints,
         peerT3Ids: [],
         parentT2: this.id,
+        sectionTitle: assignment.sectionTitle,
+        dependsOn: [],
         executionMode: "parallel"
       }];
     }
@@ -4864,6 +5148,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;
       };
@@ -5302,7 +5594,7 @@ var T1Administrator = class extends BaseTier {
   }
   async execute(userPrompt, images, systemContext, signal) {
     this.signal = signal;
-    this.taskId = crypto.randomUUID();
+    this.taskId = crypto3.randomUUID();
     this.setLabel("Administrator");
     this.setStatus("ACTIVE");
     this.taskGoal = userPrompt;
@@ -5493,10 +5785,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}
 
@@ -5978,16 +6275,16 @@ function resolveInWorkspace(workspaceRoot, input) {
   if (typeof input !== "string" || input.length === 0) {
     throw new WorkspaceSandboxError(String(input), workspaceRoot);
   }
-  const root = path18__default.default.resolve(workspaceRoot);
-  const abs = path18__default.default.isAbsolute(input) ? path18__default.default.resolve(input) : path18__default.default.resolve(root, input);
-  const rel = path18__default.default.relative(root, abs);
-  if (rel === "" || rel === ".") ; else if (rel.startsWith("..") || path18__default.default.isAbsolute(rel)) {
+  const root = path20__default.default.resolve(workspaceRoot);
+  const abs = path20__default.default.isAbsolute(input) ? path20__default.default.resolve(input) : path20__default.default.resolve(root, input);
+  const rel = path20__default.default.relative(root, abs);
+  if (rel === "" || rel === ".") ; else if (rel.startsWith("..") || path20__default.default.isAbsolute(rel)) {
     throw new WorkspaceSandboxError(input, root);
   }
   try {
-    const real = fs17__default.default.realpathSync(abs);
-    const realRel = path18__default.default.relative(root, real);
-    if (realRel !== "" && realRel !== "." && (realRel.startsWith("..") || path18__default.default.isAbsolute(realRel))) {
+    const real = fs19__default.default.realpathSync(abs);
+    const realRel = path20__default.default.relative(root, real);
+    if (realRel !== "" && realRel !== "." && (realRel.startsWith("..") || path20__default.default.isAbsolute(realRel))) {
       throw new WorkspaceSandboxError(input, root);
     }
   } catch (e) {
@@ -6048,7 +6345,7 @@ var FileWriteTool = class extends BaseTool {
       } catch {
       }
     }
-    await fs4__default.default.mkdir(path18__default.default.dirname(absPath), { recursive: true });
+    await fs4__default.default.mkdir(path20__default.default.dirname(absPath), { recursive: true });
     await fs4__default.default.writeFile(absPath, content, "utf-8");
     return `Written ${content.length} characters to ${filePath}`;
   }
@@ -6546,7 +6843,7 @@ var ImageAnalyzeTool = class extends BaseTool {
 };
 async function fileToImageAttachment(filePath) {
   const data = await fs4__default.default.readFile(filePath);
-  const ext = path18__default.default.extname(filePath).toLowerCase();
+  const ext = path20__default.default.extname(filePath).toLowerCase();
   const mimeMap = {
     ".jpg": "image/jpeg",
     ".jpeg": "image/jpeg",
@@ -6580,14 +6877,14 @@ var PDFCreateTool = class extends BaseTool {
     const filePath = input["path"];
     const content = input["content"];
     const title = input["title"];
-    const dir = path18__default.default.dirname(filePath);
-    if (!fs17__default.default.existsSync(dir)) {
-      fs17__default.default.mkdirSync(dir, { recursive: true });
+    const dir = path20__default.default.dirname(filePath);
+    if (!fs19__default.default.existsSync(dir)) {
+      fs19__default.default.mkdirSync(dir, { recursive: true });
     }
     return new Promise((resolve, reject) => {
       try {
         const doc = new PDFDocument__default.default({ margin: 50 });
-        const stream = fs17__default.default.createWriteStream(filePath);
+        const stream = fs19__default.default.createWriteStream(filePath);
         doc.pipe(stream);
         if (title) {
           doc.info["Title"] = title;
@@ -6665,22 +6962,22 @@ var CodeInterpreterTool = class extends BaseTool {
       }
       cmdPrefix = NODE_CMD;
     }
-    const tmpDir = path18__default.default.join(this.workspaceRoot, ".cascade", "tmp");
-    if (!fs17__default.default.existsSync(tmpDir)) {
-      fs17__default.default.mkdirSync(tmpDir, { recursive: true });
+    const tmpDir = path20__default.default.join(this.workspaceRoot, ".cascade", "tmp");
+    if (!fs19__default.default.existsSync(tmpDir)) {
+      fs19__default.default.mkdirSync(tmpDir, { recursive: true });
     }
     const extension = language === "python" ? "py" : "js";
-    const fileName = `intp_${crypto.randomUUID().slice(0, 8)}.${extension}`;
-    const filePath = path18__default.default.join(tmpDir, fileName);
-    fs17__default.default.writeFileSync(filePath, code, "utf-8");
+    const fileName = `intp_${crypto3.randomUUID().slice(0, 8)}.${extension}`;
+    const filePath = path20__default.default.join(tmpDir, fileName);
+    fs19__default.default.writeFileSync(filePath, code, "utf-8");
     const execArgs = [filePath, ...args];
     return new Promise((resolve) => {
       const startMs = Date.now();
       child_process.execFile(cmdPrefix, execArgs, { cwd: this.workspaceRoot, timeout: 3e4 }, (error, stdout, stderr) => {
         const duration = Date.now() - startMs;
         try {
-          if (fs17__default.default.existsSync(filePath)) {
-            fs17__default.default.unlinkSync(filePath);
+          if (fs19__default.default.existsSync(filePath)) {
+            fs19__default.default.unlinkSync(filePath);
           }
         } catch (cleanupErr) {
           console.error(`Failed to cleanup interpreter script ${filePath}:`, cleanupErr);
@@ -6959,7 +7256,7 @@ var GlobTool = class extends BaseTool {
   };
   async execute(input, _options) {
     const pattern = input["pattern"];
-    const searchPath = input["path"] ? path18__default.default.resolve(this.workspaceRoot, input["path"]) : this.workspaceRoot;
+    const searchPath = input["path"] ? path20__default.default.resolve(this.workspaceRoot, input["path"]) : this.workspaceRoot;
     const matches = await glob.glob(pattern, {
       cwd: searchPath,
       ignore: ["node_modules/**", ".git/**", "dist/**", "build/**"],
@@ -6972,7 +7269,7 @@ var GlobTool = class extends BaseTool {
     const withMtime = await Promise.all(
       matches.map(async (rel) => {
         try {
-          const stat = await fs4__default.default.stat(path18__default.default.join(searchPath, rel));
+          const stat = await fs4__default.default.stat(path20__default.default.join(searchPath, rel));
           return { rel, mtime: stat.mtimeMs };
         } catch {
           return { rel, mtime: 0 };
@@ -7021,7 +7318,7 @@ var GrepTool = class extends BaseTool {
   };
   async execute(input, _options) {
     const pattern = input["pattern"];
-    const searchPath = input["path"] ? path18__default.default.resolve(this.workspaceRoot, input["path"]) : this.workspaceRoot;
+    const searchPath = input["path"] ? path20__default.default.resolve(this.workspaceRoot, input["path"]) : this.workspaceRoot;
     const globPattern = input["glob"];
     const outputMode = input["output_mode"] ?? "content";
     const context = input["context"] ?? 0;
@@ -7075,12 +7372,12 @@ var GrepTool = class extends BaseTool {
         nodir: true
       });
     } catch {
-      files = [path18__default.default.relative(searchPath, searchPath) || "."];
+      files = [path20__default.default.relative(searchPath, searchPath) || "."];
     }
     const results = [];
     let totalCount = 0;
     for (const rel of files) {
-      const abs = path18__default.default.join(searchPath, rel);
+      const abs = path20__default.default.join(searchPath, rel);
       let content;
       try {
         content = await fs4__default.default.readFile(abs, "utf-8");
@@ -7442,10 +7739,10 @@ var ToolRegistry = class extends EventEmitter__default.default {
   }
   isIgnored(filePath) {
     if (!filePath) return false;
-    const abs = path18__default.default.resolve(this.workspaceRoot, filePath);
-    const rel = path18__default.default.relative(this.workspaceRoot, abs);
-    if (!rel || rel.startsWith("..") || path18__default.default.isAbsolute(rel)) return true;
-    const posixRel = rel.split(path18__default.default.sep).join("/");
+    const abs = path20__default.default.resolve(this.workspaceRoot, filePath);
+    const rel = path20__default.default.relative(this.workspaceRoot, abs);
+    if (!rel || rel.startsWith("..") || path20__default.default.isAbsolute(rel)) return true;
+    const posixRel = rel.split(path20__default.default.sep).join("/");
     return this.ignoreMatcher.ignores(posixRel);
   }
 };
@@ -7562,6 +7859,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",
@@ -7814,7 +8114,8 @@ var WorkspaceConfigSchema = zod.z.object({
   cascadeMdPath: zod.z.string().default("CASCADE.md"),
   configPath: zod.z.string().default(".cascade/config.json"),
   keystorePath: zod.z.string().default(".cascade/keystore.enc"),
-  auditLogPath: zod.z.string().default(".cascade/audit.log")
+  auditLogPath: zod.z.string().default(".cascade/audit.log"),
+  debugWorldState: zod.z.boolean().default(false)
 });
 var CascadeConfigSchema = zod.z.object({
   version: zod.z.literal("1.0").default("1.0"),
@@ -7959,6 +8260,14 @@ var CascadeConfigSchema = zod.z.object({
    *   'parallel' / 'sequential' — force it.
    */
   t3Execution: zod.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: zod.z.object({
+    paths: zod.z.array(zod.z.object({ pattern: zod.z.string().min(1), policy: zod.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
@@ -8227,9 +8536,10 @@ var TaskAnalyzer = class {
     analysisCache.clear();
   }
 };
-var DEFAULT_STATS_FILE = path18__default.default.join(os4__default.default.homedir(), ".cascade", "model-perf.json");
+var DEFAULT_STATS_FILE = path20__default.default.join(os6__default.default.homedir(), ".cascade", "model-perf.json");
 var ModelPerformanceTracker = class {
   stats = /* @__PURE__ */ new Map();
+  featureStats = /* @__PURE__ */ new Map();
   statsFile;
   loaded = false;
   constructor(statsFile = DEFAULT_STATS_FILE) {
@@ -8241,18 +8551,29 @@ var ModelPerformanceTracker = class {
     try {
       const raw = await fs4__default.default.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 fs4__default.default.mkdir(path18__default.default.dirname(this.statsFile), { recursive: true });
-      const obj = {};
-      for (const [key, stat] of this.stats) obj[key] = stat;
-      await fs4__default.default.writeFile(this.statsFile, JSON.stringify(obj, null, 2), "utf-8");
+      await fs4__default.default.mkdir(path20__default.default.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 fs4__default.default.writeFile(this.statsFile, JSON.stringify({ models: modelsObj, features: featuresObj }, null, 2), "utf-8");
     } catch {
     }
   }
@@ -8273,6 +8594,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.
@@ -8287,6 +8615,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.
@@ -8651,7 +8982,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 = path18__default.default.join(this.workspacePath, ".cascade", DYNAMIC_TOOLS_FILE);
+    const file = path20__default.default.join(this.workspacePath, ".cascade", DYNAMIC_TOOLS_FILE);
     try {
       const raw = await fs4__default.default.readFile(file, "utf-8");
       const specs = JSON.parse(raw);
@@ -8675,8 +9006,8 @@ Required capability: ${description.slice(0, 300)}`;
   }
   async persist() {
     if (!this.workspacePath || !this.persistEnabled) return;
-    const dir = path18__default.default.join(this.workspacePath, ".cascade");
-    const file = path18__default.default.join(dir, DYNAMIC_TOOLS_FILE);
+    const dir = path20__default.default.join(this.workspacePath, ".cascade");
+    const file = path20__default.default.join(dir, DYNAMIC_TOOLS_FILE);
     try {
       await fs4__default.default.mkdir(dir, { recursive: true });
       await fs4__default.default.writeFile(file, JSON.stringify(Array.from(this.specs.values()), null, 2), "utf-8");
@@ -8689,6 +9020,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 = path20__default.default.join(workspacePath, ".cascade");
+    if (!fs19__default.default.existsSync(cascadeDir)) {
+      fs19__default.default.mkdirSync(cascadeDir, { recursive: true });
+    }
+    this.keyPath = path20__default.default.join(cascadeDir, "world_state.key");
+    this.dbPath = path20__default.default.join(cascadeDir, "world_state.db");
+    this.initEncryptionKey();
+    this.db = new Database__default.default(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 (fs19__default.default.existsSync(this.keyPath)) {
+      this.encryptionKey = fs19__default.default.readFileSync(this.keyPath);
+    } else {
+      this.encryptionKey = crypto3__default.default.randomBytes(32);
+      fs19__default.default.writeFileSync(this.keyPath, this.encryptionKey);
+    }
+  }
+  encrypt(text) {
+    const iv = crypto3__default.default.randomBytes(16);
+    const cipher = crypto3__default.default.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 = crypto3__default.default.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 = crypto3__default.default.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 = path20__default.default.join(os6__default.default.tmpdir(), "cascade_world_state_debug.json");
+      const entries = this.getAllEntries();
+      fs19__default.default.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 ignore2 = ignoreFactory__namespace.default ?? ignoreFactory__namespace;
+var PrivacyPaths = class {
+  localOnly;
+  hasRules;
+  constructor(policies = []) {
+    this.localOnly = ignore2();
+    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__default.default {
@@ -8708,6 +9199,9 @@ var Cascade = class _Cascade extends EventEmitter__default.default {
   taskAnalyzer;
   perfTracker;
   toolCreator;
+  worldStateDB;
+  encryptedAuditLogger;
+  guidanceQueue;
   workspacePath;
   constructor(config, workspacePath, store) {
     super();
@@ -8729,6 +9223,23 @@ var Cascade = class _Cascade extends EventEmitter__default.default {
     });
     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) {
@@ -8891,6 +9402,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
@@ -8977,6 +9494,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 {
@@ -9124,7 +9646,7 @@ ${prompt}` : prompt;
     this.router.beginRun();
     this.router.setRunSignal(options.signal);
     const startMs = Date.now();
-    const taskId = crypto.randomUUID();
+    const taskId = crypto3.randomUUID();
     this.decisionLog = [];
     const escalator = new PermissionEscalator(this.config.approvalTimeoutMs ?? 6e5, this.config.autonomy === "auto");
     escalator.on("permission:user-required", async (req) => {
@@ -9402,6 +9924,7 @@ ${prompt}` : prompt;
       durationMs,
       costByTier: stats.costByTier,
       tokensByTier: stats.tokensByTier,
+      costByFeature: stats.costByFeature,
       costPercentByTier: this.router.getTierCostPercentages()
     };
   }
@@ -9469,7 +9992,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 && fs17__default.default.existsSync(this.storePath)) {
+      if (password && fs19__default.default.existsSync(this.storePath)) {
         try {
           const fileEntries = this.decryptFile(password);
           for (const [k, v] of Object.entries(fileEntries)) {
@@ -9488,8 +10011,8 @@ var Keystore = class {
         "Keystore unlock requires a password because the OS keychain (keytar) is not available on this system."
       );
     }
-    if (!fs17__default.default.existsSync(this.storePath)) {
-      const salt = crypto__default.default.randomBytes(SALT_LEN);
+    if (!fs19__default.default.existsSync(this.storePath)) {
+      const salt = crypto3__default.default.randomBytes(SALT_LEN);
       this.masterKey = this.deriveKey(password, salt);
       this.writeWithSalt({}, salt);
       this.cache = {};
@@ -9502,8 +10025,8 @@ var Keystore = class {
   }
   /** Synchronous legacy unlock kept for AES-only environments. */
   unlockSync(password) {
-    if (!fs17__default.default.existsSync(this.storePath)) {
-      const salt = crypto__default.default.randomBytes(SALT_LEN);
+    if (!fs19__default.default.existsSync(this.storePath)) {
+      const salt = crypto3__default.default.randomBytes(SALT_LEN);
       this.masterKey = this.deriveKey(password, salt);
       this.writeWithSalt({}, salt);
       this.cache = {};
@@ -9560,12 +10083,12 @@ var Keystore = class {
     }
   }
   decryptFile(password, knownSalt) {
-    if (!fs17__default.default.existsSync(this.storePath)) return {};
+    if (!fs19__default.default.existsSync(this.storePath)) return {};
     try {
       const { salt, ciphertext, iv, tag } = this.readRaw();
       const useSalt = knownSalt ?? salt;
       const key = this.masterKey ?? this.deriveKey(password, useSalt);
-      const decipher = crypto__default.default.createDecipheriv(ALGORITHM, key, iv);
+      const decipher = crypto3__default.default.createDecipheriv(ALGORITHM, key, iv);
       decipher.setAuthTag(tag);
       const decrypted = Buffer.concat([decipher.update(ciphertext), decipher.final()]);
       return JSON.parse(decrypted.toString("utf-8"));
@@ -9576,28 +10099,28 @@ var Keystore = class {
   saveAll(data) {
     if (!this.masterKey) return;
     const raw = this.readRaw();
-    const iv = crypto__default.default.randomBytes(IV_LEN);
-    const cipher = crypto__default.default.createCipheriv(ALGORITHM, this.masterKey, iv);
+    const iv = crypto3__default.default.randomBytes(IV_LEN);
+    const cipher = crypto3__default.default.createCipheriv(ALGORITHM, this.masterKey, iv);
     const plaintext = Buffer.from(JSON.stringify(data), "utf-8");
     const ciphertext = Buffer.concat([cipher.update(plaintext), cipher.final()]);
     const tag = cipher.getAuthTag();
     const out = Buffer.concat([raw.salt, iv, tag, ciphertext]);
-    fs17__default.default.mkdirSync(path18__default.default.dirname(this.storePath), { recursive: true });
-    fs17__default.default.writeFileSync(this.storePath, out, { mode: 384 });
+    fs19__default.default.mkdirSync(path20__default.default.dirname(this.storePath), { recursive: true });
+    fs19__default.default.writeFileSync(this.storePath, out, { mode: 384 });
   }
   writeWithSalt(data, salt) {
     if (!this.masterKey) throw new Error("writeWithSalt called before masterKey was set");
-    const iv = crypto__default.default.randomBytes(IV_LEN);
-    const cipher = crypto__default.default.createCipheriv(ALGORITHM, this.masterKey, iv);
+    const iv = crypto3__default.default.randomBytes(IV_LEN);
+    const cipher = crypto3__default.default.createCipheriv(ALGORITHM, this.masterKey, iv);
     const plaintext = Buffer.from(JSON.stringify(data), "utf-8");
     const ciphertext = Buffer.concat([cipher.update(plaintext), cipher.final()]);
     const tag = cipher.getAuthTag();
     const out = Buffer.concat([salt, iv, tag, ciphertext]);
-    fs17__default.default.mkdirSync(path18__default.default.dirname(this.storePath), { recursive: true });
-    fs17__default.default.writeFileSync(this.storePath, out, { mode: 384 });
+    fs19__default.default.mkdirSync(path20__default.default.dirname(this.storePath), { recursive: true });
+    fs19__default.default.writeFileSync(this.storePath, out, { mode: 384 });
   }
   readRaw() {
-    const buf = fs17__default.default.readFileSync(this.storePath);
+    const buf = fs19__default.default.readFileSync(this.storePath);
     let offset = 0;
     const salt = buf.subarray(offset, offset + SALT_LEN);
     offset += SALT_LEN;
@@ -9609,15 +10132,15 @@ var Keystore = class {
     return { salt, iv, tag, ciphertext };
   }
   deriveKey(password, salt) {
-    return crypto__default.default.pbkdf2Sync(password, salt, PBKDF2_ITERATIONS, KEY_LEN, "sha256");
+    return crypto3__default.default.pbkdf2Sync(password, salt, PBKDF2_ITERATIONS, KEY_LEN, "sha256");
   }
 };
-var ignore2 = ignoreFactory__namespace.default ?? ignoreFactory__namespace;
+var ignore3 = ignoreFactory__namespace.default ?? ignoreFactory__namespace;
 var CascadeIgnore = class {
   ig;
   loaded = false;
   constructor() {
-    this.ig = ignore2();
+    this.ig = ignore3();
     this.ig.add([
       ".cascade/keystore.enc",
       ".cascade/memory.db",
@@ -9630,7 +10153,7 @@ var CascadeIgnore = class {
     ]);
   }
   async load(workspacePath) {
-    const filePath = path18__default.default.join(workspacePath, ".cascadeignore");
+    const filePath = path20__default.default.join(workspacePath, ".cascadeignore");
     try {
       const content = await fs4__default.default.readFile(filePath, "utf-8");
       const lines = content.split("\n").filter((l) => l.trim() && !l.startsWith("#"));
@@ -9641,7 +10164,7 @@ var CascadeIgnore = class {
   }
   isIgnored(filePath, workspacePath) {
     try {
-      const relative = workspacePath ? path18__default.default.relative(workspacePath, filePath) : filePath;
+      const relative = workspacePath ? path20__default.default.relative(workspacePath, filePath) : filePath;
       return this.ig.ignores(relative);
     } catch {
       return false;
@@ -9652,7 +10175,7 @@ var CascadeIgnore = class {
   }
 };
 async function loadCascadeMd(workspacePath) {
-  const filePath = path18__default.default.join(workspacePath, "CASCADE.md");
+  const filePath = path20__default.default.join(workspacePath, "CASCADE.md");
   try {
     const raw = await fs4__default.default.readFile(filePath, "utf-8");
     return parseCascadeMd(raw);
@@ -9683,7 +10206,7 @@ ${raw.trim()}`;
 var MemoryStore = class _MemoryStore {
   db;
   constructor(dbPath) {
-    fs17__default.default.mkdirSync(path18__default.default.dirname(dbPath), { recursive: true });
+    fs19__default.default.mkdirSync(path20__default.default.dirname(dbPath), { recursive: true });
     try {
       this.db = new Database__default.default(dbPath, { timeout: 5e3 });
       this.db.pragma("journal_mode = WAL");
@@ -9807,7 +10330,7 @@ Original error: ${err.message}`
       VALUES (?, ?, ?, ?, ?, ?, ?)
     `);
     for (const msg of messages) {
-      stmt.run(crypto.randomUUID(), newId, msg.role, msg.content, msg.timestamp, msg.tokens, msg.agent_messages);
+      stmt.run(crypto3.randomUUID(), newId, msg.role, msg.content, msg.timestamp, msg.tokens, msg.agent_messages);
     }
     const snapshots = this.db.prepare("SELECT * FROM file_snapshots WHERE session_id = ?").all(originalId);
     const snapStmt = this.db.prepare(`
@@ -9815,7 +10338,7 @@ Original error: ${err.message}`
       VALUES (?, ?, ?, ?, ?)
     `);
     for (const snap of snapshots) {
-      snapStmt.run(crypto.randomUUID(), newId, snap.file_path, snap.content, snap.timestamp);
+      snapStmt.run(crypto3.randomUUID(), newId, snap.file_path, snap.content, snap.timestamp);
     }
   }
   // ── Runtime Sessions / Nodes ─────────────────
@@ -10113,7 +10636,7 @@ Original error: ${err.message}`
       this.db.prepare(`
         INSERT INTO file_snapshots (id, session_id, file_path, content, timestamp)
         VALUES (?, ?, ?, ?, ?)
-      `).run(crypto.randomUUID(), sessionId, filePath, content, (/* @__PURE__ */ new Date()).toISOString());
+      `).run(crypto3.randomUUID(), sessionId, filePath, content, (/* @__PURE__ */ new Date()).toISOString());
     });
   }
   getLatestFileSnapshots(sessionId) {
@@ -10441,15 +10964,15 @@ var ConfigManager = class {
   globalDir;
   constructor(workspacePath = process.cwd()) {
     this.workspacePath = workspacePath;
-    this.globalDir = path18__default.default.join(os4__default.default.homedir(), GLOBAL_CONFIG_DIR);
+    this.globalDir = path20__default.default.join(os6__default.default.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(path18__default.default.join(this.globalDir, GLOBAL_KEYSTORE_FILE));
-    this.store = new MemoryStore(path18__default.default.join(this.workspacePath, CASCADE_DB_FILE));
+    this.keystore = new Keystore(path20__default.default.join(this.globalDir, GLOBAL_KEYSTORE_FILE));
+    this.store = new MemoryStore(path20__default.default.join(this.workspacePath, CASCADE_DB_FILE));
     await this.injectEnvKeys();
     await this.ensureDefaultIdentity();
   }
@@ -10472,8 +10995,8 @@ var ConfigManager = class {
     return this.workspacePath;
   }
   async save() {
-    const configPath = path18__default.default.join(this.workspacePath, CASCADE_CONFIG_FILE);
-    await fs4__default.default.mkdir(path18__default.default.dirname(configPath), { recursive: true });
+    const configPath = path20__default.default.join(this.workspacePath, CASCADE_CONFIG_FILE);
+    await fs4__default.default.mkdir(path20__default.default.dirname(configPath), { recursive: true });
     await fs4__default.default.writeFile(configPath, JSON.stringify(this.config, null, 2), "utf-8");
   }
   async updateConfig(updates) {
@@ -10497,7 +11020,7 @@ var ConfigManager = class {
     return configProvider?.apiKey;
   }
   async loadConfig() {
-    const configPath = path18__default.default.join(this.workspacePath, CASCADE_CONFIG_FILE);
+    const configPath = path20__default.default.join(this.workspacePath, CASCADE_CONFIG_FILE);
     try {
       const raw = await fs4__default.default.readFile(configPath, "utf-8");
       return validateConfig(JSON.parse(raw));
@@ -10534,7 +11057,7 @@ var ConfigManager = class {
     const existing = this.store.getDefaultIdentity();
     if (existing) return;
     const identity = {
-      id: crypto.randomUUID(),
+      id: crypto3.randomUUID(),
       name: "Default",
       description: "Default Cascade identity",
       createdAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -10727,6 +11250,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) => {
@@ -10758,7 +11299,7 @@ var DashboardSocket = class {
     this.io.close();
   }
 };
-var __dirname$1 = path18__default.default.dirname(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href))));
+var __dirname$1 = path20__default.default.dirname(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href))));
 var DashboardServer = class {
   app;
   httpServer;
@@ -10769,6 +11310,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;
@@ -10828,7 +11376,9 @@ var DashboardServer = class {
       this.persistConfig();
     });
     this.socket.onCascadeRun(async (prompt, model, socketId, requestedSessionId) => {
-      const sessionId = requestedSessionId ?? crypto.randomUUID();
+      const sessionId = requestedSessionId ?? crypto3.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;
@@ -10847,7 +11397,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", {
@@ -10864,6 +11415,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() });
       }
     });
   }
@@ -10911,9 +11472,9 @@ var DashboardServer = class {
    */
   persistConfig() {
     try {
-      const configPath = path18__default.default.join(this.workspacePath, CASCADE_CONFIG_FILE);
-      fs17__default.default.mkdirSync(path18__default.default.dirname(configPath), { recursive: true });
-      fs17__default.default.writeFileSync(configPath, JSON.stringify(this.config, null, 2), "utf-8");
+      const configPath = path20__default.default.join(this.workspacePath, CASCADE_CONFIG_FILE);
+      fs19__default.default.mkdirSync(path20__default.default.dirname(configPath), { recursive: true });
+      fs19__default.default.writeFileSync(configPath, JSON.stringify(this.config, null, 2), "utf-8");
     } catch (err) {
       console.warn(`[dashboard] Failed to persist config: ${err instanceof Error ? err.message : String(err)}`);
     }
@@ -10928,15 +11489,15 @@ var DashboardServer = class {
   resolveDashboardSecret() {
     const fromConfig = this.config.dashboard.secret ?? process.env["CASCADE_DASHBOARD_SECRET"];
     if (fromConfig) return fromConfig;
-    const secretPath = path18__default.default.join(this.workspacePath, CASCADE_DASHBOARD_SECRET_FILE);
+    const secretPath = path20__default.default.join(this.workspacePath, CASCADE_DASHBOARD_SECRET_FILE);
     try {
-      if (fs17__default.default.existsSync(secretPath)) {
-        const existing = fs17__default.default.readFileSync(secretPath, "utf-8").trim();
+      if (fs19__default.default.existsSync(secretPath)) {
+        const existing = fs19__default.default.readFileSync(secretPath, "utf-8").trim();
         if (existing.length >= 16) return existing;
       }
-      const generated = crypto.randomUUID();
-      fs17__default.default.mkdirSync(path18__default.default.dirname(secretPath), { recursive: true });
-      fs17__default.default.writeFileSync(secretPath, generated, { encoding: "utf-8", mode: 384 });
+      const generated = crypto3.randomUUID();
+      fs19__default.default.mkdirSync(path20__default.default.dirname(secretPath), { recursive: true });
+      fs19__default.default.writeFileSync(secretPath, generated, { encoding: "utf-8", mode: 384 });
       if (this.config.dashboard.auth) {
         console.warn(
           `Dashboard auth enabled with no secret configured; persisted a generated secret to ${secretPath}. Set CASCADE_DASHBOARD_SECRET or config.dashboard.secret to override.`
@@ -10945,7 +11506,7 @@ var DashboardServer = class {
       return generated;
     } catch {
       console.warn("Unable to persist dashboard secret; falling back to a process-ephemeral secret.");
-      return crypto.randomUUID();
+      return crypto3.randomUUID();
     }
   }
   /**
@@ -10963,7 +11524,7 @@ var DashboardServer = class {
   // ── Setup ─────────────────────────────────────
   getGlobalStore() {
     if (!this.globalStore) {
-      const globalDbPath = path18__default.default.join(os4__default.default.homedir(), GLOBAL_CONFIG_DIR, GLOBAL_RUNTIME_DB_FILE);
+      const globalDbPath = path20__default.default.join(os6__default.default.homedir(), GLOBAL_CONFIG_DIR, GLOBAL_RUNTIME_DB_FILE);
       this.globalStore = new MemoryStore(globalDbPath);
     }
     return this.globalStore;
@@ -10993,7 +11554,7 @@ var DashboardServer = class {
           metadata: { totalTokens: 0, totalCostUsd: 0, modelsUsed: [], toolsUsed: [], taskCount: 0 }
         });
       }
-      this.store.addMessage({ id: crypto.randomUUID(), sessionId, role: "user", content: prompt, timestamp: now });
+      this.store.addMessage({ id: crypto3.randomUUID(), sessionId, role: "user", content: prompt, timestamp: now });
     } catch (err) {
       console.warn("[dashboard] failed to persist run start:", err);
     }
@@ -11004,13 +11565,28 @@ var DashboardServer = class {
   persistRunEnd(sessionId, title, latestPrompt, reply, status) {
     try {
       if (reply && reply.trim()) {
-        this.store.addMessage({ id: crypto.randomUUID(), sessionId, role: "assistant", content: reply, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
+        this.store.addMessage({ id: crypto3.randomUUID(), sessionId, role: "assistant", content: reply, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
       }
     } catch (err) {
       console.warn("[dashboard] failed to persist run end:", err);
     }
     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 };
@@ -11104,12 +11680,12 @@ ${prompt}`;
     }
   }
   watchRuntimeChanges() {
-    const workspaceDbPath = path18__default.default.join(this.workspacePath, CASCADE_DB_FILE);
-    const globalDbPath = path18__default.default.join(os4__default.default.homedir(), GLOBAL_CONFIG_DIR, GLOBAL_RUNTIME_DB_FILE);
+    const workspaceDbPath = path20__default.default.join(this.workspacePath, CASCADE_DB_FILE);
+    const globalDbPath = path20__default.default.join(os6__default.default.homedir(), GLOBAL_CONFIG_DIR, GLOBAL_RUNTIME_DB_FILE);
     const watchPaths = [workspaceDbPath, globalDbPath].filter((p, index, arr) => arr.indexOf(p) === index);
     for (const watchPath of watchPaths) {
-      if (!fs17__default.default.existsSync(watchPath)) continue;
-      fs17__default.default.watchFile(watchPath, { interval: 3e3 }, () => {
+      if (!fs19__default.default.existsSync(watchPath)) continue;
+      fs19__default.default.watchFile(watchPath, { interval: 3e3 }, () => {
         this.throttledBroadcast(watchPath === globalDbPath ? "global" : "workspace");
       });
     }
@@ -11179,7 +11755,7 @@ ${prompt}`;
       const truthy = Buffer.from("1");
       const falsy = Buffer.from("0");
       const probe = ok ? truthy : falsy;
-      const authorized = crypto.timingSafeEqual(probe, truthy);
+      const authorized = crypto3.timingSafeEqual(probe, truthy);
       if (authorized) {
         const token = createToken(
           { id: username, username, role: "admin" },
@@ -11217,7 +11793,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 });
@@ -11239,7 +11816,7 @@ ${prompt}`;
       const sessionId = req.params.id;
       this.store.deleteSession(sessionId);
       this.store.deleteRuntimeSession(sessionId);
-      const globalDbPath = path18__default.default.join(os4__default.default.homedir(), GLOBAL_CONFIG_DIR, GLOBAL_RUNTIME_DB_FILE);
+      const globalDbPath = path20__default.default.join(os6__default.default.homedir(), GLOBAL_CONFIG_DIR, GLOBAL_RUNTIME_DB_FILE);
       const globalStore = new MemoryStore(globalDbPath);
       try {
         globalStore.deleteRuntimeSession(sessionId);
@@ -11251,9 +11828,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 = path18__default.default.join(os4__default.default.homedir(), GLOBAL_CONFIG_DIR, GLOBAL_RUNTIME_DB_FILE);
+      const globalDbPath = path20__default.default.join(os6__default.default.homedir(), GLOBAL_CONFIG_DIR, GLOBAL_RUNTIME_DB_FILE);
       if (body?.ids && Array.isArray(body.ids) && body.ids.length > 0) {
         const globalStore = new MemoryStore(globalDbPath);
         try {
@@ -11276,7 +11878,7 @@ ${prompt}`;
     });
     this.app.delete("/api/runtime", auth, (_req, res) => {
       this.store.deleteAllRuntimeNodes();
-      const globalDbPath = path18__default.default.join(os4__default.default.homedir(), GLOBAL_CONFIG_DIR, GLOBAL_RUNTIME_DB_FILE);
+      const globalDbPath = path20__default.default.join(os6__default.default.homedir(), GLOBAL_CONFIG_DIR, GLOBAL_RUNTIME_DB_FILE);
       const globalStore = new MemoryStore(globalDbPath);
       try {
         globalStore.deleteAllRuntimeNodes();
@@ -11300,7 +11902,7 @@ ${prompt}`;
         const existing = this.store.getDefaultIdentity();
         if (existing) this.store.updateIdentity(existing.id, { isDefault: false });
       }
-      const id = crypto.randomUUID();
+      const id = crypto3.randomUUID();
       const identity = {
         id,
         name: body.name,
@@ -11327,6 +11929,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);
@@ -11349,12 +11964,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 = path18__default.default.join(this.workspacePath, CASCADE_CONFIG_FILE);
-        const existing = fs17__default.default.existsSync(configPath) ? JSON.parse(fs17__default.default.readFileSync(configPath, "utf-8")) : {};
+        const configPath = path20__default.default.join(this.workspacePath, CASCADE_CONFIG_FILE);
+        const existing = fs19__default.default.existsSync(configPath) ? JSON.parse(fs19__default.default.readFileSync(configPath, "utf-8")) : {};
         const updated = { ...existing, tierLimits: this.config.tierLimits, budget: this.config.budget };
         const tmp = configPath + ".tmp";
-        fs17__default.default.writeFileSync(tmp, JSON.stringify(updated, null, 2), "utf-8");
-        fs17__default.default.renameSync(tmp, configPath);
+        fs19__default.default.writeFileSync(tmp, JSON.stringify(updated, null, 2), "utf-8");
+        fs19__default.default.renameSync(tmp, configPath);
         res.json({ ok: true });
       } catch (err) {
         res.status(500).json({ error: `Failed to save config: ${err instanceof Error ? err.message : String(err)}` });
@@ -11382,7 +11997,7 @@ ${prompt}`;
     this.app.get("/api/runtime", auth, (req, res) => {
       const scope = req.query["scope"] ?? "workspace";
       if (scope === "global") {
-        const globalDbPath = path18__default.default.join(os4__default.default.homedir(), GLOBAL_CONFIG_DIR, GLOBAL_RUNTIME_DB_FILE);
+        const globalDbPath = path20__default.default.join(os6__default.default.homedir(), GLOBAL_CONFIG_DIR, GLOBAL_RUNTIME_DB_FILE);
         const globalStore = new MemoryStore(globalDbPath);
         try {
           res.json({
@@ -11410,7 +12025,7 @@ ${prompt}`;
         return;
       }
       const requestedSessionId = typeof body.sessionId === "string" && body.sessionId.trim() ? body.sessionId.trim() : void 0;
-      const sessionId = requestedSessionId ?? crypto.randomUUID();
+      const sessionId = requestedSessionId ?? crypto3.randomUUID();
       res.json({ sessionId, status: "ACTIVE" });
       const prompt = body.prompt;
       const runPrompt = requestedSessionId ? this.buildContinuationPrompt(sessionId, prompt) : prompt;
@@ -11432,6 +12047,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,
@@ -11462,13 +12078,13 @@ ${prompt}`;
         }))
       });
     });
-    const prodPath = path18__default.default.resolve(__dirname$1, "../web/dist");
-    const devPath = path18__default.default.resolve(__dirname$1, "../../web/dist");
-    const webDistPath = fs17__default.default.existsSync(prodPath) ? prodPath : devPath;
-    if (fs17__default.default.existsSync(webDistPath)) {
+    const prodPath = path20__default.default.resolve(__dirname$1, "../web/dist");
+    const devPath = path20__default.default.resolve(__dirname$1, "../../web/dist");
+    const webDistPath = fs19__default.default.existsSync(prodPath) ? prodPath : devPath;
+    if (fs19__default.default.existsSync(webDistPath)) {
       this.app.use(express__default.default.static(webDistPath));
       this.app.get("*", (_req, res) => {
-        res.sendFile(path18__default.default.join(webDistPath, "index.html"));
+        res.sendFile(path20__default.default.join(webDistPath, "index.html"));
       });
     } else {
       this.app.get("/", (_req, res) => {