cascade-ai 0.15.2 → 0.16.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;
@@ -2392,6 +2407,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:

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;
@@ -2392,6 +2407,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:

package/dist/index.js

@@ -190,7 +190,7 @@ var init_audit_logger = __esm({
 });
 
 // src/constants.ts
-var CASCADE_VERSION = "0.15.2";
+var CASCADE_VERSION = "0.16.0";
 var CASCADE_CONFIG_DIR = ".cascade";
 var CASCADE_MD_FILE = "CASCADE.md";
 var CASCADE_IGNORE_FILE = ".cascadeignore";
@@ -5506,6 +5506,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,
@@ -5854,12 +5858,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) {
@@ -5962,6 +5968,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 = "";
@@ -6229,7 +6244,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];
@@ -6269,7 +6284,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();
       }
@@ -8067,6 +8089,13 @@ var PermissionEscalator = class extends EventEmitter {
    * 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 */
@@ -8095,6 +8124,15 @@ var PermissionEscalator = class extends EventEmitter {
    * 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 {
@@ -8139,7 +8177,7 @@ var PermissionEscalator = class extends EventEmitter {
       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 {
@@ -8169,7 +8207,7 @@ var PermissionEscalator = class extends EventEmitter {
       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);
       };
@@ -12088,6 +12126,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: