cascade-ai 0.15.2 → 0.17.0

package/dist/index.d.cts

@@ -1574,10 +1574,15 @@ type T1Evaluator = (req: PermissionRequest) => Promise<PermissionDecision | null
  * PermissionEscalator manages the hierarchical permission flow for a single task run.
  *
  * Decision cascade:
- * 1. Check session cache (section-wide key `${t2Id}:${toolName}`) → return if hit
- * 2. Ask T2 evaluator → if decision returned, cache + return
- * 3. Ask T1 evaluator → if decision returned, cache + return
- * 4. Emit `permission:user-required` → wait for external decision via `resolveUserDecision()`
+ * 1. Check the task-wide cache (USER/T1 "always" decisions, keyed by `toolName`
+ *    alone) → return if hit. These are deliberately NOT scoped to one T2, so a
+ *    user's or T1's "Always" covers every sibling worker anywhere in the run.
+ * 2. Check the per-T2 session cache (section-wide key `${t2Id}:${toolName}`)
+ *    → return if hit
+ * 3. Ask T2 evaluator → if decision returned, cache (per-T2) + return
+ * 4. Ask T1 evaluator → if decision returned, cache (task-wide) + return
+ * 5. Emit `permission:user-required` → wait for external decision via
+ *    `resolveUserDecision()`; an "always" answer caches task-wide.
  */
 declare class PermissionEscalator extends EventEmitter {
     /**
@@ -1585,6 +1590,13 @@ declare class PermissionEscalator extends EventEmitter {
      * All T3 workers under the same T2 share cached decisions for the same tool.
      */
     private sessionCache;
+    /**
+     * 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").
+     */
+    private taskWideCache;
     private t2Evaluator?;
     private t1Evaluator?;
     /** Pending user-decision resolvers keyed by request ID */
@@ -1742,6 +1754,9 @@ declare class T1Administrator extends BaseTier {
      * so it never blocks the approval gate.
      */
     private reviewPlan;
+    /** Structured, grounded summary of what's already done — used to keep
+     * corrective replan passes from re-emitting completed sections. */
+    private summarizeCompletedSections;
     private decomposeTask;
     private validatePlan;
     private dispatchT2Managers;
@@ -2346,6 +2361,17 @@ declare class DashboardSocket {
     private setupHandlers;
     onSessionRate(callback: (sessionId: string, rating: 'good' | 'bad') => void): void;
     onSessionHalt(callback: (sessionId: string) => void): void;
+    /**
+     * 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: (data: {
+        sessionId: string;
+        approved: boolean;
+        note?: string;
+        editedPlan?: unknown;
+    }) => void): void;
     onSessionSteer(callback: (message: string, sessionId?: string, nodeId?: string) => void): void;
     onConfigUpdate(callback: (data: {
         keys?: Record<string, string>;
@@ -2385,6 +2411,14 @@ declare class DashboardServer {
      * map is how that answer reaches the run that's blocked on it.
      */
     private pendingApprovals;
+    /**
+     * 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.
+     */
+    private whyBySession;
+    /** Cron scheduler for the Schedules UI — runs tasks while this server is up. */
+    private scheduler;
     private port;
     private host;
     private workspacePath;
@@ -2392,6 +2426,14 @@ declare class DashboardServer {
     start(): Promise<void>;
     stop(): Promise<void>;
     getSocket(): DashboardSocket;
+    /**
+     * 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: string): void;
     /**
      * Write the in-memory config back to the workspace config file so mutations
      * made over the socket (Settings → Save) persist across restarts. Best-effort:
@@ -2417,6 +2459,12 @@ declare class DashboardServer {
     private persistRunStart;
     /** Record run end: the assistant reply (when there is one) and the runtime row's final status. */
     private persistRunEnd;
+    /**
+     * 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).
+     */
+    private captureWhy;
     /**
      * Route steering text into running Cascade instances. Targets the given
      * session, or every active session when none is specified (the desktop
@@ -2434,6 +2482,13 @@ declare class DashboardServer {
      * timeout denies it.
      */
     private makeApprovalCallback;
+    /**
+     * 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.
+     */
+    private runScheduledTask;
     /** Deny + clear any approvals still pending for a session (run end / abort). */
     private denyPendingApprovals;
     private persistRuntimeRow;

package/dist/index.d.ts

@@ -1574,10 +1574,15 @@ type T1Evaluator = (req: PermissionRequest) => Promise<PermissionDecision | null
  * PermissionEscalator manages the hierarchical permission flow for a single task run.
  *
  * Decision cascade:
- * 1. Check session cache (section-wide key `${t2Id}:${toolName}`) → return if hit
- * 2. Ask T2 evaluator → if decision returned, cache + return
- * 3. Ask T1 evaluator → if decision returned, cache + return
- * 4. Emit `permission:user-required` → wait for external decision via `resolveUserDecision()`
+ * 1. Check the task-wide cache (USER/T1 "always" decisions, keyed by `toolName`
+ *    alone) → return if hit. These are deliberately NOT scoped to one T2, so a
+ *    user's or T1's "Always" covers every sibling worker anywhere in the run.
+ * 2. Check the per-T2 session cache (section-wide key `${t2Id}:${toolName}`)
+ *    → return if hit
+ * 3. Ask T2 evaluator → if decision returned, cache (per-T2) + return
+ * 4. Ask T1 evaluator → if decision returned, cache (task-wide) + return
+ * 5. Emit `permission:user-required` → wait for external decision via
+ *    `resolveUserDecision()`; an "always" answer caches task-wide.
  */
 declare class PermissionEscalator extends EventEmitter {
     /**
@@ -1585,6 +1590,13 @@ declare class PermissionEscalator extends EventEmitter {
      * All T3 workers under the same T2 share cached decisions for the same tool.
      */
     private sessionCache;
+    /**
+     * 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").
+     */
+    private taskWideCache;
     private t2Evaluator?;
     private t1Evaluator?;
     /** Pending user-decision resolvers keyed by request ID */
@@ -1742,6 +1754,9 @@ declare class T1Administrator extends BaseTier {
      * so it never blocks the approval gate.
      */
     private reviewPlan;
+    /** Structured, grounded summary of what's already done — used to keep
+     * corrective replan passes from re-emitting completed sections. */
+    private summarizeCompletedSections;
     private decomposeTask;
     private validatePlan;
     private dispatchT2Managers;
@@ -2346,6 +2361,17 @@ declare class DashboardSocket {
     private setupHandlers;
     onSessionRate(callback: (sessionId: string, rating: 'good' | 'bad') => void): void;
     onSessionHalt(callback: (sessionId: string) => void): void;
+    /**
+     * 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: (data: {
+        sessionId: string;
+        approved: boolean;
+        note?: string;
+        editedPlan?: unknown;
+    }) => void): void;
     onSessionSteer(callback: (message: string, sessionId?: string, nodeId?: string) => void): void;
     onConfigUpdate(callback: (data: {
         keys?: Record<string, string>;
@@ -2385,6 +2411,14 @@ declare class DashboardServer {
      * map is how that answer reaches the run that's blocked on it.
      */
     private pendingApprovals;
+    /**
+     * 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.
+     */
+    private whyBySession;
+    /** Cron scheduler for the Schedules UI — runs tasks while this server is up. */
+    private scheduler;
     private port;
     private host;
     private workspacePath;
@@ -2392,6 +2426,14 @@ declare class DashboardServer {
     start(): Promise<void>;
     stop(): Promise<void>;
     getSocket(): DashboardSocket;
+    /**
+     * 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: string): void;
     /**
      * Write the in-memory config back to the workspace config file so mutations
      * made over the socket (Settings → Save) persist across restarts. Best-effort:
@@ -2417,6 +2459,12 @@ declare class DashboardServer {
     private persistRunStart;
     /** Record run end: the assistant reply (when there is one) and the runtime row's final status. */
     private persistRunEnd;
+    /**
+     * 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).
+     */
+    private captureWhy;
     /**
      * Route steering text into running Cascade instances. Targets the given
      * session, or every active session when none is specified (the desktop
@@ -2434,6 +2482,13 @@ declare class DashboardServer {
      * timeout denies it.
      */
     private makeApprovalCallback;
+    /**
+     * 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.
+     */
+    private runScheduledTask;
     /** Deny + clear any approvals still pending for a session (run end / abort). */
     private denyPendingApprovals;
     private persistRuntimeRow;