cascade-ai 0.15.2 → 0.17.0

package/dist/cli.cjs

@@ -43,6 +43,7 @@ var bcrypt = require('bcryptjs');
 var socket_io = require('socket.io');
 var parser = require('socket.io-msgpack-parser');
 var jwt = require('jsonwebtoken');
+var cron = require('node-cron');
 
 var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
@@ -93,6 +94,7 @@ var rateLimit__default = /*#__PURE__*/_interopDefault(rateLimit);
 var bcrypt__default = /*#__PURE__*/_interopDefault(bcrypt);
 var parser__default = /*#__PURE__*/_interopDefault(parser);
 var jwt__default = /*#__PURE__*/_interopDefault(jwt);
+var cron__default = /*#__PURE__*/_interopDefault(cron);
 
 // Cascade AI — Multi-tier AI Orchestration System
 var __defProp = Object.defineProperty;
@@ -109,7 +111,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.15.2";
+    CASCADE_VERSION = "0.17.0";
     CASCADE_CONFIG_FILE = ".cascade/config.json";
     CASCADE_DB_FILE = ".cascade/memory.db";
     CASCADE_DASHBOARD_SECRET_FILE = ".cascade/dashboard-secret";
@@ -3230,6 +3232,11 @@ function validateConfig(raw) {
 
 // src/config/index.ts
 init_constants();
+var KEY_OPTIONAL_PROVIDER_TYPES = /* @__PURE__ */ new Set(["ollama", "openai-compatible"]);
+function hasUsableProvider(providers) {
+  if (!providers?.length) return false;
+  return providers.some((p) => KEY_OPTIONAL_PROVIDER_TYPES.has(p.type) || !!p.apiKey);
+}
 var ConfigManager = class {
   config;
   keystore;
@@ -7518,6 +7525,10 @@ HIERARCHY CONTEXT: ${this.hierarchyContext}` : ""),
     const worker = new T3Worker(this.router, this.toolRegistry, this.id);
     if (this.store) worker.setStore(this.store, taskId);
     worker.setPeerBus(this.t3PeerBus);
+    if (this.permissionEscalator) worker.setPermissionEscalator(this.permissionEscalator);
+    if (this.toolCreator) worker.setToolCreator(this.toolCreator);
+    worker.on("log", (e) => this.emit("log", e));
+    worker.on("tier:status", (e) => this.emit("tier:status", e));
     worker.on("stream:token", (e) => this.emit("stream:token", e));
     worker.on("tool:approval-request", (e) => this.emit("tool:approval-request", {
       ...e,
@@ -7869,12 +7880,14 @@ Board guidance (must be followed in the plan): ${decision.note}`,
         status: "IN_PROGRESS"
       });
       const okBefore = okCount(allT2Results);
+      const completedSummary = this.summarizeCompletedSections(allT2Results);
+      const correctionContext = [systemContext, completedSummary].filter(Boolean).join("\n\n") || void 0;
       const correctionPlan = await this.decomposeTask(`The previous execution plan failed to fully satisfy the original goal or encountered errors.
 Review reason: ${reviewResult.reason}
 
 Original goal: ${enrichedPrompt}
 
-Create a CORRECTION PLAN that contains only the new sections needed to fix the issues. Do not repeat successful sections.`);
+Create a CORRECTION PLAN that contains only the new sections needed to fix the issues. Do not repeat successful sections.`, correctionContext);
       const correctionResults = await this.dispatchT2Managers(correctionPlan.sections);
       allT2Results = [...allT2Results, ...correctionResults];
       if (okCount(allT2Results) <= okBefore) {
@@ -7977,6 +7990,15 @@ In 3-5 terse bullets, flag the most important RISKS, GAPS, or over-/under-decomp
       return null;
     }
   }
+  /** Structured, grounded summary of what's already done — used to keep
+   * corrective replan passes from re-emitting completed sections. */
+  summarizeCompletedSections(results) {
+    const done = results.filter((r) => r.status === "COMPLETED" || r.status === "PARTIAL");
+    if (done.length === 0) return "";
+    const lines = done.map((r) => `- "${r.sectionTitle}" [${r.status}]: ${(r.sectionSummary || "(no summary)").slice(0, 300)}`);
+    return `ALREADY COMPLETED SECTIONS (do not redo these \u2014 plan only what's still missing):
+${lines.join("\n")}`;
+  }
   async decomposeTask(prompt, systemContext) {
     const db = this.router.getWorldStateDB?.();
     let worldStateContext = "";
@@ -8244,7 +8266,7 @@ Leave dependsOn empty for sections that can run immediately in parallel.`;
         }
       }
       if (readyIds.length === 0) return;
