cascade-ai 0.15.1 → 0.16.0

package/dist/cli.cjs

@@ -109,7 +109,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.1";
+    CASCADE_VERSION = "0.16.0";
     CASCADE_CONFIG_FILE = ".cascade/config.json";
     CASCADE_DB_FILE = ".cascade/memory.db";
     CASCADE_DASHBOARD_SECRET_FILE = ".cascade/dashboard-secret";
@@ -3230,6 +3230,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 +7523,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 +7878,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 +7988,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 +8264,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 +8304,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 +10115,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 +10150,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 +10203,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 +10233,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 +15312,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 +15331,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 +15382,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: [
@@ -16255,6 +16317,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:
@@ -17558,7 +17630,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 +17671,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);