-      await Promise.all(readyIds.map(async (id) => {
+      const runOne = async (id) => {
         resultMap.set(id, null);
         const index = sections.findIndex((s) => s.sectionId === id);
         const section = sections[index];
@@ -8284,7 +8306,14 @@ Leave dependsOn empty for sections that can run immediately in parallel.`;
         for (const dependentId of adj.get(id) ?? /* @__PURE__ */ new Set()) {
           inDegree.set(dependentId, Math.max(0, (inDegree.get(dependentId) ?? 1) - 1));
         }
-      }));
+      };
+      if (this.router.getT3ExecutionMode?.() === "sequential") {
+        for (const id of readyIds) {
+          await runOne(id);
+        }
+      } else {
+        await Promise.all(readyIds.map(runOne));
+      }
       if (Array.from(inDegree.values()).some((deg) => deg === 0) && resultMap.size < totalSections) {
         await executeWave();
       }
@@ -10088,6 +10117,13 @@ var PermissionEscalator = class extends EventEmitter__default.default {
    * All T3 workers under the same T2 share cached decisions for the same tool.
    */
   sessionCache = /* @__PURE__ */ new Map();
+  /**
+   * Task-wide cache keyed by `toolName` alone, for USER- and T1-level
+   * "always" decisions — these are meant to cover every sibling T2/T3 in the
+   * run, not just the one that happened to ask first (see PermissionDecision
+   * doc comment: "task-wide for T1").
+   */
+  taskWideCache = /* @__PURE__ */ new Map();
   t2Evaluator;
   t1Evaluator;
   /** Pending user-decision resolvers keyed by request ID */
@@ -10116,6 +10152,15 @@ var PermissionEscalator = class extends EventEmitter__default.default {
    * Returns a PermissionDecision from whichever tier was able to decide.
    */
   async requestPermission(req) {
+    if (!req.forceReprompt && this.taskWideCache.has(req.toolName)) {
+      return {
+        requestId: req.id,
+        approved: this.taskWideCache.get(req.toolName),
+        always: true,
+        decidedBy: "T1",
+        reasoning: "Cached from a previous task-wide decision in this session"
+      };
+    }
     const cacheKey = `${req.parentT2Id}:${req.toolName}`;
     if (!req.forceReprompt && this.sessionCache.has(cacheKey)) {
       return {
@@ -10160,7 +10205,7 @@ var PermissionEscalator = class extends EventEmitter__default.default {
       try {
         const t1Decision = await this.t1Evaluator(req);
         if (t1Decision !== null) {
-          if (t1Decision.always) this.sessionCache.set(cacheKey, t1Decision.approved);
+          if (t1Decision.always) this.taskWideCache.set(req.toolName, t1Decision.approved);
           return t1Decision;
         }
       } catch {
@@ -10190,7 +10235,7 @@ var PermissionEscalator = class extends EventEmitter__default.default {
       const wrappedResolver = (decision) => {
         if (timer) clearTimeout(timer);
         if (decision.always) {
-          this.sessionCache.set(`${req.parentT2Id}:${req.toolName}`, decision.approved);
+          this.taskWideCache.set(req.toolName, decision.approved);
         }
         resolve(decision);
       };
@@ -15269,11 +15314,18 @@ function SetupWizard({ workspacePath, onComplete }) {
     }
   });
   const currentEntry = state.entries[state.currentEntryIdx];
+  const rejectIfBlank = React2.useCallback((val, message) => {
+    if (val.trim()) return false;
+    dispatch({ type: "SET_ERROR", error: message });
+    return true;
+  }, []);
   const handleFieldSubmit = React2.useCallback((val) => {
     if (!currentEntry) return;
     if (currentEntry.type === "azure") {
       if (fieldStage === "deploymentName") {
+        if (rejectIfBlank(val, "Deployment name is required.")) return;
         dispatch({ type: "SET_ENTRY_FIELD", field: "deploymentName", value: val });
+        dispatch({ type: "SET_ERROR", error: "" });
         setFieldBuffer("");
         if (currentEntry.baseUrl && currentEntry.apiKey && currentEntry.apiVersion) {
           setFieldStage("askMore");
@@ -15281,38 +15333,50 @@ function SetupWizard({ workspacePath, onComplete }) {
           setFieldStage("baseUrl");
         }
       } else if (fieldStage === "baseUrl") {
+        if (rejectIfBlank(val, "Azure endpoint URL is required.")) return;
         dispatch({ type: "SET_ENTRY_FIELD", field: "baseUrl", value: val });
+        dispatch({ type: "SET_ERROR", error: "" });
         setFieldBuffer("");
         setFieldStage("apiKey");
       } else if (fieldStage === "apiKey") {
+        if (rejectIfBlank(val, "API key is required.")) return;
         dispatch({ type: "SET_ENTRY_FIELD", field: "apiKey", value: val });
+        dispatch({ type: "SET_ERROR", error: "" });
         setFieldBuffer("");
         setFieldStage("apiVersion");
       } else if (fieldStage === "apiVersion") {
         dispatch({ type: "SET_ENTRY_FIELD", field: "apiVersion", value: val || "2024-08-01-preview" });
+        dispatch({ type: "SET_ERROR", error: "" });
         setFieldBuffer("");
         setFieldStage("askMore");
       }
     } else if (currentEntry.type === "openai-compatible") {
       if (fieldStage === "label") {
         dispatch({ type: "SET_ENTRY_FIELD", field: "label", value: val || currentEntry.label });
+        dispatch({ type: "SET_ERROR", error: "" });
         setFieldBuffer("");
         setFieldStage("baseUrl");
       } else if (fieldStage === "baseUrl") {
+        if (rejectIfBlank(val, "Base URL is required.")) return;
         dispatch({ type: "SET_ENTRY_FIELD", field: "baseUrl", value: val });
+        dispatch({ type: "SET_ERROR", error: "" });
         setFieldBuffer("");
         setFieldStage("apiKey");
       } else if (fieldStage === "apiKey") {
         dispatch({ type: "SET_ENTRY_FIELD", field: "apiKey", value: val });
+        dispatch({ type: "SET_ERROR", error: "" });
         setFieldBuffer("");
         setFieldStage("askMore");
       }
     } else if (currentEntry.type === "ollama") {
       dispatch({ type: "SET_ENTRY_FIELD", field: "baseUrl", value: val || "http://localhost:11434" });
+      dispatch({ type: "SET_ERROR", error: "" });
       setFieldBuffer("");
       setFieldStage("askMore");
     } else {
+      if (rejectIfBlank(val, "API key is required.")) return;
       dispatch({ type: "SET_ENTRY_FIELD", field: "apiKey", value: val });
+      dispatch({ type: "SET_ERROR", error: "" });
       setFieldBuffer("");
       const nextEntry = state.entries[state.currentEntryIdx + 1];
       if (nextEntry) {
@@ -15320,7 +15384,7 @@ function SetupWizard({ workspacePath, onComplete }) {
       }
       dispatch({ type: "NEXT_ENTRY" });
     }
-  }, [currentEntry, fieldStage]);
+  }, [currentEntry, fieldStage, rejectIfBlank, state.entries, state.currentEntryIdx]);
   if (state.step === "PROVIDER_SELECT") {
     return /* @__PURE__ */ jsxRuntime.jsxs(Frame, { theme, phase: "keys", children: [
       /* @__PURE__ */ jsxRuntime.jsxs(ink.Box, { marginBottom: 1, children: [
@@ -16025,6 +16089,25 @@ var DashboardSocket = class {
       });
     });
   }
+  /**
+   * Boardroom plan decisions from a connected client. The desktop shows a
+   * plan-review modal on `plan:approval-required` and answers here; the
+   * server routes the decision into the paused run via resolvePlanApproval.
+   */
+  onPlanDecision(callback) {
+    this.io.on("connection", (socket) => {
+      socket.on("plan:decision", (payload) => {
+        if (typeof payload?.sessionId === "string" && typeof payload?.approved === "boolean") {
+          callback({
+            sessionId: payload.sessionId,
+            approved: payload.approved,
+            note: typeof payload.note === "string" && payload.note.trim() ? payload.note.trim() : void 0,
+            editedPlan: payload.editedPlan
+          });
+        }
+      });
+    });
+  }
   onSessionSteer(callback) {
     this.io.on("connection", (socket) => {
       socket.on("session:steer", (payload) => {
@@ -16069,6 +16152,122 @@ var DashboardSocket = class {
 
 // src/dashboard/server.ts
 init_constants();
+var TaskScheduler = class {
+  cronJobs = /* @__PURE__ */ new Map();
+  store;
+  runner;
+  constructor(store, runner) {
+    this.store = store;
+    this.runner = runner;
+  }
+  start() {
+    const tasks = this.store.listScheduledTasks();
+    for (const task of tasks) {
+      if (task.enabled) this.schedule(task);
+    }
+  }
+  stop() {
+    for (const job of this.cronJobs.values()) job.stop();
+    this.cronJobs.clear();
+  }
+  schedule(task) {
+    if (!cron__default.default.validate(task.cronExpression)) {
+      throw new Error(`Invalid cron expression: ${task.cronExpression}`);
+    }
+    const existing = this.cronJobs.get(task.id);
+    if (existing) {
+      try {
+        existing.stop();
+      } catch {
+      }
+    }
+    const job = cron__default.default.schedule(task.cronExpression, async () => {
+      try {
+        task.lastRun = (/* @__PURE__ */ new Date()).toISOString();
+        this.store.saveScheduledTask(task);
+        await this.runner(task);
+      } catch (err) {
+        console.error(`[scheduler] Task "${task.id}" (${task.cronExpression}) failed:`, err);
+      }
+    }, { timezone: "UTC" });
+    this.cronJobs.set(task.id, job);
+  }
+  unschedule(taskId) {
+    this.cronJobs.get(taskId)?.stop();
+    this.cronJobs.delete(taskId);
+  }
+  add(task) {
+    this.store.saveScheduledTask(task);
+    if (task.enabled) this.schedule(task);
+  }
+  remove(taskId) {
+    this.unschedule(taskId);
+    this.store.deleteScheduledTask(taskId);
+  }
+  list() {
+    return this.store.listScheduledTasks();
+  }
+  isRunning(taskId) {
+    return this.cronJobs.has(taskId);
+  }
+  static validateCron(expression) {
+    return cron__default.default.validate(expression);
+  }
+};
+
+// src/dashboard/cost-stats.ts
+var DAY_MS = 24 * 60 * 60 * 1e3;
+function utcDateKey(d) {
+  return d.toISOString().slice(0, 10);
+}
+function aggregateCostStats(sessions, opts = {}) {
+  const days = Math.max(1, opts.days ?? 30);
+  const topN = Math.max(1, opts.topN ?? 8);
+  const now = opts.now ?? /* @__PURE__ */ new Date();
+  const buckets = /* @__PURE__ */ new Map();
+  for (let i = days - 1; i >= 0; i--) {
+    const key = utcDateKey(new Date(now.getTime() - i * DAY_MS));
+    buckets.set(key, { date: key, costUsd: 0, tokens: 0, runs: 0 });
+  }
+  let totalCostUsd = 0;
+  let totalTokens = 0;
+  let totalRuns = 0;
+  for (const s of sessions) {
+    const cost = s.metadata?.totalCostUsd ?? 0;
+    const tokens = s.metadata?.totalTokens ?? 0;
+    const runs = s.metadata?.taskCount ?? 0;
+    totalCostUsd += cost;
+    totalTokens += tokens;
+    totalRuns += runs;
+    const when = new Date(s.updatedAt || s.createdAt);
+    if (!Number.isNaN(when.getTime())) {
+      const bucket = buckets.get(utcDateKey(when));
+      if (bucket) {
+        bucket.costUsd += cost;
+        bucket.tokens += tokens;
+        bucket.runs += runs;
+      }
+    }
+  }
+  const topSessions = [...sessions].filter((s) => (s.metadata?.totalCostUsd ?? 0) > 0).sort((a, b) => (b.metadata?.totalCostUsd ?? 0) - (a.metadata?.totalCostUsd ?? 0)).slice(0, topN).map((s) => ({
+    sessionId: s.id,
+    title: s.title,
+    costUsd: s.metadata?.totalCostUsd ?? 0,
+    tokens: s.metadata?.totalTokens ?? 0,
+    runs: s.metadata?.taskCount ?? 0,
+    updatedAt: s.updatedAt
+  }));
+  return {
+    totalCostUsd,
+    totalTokens,
+    totalSessions: sessions.length,
+    totalRuns,
+    perDay: [...buckets.values()],
+    topSessions
+  };
+}
+
+// src/dashboard/server.ts
 var __dirname$1 = path25__default.default.dirname(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('cli.cjs', document.baseURI).href))));
 var DashboardServer = class {
   app;
@@ -16094,6 +16293,14 @@ var DashboardServer = class {
    * map is how that answer reaches the run that's blocked on it.
    */
   pendingApprovals = /* @__PURE__ */ new Map();
+  /**
+   * The orchestration decision trail ("why") of each session's most recent
+   * run — captured when the run ends so the desktop's Why panel can show it
+   * after the fact. Bounded: oldest entry evicted past 50 sessions.
+   */
+  whyBySession = /* @__PURE__ */ new Map();
+  /** Cron scheduler for the Schedules UI — runs tasks while this server is up. */
+  scheduler;
   port;
   host;
   workspacePath;
@@ -16111,6 +16318,7 @@ var DashboardServer = class {
       secret: this.dashboardSecret,
       corsOrigin: config.dashboard.auth ? [`http://localhost:${this.port}`, `http://127.0.0.1:${this.port}`] : "*"
     });
+    this.scheduler = new TaskScheduler(store, (task) => this.runScheduledTask(task));
     this.setupMiddleware();
     this.setupRoutes();
     this.socket.onSessionRate((sessionId, rating) => {
@@ -16174,6 +16382,9 @@ var DashboardServer = class {
       cascade.on("peer:message", (e) => {
         this.socket.emitPeerMessage(e);
       });
+      cascade.on("plan:approval-required", (e) => {
+        this.socket.emitToSocket(socketId, "plan:approval-required", { sessionId, ...e });
+      });
       try {
         const result = await cascade.run({
           prompt: runPrompt,
@@ -16181,7 +16392,8 @@ var DashboardServer = class {
           approvalCallback: this.makeApprovalCallback(sessionId)
         });
         this.recordSessionTask(sessionId, result.taskId);
-        this.persistRunEnd(sessionId, title, prompt, result.output, "COMPLETED");
+        this.persistRunEnd(sessionId, title, prompt, result.output, "COMPLETED", result);
+        this.captureWhy(sessionId, cascade, result);
         this.socket.emitToSocket(socketId, "session:complete", { sessionId, result });
         this.socket.broadcast("cost:update", {
           sessionId,
@@ -16191,6 +16403,7 @@ var DashboardServer = class {
         this.throttledBroadcast("workspace");
       } catch (err) {
         this.persistRunEnd(sessionId, title, prompt, void 0, "FAILED");
+        this.captureWhy(sessionId, cascade);
         this.socket.emitToSocket(socketId, "session:error", {
           sessionId,
           error: err instanceof Error ? err.message : String(err)
@@ -16201,9 +16414,17 @@ var DashboardServer = class {
         this.denyPendingApprovals(sessionId);
       }
     });
+    this.socket.onPlanDecision(({ sessionId, approved, note, editedPlan }) => {
+      this.activeSessions.get(sessionId)?.resolvePlanApproval(
+        approved,
+        note,
+        editedPlan
+      );
+    });
     this.socket.onSessionHalt((sessionId) => {
       this.activeControllers.get(sessionId)?.abort();
       this.denyPendingApprovals(sessionId);
+      this.activeSessions.get(sessionId)?.resolvePlanApproval(false);
     });
     this.socket.onApprovalResponse(({ requestId, approved, always }) => {
       const pending = this.pendingApprovals.get(requestId);
@@ -16236,12 +16457,21 @@ var DashboardServer = class {
         resolve();
       });
     });
+    try {
+      this.scheduler.start();
+    } catch (err) {
+      console.warn("[dashboard] failed to start task scheduler:", err);
+    }
   }
   async stop() {
     if (this.broadcastTimer) {
       clearTimeout(this.broadcastTimer);
       this.broadcastTimer = null;
     }
+    try {
+      this.scheduler.stop();
+    } catch {
+    }
     this.socket.close();
     try {
       this.globalStore?.close();
@@ -16255,6 +16485,16 @@ var DashboardServer = class {
   getSocket() {
     return this.socket;
   }
+  /**
+   * Rebind the workspace tasks execute in — e.g. the desktop app's Code view
+   * opening a different project folder — without tearing down the socket
+   * server (which would drop the port/auth token/connection mid-session).
+   * The next `cascade:run` picks this up immediately since `this.workspacePath`
+   * is read live per-run (see onCascadeRun below).
+   */
+  setWorkspacePath(workspacePath) {
+    this.workspacePath = workspacePath;
+  }
   /**
    * Write the in-memory config back to the workspace config file so mutations
    * made over the socket (Settings → Save) persist across restarts. Best-effort:
@@ -16352,16 +16592,60 @@ var DashboardServer = class {
     return title;
   }
   /** Record run end: the assistant reply (when there is one) and the runtime row's final status. */
-  persistRunEnd(sessionId, title, latestPrompt, reply, status) {
+  persistRunEnd(sessionId, title, latestPrompt, reply, status, result) {
     try {
       if (reply && reply.trim()) {
         this.store.addMessage({ id: crypto.randomUUID(), sessionId, role: "assistant", content: reply, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
       }
+      if (result) {
+        const session = this.store.getSession(sessionId);
+        if (session) {
+          this.store.updateSession(sessionId, {
+            updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+            metadata: {
+              ...session.metadata,
+              totalTokens: session.metadata.totalTokens + result.usage.totalTokens,
+              totalCostUsd: session.metadata.totalCostUsd + result.usage.estimatedCostUsd,
+              taskCount: session.metadata.taskCount + 1
+            }
+          });
+        }
+      }
     } catch (err) {
       console.warn("[dashboard] failed to persist run end:", err);
     }
     this.persistRuntimeRow(sessionId, title, status, latestPrompt);
   }
+  /**
+   * Capture the run's decision trail + router economics ("why") and broadcast
+   * it so the desktop's Why panel updates live; kept per-session for the
+   * GET /api/sessions/:id/why fallback (panel opened after the run).
+   */
+  captureWhy(sessionId, cascade, result) {
+    try {
+      const stats = cascade.getRouter().getStats();
+      const savings = cascade.getRouter().getDelegationSavings();
+      const report = {
+        sessionId,
+        capturedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        decisions: cascade.getDecisionLog(),
+        savedUsd: savings.savedUsd,
+        savedPct: savings.savedPct,
+        totalCostUsd: stats.totalCostUsd,
+        totalTokens: stats.totalTokens,
+        costByTier: stats.costByTier,
+        durationMs: result?.durationMs
+      };
+      this.whyBySession.set(sessionId, report);
+      if (this.whyBySession.size > 50) {
+        const oldest = this.whyBySession.keys().next().value;
+        if (oldest) this.whyBySession.delete(oldest);
+      }
+      this.socket.broadcast("run:why", report);
+    } catch (err) {
+      console.warn("[dashboard] failed to capture decision trail:", err);
+    }
+  }
   /**
    * Route steering text into running Cascade instances. Targets the given
    * session, or every active session when none is specified (the desktop
@@ -16391,6 +16675,52 @@ var DashboardServer = class {
       this.pendingApprovals.set(request.id, { resolve, sessionId });
     });
   }
+  /**
+   * Execute one scheduled task firing. Runs headless (like `cascade run -p`):
+   * tool approvals are auto-granted since nobody may be watching when the cron
+   * fires — the Schedules UI states this. Events broadcast to every connected
+   * client so an open desktop sees the run appear live.
+   */
+  async runScheduledTask(task) {
+    const sessionId = crypto.randomUUID();
+    const prompt = task.prompt;
+    const title = this.persistRunStart(sessionId, `[${task.name}] ${prompt}`);
+    const cascade = new Cascade(this.config, task.workspacePath ?? this.workspacePath, this.store);
+    this.activeSessions.set(sessionId, cascade);
+    cascade.on("tier:status", (e) => {
+      this.socket.broadcast("tier:status", { sessionId, ...e });
+    });
+    cascade.on("peer:message", (e) => {
+      this.socket.emitPeerMessage(e);
+    });
+    try {
+      const result = await cascade.run({
+        prompt,
+        identityId: task.identityId,
+        approvalCallback: async () => ({ approved: true, always: false })
+      });
+      this.recordSessionTask(sessionId, result.taskId);
+      this.persistRunEnd(sessionId, title, prompt, result.output, "COMPLETED", result);
+      this.captureWhy(sessionId, cascade, result);
+      this.socket.broadcast("session:complete", { sessionId, result });
+      this.socket.broadcast("cost:update", {
+        sessionId,
+        totalTokens: result.usage.totalTokens,
+        totalCostUsd: result.usage.estimatedCostUsd
+      });
+      this.throttledBroadcast("workspace");
+    } catch (err) {
+      this.persistRunEnd(sessionId, title, prompt, void 0, "FAILED");
+      this.captureWhy(sessionId, cascade);
+      this.socket.broadcast("session:error", {
+        sessionId,
+        error: err instanceof Error ? err.message : String(err)
+      });
+      throw err;
+    } finally {
+      this.activeSessions.delete(sessionId);
+    }
+  }
   /** Deny + clear any approvals still pending for a session (run end / abort). */
   denyPendingApprovals(sessionId) {
     for (const [id, pending] of this.pendingApprovals) {
@@ -16903,6 +17233,9 @@ ${prompt}`;
         cascade.on("peer:message", (e) => {
           this.socket.emitPeerMessage(e);
         });
+        cascade.on("plan:approval-required", (e) => {
+          this.socket.broadcastToRoom(`session:${sessionId}`, "plan:approval-required", { sessionId, ...e });
+        });
         try {
           const result = await cascade.run({
             prompt: runPrompt,
@@ -16910,7 +17243,8 @@ ${prompt}`;
             approvalCallback: this.makeApprovalCallback(sessionId)
           });
           this.recordSessionTask(sessionId, result.taskId);
-          this.persistRunEnd(sessionId, title, prompt, result.output, "COMPLETED");
+          this.persistRunEnd(sessionId, title, prompt, result.output, "COMPLETED", result);
+          this.captureWhy(sessionId, cascade, result);
           this.socket.broadcast("cost:update", {
             sessionId,
             totalTokens: result.usage.totalTokens,
@@ -16920,6 +17254,7 @@ ${prompt}`;
           this.throttledBroadcast("workspace");
         } catch (err) {
           this.persistRunEnd(sessionId, title, prompt, void 0, "FAILED");
+          this.captureWhy(sessionId, cascade);
           this.socket.broadcastToRoom(`session:${sessionId}`, "session:error", {
             sessionId,
             error: err instanceof Error ? err.message : String(err)
@@ -16941,6 +17276,168 @@ ${prompt}`;
         }))
       });
     });
+    this.app.get("/api/sessions/:id/why", auth, (req, res) => {
+      const report = this.whyBySession.get(req.params.id);
+      if (!report) {
+        res.status(404).json({ error: "No decision trail recorded for this session in the current app run." });
+        return;
+      }
+      res.json(report);
+    });
+    this.app.get("/api/sessions/:id/changes", auth, async (req, res) => {
+      const sessionId = req.params.id;
+      const taskIds = this.sessionTaskIds.get(sessionId) ?? [];
+      const before = /* @__PURE__ */ new Map();
+      for (const taskId of taskIds) {
+        for (const { filePath, content } of this.store.getLatestFileSnapshots(taskId)) {
+          if (!before.has(filePath)) before.set(filePath, content);
+        }
+      }
+      const { readFile } = await import('fs/promises');
+      const MAX_DIFF_BYTES = 2 * 1024 * 1024;
+      const changes = await Promise.all([...before.entries()].map(async ([filePath, beforeContent]) => {
+        let after = "";
+        let missing = false;
+        try {
+          const buf = await readFile(filePath);
+          after = buf.length > MAX_DIFF_BYTES ? `[file too large to diff \u2014 ${buf.length} bytes]` : buf.toString("utf-8");
+        } catch {
+          missing = true;
+        }
+        return { filePath, before: beforeContent, after, missing, changed: missing || after !== beforeContent };
+      }));
+      res.json({ sessionId, changes: changes.filter((c) => c.changed) });
+    });
+    this.app.post("/api/sessions/:id/revert-file", auth, mutationLimiter, async (req, res) => {
+      const sessionId = req.params.id;
+      const body = req.body;
+      if (!body.filePath || typeof body.filePath !== "string") {
+        res.status(400).json({ error: "filePath is required" });
+        return;
+      }
+      const taskIds = this.sessionTaskIds.get(sessionId) ?? [];
+      let content;
+      for (const taskId of taskIds) {
+        const snap = this.store.getLatestFileSnapshots(taskId).find((s) => s.filePath === body.filePath);
+        if (snap) {
+          content = snap.content;
+          break;
+        }
+      }
+      if (content === void 0) {
+        res.status(404).json({ error: "No snapshot recorded for that file in this session." });
+        return;
+      }
+      try {
+        const { writeFile } = await import('fs/promises');
+        await writeFile(body.filePath, content, "utf-8");
+        res.json({ ok: true, filePath: body.filePath });
+      } catch (err) {
+        res.status(500).json({ error: err instanceof Error ? err.message : String(err) });
+      }
+    });
+    this.app.get("/api/costs", auth, (_req, res) => {
+      try {
+        const sessions = this.store.listSessions(void 0, 1e3);
+        const budget = this.config.budget ?? { warnAtPct: 80 };
+        res.json({
+          ...aggregateCostStats(sessions, { days: 30, topN: 8 }),
+          budget: {
+            dailyBudgetUsd: budget.dailyBudgetUsd,
+            sessionBudgetUsd: budget.sessionBudgetUsd,
+            maxCostPerRunUsd: budget.maxCostPerRunUsd
+          }
+        });
+      } catch (err) {
+        res.status(500).json({ error: err instanceof Error ? err.message : String(err) });
+      }
+    });
+    this.app.get("/api/schedules", auth, (_req, res) => {
+      try {
+        res.json(this.scheduler.list().map((t) => ({ ...t, armed: this.scheduler.isRunning(t.id) })));
+      } catch (err) {
+        res.status(500).json({ error: err instanceof Error ? err.message : String(err) });
+      }
+    });
+    this.app.post("/api/schedules", auth, mutationLimiter, (req, res) => {
+      const body = req.body;
+      if (!body.name?.trim() || !body.cronExpression?.trim() || !body.prompt?.trim()) {
+        res.status(400).json({ error: "name, cronExpression, and prompt are required" });
+        return;
+      }
+      if (!TaskScheduler.validateCron(body.cronExpression.trim())) {
+        res.status(400).json({ error: `Invalid cron expression: ${body.cronExpression}` });
+        return;
+      }
+      const task = {
+        id: crypto.randomUUID(),
+        name: body.name.trim(),
+        cronExpression: body.cronExpression.trim(),
+        prompt: body.prompt.trim(),
+        workspacePath: this.workspacePath,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        enabled: body.enabled !== false
+      };
+      try {
+        this.scheduler.add(task);
+        res.json(task);
+      } catch (err) {
+        res.status(500).json({ error: err instanceof Error ? err.message : String(err) });
+      }
+    });
+    this.app.put("/api/schedules/:id", auth, mutationLimiter, (req, res) => {
+      const id = req.params.id;
+      const existing = this.scheduler.list().find((t) => t.id === id);
+      if (!existing) {
+        res.status(404).json({ error: "Not found" });
+        return;
+      }
+      const body = req.body;
+      if (body.cronExpression !== void 0 && !TaskScheduler.validateCron(body.cronExpression)) {
+        res.status(400).json({ error: `Invalid cron expression: ${body.cronExpression}` });
+        return;
+      }
+      const updated = {
+        ...existing,
+        name: body.name?.trim() || existing.name,
+        cronExpression: body.cronExpression?.trim() || existing.cronExpression,
+        prompt: body.prompt?.trim() || existing.prompt,
+        enabled: body.enabled ?? existing.enabled
+      };
+      try {
+        this.scheduler.add(updated);
+        if (!updated.enabled) this.scheduler.unschedule(id);
+        res.json(updated);
+      } catch (err) {
+        res.status(500).json({ error: err instanceof Error ? err.message : String(err) });
+      }
+    });
+    this.app.delete("/api/schedules/:id", auth, mutationLimiter, (req, res) => {
+      try {
+        this.scheduler.remove(req.params.id);
+        res.json({ ok: true });
+      } catch (err) {
+        res.status(500).json({ error: err instanceof Error ? err.message : String(err) });
+      }
+    });
+    this.app.get("/api/audit-chain", auth, async (req, res) => {
+      try {
+        const limit = Math.min(500, Math.max(1, parseInt(req.query["limit"] || "200", 10) || 200));
+        const offset = Math.max(0, parseInt(req.query["offset"] || "0", 10) || 0);
+        const { AuditLogger: AuditLogger3 } = await Promise.resolve().then(() => (init_audit_logger(), audit_logger_exports));
+        const logger = new AuditLogger3(this.workspacePath);
+        try {
+          const all = logger.getAllLogs();
+          const total = all.length;
+          const entries = all.reverse().slice(offset, offset + limit);
+          res.json({ total, offset, entries });
+        } finally {
+          logger.close();
+        }
+      } catch (err) {
+        res.status(500).json({ error: err instanceof Error ? err.message : String(err) });
+      }
+    });
     const prodPath = path25__default.default.resolve(__dirname$1, "../web/dist");
     const devPath = path25__default.default.resolve(__dirname$1, "../../web/dist");
     const webDistPath = fs23__default.default.existsSync(prodPath) ? prodPath : devPath;
@@ -17558,7 +18055,7 @@ async function startRepl(options) {
     process.exit(1);
   }
   let config = cm.getConfig();
-  const needsSetup = !config.providers?.length || config.providers.every((p) => p.type !== "ollama" && !p.apiKey);
+  const needsSetup = !hasUsableProvider(config.providers);
   if (needsSetup) {
     console.log(chalk9__default.default.magenta("  \u25C8 No providers configured \u2014 launching setup wizard\u2026"));
     console.log();
@@ -17599,7 +18096,7 @@ async function runHeadless(prompt, options) {
     process.exit(1);
   }
   const config = cm.getConfig();
-  const needsSetup = !config.providers?.length || config.providers.every((p) => p.type !== "ollama" && !p.apiKey);
+  const needsSetup = !hasUsableProvider(config.providers);
   if (needsSetup) {
     console.error(chalk9__default.default.red("No providers configured. Run `cascade init` first."));
     process.exit(1);