@charzhu/openjaw-agent 0.3.0 → 0.3.2

package/dist/main.js

@@ -131,13 +131,18 @@ function loadAgentConfig() {
       copilot_oauth_client_id: parsedLlm?.copilot_oauth_client_id ?? DEFAULT_CONFIG.llm.copilot_oauth_client_id,
       context_compression: parsedLlm?.context_compression,
       compression_threshold: parsedLlm?.compression_threshold,
-      compression_model: parsedLlm?.compression_model
+      compression_model: parsedLlm?.compression_model,
+      max_tool_rounds: parsedLlm?.max_tool_rounds
     },
     telegram: parsed?.telegram ?? void 0,
     feishu: parsed?.feishu ?? void 0,
     wechat: parsed?.wechat ?? void 0,
     features: {
-      skill_auto_suggest: parsed?.features?.skill_auto_suggest ?? true
+      skill_auto_suggest: parsed?.features?.skill_auto_suggest ?? true,
+      dynamic_workflows: {
+        ...DEFAULT_DYNAMIC_WORKFLOWS,
+        ...parsed?.features?.dynamic_workflows ?? {}
+      }
     }
   };
   if (config.llm.provider === "anthropic") {
@@ -199,12 +204,20 @@ function updateBridgeConfig(name, values) {
   );
   return next;
 }
-var DEFAULT_COPILOT_OAUTH_CLIENT_ID, DEFAULT_CONFIG, configWriteChain;
+var DEFAULT_COPILOT_OAUTH_CLIENT_ID, DEFAULT_DYNAMIC_WORKFLOWS, DEFAULT_CONFIG, configWriteChain;
 var init_config = __esm({
   "src/config.ts"() {
     "use strict";
     init_packageRoot();
     DEFAULT_COPILOT_OAUTH_CLIENT_ID = "Iv1.b507a08c87ecfe98";
+    DEFAULT_DYNAMIC_WORKFLOWS = {
+      enabled: true,
+      planner_mode: "adaptive",
+      hard_max_workers: 1024,
+      hard_max_concurrent_workers: 128,
+      worker_timeout_ms: 18e4,
+      persist_history: true
+    };
     DEFAULT_CONFIG = {
       llm: {
         provider: "anthropic",
@@ -856,7 +869,7 @@ Start-Sleep -Milliseconds 50
   }
 }
 async function wait(duration) {
-  await new Promise((resolve5) => setTimeout(resolve5, duration * 1e3));
+  await new Promise((resolve6) => setTimeout(resolve6, duration * 1e3));
   return { output: `Waited ${duration} seconds` };
 }
 function getDisplayDimensions() {
@@ -2551,7 +2564,7 @@ var init_copilot = __esm({
           handshakeTimeout: RESPONSES_WEBSOCKET_CONNECT_TIMEOUT_MS
         });
         const request = JSON.stringify(this.buildResponsesWebSocketRequest(requestBody));
-        return new Promise((resolve5, reject) => {
+        return new Promise((resolve6, reject) => {
           const accumulator = { sawTextDelta: false, text: null, toolCalls: [] };
           let settled = false;
           const timeout = setTimeout(() => {
@@ -2565,7 +2578,7 @@ var init_copilot = __esm({
             settled = true;
             clearTimeout(timeout);
             ws.close();
-            resolve5(value);
+            resolve6(value);
           }, "finish");
           const fail = /* @__PURE__ */ __name((error) => {
             if (settled) return;
@@ -2629,7 +2642,8 @@ var init_copilot = __esm({
             messages.push({
               role: "assistant",
               content: msg.content,
-              ...toolCalls?.length ? { tool_calls: toolCalls } : {}
+              ...toolCalls?.length ? { tool_calls: toolCalls } : {},
+              ...msg.reasoningOpaque ? { reasoning_opaque: msg.reasoningOpaque } : {}
             });
           } else {
             for (const result of msg.results) {
@@ -2659,11 +2673,12 @@ var init_copilot = __esm({
           messages: this.buildChatMessages(options),
           tools: options.tools.length > 0 ? options.tools.map(toChatTool) : void 0,
           tool_choice: options.tools.length > 0 ? "auto" : void 0,
-          temperature: this.config.temperature
+          temperature: this.config.temperature,
+          stream: true
         };
         const res = await fetch(`${await this.baseUrl(options.signal)}/chat/completions`, {
           method: "POST",
-          headers: await this.headers(options),
+          headers: { ...await this.headers(options), Accept: "text/event-stream" },
           body: JSON.stringify(requestBody),
           signal: options.signal
         });
@@ -2671,19 +2686,85 @@ var init_copilot = __esm({
           const detail = await res.text();
           throw new Error(`GitHub Copilot chat error: ${res.status} ${detail}`);
         }
-        const data = await res.json();
-        const choice = data.choices?.[0];
-        if (!choice?.message) throw new Error("No response from GitHub Copilot");
-        const toolCalls = (choice.message.tool_calls ?? []).map((tc) => ({
-          id: tc.id,
-          name: tc.function.name,
-          input: safeJsonParse(tc.function.arguments)
-        }));
+        if (!res.body) throw new Error("GitHub Copilot chat: no response body for stream");
+        let text = null;
+        let finishReason;
+        let reasoningOpaque;
+        let promptTokens;
+        let completionTokens;
+        const toolSlots = [];
+        const lastSlotByIndex = /* @__PURE__ */ new Map();
+        const reader = res.body.getReader();
+        const decoder = new TextDecoder();
+        let buf = "";
+        for (; ; ) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          buf += decoder.decode(value, { stream: true });
+          let nl;
+          while ((nl = buf.indexOf("\n")) !== -1) {
+            const rawLine = buf.slice(0, nl).trim();
+            buf = buf.slice(nl + 1);
+            if (!rawLine.startsWith("data:")) continue;
+            const payload = rawLine.slice(5).trim();
+            if (payload === "[DONE]") continue;
+            let evt;
+            try {
+              evt = JSON.parse(payload);
+            } catch {
+              continue;
+            }
+            const choice = evt.choices?.[0];
+            if (choice) {
+              const delta = choice.delta;
+              if (delta) {
+                if (typeof delta.content === "string") text = (text ?? "") + delta.content;
+                if (typeof delta.reasoning_opaque === "string") {
+                  reasoningOpaque = (reasoningOpaque ?? "") + delta.reasoning_opaque;
+                }
+                const deltaToolCalls = delta.tool_calls;
+                for (const tc of deltaToolCalls ?? []) {
+                  const idx = typeof tc.index === "number" ? tc.index : 0;
+                  const fn = tc.function;
+                  const startsNewCall = typeof tc.id === "string" || typeof fn?.name === "string";
+                  let slot;
+                  if (startsNewCall) {
+                    slot = { args: "" };
+                    if (typeof tc.id === "string") slot.id = tc.id;
+                    if (fn?.name) slot.name = fn.name;
+                    toolSlots.push(slot);
+                    lastSlotByIndex.set(idx, slot);
+                  } else {
+                    slot = lastSlotByIndex.get(idx) ?? { args: "" };
+                    if (!lastSlotByIndex.has(idx)) {
+                      toolSlots.push(slot);
+                      lastSlotByIndex.set(idx, slot);
+                    }
+                  }
+                  if (typeof fn?.arguments === "string") slot.args += fn.arguments;
+                }
+              }
+              if (typeof choice.finish_reason === "string") finishReason = choice.finish_reason;
+              if (typeof choice.reasoning_opaque === "string") {
+                reasoningOpaque = choice.reasoning_opaque;
+              }
+              const msg = choice.message;
+              if (typeof msg?.reasoning_opaque === "string") reasoningOpaque = msg.reasoning_opaque;
+            }
+            const usage2 = evt.usage;
+            if (usage2) {
+              promptTokens = usage2.prompt_tokens;
+              completionTokens = usage2.completion_tokens;
+            }
+          }
+        }
+        const toolCalls = toolSlots.filter((slot) => slot.id && slot.name).map((slot) => ({ id: slot.id, name: slot.name, input: safeJsonParse(slot.args) }));
         return {
-          text: choice.message.content,
+          text,
           toolCalls,
-          stopReason: toolCalls.length > 0 ? "tool_use" : choice.finish_reason === "length" ? "max_tokens" : "end",
-          usage: this.usage(data.usage?.prompt_tokens, data.usage?.completion_tokens)
+          stopReason: toolCalls.length > 0 ? "tool_use" : finishReason === "length" ? "max_tokens" : "end",
+          usage: this.usage(promptTokens, completionTokens),
+          reasoningOpaque
         };
       }
       buildResponsesInput(options) {
@@ -3951,13 +4032,13 @@ function selectToolsForRequest(params) {
     addByName(name);
   }
   const relevantCategories = categoriesForMessage(userMessage);
-  for (const tool of allTools) {
-    if (selected.size >= maxTools) break;
+  const relevantTools = allTools.map((tool, index) => ({ index, score: toolRelevanceScore(tool.name, userMessage), tool })).filter(({ tool }) => {
     const cat = categoryForTool(tool.name);
-    if (cat === "mcp") continue;
-    if (relevantCategories.has(cat)) {
-      selected.set(tool.name, tool);
-    }
+    return cat !== "mcp" && relevantCategories.has(cat) && !selected.has(tool.name);
+  }).sort((a, b) => b.score - a.score || a.index - b.index);
+  for (const { tool } of relevantTools) {
+    if (selected.size >= maxTools) break;
+    selected.set(tool.name, tool);
   }
   if (selected.size < maxTools && relevantCategories.size === 0) {
     for (const tool of allTools) {
@@ -3988,6 +4069,20 @@ function categoriesForMessage(message) {
   }
   return categories;
 }
+function preloadRelevantCategoriesForRequest(loader, message) {
+  if (typeof loader.loadCategory !== "function") return [];
+  const loaded = [];
+  for (const category of categoriesForMessage(message)) {
+    if (category === "mcp" || category === "meta" || category === "skill") continue;
+    const added = loader.loadCategory(category);
+    if (added > 0) loaded.push(category);
+  }
+  return loaded;
+}
+function toolOutputLooksFailed(output) {
+  if (!output) return false;
+  return /^\s*\{?"?(error|success)"?\s*:\s*("|false)/i.test(output) || /\b(error|not found|enoent|failed)\b/i.test(output.slice(0, 300));
+}
 function normalizeCategory(value) {
   const normalized = value.toLowerCase();
   if (["browser", "email", "teams", "office", "wechat", "memory", "files", "system"].includes(normalized)) {
@@ -4008,6 +4103,20 @@ function categoryForTool(toolName) {
   if (toolName.startsWith("system_") || toolName.startsWith("clipboard_") || ["code_execute", "web_fetch", "web_search", "web_extract", "notify", "sleep", "ask_user", "config"].includes(toolName)) return "system";
   return "mcp";
 }
+function toolRelevanceScore(toolName, message) {
+  const lower = message.toLowerCase();
+  const name = toolName.toLowerCase();
+  if (/https?:\/\//i.test(message) && ["web_extract", "web_fetch", "web_search"].includes(name)) return 150;
+  if (/(?:^|[\s"'`])(?:~|\.\.?|[A-Za-z]:)?[\\/][^\s"'`]+|\b[\w.-]+\.(html?|md|txt|json|ya?ml|ts|tsx|js|jsx|py|csv|xlsx?|pptx?|pdf)\b/i.test(message) && ["file_read", "file_info", "file_list"].includes(name)) return 145;
+  if (/\b(repo|repository|source code|github|codebase)\b/.test(lower) && ["system_run", "code_execute", "grep", "glob", "web_extract", "web_fetch", "file_read"].includes(name)) return 140;
+  if (/https?:\/\//i.test(message) && ["browser_navigate", "browser_extract", "browser_snapshot"].includes(name)) return 135;
+  if (/\b(powerpoint|pptx?|presentation|slides?|deck)\b/.test(lower) && ["powerpoint_focus", "powerpoint_new_presentation", "powerpoint_new_slide", "powerpoint_read_content", "powerpoint_send_keys", "powerpoint_screenshot"].includes(name)) return 130;
+  if (/\b(powerpoint|pptx?|presentation|slides?|deck)\b/.test(lower) && name.startsWith("powerpoint_")) return 85;
+  if (/\b(excel|spreadsheet|xlsx?|csv|data analysis)\b/.test(lower) && ["excel_focus", "excel_new_workbook", "excel_read_content", "excel_enter_value", "excel_enter_formula"].includes(name)) return 95;
+  if (/\b(word|docx?|document|report)\b/.test(lower) && ["word_focus", "word_new_document", "word_read_content", "word_insert_text", "word_save"].includes(name)) return 95;
+  if (name === "openjaw_load_tools" || name === "invoke_skill") return 90;
+  return 0;
+}
 var DEFAULT_OPENAI_MAX_TOOLS, MCP_AUTO_GROW_HARD_CAP, BUILTIN_HEADROOM, FOUNDATION_TOOL_NAMES, PROFILE_CATEGORIES, CATEGORY_KEYWORDS;
 var init_tool_exposure = __esm({
   "src/tool-exposure.ts"() {
@@ -4031,10 +4140,10 @@ var init_tool_exposure = __esm({
     CATEGORY_KEYWORDS = [
       { category: "email", patterns: [/\b(email|mail|outlook|inbox|calendar|schedule|meeting|invite|today|tomorrow)\b/i] },
       { category: "teams", patterns: [/\b(teams|chat|channel|message|dm|meeting|standup|today|mention)\b/i] },
-      { category: "browser", patterns: [/\b(browser|page|website|web|navigate|click|screenshot|snapshot|console|image|search online)\b/i] },
-      { category: "files", patterns: [/\b(file|folder|directory|read|write|edit|grep|glob|find in repo|codebase)\b/i] },
+      { category: "browser", patterns: [/\b(browser|page|website|web|navigate|click|screenshot|snapshot|console|image|search online)\b/i, /https?:\/\//i] },
+      { category: "files", patterns: [/\b(file|folder|directory|read|write|edit|grep|glob|find in repo|codebase|source code|repo|repository|downloads?)\b/i, /(?:^|[\s"'`])(?:~|\.\.?|[A-Za-z]:)?[\\/][^\s"'`]+/i, /\b[\w.-]+\.(html?|md|txt|json|ya?ml|ts|tsx|js|jsx|py|csv|xlsx?|pptx?|pdf)\b/i] },
       { category: "system", patterns: [/\b(shell|command|terminal|run|execute|clipboard|notify|sleep|web search|fetch url|extract url|read url|article|docs?|paper|source page|news|latest|headlines|current events|breaking news)\b/i] },
-      { category: "office", patterns: [/\b(word|excel|powerpoint|spreadsheet|document|presentation|slide)\b/i] },
+      { category: "office", patterns: [/\b(word|excel|powerpoint|pptx?|spreadsheet|document|presentation|slide|deck)\b/i] },
       { category: "wechat", patterns: [/\b(wechat|weixin)\b/i] },
       { category: "memory", patterns: [/\b(memory|remember|recall|todo|preference)\b/i] }
     ];
@@ -4046,8 +4155,245 @@ var init_tool_exposure = __esm({
     __name(rememberLoadedToolExposure, "rememberLoadedToolExposure");
     __name(selectToolsForRequest, "selectToolsForRequest");
     __name(categoriesForMessage, "categoriesForMessage");
+    __name(preloadRelevantCategoriesForRequest, "preloadRelevantCategoriesForRequest");
+    __name(toolOutputLooksFailed, "toolOutputLooksFailed");
     __name(normalizeCategory, "normalizeCategory");
     __name(categoryForTool, "categoryForTool");
+    __name(toolRelevanceScore, "toolRelevanceScore");
+  }
+});
+
+// src/turn-control.ts
+var DEFAULT_MAX_TOOL_ROUNDS, IterationBudget;
+var init_turn_control = __esm({
+  "src/turn-control.ts"() {
+    "use strict";
+    DEFAULT_MAX_TOOL_ROUNDS = 100;
+    IterationBudget = class {
+      static {
+        __name(this, "IterationBudget");
+      }
+      used = 0;
+      graceUsed = false;
+      max;
+      constructor(max = DEFAULT_MAX_TOOL_ROUNDS) {
+        this.max = Math.max(1, Math.floor(max));
+      }
+      get remaining() {
+        return Math.max(0, this.max - this.used);
+      }
+      get consumed() {
+        return this.used;
+      }
+      /** True while there is budget (or the one-time grace round) left to run. */
+      canContinue() {
+        return this.remaining > 0 || !this.graceUsed;
+      }
+      /** True only when the budget is spent and we are on the grace round. */
+      isGraceRound() {
+        return this.remaining === 0 && !this.graceUsed;
+      }
+      /** Consume one round. Returns false if nothing (not even grace) is left. */
+      consume() {
+        if (this.remaining > 0) {
+          this.used += 1;
+          return true;
+        }
+        if (!this.graceUsed) {
+          this.graceUsed = true;
+          return true;
+        }
+        return false;
+      }
+      /** Give a round back (e.g. a round that made no model-visible progress). */
+      refund() {
+        if (this.used > 0) this.used -= 1;
+      }
+    };
+  }
+});
+
+// src/tool-guardrails.ts
+function isNoProgressTracked(toolName) {
+  if (MUTATING_TOOLS.has(toolName)) return false;
+  if (toolName.startsWith("powerpoint_") || toolName.startsWith("word_") || toolName.startsWith("excel_")) {
+    return false;
+  }
+  return true;
+}
+function signatureOf(toolName, args) {
+  return `${toolName}\0${canonicalJson(args ?? {})}`;
+}
+function canonicalJson(value) {
+  if (value === null || typeof value !== "object") return JSON.stringify(value) ?? "null";
+  if (Array.isArray(value)) return `[${value.map(canonicalJson).join(",")}]`;
+  const obj = value;
+  const keys = Object.keys(obj).sort();
+  return `{${keys.map((k) => `${JSON.stringify(k)}:${canonicalJson(obj[k])}`).join(",")}}`;
+}
+function hashOutput(output) {
+  let h = 2166136261;
+  const s = output ?? "";
+  for (let i = 0; i < s.length; i++) {
+    h ^= s.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return (h >>> 0).toString(16);
+}
+function appendGuardrailGuidance(result, decision) {
+  if (decision.action !== "warn" && decision.action !== "halt" || !decision.message) return result;
+  const label = decision.action === "halt" ? "Tool loop hard stop" : "Tool loop warning";
+  return `${result || ""}
+
+[${label}: ${decision.code}; count=${decision.count}; ${decision.message}]`;
+}
+function blockedToolResult(decision) {
+  return JSON.stringify({ error: decision.message, guardrail: { code: decision.code, action: decision.action } });
+}
+var DEFAULT_GUARDRAIL_THRESHOLDS, MUTATING_TOOLS, ToolLoopGuardrails;
+var init_tool_guardrails = __esm({
+  "src/tool-guardrails.ts"() {
+    "use strict";
+    DEFAULT_GUARDRAIL_THRESHOLDS = {
+      hardStopEnabled: true,
+      exactFailureWarnAfter: 2,
+      exactFailureBlockAfter: 5,
+      sameToolFailureWarnAfter: 3,
+      sameToolFailureHaltAfter: 8,
+      noProgressWarnAfter: 2,
+      noProgressBlockAfter: 5
+    };
+    MUTATING_TOOLS = /* @__PURE__ */ new Set([
+      "file_write",
+      "file_edit",
+      "file_delete",
+      "notify",
+      "ask_user",
+      "memory_append",
+      "memory_save"
+    ]);
+    __name(isNoProgressTracked, "isNoProgressTracked");
+    __name(signatureOf, "signatureOf");
+    __name(canonicalJson, "canonicalJson");
+    __name(hashOutput, "hashOutput");
+    ToolLoopGuardrails = class {
+      static {
+        __name(this, "ToolLoopGuardrails");
+      }
+      t;
+      exactFailure = /* @__PURE__ */ new Map();
+      sameToolFailure = /* @__PURE__ */ new Map();
+      noProgress = /* @__PURE__ */ new Map();
+      haltDecision = null;
+      constructor(thresholds = {}) {
+        this.t = { ...DEFAULT_GUARDRAIL_THRESHOLDS, ...thresholds };
+      }
+      /** Set once a block/halt has fired; the loop reads this to stop the turn. */
+      get halted() {
+        return this.haltDecision;
+      }
+      /**
+       * Consult before (re-)executing a tool call. Returns `block` if this exact
+       * call has already failed/no-progressed past the hard-stop threshold, so the
+       * loop can skip execution and tell the model to change strategy.
+       */
+      before(toolName, args) {
+        if (!this.t.hardStopEnabled) return { action: "allow", toolName };
+        const sig = signatureOf(toolName, args);
+        const exact = this.exactFailure.get(sig) ?? 0;
+        if (exact >= this.t.exactFailureBlockAfter) {
+          return this.recordHalt({
+            action: "block",
+            code: "repeated_exact_failure_block",
+            message: `Blocked ${toolName}: the same tool call failed ${exact} times with identical arguments. Stop retrying it unchanged; change strategy or explain the blocker.`,
+            toolName,
+            count: exact
+          });
+        }
+        if (isNoProgressTracked(toolName)) {
+          const rec = this.noProgress.get(sig);
+          if (rec && rec.count >= this.t.noProgressBlockAfter) {
+            return this.recordHalt({
+              action: "block",
+              code: "idempotent_no_progress_block",
+              message: `Blocked ${toolName}: this call returned the same result ${rec.count} times. Stop repeating it unchanged; use the result already provided or try a different approach.`,
+              toolName,
+              count: rec.count
+            });
+          }
+        }
+        return { action: "allow", toolName };
+      }
+      /**
+       * Record the outcome after a tool call. Returns a `warn` to append to the
+       * tool result, or a `halt` to stop the turn. `failed` is derived by the
+       * caller from the output shape (reuse tool-exposure's toolOutputLooksFailed).
+       */
+      after(toolName, args, output, failed) {
+        const sig = signatureOf(toolName, args);
+        if (failed) {
+          const exact = (this.exactFailure.get(sig) ?? 0) + 1;
+          this.exactFailure.set(sig, exact);
+          this.noProgress.delete(sig);
+          const same = (this.sameToolFailure.get(toolName) ?? 0) + 1;
+          this.sameToolFailure.set(toolName, same);
+          if (this.t.hardStopEnabled && same >= this.t.sameToolFailureHaltAfter) {
+            return this.recordHalt({
+              action: "halt",
+              code: "same_tool_failure_halt",
+              message: `Stopped ${toolName}: it failed ${same} times this turn. Stop retrying the same failing tool path and choose a different approach.`,
+              toolName,
+              count: same
+            });
+          }
+          if (exact >= this.t.exactFailureWarnAfter) {
+            return {
+              action: "warn",
+              code: "repeated_exact_failure_warning",
+              message: `${toolName} has failed ${exact} times with identical arguments. This looks like a loop; inspect the error and change strategy instead of retrying it unchanged.`,
+              toolName,
+              count: exact
+            };
+          }
+          if (same >= this.t.sameToolFailureWarnAfter) {
+            return {
+              action: "warn",
+              code: "same_tool_failure_warning",
+              message: `${toolName} has failed ${same} times this turn. This looks like a loop. Do not switch to text-only replies; keep using tools, but inspect the latest error and verify your assumptions before retrying.`,
+              toolName,
+              count: same
+            };
+          }
+          return { action: "allow", toolName, count: exact };
+        }
+        this.exactFailure.delete(sig);
+        this.sameToolFailure.delete(toolName);
+        if (!isNoProgressTracked(toolName)) {
+          this.noProgress.delete(sig);
+          return { action: "allow", toolName };
+        }
+        const hash3 = hashOutput(output);
+        const prev = this.noProgress.get(sig);
+        const count = prev && prev.hash === hash3 ? prev.count + 1 : 1;
+        this.noProgress.set(sig, { hash: hash3, count });
+        if (count >= this.t.noProgressWarnAfter) {
+          return {
+            action: "warn",
+            code: "idempotent_no_progress_warning",
+            message: `${toolName} returned the same result ${count} times. Use the result already provided or change the approach instead of repeating it unchanged.`,
+            toolName,
+            count
+          };
+        }
+        return { action: "allow", toolName, count };
+      }
+      recordHalt(decision) {
+        this.haltDecision = decision;
+        return decision;
+      }
+    };
+    __name(appendGuardrailGuidance, "appendGuardrailGuidance");
+    __name(blockedToolResult, "blockedToolResult");
   }
 });
 
@@ -4600,6 +4946,8 @@ var init_agent_loop = __esm({
     init_telemetry();
     init_context_compressor();
     init_tool_exposure();
+    init_turn_control();
+    init_tool_guardrails();
     init_provider_auth();
     init_connect();
     AgentLoop = class {
@@ -5120,15 +5468,25 @@ ${summary}
           const MAX_SAME_ACTIONS = 3;
           let previousCacheReadTokens = 0;
           let maxTokensContinuations = 0;
+          const budget = new IterationBudget(this.config.llm.max_tool_rounds ?? DEFAULT_MAX_TOOL_ROUNDS);
+          const guardrails = new ToolLoopGuardrails();
           for (let step = 0; ; step++) {
             if (signal.aborted) {
               yield { type: "answer", content: "[Interrupted by user]" };
               return;
             }
+            const forceFinalSummary = budget.isGraceRound();
+            if (!budget.consume()) {
+              const reason = "max_iterations";
+              yield { type: "answer", content: `[Reached the maximum of ${budget.max} tool rounds. Stopping.]`, exitReason: reason };
+              return;
+            }
             let responseText = null;
             const responseToolCalls = [];
             let responseStopReason = "end";
+            let responseReasoningOpaque;
             let responseUsage;
+            preloadRelevantCategoriesForRequest(this.toolRegistry, userMessage);
             const allTools = this.toolRegistry.listTools();
             const exposure = selectToolsForRequest({
               config: this.config,
@@ -5136,7 +5494,13 @@ ${summary}
               userMessage,
               state: this._toolExposureState
             });
-            const tools = exposure.tools;
+            const tools = forceFinalSummary ? [] : exposure.tools;
+            if (forceFinalSummary) {
+              messages.push({
+                role: "user",
+                content: "[System: You've reached the maximum number of tool-calling rounds. Do not call any more tools. Summarize what you accomplished, what is still incomplete, and any blocker, as your final answer.]"
+              });
+            }
             const chatOptions = {
               systemPrompt,
               messages,
@@ -5219,6 +5583,7 @@ ${summary}
                 responseToolCalls.push(...response.toolCalls);
                 responseStopReason = response.stopReason;
                 responseUsage = response.usage;
+                responseReasoningOpaque = response.reasoningOpaque;
               }
             } catch (apiError) {
               const errMsg = apiError instanceof Error ? apiError.message : String(apiError);
@@ -5345,10 +5710,11 @@ ${summary}
               this.conversationHistory.push({ role: "assistant", content: responseText });
               this.session.messages = this.conversationHistory;
               saveSession(this.session);
+              const exitReason = forceFinalSummary ? "max_iterations" : "completed";
               if (!this.provider.chatStream) {
-                yield { type: "answer", content: responseText ?? "" };
+                yield { type: "answer", content: responseText ?? "", exitReason };
               } else {
-                yield { type: "answer", content: "" };
+                yield { type: "answer", content: "", exitReason };
               }
               if (this._toolRoundsInRun >= 1 || responseText && responseText.length > 200) {
                 void this.postTurnMemorySave(systemPrompt, messages, tools, signal);
@@ -5380,7 +5746,8 @@ ${summary}
             messages.push({
               role: "assistant",
               content: responseText,
-              toolCalls: validToolCalls
+              toolCalls: validToolCalls,
+              reasoningOpaque: responseReasoningOpaque
             });
             const computerCalls = validToolCalls.filter((tc) => tc.name === "computer");
             const otherCalls = validToolCalls.filter((tc) => tc.name !== "computer");
@@ -5388,6 +5755,10 @@ ${summary}
               if (signal.aborted) {
                 return { id: tc.id, name: tc.name, output: "[Interrupted]", imageData: void 0 };
               }
+              const pre = guardrails.before(tc.name, tc.input);
+              if (pre.action === "block") {
+                return { id: tc.id, name: tc.name, output: blockedToolResult(pre), imageData: void 0 };
+              }
               let output;
               let imageData2;
               try {
@@ -5444,7 +5815,12 @@ ${summary}
                 }
               } catch {
               }
-              const outputStr = typeof output === "string" ? output : JSON.stringify(output ?? { error: "No output" });
+              let outputStr = typeof output === "string" ? output : JSON.stringify(output ?? { error: "No output" });
+              const failed = toolOutputLooksFailed(outputStr);
+              const verdict = guardrails.after(tc.name, tc.input, outputStr, failed);
+              if (verdict.action === "warn" || verdict.action === "halt") {
+                outputStr = appendGuardrailGuidance(outputStr, verdict);
+              }
               return { id: tc.id, name: tc.name, output: outputStr, imageData: imageData2 };
             }, "executeOne");
             const results = [];
@@ -5472,18 +5848,18 @@ ${summary}
                       content: parsed.question,
                       choices: parsed.choices ?? void 0
                     };
-                    const userResponse = await new Promise((resolve5) => {
+                    const userResponse = await new Promise((resolve6) => {
                       if (this._pendingAskUserResponse !== null) {
                         const buffered = this._pendingAskUserResponse;
                         this._pendingAskUserResponse = null;
-                        resolve5(buffered);
+                        resolve6(buffered);
                         return;
                       }
-                      this._askUserResolver = resolve5;
+                      this._askUserResolver = resolve6;
                       setTimeout(() => {
-                        if (this._askUserResolver === resolve5) {
+                        if (this._askUserResolver === resolve6) {
                           this._askUserResolver = null;
-                          resolve5("[No response from user \u2014 timed out after 5 minutes]");
+                          resolve6("[No response from user \u2014 timed out after 5 minutes]");
                         }
                       }, 5 * 60 * 1e3);
                     });
@@ -5504,6 +5880,15 @@ ${summary}
             this.conversationHistory = [...messages];
             this.session.messages = this.conversationHistory;
             saveSession(this.session);
+            if (guardrails.halted) {
+              const reason = "guardrail_halt";
+              yield {
+                type: "answer",
+                content: `[Stopped: ${guardrails.halted.message ?? "tool loop detected"}]`,
+                exitReason: reason
+              };
+              return;
+            }
             if (this._toolRoundsInRun > 0 && this._toolRoundsInRun % 5 === 0) {
               messages.push({
                 role: "user",
@@ -6146,7 +6531,7 @@ var init_browser = __esm({
           await Page.domContentEventFired();
         } else if (options.waitFor === "networkidle") {
           await Page.loadEventFired();
-          await new Promise((resolve5) => setTimeout(resolve5, 1e3));
+          await new Promise((resolve6) => setTimeout(resolve6, 1e3));
         }
         const result = await Runtime.evaluate({
           expression: "document.title"
@@ -6917,7 +7302,7 @@ var init_browser = __esm({
           if (exists) {
             return true;
           }
-          await new Promise((resolve5) => setTimeout(resolve5, 200));
+          await new Promise((resolve6) => setTimeout(resolve6, 200));
         }
         return false;
       }
@@ -7145,10 +7530,10 @@ function createBrowseTools(config, sharedBrowser) {
         }
       },
       execute: /* @__PURE__ */ __name(async (input) => {
-        const { join: join47 } = await import("node:path");
+        const { join: join48 } = await import("node:path");
         const { tmpdir: tmpdir13 } = await import("node:os");
-        const { randomUUID: randomUUID14 } = await import("node:crypto");
-        const screenshotPath = join47(tmpdir13(), `openjaw-browser-${randomUUID14().slice(0, 8)}.png`);
+        const { randomUUID: randomUUID15 } = await import("node:crypto");
+        const screenshotPath = join48(tmpdir13(), `openjaw-browser-${randomUUID15().slice(0, 8)}.png`);
         const screenshot = await browser.screenshot({ fullPage: false, path: screenshotPath });
         const snapshot = await browser.snapshot({ full: false });
         return {
@@ -7843,7 +8228,7 @@ var init_outlook_desktop = __esm({
         }
       }
       sleep(ms) {
-        return new Promise((resolve5) => setTimeout(resolve5, ms));
+        return new Promise((resolve6) => setTimeout(resolve6, ms));
       }
     };
   }
@@ -8441,7 +8826,7 @@ var init_outlook_web = __esm({
         await this.browser.typeChars(text);
       }
       sleep(ms) {
-        return new Promise((resolve5) => setTimeout(resolve5, ms));
+        return new Promise((resolve6) => setTimeout(resolve6, ms));
       }
     };
   }
@@ -8675,8 +9060,8 @@ var init_token_pool = __esm({
         if (!existsSync8(legacyDir))
           return;
         try {
-          const { readdirSync: readdirSync7 } = __require("node:fs");
-          const files = readdirSync7(legacyDir);
+          const { readdirSync: readdirSync8 } = __require("node:fs");
+          const files = readdirSync8(legacyDir);
           for (const file2 of files) {
             if (!file2.endsWith(".json"))
               continue;
@@ -8856,7 +9241,7 @@ var init_cdp_token_extractor = __esm({
         }
         logger_default.info("CDP: reloading tab for token refresh", { url: targetTab.url, audience });
         await this.reloadTab(targetTab);
-        await new Promise((resolve5) => setTimeout(resolve5, PAGE_RELOAD_WAIT_MS));
+        await new Promise((resolve6) => setTimeout(resolve6, PAGE_RELOAD_WAIT_MS));
         if (!targetTab.webSocketDebuggerUrl)
           return [];
         const freshPages = await this.listPages();
@@ -8973,19 +9358,19 @@ var init_cdp_token_extractor = __esm({
        * Evaluate a JS expression in a tab and return the string result.
        */
       async evaluateInTab(wsUrl, expression) {
-        return new Promise((resolve5) => {
+        return new Promise((resolve6) => {
           let ws;
           try {
             ws = new WebSocket(wsUrl);
           } catch (err) {
             logger_default.warn("CDP: WebSocket constructor failed", { wsUrl: wsUrl.substring(0, 60), error: String(err) });
-            resolve5(null);
+            resolve6(null);
             return;
           }
           const timer = setTimeout(() => {
             logger_default.warn("CDP: evaluateInTab timeout", { wsUrl: wsUrl.substring(0, 60) });
             ws.close();
-            resolve5(null);
+            resolve6(null);
           }, CDP_TIMEOUT_MS);
           ws.on("open", () => {
             ws.send(JSON.stringify({
@@ -8999,18 +9384,18 @@ var init_cdp_token_extractor = __esm({
             if (resp.id === 1) {
               clearTimeout(timer);
               ws.close();
-              resolve5(resp.result?.result?.value ?? null);
+              resolve6(resp.result?.result?.value ?? null);
             }
           });
           ws.on("error", (err) => {
             logger_default.warn("CDP: evaluateInTab WS error", { error: String(err), wsUrl: wsUrl.substring(0, 60) });
             clearTimeout(timer);
-            resolve5(null);
+            resolve6(null);
           });
         });
       }
       async extractFromTab(wsUrl) {
-        return new Promise((resolve5, reject) => {
+        return new Promise((resolve6, reject) => {
           const ws = new WebSocket(wsUrl);
           const timer = setTimeout(() => {
             ws.close();
@@ -9030,14 +9415,14 @@ var init_cdp_token_extractor = __esm({
               ws.close();
               const value = resp.result?.result?.value;
               if (!value) {
-                resolve5([]);
+                resolve6([]);
                 return;
               }
               try {
                 const tokens = JSON.parse(value);
-                resolve5(tokens);
+                resolve6(tokens);
               } catch {
-                resolve5([]);
+                resolve6([]);
               }
             }
           });
@@ -9053,11 +9438,11 @@ var init_cdp_token_extractor = __esm({
       async reloadTab(page) {
         if (!page.webSocketDebuggerUrl)
           return;
-        return new Promise((resolve5, reject) => {
+        return new Promise((resolve6, reject) => {
           const ws = new WebSocket(page.webSocketDebuggerUrl);
           const timer = setTimeout(() => {
             ws.close();
-            resolve5();
+            resolve6();
           }, 1e4);
           ws.on("open", () => {
             ws.send(JSON.stringify({
@@ -9071,7 +9456,7 @@ var init_cdp_token_extractor = __esm({
             if (resp.id === 1) {
               clearTimeout(timer);
               ws.close();
-              resolve5();
+              resolve6();
             }
           });
           ws.on("error", (err) => {
@@ -10732,13 +11117,13 @@ function createMemoryTools(config) {
         const todos = input.todos;
         try {
           const { appendFile: appendFile2, mkdir: mkdir5 } = await import("node:fs/promises");
-          const { existsSync: existsSync33 } = await import("node:fs");
-          const { join: join47 } = await import("node:path");
-          const { homedir: homedir31 } = await import("node:os");
-          const memoryDir = join47(homedir31(), ".openjaw", "memory");
-          if (!existsSync33(memoryDir))
+          const { existsSync: existsSync34 } = await import("node:fs");
+          const { join: join48 } = await import("node:path");
+          const { homedir: homedir32 } = await import("node:os");
+          const memoryDir = join48(homedir32(), ".openjaw", "memory");
+          if (!existsSync34(memoryDir))
             await mkdir5(memoryDir, { recursive: true });
-          const todoPath = join47(memoryDir, "TODOS.md");
+          const todoPath = join48(memoryDir, "TODOS.md");
           const { writeFile: writeFile5 } = await import("node:fs/promises");
           await writeFile5(todoPath, `# Session Todos
 
@@ -12059,7 +12444,7 @@ var init_teams_desktop = __esm({
         }
       }
       sleep(ms) {
-        return new Promise((resolve5) => setTimeout(resolve5, ms));
+        return new Promise((resolve6) => setTimeout(resolve6, ms));
       }
       /**
        * Get the current Teams window state
@@ -12926,7 +13311,7 @@ var init_teams_web = __esm({
         }
       }
       sleep(ms) {
-        return new Promise((resolve5) => setTimeout(resolve5, ms));
+        return new Promise((resolve6) => setTimeout(resolve6, ms));
       }
     };
   }
@@ -14324,7 +14709,7 @@ var init_teams_chat_monitor = __esm({
         return this.sentMessages.has(normalized);
       }
       sleep(ms) {
-        return new Promise((resolve5) => setTimeout(resolve5, ms));
+        return new Promise((resolve6) => setTimeout(resolve6, ms));
       }
       /**
        * Attempt to reconnect the browser after detecting a disconnection.
@@ -15111,7 +15496,7 @@ ${lines.join("\n")}`;
             globalThis.__teamsSeenMessages.set(chatName, seenIds);
           }
           if (syncMode) {
-            return new Promise((resolve5) => {
+            return new Promise((resolve6) => {
               const timer2 = setInterval(async () => {
                 try {
                   const current = await channel.readCurrentChatMessages();
@@ -15120,7 +15505,7 @@ ${lines.join("\n")}`;
                     if (!seenIds.has(msgId) && msg.sender !== currentUserName) {
                       clearInterval(timer2);
                       seenIds.add(msgId);
-                      resolve5({
+                      resolve6({
                         success: true,
                         channel: channelType,
                         sync: true,
@@ -15197,7 +15582,7 @@ ${lines.join("\n")}`;
             globalThis.__teamsSeenMessages.set(chatName, seenIds);
           }
           if (syncMode) {
-            return new Promise((resolve5) => {
+            return new Promise((resolve6) => {
               const timer2 = setInterval(async () => {
                 try {
                   const current = await channel.readCurrentChatMessages();
@@ -15206,7 +15591,7 @@ ${lines.join("\n")}`;
                     if (!seenIds.has(msgId) && msg.sender !== currentUserName) {
                       clearInterval(timer2);
                       seenIds.add(msgId);
-                      resolve5({
+                      resolve6({
                         success: true,
                         channel: channelType,
                         sync: true,
@@ -15564,7 +15949,7 @@ ${lines.join("\n")}`;
   return allTools;
 }
 function sleep2(ms) {
-  return new Promise((resolve5) => setTimeout(resolve5, ms));
+  return new Promise((resolve6) => setTimeout(resolve6, ms));
 }
 var MAX_STORED_ENTRIES, ENTRY_TTL_MS;
 var init_chat = __esm({
@@ -16388,11 +16773,11 @@ function createShellTools(_config, hooks) {
         const shell = input.shell ?? true;
         if (input.background) {
           const { tmpdir: tmpdir13 } = await import("node:os");
-          const { join: join47 } = await import("node:path");
-          const { randomUUID: randomUUID14 } = await import("node:crypto");
+          const { join: join48 } = await import("node:path");
+          const { randomUUID: randomUUID15 } = await import("node:crypto");
           const { createWriteStream: createWriteStream2 } = await import("node:fs");
-          const taskId = randomUUID14().slice(0, 8);
-          const outputPath = join47(tmpdir13(), `oj-bg-${taskId}.log`);
+          const taskId = randomUUID15().slice(0, 8);
+          const outputPath = join48(tmpdir13(), `oj-bg-${taskId}.log`);
           const detached = spawn(command, [], {
             shell,
             cwd,
@@ -16412,7 +16797,7 @@ function createShellTools(_config, hooks) {
             message: `Command started in background (PID: ${detached.pid}). Output: ${outputPath}`
           };
         }
-        return new Promise((resolve5) => {
+        return new Promise((resolve6) => {
           const proc = spawn(command, [], {
             shell,
             cwd,
@@ -16430,7 +16815,7 @@ function createShellTools(_config, hooks) {
           proc.on("close", (code) => {
             const stdoutResult = truncateOutput(stdout.trim());
             const stderrResult = truncateOutput(stderr.trim());
-            resolve5({
+            resolve6({
               command,
               exitCode: code,
               stdout: stdoutResult.text,
@@ -16441,7 +16826,7 @@ function createShellTools(_config, hooks) {
             });
           });
           proc.on("error", (error) => {
-            resolve5({
+            resolve6({
               command,
               exitCode: -1,
               stdout: "",
@@ -16475,10 +16860,10 @@ function createShellTools(_config, hooks) {
       },
       requiresConfirmation: false,
       execute: /* @__PURE__ */ __name(async (input) => {
-        const { writeFileSync: writeFileSync22, unlinkSync: unlinkSync9 } = await import("node:fs");
-        const { join: join47 } = await import("node:path");
+        const { writeFileSync: writeFileSync23, unlinkSync: unlinkSync9 } = await import("node:fs");
+        const { join: join48 } = await import("node:path");
         const { tmpdir: tmpdir13 } = await import("node:os");
-        const { randomUUID: randomUUID14 } = await import("node:crypto");
+        const { randomUUID: randomUUID15 } = await import("node:crypto");
         const { execFile: execFile3 } = await import("node:child_process");
         const code = input.code;
         const language = input.language;
@@ -16495,14 +16880,14 @@ function createShellTools(_config, hooks) {
         const interpreter = interpreterMap[language];
         if (!interpreter)
           return { error: `Unsupported language: ${language}` };
-        const tmpFile = join47(tmpdir13(), `oj-code-${randomUUID14().slice(0, 8)}${ext}`);
+        const tmpFile = join48(tmpdir13(), `oj-code-${randomUUID15().slice(0, 8)}${ext}`);
         try {
-          writeFileSync22(tmpFile, code, "utf-8");
+          writeFileSync23(tmpFile, code, "utf-8");
           const startTime = Date.now();
-          const result = await new Promise((resolve5) => {
+          const result = await new Promise((resolve6) => {
             execFile3(interpreter.cmd, [...interpreter.args, tmpFile], { timeout, maxBuffer: 10 * 1024 * 1024 }, (error, stdout2, stderr2) => {
               const exitCode = error ? typeof error.code === "number" ? error.code : 1 : 0;
-              resolve5({ exitCode, stdout: stdout2 ?? "", stderr: stderr2 ?? "" });
+              resolve6({ exitCode, stdout: stdout2 ?? "", stderr: stderr2 ?? "" });
             });
           });
           const executionTimeMs = Date.now() - startTime;
@@ -16595,7 +16980,7 @@ function createShellTools(_config, hooks) {
         required: ["title", "message"]
       },
       execute: /* @__PURE__ */ __name(async (input) => {
-        return new Promise((resolve5) => {
+        return new Promise((resolve6) => {
           notifier.notify({
             title: input.title,
             message: input.message,
@@ -16603,9 +16988,9 @@ function createShellTools(_config, hooks) {
             sound: true
           }, (err) => {
             if (err) {
-              resolve5({ error: err.message });
+              resolve6({ error: err.message });
             } else {
-              resolve5({ success: true });
+              resolve6({ success: true });
             }
           });
         });
@@ -16709,7 +17094,7 @@ function createShellTools(_config, hooks) {
       },
       execute: /* @__PURE__ */ __name(async (input) => {
         const seconds = Math.min(Math.max(0.1, input.seconds), 60);
-        await new Promise((resolve5) => setTimeout(resolve5, seconds * 1e3));
+        await new Promise((resolve6) => setTimeout(resolve6, seconds * 1e3));
         return { waited: seconds, message: `Waited ${seconds} seconds` };
       }, "execute")
     },
@@ -17821,7 +18206,7 @@ var init_office_desktop = __esm({
         return Array.isArray(parsed) ? parsed : [parsed];
       }
       sleep(ms) {
-        return new Promise((resolve5) => setTimeout(resolve5, ms));
+        return new Promise((resolve6) => setTimeout(resolve6, ms));
       }
     };
   }
@@ -19502,7 +19887,7 @@ public class Win32Send {
         }
       }
       sleep(ms) {
-        return new Promise((resolve5) => setTimeout(resolve5, ms));
+        return new Promise((resolve6) => setTimeout(resolve6, ms));
       }
     };
   }
@@ -19567,7 +19952,7 @@ function getActiveMonitors() {
   return result;
 }
 function sleep3(ms) {
-  return new Promise((resolve5) => setTimeout(resolve5, ms));
+  return new Promise((resolve6) => setTimeout(resolve6, ms));
 }
 async function fileHash(filePath) {
   const data = fs.readFileSync(filePath);
@@ -21040,11 +21425,11 @@ function loadFlatSkillsFromDir(dir2, source, priority, out) {
 function loadPackagedSkillsFromDir(dir2, out) {
   for (const entry of safeReadDir(dir2)) {
     if (!entry.isDirectory()) continue;
-    const rootDir = join22(dir2, entry.name);
-    const entrypoint = findPackageEntrypoint(rootDir);
+    const rootDir2 = join22(dir2, entry.name);
+    const entrypoint = findPackageEntrypoint(rootDir2);
     if (!entrypoint) continue;
-    const filePath = join22(rootDir, entrypoint);
-    const skill = parseSkillAtPath(filePath, rootDir, entrypoint, "user", `${entry.name}.md`);
+    const filePath = join22(rootDir2, entrypoint);
+    const skill = parseSkillAtPath(filePath, rootDir2, entrypoint, "user", `${entry.name}.md`);
     if (skill) putSkill(out, skill, 2);
   }
 }
@@ -21057,7 +21442,7 @@ function findPackageEntrypoint(dir2) {
   const markdown = entries.filter((entry) => isMarkdown(entry.name));
   return markdown.length === 1 ? markdown[0].name : null;
 }
-function parseSkillAtPath(filePath, rootDir, entrypoint, source, fallbackFilename) {
+function parseSkillAtPath(filePath, rootDir2, entrypoint, source, fallbackFilename) {
   try {
     const content = readFileSync14(filePath, "utf-8").trim();
     if (!content) return null;
@@ -21068,7 +21453,7 @@ function parseSkillAtPath(filePath, rootDir, entrypoint, source, fallbackFilenam
       name,
       meta: { ...parsed.meta, name },
       filePath,
-      rootDir,
+      rootDir: rootDir2,
       entrypoint,
       source,
       hasFrontmatter: parsed.hasFrontmatter
@@ -21725,12 +22110,12 @@ var init_telegram = __esm({
 Options: ${chunk.choices.join(" | ")}` : "";
                   await this.bot.sendMessage(chatId, `\u2753 ${question}${choicesText}`);
                   updateStatus("\u2753 Waiting for your response...");
-                  const userReply = await new Promise((resolve5) => {
-                    this._pendingReplyResolver = resolve5;
+                  const userReply = await new Promise((resolve6) => {
+                    this._pendingReplyResolver = resolve6;
                     setTimeout(() => {
-                      if (this._pendingReplyResolver === resolve5) {
+                      if (this._pendingReplyResolver === resolve6) {
                         this._pendingReplyResolver = null;
-                        resolve5("[No response \u2014 timed out]");
+                        resolve6("[No response \u2014 timed out]");
                       }
                     }, 5 * 60 * 1e3);
                   });
@@ -22328,7 +22713,7 @@ async function promptConsent(servers) {
     input: process.stdin,
     output: process.stderr
   });
-  const ask = /* @__PURE__ */ __name((question) => new Promise((resolve5) => rl.question(question, resolve5)), "ask");
+  const ask = /* @__PURE__ */ __name((question) => new Promise((resolve6) => rl.question(question, resolve6)), "ask");
   const w = process.stderr.columns || 80;
   const inner = w - 4;
   const hLine = "\u2500".repeat(inner);
@@ -24383,7 +24768,7 @@ try {
 }
 `;
   const encoded = Buffer.from(script, "utf16le").toString("base64");
-  return new Promise((resolve5) => {
+  return new Promise((resolve6) => {
     const proc = spawn3("powershell.exe", ["-NoProfile", "-STA", "-EncodedCommand", encoded], {
       stdio: ["pipe", "pipe", "pipe"],
       windowsHide: true
@@ -24398,22 +24783,22 @@ try {
     });
     const timer = setTimeout(() => {
       if (!proc.killed) proc.kill();
-      resolve5(null);
+      resolve6(null);
     }, (timeoutSeconds + 5) * 1e3);
     proc.on("exit", () => {
       clearTimeout(timer);
       const output = stdout.replace(/#< CLIXML[\s\S]*/m, "").trim();
       if (output === "NO_SPEECH" || output.startsWith("ERROR") || !output) {
-        resolve5(null);
+        resolve6(null);
         return;
       }
       const parts = output.split("|");
       const text = parts[0]?.trim();
       const confidence = parseFloat(parts[1] || "0");
       if (text) {
-        resolve5({ text, confidence: isNaN(confidence) ? 0.5 : confidence });
+        resolve6({ text, confidence: isNaN(confidence) ? 0.5 : confidence });
       } else {
-        resolve5(null);
+        resolve6(null);
       }
       try {
         if (existsSync21(resultFile)) unlinkSync5(resultFile);
@@ -24750,6 +25135,7 @@ var init_PromptInput = __esm({
       { name: "/repl", description: "\u{1F527} Start interactive code REPL" },
       { name: "/voice", description: "\u{1F50A} Toggle voice output (TTS)" },
       { name: "/fork", description: "\u{1F500} Spawn background sub-agent" },
+      { name: "/workflow", description: "\u{1F9ED} Run advisory dynamic workflow" },
       { name: "/tasks", description: "List background tasks" },
       { name: "/clear", description: "Clear conversation history" },
       { name: "/compact", description: "Summarize old messages to free context" },
@@ -24782,6 +25168,12 @@ var init_PromptInput = __esm({
         { name: "pause", description: "Pause a task: /schedule pause <id>" },
         { name: "resume", description: "Resume a task: /schedule resume <id>" }
       ],
+      "/workflow": [
+        { name: "status", description: "Open live worker status" },
+        { name: "list", description: "List recent workflows" },
+        { name: "show <id>", description: "Show workflow summary" },
+        { name: "cancel <id>", description: "Cancel a run or worker" }
+      ],
       "/repl": [
         { name: "python", description: "Python interactive shell" },
         { name: "node", description: "Node.js interactive shell" },
@@ -25985,8 +26377,8 @@ function isSensitivePath(resolved) {
     if (re.test(normalized)) return true;
   }
   for (const re of SENSITIVE_FILE_PATTERNS) {
-    const basename4 = path2.basename(resolved);
-    if (re.test(basename4)) return true;
+    const basename5 = path2.basename(resolved);
+    if (re.test(basename5)) return true;
   }
   return false;
 }
@@ -26104,34 +26496,34 @@ ${output}
   }
 }
 function expandUrl(ref, warnings) {
-  return new Promise((resolve5) => {
+  return new Promise((resolve6) => {
     const url = ref.target;
     const mod = url.startsWith("https") ? https : http;
     const req = mod.get(url, { timeout: 15e3 }, (res) => {
       if (res.statusCode && (res.statusCode >= 300 && res.statusCode < 400) && res.headers.location) {
         const redirectMod = res.headers.location.startsWith("https") ? https : http;
         const req2 = redirectMod.get(res.headers.location, { timeout: 15e3 }, (res2) => {
-          collectResponse(res2, ref, warnings, resolve5);
+          collectResponse(res2, ref, warnings, resolve6);
         });
         req2.on("error", (e) => {
           warnings.push(`\u26A0\uFE0F @url fetch error: ${e.message}`);
-          resolve5(null);
+          resolve6(null);
         });
         return;
       }
-      collectResponse(res, ref, warnings, resolve5);
+      collectResponse(res, ref, warnings, resolve6);
     });
     req.on("error", (e) => {
       warnings.push(`\u26A0\uFE0F @url fetch error: ${e.message}`);
-      resolve5(null);
+      resolve6(null);
     });
   });
 }
-function collectResponse(res, ref, warnings, resolve5) {
+function collectResponse(res, ref, warnings, resolve6) {
   if (res.statusCode && res.statusCode >= 400) {
     warnings.push(`\u26A0\uFE0F @url returned HTTP ${res.statusCode}: ${ref.target}`);
     res.resume();
-    resolve5(null);
+    resolve6(null);
     return;
   }
   const chunks = [];
@@ -26143,14 +26535,14 @@ function collectResponse(res, ref, warnings, resolve5) {
       text = text.slice(0, 5e4) + "\n\u2026 (truncated)";
     }
     const tokens = estimateTokens2(text);
-    resolve5(`\u{1F310} @url:${ref.target} (${tokens} tokens)
+    resolve6(`\u{1F310} @url:${ref.target} (${tokens} tokens)
 \`\`\`
 ${text}
 \`\`\``);
   });
   res.on("error", (e) => {
     warnings.push(`\u26A0\uFE0F @url fetch error: ${e.message}`);
-    resolve5(null);
+    resolve6(null);
   });
 }
 function stripHtml(html) {
@@ -26651,13 +27043,13 @@ Type /resume <id> to resume.` });
         if (input === "/export") {
           try {
             const { writeFile: writeFile5, mkdir: mkdir5 } = await import("node:fs/promises");
-            const { join: join47 } = await import("node:path");
-            const { homedir: homedir31 } = await import("node:os");
-            const { existsSync: existsSync33 } = await import("node:fs");
-            const exportDir = join47(homedir31(), ".openjaw-agent", "exports");
-            if (!existsSync33(exportDir)) await mkdir5(exportDir, { recursive: true });
+            const { join: join48 } = await import("node:path");
+            const { homedir: homedir32 } = await import("node:os");
+            const { existsSync: existsSync34 } = await import("node:fs");
+            const exportDir = join48(homedir32(), ".openjaw-agent", "exports");
+            if (!existsSync34(exportDir)) await mkdir5(exportDir, { recursive: true });
             const filename = `session-${agentLoop.sessionId}.md`;
-            const filepath = join47(exportDir, filename);
+            const filepath = join48(exportDir, filename);
             const lines = [
               `# OpenJaw Agent Session ${agentLoop.sessionId}`,
               `Date: ${(/* @__PURE__ */ new Date()).toISOString()}`,
@@ -26876,9 +27268,9 @@ ${list}` });
             const cmd = lang === "python" ? "python" : lang === "node" ? "node" : "pwsh";
             const args = lang === "python" ? ["-i", "-u"] : lang === "node" ? ["-i"] : ["-NoProfile", "-NoLogo"];
             try {
-              const { spawn: spawn9 } = await import("node:child_process");
+              const { spawn: spawn8 } = await import("node:child_process");
               if (replRef.current) replRef.current.kill();
-              const proc = spawn9(cmd, args, {
+              const proc = spawn8(cmd, args, {
                 stdio: ["pipe", "pipe", "pipe"],
                 windowsHide: true
               });
@@ -26918,7 +27310,7 @@ ${list}` });
         if (replRef.current && replLangRef.current && !input.startsWith("/")) {
           const proc = replRef.current;
           proc.stdin?.write(input + "\n");
-          await new Promise((resolve5) => setTimeout(resolve5, 800));
+          await new Promise((resolve6) => setTimeout(resolve6, 800));
           const flush = proc._ojFlush;
           const output = flush ? flush() : "";
           if (output.trim()) {
@@ -27232,14 +27624,14 @@ Options: ${chunk.choices.join(" | ")}` : chunk.content;
                 waitingForAskUserRef.current = true;
                 setIsRunning(false);
                 setWaitingForAskUser(true);
-                await new Promise((resolve5) => {
+                await new Promise((resolve6) => {
                   const checkInterval = setInterval(() => {
                     if (!waitingForAskUserRef.current || !agentLoop.isWaitingForAskUser) {
                       clearInterval(checkInterval);
                       waitingForAskUserRef.current = false;
                       setWaitingForAskUser(false);
                       setIsRunning(true);
-                      resolve5();
+                      resolve6();
                     }
                   }, 200);
                 });
@@ -27535,8 +27927,8 @@ async function withTimeout(promise, ms) {
   try {
     return await Promise.race([
       promise,
-      new Promise((resolve5) => {
-        timeoutId = setTimeout(() => resolve5(SKILL_TIMEOUT), ms);
+      new Promise((resolve6) => {
+        timeoutId = setTimeout(() => resolve6(SKILL_TIMEOUT), ms);
       })
     ]);
   } finally {
@@ -28146,12 +28538,12 @@ var init_teams = __esm({
 Options: ${chunk.choices.join(" | ")}` : "";
                 await this.sendToSelfChat(`\u2753 ${question}${choicesText}`);
                 if (!answerSent) await updateStatus("\u{1F916} OpenJaw Agent \u2014 \u2753 Waiting for your response...");
-                const userReply = await new Promise((resolve5) => {
-                  this._pendingReplyResolver = resolve5;
+                const userReply = await new Promise((resolve6) => {
+                  this._pendingReplyResolver = resolve6;
                   setTimeout(() => {
-                    if (this._pendingReplyResolver === resolve5) {
+                    if (this._pendingReplyResolver === resolve6) {
                       this._pendingReplyResolver = null;
-                      resolve5("[No response \u2014 timed out]");
+                      resolve6("[No response \u2014 timed out]");
                     }
                   }, 5 * 60 * 1e3);
                 });
@@ -28635,12 +29027,12 @@ ${err.stack?.split("\n").slice(0, 3).join("\n")}` : String(err);
       }
       /** Wait for the next user message (used by ask_user flow) */
       waitForUserReply(_chatId) {
-        return new Promise((resolve5) => {
-          this._pendingReplyResolver = resolve5;
+        return new Promise((resolve6) => {
+          this._pendingReplyResolver = resolve6;
           setTimeout(() => {
-            if (this._pendingReplyResolver === resolve5) {
+            if (this._pendingReplyResolver === resolve6) {
               this._pendingReplyResolver = null;
-              resolve5("[No response \u2014 timed out]");
+              resolve6("[No response \u2014 timed out]");
             }
           }, 5 * 60 * 1e3);
         });
@@ -28931,9 +29323,9 @@ var init_wechat2 = __esm({
         try {
           const qrTerminal = await import("qrcode-terminal");
           const mod = qrTerminal.default || qrTerminal;
-          const qrAscii = await new Promise((resolve5, reject) => {
+          const qrAscii = await new Promise((resolve6, reject) => {
             try {
-              mod.generate(qrUrl, { small: true }, (out) => resolve5(out));
+              mod.generate(qrUrl, { small: true }, (out) => resolve6(out));
             } catch (e) {
               reject(e);
             }
@@ -29199,12 +29591,12 @@ Scan URL manually: ${qrUrl}` });
                 const choicesText = chunk.choices?.length ? `
 \u9009\u9879: ${chunk.choices.join(" | ")}` : "";
                 await this.sendText(userId, `\u2753 ${question}${choicesText}`, contextToken);
-                const userReply = await new Promise((resolve5) => {
-                  this._pendingReplyResolver = resolve5;
+                const userReply = await new Promise((resolve6) => {
+                  this._pendingReplyResolver = resolve6;
                   setTimeout(() => {
-                    if (this._pendingReplyResolver === resolve5) {
+                    if (this._pendingReplyResolver === resolve6) {
                       this._pendingReplyResolver = null;
-                      resolve5("[No response \u2014 timed out]");
+                      resolve6("[No response \u2014 timed out]");
                     }
                   }, 5 * 60 * 1e3);
                 });
@@ -30705,8 +31097,8 @@ function createPromptCollector(bus, getSessionId) {
   }, "emit");
   const register = /* @__PURE__ */ __name((kind) => {
     const requestId = randomUUID12();
-    const promise = new Promise((resolve5) => {
-      pending.set(requestId, { kind, resolve: resolve5 });
+    const promise = new Promise((resolve6) => {
+      pending.set(requestId, { kind, resolve: resolve6 });
     });
     return { promise, requestId };
   }, "register");
@@ -31686,11 +32078,11 @@ function detectTerminal() {
   }
   return process.env.TERM ?? null;
 }
-function supportsOsc52Clipboard(terminal = env.terminal) {
-  return OSC52_CAPABLE_TERMINALS.includes(terminal ?? "");
+function supportsOsc52Clipboard(terminal2 = env.terminal) {
+  return OSC52_CAPABLE_TERMINALS.includes(terminal2 ?? "");
 }
 function execFileNoThrow(file2, args, options = {}) {
-  return new Promise((resolve5) => {
+  return new Promise((resolve6) => {
     const child = spawn4(file2, args, {
       cwd: options.useCwd ? process.cwd() : void 0,
       env: options.env,
@@ -31713,13 +32105,13 @@ function execFileNoThrow(file2, args, options = {}) {
       if (timer) {
         clearTimeout(timer);
       }
-      resolve5({ stdout, stderr, code: 1, error: String(error) });
+      resolve6({ stdout, stderr, code: 1, error: String(error) });
     });
     child.on("close", (code) => {
       if (timer) {
         clearTimeout(timer);
       }
-      resolve5({ stdout, stderr, code: timedOut ? 124 : code ?? 0 });
+      resolve6({ stdout, stderr, code: timedOut ? 124 : code ?? 0 });
     });
     if (options.input) {
       child.stdin?.write(options.input);
@@ -31751,7 +32143,7 @@ function shouldEmitClipboardSequence(env2 = process.env) {
   }
   return !!env2["SSH_CONNECTION"] || !env2["TMUX"] && !env2["STY"];
 }
-function shouldUseNativeClipboard(env2 = process.env, terminal = env.terminal) {
+function shouldUseNativeClipboard(env2 = process.env, terminal2 = env.terminal) {
   if (env2.SSH_CONNECTION) {
     return false;
   }
@@ -31761,7 +32153,7 @@ function shouldUseNativeClipboard(env2 = process.env, terminal = env.terminal) {
   if (!shouldEmitClipboardSequence(env2)) {
     return true;
   }
-  return !supportsOsc52Clipboard(terminal);
+  return !supportsOsc52Clipboard(terminal2);
 }
 function tmuxPassthrough(payload) {
   return `${ESC}Ptmux;${payload.replaceAll(ESC, ESC + ESC)}${ST}`;
@@ -33197,7 +33589,7 @@ function needsAltScreenResizeScrollbackClear(env2 = process.env) {
 function supportsExtendedKeys() {
   return EXTENDED_KEYS_TERMINALS.includes(env.terminal ?? "");
 }
-function writeDiffToTerminal(terminal, diff2, skipSyncMarkers = false, onDrain) {
+function writeDiffToTerminal(terminal2, diff2, skipSyncMarkers = false, onDrain) {
   if (diff2.length === 0) {
     return { bytes: 0, backpressure: false };
   }
@@ -33242,7 +33634,7 @@ function writeDiffToTerminal(terminal, diff2, skipSyncMarkers = false, onDrain)
   if (useSync) {
     buffer += ESU;
   }
-  const wrote = onDrain ? terminal.stdout.write(buffer, () => onDrain()) : terminal.stdout.write(buffer);
+  const wrote = onDrain ? terminal2.stdout.write(buffer, () => onDrain()) : terminal2.stdout.write(buffer);
   return { bytes: Buffer.byteLength(buffer, "utf8"), backpressure: !wrote };
 }
 function logForDebugging(_message, _options = {}) {
@@ -36692,8 +37084,8 @@ function setTerminalFocused(v) {
     cb();
   }
   if (!v) {
-    for (const resolve5 of resolvers) {
-      resolve5();
+    for (const resolve6 of resolvers) {
+      resolve6();
     }
     resolvers.clear();
   }
@@ -42931,11 +43323,11 @@ $ npm install --save-dev react-devtools-core
        * and the terminal doesn't respond, the promise remains pending.
        */
       send(query) {
-        return new Promise((resolve5) => {
+        return new Promise((resolve6) => {
           this.queue.push({
             kind: "query",
             match: query.match,
-            resolve: /* @__PURE__ */ __name((r) => resolve5(r), "resolve")
+            resolve: /* @__PURE__ */ __name((r) => resolve6(r), "resolve")
           });
           this.stdout.write(query.request);
         });
@@ -42950,8 +43342,8 @@ $ npm install --save-dev react-devtools-core
        * Safe to call with no pending queries — still waits for a round-trip.
        */
       flush() {
-        return new Promise((resolve5) => {
-          this.queue.push({ kind: "sentinel", resolve: resolve5 });
+        return new Promise((resolve6) => {
+          this.queue.push({ kind: "sentinel", resolve: resolve6 });
           this.stdout.write(SENTINEL);
         });
       }
@@ -45431,8 +45823,8 @@ $ npm install --save-dev react-devtools-core
         }
       }
       async waitUntilExit() {
-        this.exitPromise ||= new Promise((resolve5, reject) => {
-          this.resolveExitPromise = resolve5;
+        this.exitPromise ||= new Promise((resolve6, reject) => {
+          this.resolveExitPromise = resolve6;
           this.rejectExitPromise = reject;
         });
         return this.exitPromise;
@@ -45923,10 +46315,10 @@ async function writeClipboardText(text, platform2 = process.platform, start = sp
   const candidates = writeClipboardCommands(platform2, env2);
   for (const { cmd, args } of candidates) {
     try {
-      const ok = await new Promise((resolve5) => {
+      const ok = await new Promise((resolve6) => {
         const child = start(cmd, [...args], { stdio: ["pipe", "ignore", "ignore"], windowsHide: true });
-        child.once("error", () => resolve5(false));
-        child.once("close", (code) => resolve5(code === 0));
+        child.once("error", () => resolve6(false));
+        child.once("close", (code) => resolve6(code === 0));
         child.stdin?.end(text);
       });
       if (ok) {
@@ -45985,8 +46377,8 @@ async function readOsc52Clipboard(querier, timeoutMs = 500) {
   if (!querier) {
     return null;
   }
-  const timeout = new Promise((resolve5) => {
-    setTimeout(() => resolve5(void 0), timeoutMs);
+  const timeout = new Promise((resolve6) => {
+    setTimeout(() => resolve6(void 0), timeoutMs);
   });
   const query = querier.send({
     request: buildOsc52ClipboardQuery(),
@@ -46143,12 +46535,12 @@ async function backupFile(filePath, ops) {
   const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
   await ops.copyFile(filePath, `${filePath}.backup.${stamp}`);
 }
-async function configureTerminalKeybindings(terminal, options) {
+async function configureTerminalKeybindings(terminal2, options) {
   const env2 = options?.env ?? process.env;
   const platform2 = options?.platform ?? process.platform;
   const homeDir = options?.homeDir ?? homedir25();
   const ops = { ...DEFAULT_FILE_OPS, ...options?.fileOps ?? {} };
-  const meta = TERMINAL_META[terminal];
+  const meta = TERMINAL_META[terminal2];
   if (isRemoteShellSession(env2)) {
     return {
       success: false,
@@ -46343,6 +46735,7 @@ var init_overlayStore = __esm({
     buildOverlayState = /* @__PURE__ */ __name(() => ({
       agents: false,
       agentsInitialHistoryIndex: 0,
+      agentsWorkflowId: null,
       approval: null,
       clarify: null,
       confirm: null,
@@ -46358,13 +46751,14 @@ var init_overlayStore = __esm({
     $overlayState = atom2(buildOverlayState());
     $isBlocked = computed2(
       $overlayState,
-      ({ agents, approval, clarify, confirm, mcpHub, modelPicker, pager, picker, secret, skillsHub, sudo }) => Boolean(agents || approval || clarify || confirm || mcpHub || modelPicker || pager || picker || secret || skillsHub || sudo)
+      ({ agents, approval, clarify, confirm, mcpHub, pager, picker, secret, skillsHub, sudo }) => Boolean(agents || approval || clarify || confirm || mcpHub || pager || picker || secret || skillsHub || sudo)
     );
     patchOverlayState = /* @__PURE__ */ __name((next) => $overlayState.set(typeof next === "function" ? next($overlayState.get()) : { ...$overlayState.get(), ...next }), "patchOverlayState");
     resetFlowOverlays = /* @__PURE__ */ __name(() => $overlayState.set({
       ...buildOverlayState(),
       agents: $overlayState.get().agents,
       agentsInitialHistoryIndex: $overlayState.get().agentsInitialHistoryIndex,
+      agentsWorkflowId: $overlayState.get().agentsWorkflowId,
       mcpHub: $overlayState.get().mcpHub,
       modelPicker: $overlayState.get().modelPicker,
       modelPickerMode: $overlayState.get().modelPickerMode,
@@ -47164,13 +47558,25 @@ var init_debug = __esm({
   }
 });
 
+// src/app/workflowStore.ts
+import { atom as atom3 } from "nanostores";
+var $workflowSnapshots, setWorkflowSnapshot;
+var init_workflowStore = __esm({
+  "src/app/workflowStore.ts"() {
+    "use strict";
+    $workflowSnapshots = atom3({});
+    setWorkflowSnapshot = /* @__PURE__ */ __name((snapshot) => $workflowSnapshots.set({ ...$workflowSnapshots.get(), [snapshot.id]: snapshot }), "setWorkflowSnapshot");
+  }
+});
+
 // src/app/slash/commands/openjaw.ts
-var fmt, money, stub, eventLine, parseScheduleInput, showUsage, openjawCommands;
+var fmt, money, stub, eventLine, parseScheduleInput, asWorkflowSnapshot, workflowLine, workflowRows, showUsage, openjawCommands;
 var init_openjaw = __esm({
   "src/app/slash/commands/openjaw.ts"() {
     "use strict";
     init_usage();
     init_overlayStore();
+    init_workflowStore();
     fmt = /* @__PURE__ */ __name((n) => (n ?? 0).toLocaleString(), "fmt");
     money = /* @__PURE__ */ __name((n) => `$${(n ?? 0).toFixed(4)}`, "money");
     stub = /* @__PURE__ */ __name((ctx, command, message) => {
@@ -47210,6 +47616,14 @@ var init_openjaw = __esm({
       }
       return null;
     }, "parseScheduleInput");
+    asWorkflowSnapshot = /* @__PURE__ */ __name((run) => run ? run : null, "asWorkflowSnapshot");
+    workflowLine = /* @__PURE__ */ __name((run) => {
+      const active = run.workers.filter((worker) => worker.status === "running" || worker.status === "queued").length;
+      const done = run.workers.filter((worker) => worker.status === "completed").length;
+      return `${run.id} \xB7 ${run.status} \xB7 ${done}/${run.workers.length} done${active ? ` \xB7 ${active} active` : ""} \xB7 ${run.goal}`;
+    }, "workflowLine");
+    workflowRows = /* @__PURE__ */ __name((runs) => runs.map((run) => [run.id, `${run.status} \xB7 ${run.workerCount}/${run.plannedWorkerCount} workers
+${run.goal}`]), "workflowRows");
     showUsage = /* @__PURE__ */ __name((ctx, render2) => {
       ctx.gateway.rpc("session.usage", { session_id: ctx.sid }).then(ctx.guarded(render2)).catch(ctx.guardedErr);
     }, "showUsage");
@@ -47231,6 +47645,10 @@ var init_openjaw = __esm({
               if (!r.messages?.length) {
                 ctx.transcript.sys("connect: no output");
               }
+              if (!ctx.sid && r.config_updates) {
+                ctx.transcript.sys("provider connected \u2014 starting OpenJaw session\u2026");
+                ctx.session.newSession();
+              }
             })
           ).catch(ctx.guardedErr);
         }, "run")
@@ -47324,6 +47742,70 @@ var init_openjaw = __esm({
           ).catch(ctx.guardedErr);
         }, "run")
       },
+      {
+        aliases: ["wf"],
+        help: "start or inspect an advisory dynamic workflow",
+        name: "workflow",
+        usage: "/workflow <goal> | /workflow status [id] | list | show [id] | cancel <id>",
+        run: /* @__PURE__ */ __name((arg, ctx) => {
+          const text = arg.trim();
+          if (!text) {
+            return ctx.transcript.sys("usage: /workflow <goal> | /workflow status [id] | list | show [id] | cancel <id>");
+          }
+          const [subRaw, ...rest] = text.split(/\s+/);
+          const sub = subRaw?.toLowerCase() ?? "";
+          const remainder = rest.join(" ").trim();
+          if (sub === "status") {
+            return ctx.gateway.rpc("workflow.status", { id: remainder, session_id: ctx.sid }).then(
+              ctx.guarded((r) => {
+                const snapshot = asWorkflowSnapshot(r.run);
+                if (!snapshot) return ctx.transcript.sys(r.error || "no workflows yet");
+                setWorkflowSnapshot(snapshot);
+                patchOverlayState({ agents: true, agentsInitialHistoryIndex: 0, agentsWorkflowId: snapshot.id });
+                ctx.transcript.sys(`workflow status \xB7 ${workflowLine(snapshot)}`);
+              })
+            ).catch(ctx.guardedErr);
+          }
+          if (sub === "list" || sub === "ls") {
+            return ctx.gateway.rpc("workflow.list", { limit: 30, session_id: ctx.sid }).then(
+              ctx.guarded((r) => {
+                const runs = r.runs ?? [];
+                if (!runs.length) return ctx.transcript.sys("no workflows yet");
+                ctx.transcript.panel("Workflows", [{ rows: workflowRows(runs) }]);
+              })
+            ).catch(ctx.guardedErr);
+          }
+          if (sub === "show") {
+            return ctx.gateway.rpc("workflow.show", { id: remainder, session_id: ctx.sid }).then(
+              ctx.guarded((r) => {
+                const snapshot = asWorkflowSnapshot(r.run);
+                if (!snapshot) return ctx.transcript.sys(r.error || "no workflows yet");
+                setWorkflowSnapshot(snapshot);
+                ctx.transcript.page(snapshot.summary || workflowLine(snapshot), `Workflow ${snapshot.id}`);
+              })
+            ).catch(ctx.guardedErr);
+          }
+          if (sub === "cancel" || sub === "stop") {
+            if (!remainder) return ctx.transcript.sys("usage: /workflow cancel <runId|workerId>");
+            return ctx.gateway.rpc("workflow.cancel", { id: remainder, session_id: ctx.sid }).then(
+              ctx.guarded((r) => {
+                const snapshot = asWorkflowSnapshot(r.run);
+                if (snapshot) setWorkflowSnapshot(snapshot);
+                ctx.transcript.sys(r.ok ? `workflow cancel requested: ${remainder}` : r.error || `not found: ${remainder}`);
+              })
+            ).catch(ctx.guardedErr);
+          }
+          return ctx.gateway.rpc("workflow.start", { goal: text, session_id: ctx.sid }).then(
+            ctx.guarded((r) => {
+              const snapshot = asWorkflowSnapshot(r.run);
+              if (!snapshot) return ctx.transcript.sys(r.error || "workflow failed to start");
+              setWorkflowSnapshot(snapshot);
+              patchOverlayState({ agents: true, agentsInitialHistoryIndex: 0, agentsWorkflowId: snapshot.id });
+              ctx.transcript.sys(`workflow ${snapshot.id} started \xB7 ${snapshot.plannedWorkerCount} workers \xB7 concurrency ${snapshot.concurrency}`);
+            })
+          ).catch(ctx.guardedErr);
+        }, "run")
+      },
       {
         help: "schedule a recurring prompt",
         name: "schedule",
@@ -47456,7 +47938,7 @@ var init_openjaw = __esm({
 });
 
 // src/app/delegationStore.ts
-import { atom as atom3 } from "nanostores";
+import { atom as atom4 } from "nanostores";
 var buildState, $delegationState, getDelegationState, patchDelegationState, $overlaySectionsOpen, toggleOverlaySection, applyDelegationStatus;
 var init_delegationStore = __esm({
   "src/app/delegationStore.ts"() {
@@ -47467,10 +47949,10 @@ var init_delegationStore = __esm({
       paused: false,
       updatedAt: null
     }), "buildState");
-    $delegationState = atom3(buildState());
+    $delegationState = atom4(buildState());
     getDelegationState = /* @__PURE__ */ __name(() => $delegationState.get(), "getDelegationState");
     patchDelegationState = /* @__PURE__ */ __name((next) => $delegationState.set({ ...$delegationState.get(), ...next }), "patchDelegationState");
-    $overlaySectionsOpen = atom3({});
+    $overlaySectionsOpen = atom4({});
     toggleOverlaySection = /* @__PURE__ */ __name((title, defaultOpen) => {
       const state = $overlaySectionsOpen.get();
       const current = title in state ? state[title] : defaultOpen;
@@ -47496,7 +47978,7 @@ var init_delegationStore = __esm({
 });
 
 // src/app/spawnHistoryStore.ts
-import { atom as atom4 } from "nanostores";
+import { atom as atom5 } from "nanostores";
 function summarizeLabel(subagents) {
   const top = subagents.filter((s) => s.parentId == null || subagents.every((o) => o.id !== s.parentId)).slice(0, 2).map((s) => s.goal || "subagent").join(" \xB7 ");
   return top || `${subagents.length} agent${subagents.length === 1 ? "" : "s"}`;
@@ -47539,8 +48021,8 @@ var init_spawnHistoryStore = __esm({
   "src/app/spawnHistoryStore.ts"() {
     "use strict";
     HISTORY_LIMIT = 10;
-    $spawnHistory = atom4([]);
-    $spawnDiff = atom4(null);
+    $spawnHistory = atom5([]);
+    $spawnDiff = atom5(null);
     getSpawnHistory = /* @__PURE__ */ __name(() => $spawnHistory.get(), "getSpawnHistory");
     clearDiffPair = /* @__PURE__ */ __name(() => $spawnDiff.set(null), "clearDiffPair");
     setDiffPair = /* @__PURE__ */ __name((pair) => $spawnDiff.set(pair), "setDiffPair");
@@ -47850,15 +48332,15 @@ var init_ops = __esm({
           }
           const [a, b] = parts;
           const history = getSpawnHistory();
-          const resolve5 = /* @__PURE__ */ __name((token) => {
+          const resolve6 = /* @__PURE__ */ __name((token) => {
             const n = parseInt(token, 10);
             if (Number.isFinite(n) && n >= 1 && n <= history.length) {
               return history[n - 1] ?? null;
             }
             return null;
           }, "resolve");
-          const baseline = resolve5(a);
-          const candidate = resolve5(b);
+          const baseline = resolve6(a);
+          const candidate = resolve6(b);
           if (!baseline || !candidate) {
             return ctx.transcript.sys(`replay-diff: could not resolve indices \xB7 history has ${history.length} entries`);
           }
@@ -48731,76 +49213,20 @@ var init_session2 = __esm({
   }
 });
 
-// src/lib/externalCli.ts
-import { spawn as spawn6 } from "node:child_process";
-var resolveHermesBin, launchHermesCommand;
-var init_externalCli = __esm({
-  "src/lib/externalCli.ts"() {
-    "use strict";
-    resolveHermesBin = /* @__PURE__ */ __name(() => process.env.OPENJAW_BIN?.trim() || "hermes", "resolveHermesBin");
-    launchHermesCommand = /* @__PURE__ */ __name((args) => new Promise((resolve5) => {
-      const child = spawn6(resolveHermesBin(), args, { stdio: "inherit" });
-      child.on("error", (err) => resolve5({ code: null, error: err.message }));
-      child.on("exit", (code) => resolve5({ code }));
-    }), "launchHermesCommand");
-  }
-});
-
-// src/app/setupHandoff.ts
-async function runExternalSetup({ args, ctx, done, launcher, suspend }) {
-  const { gateway, session, transcript } = ctx;
-  transcript.sys(`launching \`hermes ${args.join(" ")}\`\u2026`);
-  patchUiState({ status: "setup running\u2026" });
-  let result = { code: null };
-  await suspend(async () => {
-    result = await launcher(args);
-  });
-  if (result.error) {
-    transcript.sys(`error launching hermes: ${result.error}`);
-    patchUiState({ status: "setup required" });
-    return;
-  }
-  if (result.code !== 0) {
-    transcript.sys(`hermes ${args[0]} exited with code ${result.code}`);
-    patchUiState({ status: "setup required" });
-    return;
-  }
-  const setup = await gateway.rpc("setup.status", {});
-  if (setup?.provider_configured === false) {
-    transcript.sys("still no provider configured");
-    patchUiState({ status: "setup required" });
-    return;
-  }
-  transcript.sys(done);
-  session.newSession();
-}
-var init_setupHandoff = __esm({
-  "src/app/setupHandoff.ts"() {
-    "use strict";
-    init_uiStore();
-    __name(runExternalSetup, "runExternalSetup");
-  }
-});
-
 // src/app/slash/commands/setup.ts
 var setupCommands;
 var init_setup = __esm({
   "src/app/slash/commands/setup.ts"() {
     "use strict";
-    init_entry_exports();
-    init_externalCli();
-    init_setupHandoff();
+    init_overlayStore();
     setupCommands = [
       {
-        help: "run full setup wizard (launches `hermes setup`)",
+        help: "first-run setup help; opens provider connection picker",
         name: "setup",
-        run: /* @__PURE__ */ __name((arg, ctx) => void runExternalSetup({
-          args: ["setup", ...arg.split(/\s+/).filter(Boolean)],
-          ctx,
-          done: "setup complete \u2014 starting session\u2026",
-          launcher: launchHermesCommand,
-          suspend: withInkSuspended
-        }), "run")
+        run: /* @__PURE__ */ __name((_arg, ctx) => {
+          ctx.transcript.sys("OpenJaw setup: run /connect to set up a provider, then /model to choose a model.");
+          patchOverlayState({ modelPicker: true, modelPickerMode: "connect" });
+        }, "run")
       }
     ];
   }
@@ -48956,17 +49382,856 @@ var init_catalog = __esm({
   }
 });
 
-// src/rpcHandlers.ts
-import { spawn as spawn7 } from "node:child_process";
-import { randomUUID as randomUUID13 } from "node:crypto";
-import { existsSync as existsSync31, mkdirSync as mkdirSync17, readFileSync as readFileSync28, rmSync, statSync as statSync4, writeFileSync as writeFileSync19 } from "node:fs";
+// src/workflows/planner.ts
+function resolveDynamicWorkflowConfig(config) {
+  const raw = config.features?.dynamic_workflows ?? {};
+  return {
+    enabled: raw.enabled ?? DEFAULT_DYNAMIC_WORKFLOW_CONFIG.enabled,
+    plannerMode: "adaptive",
+    hardMaxWorkers: clampInt(raw.hard_max_workers, DEFAULT_DYNAMIC_WORKFLOW_CONFIG.hardMaxWorkers, 1, 1e4),
+    hardMaxConcurrentWorkers: clampInt(
+      raw.hard_max_concurrent_workers,
+      DEFAULT_DYNAMIC_WORKFLOW_CONFIG.hardMaxConcurrentWorkers,
+      1,
+      2048
+    ),
+    workerTimeoutMs: clampInt(raw.worker_timeout_ms, DEFAULT_DYNAMIC_WORKFLOW_CONFIG.workerTimeoutMs, 1e4, 36e5),
+    persistHistory: raw.persist_history ?? DEFAULT_DYNAMIC_WORKFLOW_CONFIG.persistHistory
+  };
+}
+function initialConcurrency(plannedWorkers, limits) {
+  if (plannedWorkers <= 0) return 0;
+  return Math.min(Math.ceil(Math.sqrt(plannedWorkers) * 2), plannedWorkers, limits.hardMaxConcurrentWorkers);
+}
+function adjustConcurrency(current, plannedWorkers, limits, event) {
+  if (plannedWorkers <= 0) return 0;
+  if (event === "rate_limited") return Math.max(1, Math.floor(current / 2));
+  return Math.min(current + 1, plannedWorkers, limits.hardMaxConcurrentWorkers);
+}
+function planWorkflow(goal, runId, limits) {
+  const taskGoals = deriveTaskGoals(goal);
+  const specs = [];
+  const maxWorkers = limits.hardMaxWorkers;
+  for (const taskGoal of taskGoals) {
+    if (specs.length >= maxWorkers) break;
+    const id = `${runId}-w${specs.length + 1}`;
+    specs.push({
+      depth: 0,
+      goal: taskGoal,
+      id,
+      index: specs.length,
+      parentId: null,
+      prompt: buildTaskPrompt(goal, taskGoal),
+      role: "task"
+    });
+  }
+  const taskSpecs = [...specs];
+  const verifierEvery = taskSpecs.length >= 8 ? 4 : 3;
+  for (let i = 0; i < taskSpecs.length && specs.length < maxWorkers; i += verifierEvery) {
+    const batch = taskSpecs.slice(i, i + verifierEvery);
+    const id = `${runId}-w${specs.length + 1}`;
+    specs.push({
+      depth: 1,
+      dependsOn: batch.map((item) => item.id),
+      goal: `Verify findings from workers ${batch.map((item) => item.index + 1).join(", ")}`,
+      id,
+      index: specs.length,
+      parentId: batch[0]?.id ?? null,
+      prompt: buildVerifierPrompt(goal, batch),
+      role: "verifier"
+    });
+  }
+  return { concurrency: initialConcurrency(specs.length, limits), specs };
+}
+function deriveTaskGoals(goal) {
+  const explicit = extractExplicitTasks(goal);
+  const words = goal.trim().split(/\s+/).filter(Boolean).length;
+  const complexity = Math.min(12, Math.max(3, Math.ceil(words / 35)));
+  const inferred = inferLanes(goal);
+  const seeds = explicit.length > 1 ? explicit : inferred;
+  const out = [];
+  for (const item of seeds) {
+    pushUnique(out, item);
+  }
+  while (out.length < complexity) {
+    const next = DEFAULT_LANES[out.length % DEFAULT_LANES.length];
+    pushUnique(out, next);
+    if (out.length >= DEFAULT_LANES.length && explicit.length <= 1) break;
+  }
+  return out.slice(0, Math.max(1, out.length));
+}
+function extractExplicitTasks(goal) {
+  return goal.split(/\r?\n/).map((line) => line.trim().replace(/^[-*+]\s+/, "").replace(/^\d+[.)]\s+/, "").trim()).filter((line) => line.length >= 12);
+}
+function inferLanes(goal) {
+  const lower = goal.toLowerCase();
+  const lanes = ["Map the current state and locate relevant files or evidence"];
+  if (/code|repo|branch|test|build|bug|feature|implement/.test(lower)) {
+    lanes.push("Review implementation risks, edge cases, and integration points");
+    lanes.push("Inspect validation strategy and likely test coverage");
+  }
+  if (/research|latest|current|external|claude|compare|similar/.test(lower)) {
+    lanes.push("Research external context and comparable workflow behavior");
+  }
+  if (/ui|status|overlay|navigate|progress|worker/.test(lower)) {
+    lanes.push("Evaluate user experience, status visibility, and navigation requirements");
+  }
+  if (/security|safe|permission|mutat|write|approval/.test(lower)) {
+    lanes.push("Analyze safety boundaries, permissions, and failure modes");
+  }
+  lanes.push("Draft concrete recommendations and acceptance criteria");
+  return lanes;
+}
+function pushUnique(items, value) {
+  const normalized = value.trim();
+  if (!normalized) return;
+  if (!items.some((item) => item.toLowerCase() === normalized.toLowerCase())) items.push(normalized);
+}
+function buildTaskPrompt(overallGoal, taskGoal) {
+  return [
+    `Overall workflow goal: ${overallGoal}`,
+    `Your assigned read-only worker goal: ${taskGoal}`,
+    "",
+    "Work independently. Use only read/search/analysis tools. Do not modify files, send messages, update memory, or run shell/code execution.",
+    "Return concise findings with evidence, confidence, and open questions."
+  ].join("\n");
+}
+function buildVerifierPrompt(overallGoal, batch) {
+  return [
+    `Overall workflow goal: ${overallGoal}`,
+    `Verify the likely claims and gaps for these worker lanes: ${batch.map((item) => item.goal).join("; ")}`,
+    "",
+    "Use read-only checks. Label findings as verified, partially verified, or unverified. Do not modify anything."
+  ].join("\n");
+}
+var DEFAULT_DYNAMIC_WORKFLOW_CONFIG, clampInt, DEFAULT_LANES;
+var init_planner = __esm({
+  "src/workflows/planner.ts"() {
+    "use strict";
+    DEFAULT_DYNAMIC_WORKFLOW_CONFIG = {
+      enabled: true,
+      plannerMode: "adaptive",
+      hardMaxWorkers: 1024,
+      hardMaxConcurrentWorkers: 128,
+      workerTimeoutMs: 18e4,
+      persistHistory: true
+    };
+    clampInt = /* @__PURE__ */ __name((value, fallback, min, max) => {
+      const parsed = typeof value === "number" ? value : Number(value);
+      if (!Number.isFinite(parsed)) return fallback;
+      return Math.min(max, Math.max(min, Math.floor(parsed)));
+    }, "clampInt");
+    __name(resolveDynamicWorkflowConfig, "resolveDynamicWorkflowConfig");
+    __name(initialConcurrency, "initialConcurrency");
+    __name(adjustConcurrency, "adjustConcurrency");
+    __name(planWorkflow, "planWorkflow");
+    __name(deriveTaskGoals, "deriveTaskGoals");
+    __name(extractExplicitTasks, "extractExplicitTasks");
+    __name(inferLanes, "inferLanes");
+    DEFAULT_LANES = [
+      "Map the current state and locate relevant files or evidence",
+      "Review implementation risks, edge cases, and integration points",
+      "Inspect validation strategy and likely test coverage",
+      "Analyze safety boundaries, permissions, and failure modes",
+      "Draft concrete recommendations and acceptance criteria"
+    ];
+    __name(pushUnique, "pushUnique");
+    __name(buildTaskPrompt, "buildTaskPrompt");
+    __name(buildVerifierPrompt, "buildVerifierPrompt");
+  }
+});
+
+// src/workflows/persistence.ts
+import { existsSync as existsSync31, mkdirSync as mkdirSync17, readdirSync as readdirSync7, readFileSync as readFileSync28, writeFileSync as writeFileSync19 } from "node:fs";
 import { homedir as homedir28 } from "node:os";
-import { basename as basename3, extname as extname4, join as join42 } from "node:path";
+import { basename as basename3, join as join42, resolve as resolve4 } from "node:path";
+function ensureDir(path3) {
+  if (!existsSync31(path3)) mkdirSync17(path3, { recursive: true });
+}
+function safeSegment(value) {
+  return value.replace(/[^a-zA-Z0-9._-]+/g, "-").slice(0, 80) || "default";
+}
+function readJson(path3) {
+  try {
+    return JSON.parse(readFileSync28(path3, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function saveWorkflowSnapshot(snapshot) {
+  ensureDir(workflowDir());
+  const path3 = join42(workflowDir(), `${safeSegment(snapshot.id)}.json`);
+  writeFileSync19(path3, `${JSON.stringify(snapshot, null, 2)}
+`, "utf8");
+  return path3;
+}
+function loadWorkflowSnapshot(id) {
+  const path3 = join42(workflowDir(), `${safeSegment(id)}.json`);
+  return readJson(path3);
+}
+function listWorkflowSnapshots(limit = 30) {
+  if (!existsSync31(workflowDir())) return [];
+  const entries = [];
+  for (const entry of readdirSync7(workflowDir(), { withFileTypes: true })) {
+    if (!entry.isFile() || !entry.name.endsWith(".json")) continue;
+    const path3 = join42(workflowDir(), entry.name);
+    const snapshot = readJson(path3);
+    if (!snapshot) continue;
+    entries.push({
+      finishedAt: snapshot.finishedAt,
+      goal: snapshot.goal,
+      id: snapshot.id,
+      path: path3,
+      plannedWorkerCount: snapshot.plannedWorkerCount,
+      startedAt: snapshot.startedAt,
+      status: snapshot.status,
+      workerCount: snapshot.workers.length
+    });
+  }
+  return entries.sort((a, b) => (b.finishedAt ?? b.startedAt) - (a.finishedAt ?? a.startedAt)).slice(0, Math.max(1, limit));
+}
+function saveSpawnTreeSnapshot(input) {
+  const sessionId = safeSegment(input.session_id ?? "default");
+  const dir2 = join42(spawnTreeDir(), sessionId);
+  ensureDir(dir2);
+  const stamp = new Date((input.finished_at ?? Date.now() / 1e3) * 1e3).toISOString().replace(/[:.]/g, "-");
+  const path3 = join42(dir2, `${stamp}-${Math.random().toString(36).slice(2, 8)}.json`);
+  const snapshot = {
+    count: input.subagents?.length ?? 0,
+    finished_at: input.finished_at,
+    label: input.label,
+    session_id: input.session_id,
+    started_at: input.started_at,
+    subagents: input.subagents ?? []
+  };
+  writeFileSync19(path3, `${JSON.stringify(snapshot, null, 2)}
+`, "utf8");
+  return path3;
+}
+function listSpawnTreeSnapshots(sessionId = "default", limit = 30) {
+  const dir2 = join42(spawnTreeDir(), safeSegment(sessionId));
+  if (!existsSync31(dir2)) return [];
+  const entries = [];
+  for (const entry of readdirSync7(dir2, { withFileTypes: true })) {
+    if (!entry.isFile() || !entry.name.endsWith(".json")) continue;
+    const path3 = join42(dir2, entry.name);
+    const snapshot = readJson(path3);
+    if (!snapshot) continue;
+    entries.push({
+      count: snapshot.count,
+      finished_at: snapshot.finished_at,
+      label: snapshot.label,
+      path: path3,
+      session_id: snapshot.session_id,
+      started_at: snapshot.started_at
+    });
+  }
+  return entries.sort((a, b) => (b.finished_at ?? 0) - (a.finished_at ?? 0)).slice(0, Math.max(1, limit));
+}
+function loadSpawnTreeSnapshot(path3) {
+  const root = resolve4(spawnTreeDir());
+  const resolved = resolve4(path3);
+  if (!resolved.startsWith(root)) return null;
+  const snapshot = readJson(resolved);
+  return snapshot ? { ...snapshot, path: resolved } : null;
+}
+var rootDir, workflowDir, spawnTreeDir;
+var init_persistence = __esm({
+  "src/workflows/persistence.ts"() {
+    "use strict";
+    rootDir = /* @__PURE__ */ __name(() => join42(homedir28(), ".openjaw-agent"), "rootDir");
+    workflowDir = /* @__PURE__ */ __name(() => join42(rootDir(), "workflows"), "workflowDir");
+    spawnTreeDir = /* @__PURE__ */ __name(() => join42(rootDir(), "spawn-trees"), "spawnTreeDir");
+    __name(ensureDir, "ensureDir");
+    __name(safeSegment, "safeSegment");
+    __name(readJson, "readJson");
+    __name(saveWorkflowSnapshot, "saveWorkflowSnapshot");
+    __name(loadWorkflowSnapshot, "loadWorkflowSnapshot");
+    __name(listWorkflowSnapshots, "listWorkflowSnapshots");
+    __name(saveSpawnTreeSnapshot, "saveSpawnTreeSnapshot");
+    __name(listSpawnTreeSnapshots, "listSpawnTreeSnapshots");
+    __name(loadSpawnTreeSnapshot, "loadSpawnTreeSnapshot");
+  }
+});
+
+// src/workflows/readOnlyTools.ts
+function isWorkflowReadOnlyTool(name) {
+  return READ_ONLY_TOOLS.has(name);
+}
+var READ_ONLY_TOOLS, ReadOnlyToolRuntime;
+var init_readOnlyTools = __esm({
+  "src/workflows/readOnlyTools.ts"() {
+    "use strict";
+    READ_ONLY_TOOLS = /* @__PURE__ */ new Set([
+      "browser_snapshot",
+      "browser_extract",
+      "file_info",
+      "file_list",
+      "file_read",
+      "glob",
+      "grep",
+      "image_view",
+      "web_extract",
+      "web_fetch",
+      "web_search"
+    ]);
+    __name(isWorkflowReadOnlyTool, "isWorkflowReadOnlyTool");
+    ReadOnlyToolRuntime = class {
+      constructor(inner) {
+        this.inner = inner;
+      }
+      inner;
+      static {
+        __name(this, "ReadOnlyToolRuntime");
+      }
+      listTools() {
+        return this.inner.listTools().filter((tool) => isWorkflowReadOnlyTool(tool.name));
+      }
+      async execute(name, input) {
+        if (!isWorkflowReadOnlyTool(name)) {
+          throw new Error(`Tool ${name} is not available in advisory workflow workers`);
+        }
+        return await this.inner.execute(name, input);
+      }
+    };
+  }
+});
+
+// src/workflows/manager.ts
+import { randomUUID as randomUUID13 } from "node:crypto";
+function buildPlannerSystemPrompt(limits) {
+  return [
+    "You are the OpenJaw dynamic workflow planner.",
+    "Return ONLY valid JSON. Do not include markdown fences or prose.",
+    "Create a task graph for advisory read-only worker agents. Do not answer the user task.",
+    "Use enough workers to represent genuinely different research lanes, viewpoints, critics, verifiers, and a final synthesizer. Do not default to a small fixed count.",
+    "For panel-review prompts, create separate panelist workers for each requested philosophy and a critic/risk worker before the synthesizer.",
+    `Physical caps: at most ${limits.hardMaxWorkers} total workers and ${limits.hardMaxConcurrentWorkers} concurrent workers. Normal plans should be smaller than the cap but may contain dozens of workers when useful.`,
+    'Schema: {"language":"optional output language","workers":[{"id":"kebab-id","role":"researcher|panelist|critic|verifier|synthesizer","philosophy":"optional","goal":"specific worker goal","depends_on":["worker-id"]}]}',
+    "Always include exactly one synthesizer worker that depends on the most important research, panelist, critic, and verifier workers."
+  ].join("\n");
+}
+function parseModelPlan(content, goal, runId, limits) {
+  const parsed = JSON.parse(extractJsonObject(content));
+  const workers = Array.isArray(parsed.workers) ? parsed.workers : [];
+  const specs = [];
+  const usedIds = /* @__PURE__ */ new Set();
+  for (const worker of workers.slice(0, limits.hardMaxWorkers)) {
+    const rawGoal = String(worker.goal ?? "").trim();
+    if (!rawGoal) continue;
+    const id = uniqueWorkerId(runId, worker.id || rawGoal, usedIds, specs.length + 1);
+    const role = normalizeRole(worker.role);
+    const dependsOn = Array.isArray(worker.depends_on) ? worker.depends_on.map(String).map((value) => scopedWorkerId(runId, value)).filter((value) => usedIds.has(value)) : [];
+    specs.push({
+      depth: dependsOn.length > 0 || role !== "task" ? 1 : 0,
+      dependsOn,
+      goal: rawGoal,
+      id,
+      index: specs.length,
+      parentId: dependsOn[0] ?? null,
+      prompt: buildModelWorkerPrompt(goal, rawGoal, worker.role, worker.philosophy, parsed.language),
+      role
+    });
+  }
+  return ensureSynthesizer({ concurrency: 0, specs }, goal, runId, limits);
+}
+function ensureSynthesizer(plan, goal, runId, limits) {
+  const specs = plan.specs.slice(0, limits.hardMaxWorkers);
+  const existing = specs.find((spec) => spec.role === "synthesizer");
+  const dependencies = specs.filter((spec) => spec.role !== "synthesizer").map((spec) => spec.id);
+  if (existing) {
+    existing.dependsOn = existing.dependsOn?.length ? existing.dependsOn : dependencies;
+    existing.depth = Math.max(existing.depth, 1);
+    existing.parentId = existing.dependsOn[0] ?? null;
+  } else if (specs.length < limits.hardMaxWorkers) {
+    specs.push({
+      depth: 1,
+      dependsOn: dependencies,
+      goal: "Synthesize the panel and research outputs into the final answer",
+      id: `${runId}-synthesizer`,
+      index: specs.length,
+      parentId: dependencies[0] ?? null,
+      prompt: buildModelWorkerPrompt(goal, "Synthesize all completed worker outputs into the final answer for the user.", "synthesizer", void 0, void 0),
+      role: "synthesizer"
+    });
+  }
+  return { concurrency: Math.min(Math.ceil(Math.sqrt(specs.length) * 2), specs.length, limits.hardMaxConcurrentWorkers), specs };
+}
+function buildModelWorkerPrompt(overallGoal, workerGoal, role, philosophy, language) {
+  return [
+    `Overall workflow goal: ${overallGoal}`,
+    `Worker role: ${role || "researcher"}`,
+    philosophy ? `Investment/work philosophy: ${philosophy}` : "",
+    language ? `Final language preference: ${language}` : "",
+    `Assigned goal: ${workerGoal}`,
+    "",
+    "Use only read/search/analysis tools. Do not modify files, send messages, update memory, or run shell/code execution.",
+    "If prior worker outputs are provided below, use them as context and explicitly resolve agreements, disagreements, and uncertainty.",
+    "Return evidence-backed findings. A synthesizer must produce the final answer directly for the user."
+  ].filter(Boolean).join("\n");
+}
+function normalizeRole(role) {
+  const lower = String(role ?? "").toLowerCase();
+  if (lower.includes("synth") || lower.includes("chair")) return "synthesizer";
+  if (lower.includes("verify") || lower.includes("critic") || lower.includes("risk")) return "verifier";
+  return "task";
+}
+function extractJsonObject(content) {
+  const trimmed = content.trim().replace(/^```(?:json)?\s*/i, "").replace(/```$/i, "").trim();
+  const start = trimmed.indexOf("{");
+  const end = trimmed.lastIndexOf("}");
+  if (start < 0 || end < start) throw new Error("planner response did not contain a JSON object");
+  return trimmed.slice(start, end + 1);
+}
+function uniqueWorkerId(runId, value, used, index) {
+  const base = scopedWorkerId(runId, value) || `${runId}-w${index}`;
+  let candidate = base;
+  let suffix = 2;
+  while (used.has(candidate)) {
+    candidate = `${base}-${suffix}`;
+    suffix += 1;
+  }
+  used.add(candidate);
+  return candidate;
+}
+function scopedWorkerId(runId, value) {
+  const slug = value.toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 48);
+  return slug.startsWith(`${runId}-`) ? slug : `${runId}-${slug || "worker"}`;
+}
+function firstParagraph(value) {
+  return value.split(/\n\s*\n/)[0]?.trim().slice(0, 800) || value.trim().slice(0, 800);
+}
+function inferVerificationState(value) {
+  const lower = value.toLowerCase();
+  if (lower.includes("partially verified") || lower.includes("partial")) return "partial";
+  if (lower.includes("unverified") || lower.includes("not verified")) return "unverified";
+  if (lower.includes("verified")) return "verified";
+  return "pending";
+}
+function dependencyOutputContext(run, spec) {
+  const dependencyIds = spec.dependsOn ?? [];
+  if (dependencyIds.length === 0) return "";
+  const blocks = dependencyIds.map((id) => run.workers.find((worker) => worker.id === id)).filter((worker) => Boolean(worker)).map((worker) => [
+    `## Worker ${worker.id}`,
+    `Role: ${worker.workerRole ?? "task"}`,
+    `Goal: ${worker.goal}`,
+    `Status: ${worker.status}`,
+    worker.summary ? `Summary: ${worker.summary}` : "",
+    worker.details ? `Details:
+${worker.details}` : ""
+  ].filter(Boolean).join("\n"));
+  return blocks.length ? `# Prior worker outputs
+${blocks.join("\n\n")}` : "";
+}
+var terminal, WorkflowManager;
+var init_manager = __esm({
+  "src/workflows/manager.ts"() {
+    "use strict";
+    init_agent_loop();
+    init_providers();
+    init_planner();
+    init_persistence();
+    init_readOnlyTools();
+    terminal = /* @__PURE__ */ new Set(["cancelled", "completed", "failed"]);
+    WorkflowManager = class {
+      constructor(config, toolRuntime, systemPromptFn, bus, options = {}) {
+        this.config = config;
+        this.toolRuntime = toolRuntime;
+        this.systemPromptFn = systemPromptFn;
+        this.bus = bus;
+        this.planner = options.planner;
+        this.runner = options.runner ?? this.defaultRunner;
+      }
+      config;
+      toolRuntime;
+      systemPromptFn;
+      bus;
+      static {
+        __name(this, "WorkflowManager");
+      }
+      runs = /* @__PURE__ */ new Map();
+      planner;
+      runner;
+      async start(goal, sessionId) {
+        const limits = resolveDynamicWorkflowConfig(this.config);
+        if (!limits.enabled) {
+          throw new Error("dynamic workflows are disabled in config");
+        }
+        const id = `wf-${randomUUID13().slice(0, 8)}`;
+        const plan = await this.buildPlan(goal, id, limits);
+        const now2 = Date.now();
+        const run = {
+          abortController: new AbortController(),
+          activeAborts: /* @__PURE__ */ new Map(),
+          concurrency: plan.concurrency,
+          config: limits,
+          goal,
+          id,
+          plannedWorkerCount: plan.specs.length,
+          startedAt: now2,
+          status: "running",
+          workers: plan.specs.map((spec) => this.workerFromSpec(spec, id, plan.specs.length, now2))
+        };
+        this.runs.set(id, run);
+        this.emitWorkflow("workflow.start", run, sessionId);
+        for (const worker of run.workers) {
+          this.emitSubagent("subagent.spawn_requested", run, worker, sessionId);
+        }
+        void this.executeRun(run, plan.specs, sessionId);
+        return { run: this.snapshot(run), started: true };
+      }
+      status(id) {
+        const run = id ? this.runs.get(id) : this.latestRun();
+        if (run) return this.snapshot(run);
+        if (id) return loadWorkflowSnapshot(id);
+        const first = listWorkflowSnapshots(1)[0];
+        return first ? loadWorkflowSnapshot(first.id) : null;
+      }
+      list(limit = 30) {
+        const live = [...this.runs.values()].map((run) => ({
+          finishedAt: run.finishedAt,
+          goal: run.goal,
+          id: run.id,
+          plannedWorkerCount: run.plannedWorkerCount,
+          startedAt: run.startedAt,
+          status: run.status,
+          workerCount: run.workers.length
+        }));
+        const persisted = listWorkflowSnapshots(limit);
+        const seen = new Set(live.map((entry) => entry.id));
+        return [...live, ...persisted.filter((entry) => !seen.has(entry.id))].sort((a, b) => (b.finishedAt ?? b.startedAt) - (a.finishedAt ?? a.startedAt)).slice(0, Math.max(1, limit));
+      }
+      cancel(id) {
+        const run = this.runs.get(id);
+        if (run) {
+          this.cancelRun(run);
+          return { found: true, run: this.snapshot(run) };
+        }
+        for (const candidate of this.runs.values()) {
+          const worker = candidate.workers.find((item) => item.id === id);
+          if (!worker) continue;
+          candidate.activeAborts.get(worker.id)?.();
+          this.updateWorker(candidate, worker.id, {
+            currentStep: "cancel requested",
+            status: "interrupted"
+          });
+          return { found: true, run: this.snapshot(candidate), workerId: worker.id };
+        }
+        return { found: false };
+      }
+      async buildPlan(goal, runId, limits) {
+        if (this.planner) {
+          return ensureSynthesizer(await this.planner(goal, runId, limits), goal, runId, limits);
+        }
+        try {
+          const provider = createProvider(this.config);
+          const controller = new AbortController();
+          const timer = setTimeout(() => controller.abort(), Math.min(6e4, limits.workerTimeoutMs));
+          try {
+            const result = await provider.chat({
+              systemPrompt: buildPlannerSystemPrompt(limits),
+              messages: [{ role: "user", content: goal }],
+              tools: [],
+              signal: controller.signal
+            });
+            const parsed = parseModelPlan(result.text ?? "", goal, runId, limits);
+            if (parsed.specs.length > 0) return parsed;
+          } finally {
+            clearTimeout(timer);
+          }
+        } catch {
+        }
+        return ensureSynthesizer(planWorkflow(goal, runId, limits), goal, runId, limits);
+      }
+      async executeRun(run, specs, sessionId) {
+        const queue = [...specs];
+        const active = /* @__PURE__ */ new Map();
+        let stableCompletions = 0;
+        try {
+          while ((queue.length > 0 || active.size > 0) && !run.abortController.signal.aborted) {
+            const ready = queue.filter((spec) => this.dependenciesFinished(run, spec));
+            while (ready.length > 0 && active.size < run.concurrency && !run.abortController.signal.aborted) {
+              const spec = ready.shift();
+              queue.splice(queue.indexOf(spec), 1);
+              const promise = this.executeWorker(run, spec, sessionId).then(() => {
+                stableCompletions += 1;
+                if (stableCompletions % Math.max(2, run.concurrency) === 0) {
+                  run.concurrency = adjustConcurrency(run.concurrency, run.plannedWorkerCount, run.config, "stable_completion");
+                }
+              }).catch((err) => {
+                const message = err instanceof Error ? err.message : String(err);
+                if (/rate|429|quota|throttle/i.test(message)) {
+                  run.concurrency = adjustConcurrency(run.concurrency, run.plannedWorkerCount, run.config, "rate_limited");
+                }
+              }).finally(() => active.delete(spec.id));
+              active.set(spec.id, promise);
+            }
+            if (active.size === 0) break;
+            await Promise.race(active.values());
+          }
+          if (run.abortController.signal.aborted) {
+            for (const worker of run.workers) {
+              if (worker.status === "queued" || worker.status === "running") {
+                this.updateWorker(run, worker.id, { currentStep: "cancelled", status: "interrupted" });
+              }
+            }
+            run.status = "cancelled";
+            run.summary = this.summarize(run, "cancelled");
+          } else if (run.workers.some((worker) => worker.status === "failed")) {
+            run.status = "failed";
+            run.summary = this.summarize(run, "failed");
+          } else {
+            run.status = "completed";
+            run.summary = this.summarize(run, "completed");
+          }
+        } catch (err) {
+          run.status = "failed";
+          run.summary = `Workflow failed: ${err instanceof Error ? err.message : String(err)}`;
+        } finally {
+          run.finishedAt = Date.now();
+          if (run.config.persistHistory) saveWorkflowSnapshot(this.snapshot(run));
+          this.emitWorkflow(run.status === "failed" ? "workflow.error" : "workflow.complete", run, sessionId);
+        }
+      }
+      async executeWorker(run, spec, sessionId) {
+        if (run.abortController.signal.aborted) return;
+        this.updateWorker(run, spec.id, {
+          currentStep: "starting",
+          startedAt: Date.now(),
+          status: "running"
+        });
+        this.emitSubagent("subagent.start", run, this.worker(run, spec.id), sessionId);
+        const controller = new AbortController();
+        const timeoutMs = spec.role === "synthesizer" ? run.config.workerTimeoutMs * 3 : run.config.workerTimeoutMs;
+        const timeout = setTimeout(() => controller.abort(), timeoutMs);
+        run.activeAborts.set(spec.id, () => controller.abort());
+        const signal = AbortSignal.any([controller.signal, run.abortController.signal]);
+        try {
+          const result = await this.runner({
+            config: this.config,
+            run: this.snapshot(run),
+            signal,
+            spec,
+            systemPromptFn: this.systemPromptFn,
+            toolRuntime: new ReadOnlyToolRuntime(this.toolRuntime),
+            update: /* @__PURE__ */ __name((patch) => {
+              this.updateWorker(run, spec.id, patch);
+              this.emitSubagent("subagent.progress", run, this.worker(run, spec.id), sessionId);
+            }, "update")
+          });
+          this.updateWorker(run, spec.id, {
+            currentStep: "complete",
+            details: result,
+            durationSeconds: (Date.now() - (this.worker(run, spec.id).startedAt ?? Date.now())) / 1e3,
+            status: signal.aborted ? "interrupted" : "completed",
+            summary: firstParagraph(result),
+            verificationState: spec.role === "verifier" ? inferVerificationState(result) : "not_applicable"
+          });
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          this.updateWorker(run, spec.id, {
+            currentStep: signal.aborted ? "interrupted" : "failed",
+            details: message,
+            durationSeconds: (Date.now() - (this.worker(run, spec.id).startedAt ?? Date.now())) / 1e3,
+            status: signal.aborted ? "interrupted" : "failed",
+            summary: message,
+            verificationState: "unverified"
+          });
+          if (!signal.aborted) throw err;
+        } finally {
+          clearTimeout(timeout);
+          run.activeAborts.delete(spec.id);
+          this.emitSubagent("subagent.complete", run, this.worker(run, spec.id), sessionId);
+          if (run.config.persistHistory) saveWorkflowSnapshot(this.snapshot(run));
+        }
+      }
+      defaultRunner = /* @__PURE__ */ __name(async (ctx) => {
+        const workerConfig = {
+          ...ctx.config,
+          features: { ...ctx.config.features, skill_auto_suggest: false }
+        };
+        const loop = new AgentLoop(workerConfig, ctx.toolRuntime);
+        const sections = await ctx.systemPromptFn();
+        const systemPrompt = [
+          ...sections,
+          "# Advisory Workflow Worker Rules",
+          "You are a read-only workflow worker. Never modify files, execute shell/code, send messages, update memory, or perform browser actions that change state.",
+          "Use available read/search tools only. Return concise evidence-backed findings."
+        ].filter(Boolean).join("\n\n");
+        ctx.signal.addEventListener("abort", () => loop.abort(), { once: true });
+        let answer = "";
+        let streamedText = "";
+        let outputTail = [];
+        let toolCount = 0;
+        const userPrompt = [ctx.spec.prompt, dependencyOutputContext(ctx.run, ctx.spec)].filter(Boolean).join("\n\n");
+        for await (const chunk of loop.run(userPrompt, systemPrompt)) {
+          if (ctx.signal.aborted) {
+            loop.abort();
+            break;
+          }
+          if (chunk.type === "thinking" && chunk.content.trim()) {
+            streamedText += chunk.content;
+            ctx.update({ currentStep: chunk.content.trim().slice(0, 180), thinking: [chunk.content.trim().slice(0, 500)] });
+          }
+          if (chunk.type === "tool_call") {
+            toolCount += 1;
+            ctx.update({ currentStep: `using ${chunk.toolName ?? "tool"}`, toolCount, tools: [`${chunk.toolName ?? "tool"}(...)`] });
+          }
+          if (chunk.type === "tool_result") {
+            outputTail = [...outputTail, { isError: /error/i.test(chunk.content), preview: chunk.content.slice(0, 240), tool: chunk.toolName ?? "tool" }].slice(-8);
+            ctx.update({ outputTail });
+          }
+          if (chunk.type === "answer" && chunk.content.trim()) answer = chunk.content.trim();
+        }
+        const result = answer || streamedText.trim();
+        if (ctx.signal.aborted) {
+          if (result) {
+            return `${result}
+
+[Partial output preserved after worker interruption.]`;
+          }
+          throw new Error("worker interrupted");
+        }
+        return result || "Worker completed with no final answer.";
+      }, "defaultRunner");
+      workerFromSpec(spec, workflowId, taskCount, now2) {
+        return {
+          currentStep: "queued",
+          depth: spec.depth,
+          goal: spec.goal,
+          id: spec.id,
+          index: spec.index,
+          notes: [],
+          parentId: spec.parentId,
+          startedAt: now2,
+          status: "queued",
+          taskCount,
+          thinking: [],
+          toolCount: 0,
+          tools: [],
+          verificationState: spec.role === "verifier" ? "pending" : "not_applicable",
+          workflowId,
+          workerRole: spec.role
+        };
+      }
+      dependenciesFinished(run, spec) {
+        return (spec.dependsOn ?? []).every((id) => {
+          const status = run.workers.find((worker) => worker.id === id)?.status;
+          return status === "completed" || status === "failed" || status === "interrupted";
+        });
+      }
+      updateWorker(run, id, patch) {
+        run.workers = run.workers.map((worker) => worker.id === id ? { ...worker, ...patch } : worker);
+      }
+      worker(run, id) {
+        return run.workers.find((worker) => worker.id === id) ?? run.workers[0];
+      }
+      snapshot(run) {
+        return {
+          concurrency: run.concurrency,
+          finishedAt: run.finishedAt,
+          goal: run.goal,
+          id: run.id,
+          plannedWorkerCount: run.plannedWorkerCount,
+          startedAt: run.startedAt,
+          status: run.status,
+          summary: run.summary,
+          workers: run.workers.map((worker) => ({ ...worker }))
+        };
+      }
+      latestRun() {
+        const runs = [...this.runs.values()].sort((a, b) => b.startedAt - a.startedAt);
+        return runs[0] ?? null;
+      }
+      cancelRun(run) {
+        if (terminal.has(run.status)) return;
+        run.abortController.abort();
+        for (const abort of run.activeAborts.values()) abort();
+        run.status = "cancelled";
+      }
+      summarize(run, status) {
+        const synthesizer = run.workers.find((worker) => worker.workerRole === "synthesizer" && worker.details && worker.details !== "worker interrupted");
+        if ((status === "completed" || status === "cancelled" || status === "failed") && synthesizer?.details) {
+          return [synthesizer.details, "No files were modified by advisory workflow workers."].join("\n\n");
+        }
+        const counts = run.workers.reduce((acc, worker) => {
+          acc[worker.status] = (acc[worker.status] ?? 0) + 1;
+          return acc;
+        }, {});
+        const highlights = run.workers.filter((worker) => worker.summary).slice(0, 8).map((worker) => `- ${worker.goal}: ${worker.summary}`).join("\n");
+        return [
+          `Workflow ${status}: ${run.goal}`,
+          `Workers: ${run.workers.length} planned \xB7 ${counts.completed ?? 0} completed \xB7 ${counts.failed ?? 0} failed \xB7 ${counts.interrupted ?? 0} interrupted.`,
+          "No files were modified by advisory workflow workers.",
+          highlights ? `
+Key worker summaries:
+${highlights}` : ""
+        ].filter(Boolean).join("\n");
+      }
+      emitWorkflow(type, run, sessionId) {
+        this.bus.emitEvent({
+          payload: this.snapshot(run),
+          session_id: sessionId ?? void 0,
+          type
+        });
+      }
+      emitSubagent(type, run, worker, sessionId) {
+        this.bus.emitEvent({
+          payload: {
+            cost_usd: worker.costUsd,
+            current_step: worker.currentStep,
+            depth: worker.depth,
+            details: worker.details,
+            duration_seconds: worker.durationSeconds,
+            files_read: worker.filesRead,
+            files_written: worker.filesWritten,
+            goal: worker.goal,
+            input_tokens: worker.inputTokens,
+            output_tail: worker.outputTail?.map((entry) => ({ is_error: entry.isError, preview: entry.preview, tool: entry.tool })),
+            output_tokens: worker.outputTokens,
+            parent_id: worker.parentId,
+            status: worker.status,
+            subagent_id: worker.id,
+            summary: worker.summary,
+            task_count: worker.taskCount,
+            task_index: worker.index,
+            text: worker.currentStep ?? worker.summary,
+            tool_count: worker.toolCount,
+            verification_state: worker.verificationState,
+            workflow_id: run.id,
+            worker_role: worker.workerRole
+          },
+          session_id: sessionId ?? void 0,
+          type
+        });
+      }
+    };
+    __name(buildPlannerSystemPrompt, "buildPlannerSystemPrompt");
+    __name(parseModelPlan, "parseModelPlan");
+    __name(ensureSynthesizer, "ensureSynthesizer");
+    __name(buildModelWorkerPrompt, "buildModelWorkerPrompt");
+    __name(normalizeRole, "normalizeRole");
+    __name(extractJsonObject, "extractJsonObject");
+    __name(uniqueWorkerId, "uniqueWorkerId");
+    __name(scopedWorkerId, "scopedWorkerId");
+    __name(firstParagraph, "firstParagraph");
+    __name(inferVerificationState, "inferVerificationState");
+    __name(dependencyOutputContext, "dependencyOutputContext");
+  }
+});
+
+// src/rpcHandlers.ts
+import { spawn as spawn6 } from "node:child_process";
+import { randomUUID as randomUUID14 } from "node:crypto";
+import { existsSync as existsSync32, mkdirSync as mkdirSync18, readFileSync as readFileSync29, rmSync, statSync as statSync4, writeFileSync as writeFileSync20 } from "node:fs";
+import { homedir as homedir29 } from "node:os";
+import { basename as basename4, extname as extname4, join as join43 } from "node:path";
 function registerRpcHandlers(options) {
   const { agentConfig, agentLoop, bridgeEmitter, bridgeManager, bus, mcpManager, systemPromptFn, toolRegistry, voiceManager } = options;
   let currentRun = null;
   const pendingResponders = /* @__PURE__ */ new Map();
   const promptCollector = createPromptCollector(bus, () => agentLoop.sessionId);
+  const workflowManager = new WorkflowManager(agentConfig, toolRegistry, systemPromptFn, bus);
   const OAUTH_FLOW_TTL_MS = 15 * 60 * 1e3;
   const oauthFlows = /* @__PURE__ */ new Map();
   const cleanupOAuthFlow = /* @__PURE__ */ __name((flowId, abort) => {
@@ -48985,7 +50250,7 @@ function registerRpcHandlers(options) {
     const user = bridgeUser(rawEvent, source);
     const text = formatBridgeText(rawEvent, source, user);
     bus.emitEvent({
-      payload: { source, task_id: randomUUID13(), text, user },
+      payload: { source, task_id: randomUUID14(), text, user },
       session_id: agentLoop.sessionId,
       type: "bridge.message"
     });
@@ -48994,7 +50259,7 @@ function registerRpcHandlers(options) {
   bus.registerRpc("setup.status", () => {
     const hasConfigKey = Boolean(agentConfig.llm.api_key && agentConfig.llm.api_key !== "proxy-token");
     const hasEnvKey = Boolean(
-      process.env.ANTHROPIC_AUTH_TOKEN || process.env.ANTHROPIC_API_KEY || process.env.OPENAI_API_KEY || process.env.GITHUB_TOKEN
+      process.env.ANTHROPIC_AUTH_TOKEN || process.env.ANTHROPIC_API_KEY || process.env.OPENAI_API_KEY || process.env.GITHUB_COPILOT_TOKEN || process.env.GITHUB_TOKEN
     );
     const hasStoredCredential = PROVIDERS2.some((p) => {
       try {
@@ -49342,12 +50607,12 @@ ${helpMessage}` : field.label;
     const id = String(params.session_id ?? agentLoop.sessionId) || agentLoop.sessionId;
     const data = loadSession(id);
     const messages = data?.messages ?? agentLoop.history;
-    const exportDir = join42(homedir28(), ".openjaw-agent", "exports");
-    if (!existsSync31(exportDir)) {
-      mkdirSync17(exportDir, { recursive: true });
+    const exportDir = join43(homedir29(), ".openjaw-agent", "exports");
+    if (!existsSync32(exportDir)) {
+      mkdirSync18(exportDir, { recursive: true });
     }
     const safeId = id.replace(/[^a-zA-Z0-9_.-]/g, "_") || agentLoop.sessionId;
-    const file2 = join42(exportDir, `session-${safeId}.md`);
+    const file2 = join43(exportDir, `session-${safeId}.md`);
     const lines = [
       `# OpenJaw Agent Session ${id}`,
       `Date: ${(/* @__PURE__ */ new Date()).toISOString()}`,
@@ -49360,7 +50625,7 @@ ${helpMessage}` : field.label;
     for (const message of messages) {
       lines.push(...sessionMessageToMarkdown(message));
     }
-    writeFileSync19(file2, lines.join("\n"), "utf-8");
+    writeFileSync20(file2, lines.join("\n"), "utf-8");
     return { file: file2, message_count: messages.length };
   });
   bus.registerRpc("session.interrupt", () => {
@@ -49377,8 +50642,8 @@ ${helpMessage}` : field.label;
       return { deleted: "" };
     }
     try {
-      const file2 = join42(homedir28(), ".openjaw-agent", "sessions", `${id}.json`);
-      if (existsSync31(file2)) {
+      const file2 = join43(homedir29(), ".openjaw-agent", "sessions", `${id}.json`);
+      if (existsSync32(file2)) {
         rmSync(file2);
       }
       return { deleted: id };
@@ -49451,11 +50716,11 @@ ${helpMessage}` : field.label;
   bus.registerRpc("shell.exec", async (params) => {
     const command = String(params.command ?? "");
     if (!command) return { code: -1, stderr: "empty command" };
-    return await new Promise((resolve5) => {
+    return await new Promise((resolve6) => {
       const isWin = process.platform === "win32";
       const shell = isWin ? "powershell.exe" : "sh";
       const args = isWin ? ["-NoProfile", "-Command", command] : ["-c", command];
-      const child = spawn7(shell, args, { timeout: 3e4 });
+      const child = spawn6(shell, args, { timeout: 3e4 });
       let stdout = "";
       let stderr = "";
       let truncated = false;
@@ -49478,10 +50743,10 @@ ${helpMessage}` : field.label;
         if (truncated) {
           stderr += "\n[output truncated to 1MB]";
         }
-        resolve5({ code: code ?? -1, stderr, stdout });
+        resolve6({ code: code ?? -1, stderr, stdout });
       });
       child.on("error", (err) => {
-        resolve5({ code: -1, stderr: err.message });
+        resolve6({ code: -1, stderr: err.message });
       });
     });
   });
@@ -49603,7 +50868,7 @@ ${helpMessage}` : field.label;
       return agentConfig.llm.copilot_enterprise_url;
     })();
     const flow = await startCopilotDeviceFlow(clientId, enterpriseUrl);
-    const flowId = randomUUID13();
+    const flowId = randomUUID14();
     const controller = new AbortController();
     const timer = setTimeout(() => {
       cleanupOAuthFlow(flowId, true);
@@ -49767,7 +51032,7 @@ ${helpMessage}` : field.label;
       Object.assign(agentConfig.llm, result.configUpdates);
       bus.emitEvent({ payload: sessionInfoSnapshot(agentLoop, toolRegistry), session_id: agentLoop.sessionId, type: "session.info" });
     }
-    return { messages };
+    return { config_updates: result.configUpdates, messages };
   });
   bus.registerRpc("provider.disconnect", (params) => {
     const provider = String(params.provider ?? "").trim();
@@ -49827,6 +51092,32 @@ ${helpMessage}` : field.label;
       tasks: forks.map((task) => ({ id: task.id, prompt: task.prompt, status: task.status }))
     };
   });
+  bus.registerRpc("workflow.start", async (params) => {
+    const goal = String(params.goal ?? params.prompt ?? "").trim();
+    if (!goal) return { error: "usage: /workflow <goal>", ok: false };
+    const result = await workflowManager.start(goal, agentLoop.sessionId);
+    return { ok: true, run: result.run };
+  });
+  bus.registerRpc("workflow.status", (params) => {
+    const id = String(params.id ?? params.run_id ?? "").trim();
+    const run = workflowManager.status(id || void 0);
+    return run ? { ok: true, run } : { error: id ? `workflow not found: ${id}` : "no workflows yet", ok: false };
+  });
+  bus.registerRpc("workflow.list", (params) => {
+    const limit = Number(params.limit ?? 30);
+    return { ok: true, runs: workflowManager.list(Number.isFinite(limit) ? Math.max(1, Math.floor(limit)) : 30) };
+  });
+  bus.registerRpc("workflow.show", (params) => {
+    const id = String(params.id ?? params.run_id ?? "").trim();
+    const run = workflowManager.status(id || void 0);
+    return run ? { ok: true, run, summary: run.summary ?? "" } : { error: id ? `workflow not found: ${id}` : "no workflows yet", ok: false };
+  });
+  bus.registerRpc("workflow.cancel", (params) => {
+    const id = String(params.id ?? params.run_id ?? params.worker_id ?? "").trim();
+    if (!id) return { error: "usage: /workflow cancel <runId|workerId>", ok: false };
+    const result = workflowManager.cancel(id);
+    return result.found ? { ok: true, ...result } : { error: `workflow or worker not found: ${id}`, ok: false };
+  });
   bus.registerRpc("schedule.add", (params) => {
     const prompt = String(params.prompt ?? "").trim();
     const raw = String(params.schedule ?? "").trim();
@@ -50097,13 +51388,13 @@ ${helpMessage}` : field.label;
     const firstSpace = raw.search(/\s/);
     const path3 = firstSpace > 0 ? raw.slice(0, firstSpace) : raw;
     const remainder = firstSpace > 0 ? raw.slice(firstSpace).trim() : "";
-    if (!existsSync31(path3)) {
+    if (!existsSync32(path3)) {
       throw new Error(`image.attach: file not found: ${path3}`);
     }
     let buffer;
     let fileSize = 0;
     try {
-      buffer = readFileSync28(path3);
+      buffer = readFileSync29(path3);
       fileSize = statSync4(path3).size;
     } catch (err) {
       throw new Error(`image.attach: ${err instanceof Error ? err.message : String(err)}`);
@@ -50113,12 +51404,12 @@ ${helpMessage}` : field.label;
     pendingImage = {
       base64: buffer.toString("base64"),
       mimeType,
-      name: basename3(path3)
+      name: basename4(path3)
     };
     const tokenEstimate = Math.max(1, Math.ceil(buffer.byteLength / 750));
     return {
       height: 0,
-      name: basename3(path3),
+      name: basename4(path3),
       remainder,
       token_estimate: tokenEstimate,
       width: 0
@@ -50149,13 +51440,13 @@ ${helpMessage}` : field.label;
     }
   });
   bus.registerRpc("reload.env", () => {
-    const envPath = join42(homedir28(), ".openjaw-agent", ".env");
-    if (!existsSync31(envPath)) {
+    const envPath = join43(homedir29(), ".openjaw-agent", ".env");
+    if (!existsSync32(envPath)) {
       return { updated: 0 };
     }
     let updated = 0;
     try {
-      const raw = readFileSync28(envPath, "utf-8");
+      const raw = readFileSync29(envPath, "utf-8");
       for (const line of raw.split(/\r?\n/)) {
         const trimmed = line.trim();
         if (!trimmed || trimmed.startsWith("#")) continue;
@@ -50195,8 +51486,25 @@ ${helpMessage}` : field.label;
     error: "checkpoints are not enabled in this build",
     success: false
   }));
-  bus.registerRpc("spawn_tree.list", () => ({ entries: [] }));
-  bus.registerRpc("spawn_tree.load", () => ({ subagents: [] }));
+  bus.registerRpc("spawn_tree.save", (params) => ({
+    path: saveSpawnTreeSnapshot({
+      finished_at: typeof params.finished_at === "number" ? params.finished_at : Date.now() / 1e3,
+      label: typeof params.label === "string" ? params.label : void 0,
+      session_id: typeof params.session_id === "string" ? params.session_id : agentLoop.sessionId ?? "default",
+      started_at: typeof params.started_at === "number" || params.started_at === null ? params.started_at : null,
+      subagents: Array.isArray(params.subagents) ? params.subagents : []
+    })
+  }));
+  bus.registerRpc("spawn_tree.list", (params) => ({
+    entries: listSpawnTreeSnapshots(
+      typeof params.session_id === "string" ? params.session_id : agentLoop.sessionId ?? "default",
+      typeof params.limit === "number" ? params.limit : 30
+    )
+  }));
+  bus.registerRpc("spawn_tree.load", (params) => {
+    const path3 = String(params.path ?? "").trim();
+    return path3 ? loadSpawnTreeSnapshot(path3) ?? { subagents: [] } : { subagents: [] };
+  });
   bus.registerRpc("skills.reload", async () => {
     try {
       clearSkillsCache();
@@ -50280,9 +51588,19 @@ ${helpMessage}` : field.label;
     }
     return { output: name ? `unknown command: /${name}` : "(no command)", type: "exec" };
   });
-  bus.registerRpc("delegation.status", () => ({ delegated: [], paused: false }));
+  bus.registerRpc("delegation.status", () => ({
+    active: [],
+    max_concurrent_children: agentConfig.features?.dynamic_workflows?.hard_max_concurrent_workers ?? 128,
+    max_spawn_depth: agentConfig.features?.dynamic_workflows?.hard_max_workers ?? 1024,
+    paused: false
+  }));
   bus.registerRpc("delegation.pause", (params) => ({ paused: Boolean(params.paused) }));
-  bus.registerRpc("subagent.interrupt", () => ({ ok: true }));
+  bus.registerRpc("subagent.interrupt", (params) => {
+    const id = String(params.subagent_id ?? "").trim();
+    if (!id) return { found: false };
+    const result = workflowManager.cancel(id);
+    return { found: result.found, subagent_id: id };
+  });
   syncMcpTools(mcpManager, toolRegistry);
   bus.emitEvent({
     payload: sessionInfoSnapshot(agentLoop, toolRegistry),
@@ -50330,6 +51648,8 @@ var init_rpcHandlers = __esm({
     init_registry2();
     init_usage();
     init_usageSnapshot();
+    init_manager();
+    init_persistence();
     init_registry3();
     PROVIDERS2 = ["anthropic", "openai", "github-copilot"];
     PROVIDER_LABELS = {
@@ -50515,8 +51835,8 @@ var init_rpcHandlers = __esm({
 ${raw}`;
       return `${header}: ${raw}`;
     }, "formatBridgeText");
-    runProcess = /* @__PURE__ */ __name((command, args, timeout = 2e4) => new Promise((resolve5) => {
-      const child = spawn7(command, args, { timeout, windowsHide: true });
+    runProcess = /* @__PURE__ */ __name((command, args, timeout = 2e4) => new Promise((resolve6) => {
+      const child = spawn6(command, args, { timeout, windowsHide: true });
       let stdout = "";
       let stderr = "";
       let truncated = false;
@@ -50539,9 +51859,9 @@ ${raw}`;
         if (truncated) {
           stderr += "\n[output truncated to 1MB]";
         }
-        resolve5({ code: code ?? -1, stderr, stdout });
+        resolve6({ code: code ?? -1, stderr, stdout });
       });
-      child.on("error", (err) => resolve5({ code: -1, stderr: err.message, stdout }));
+      child.on("error", (err) => resolve6({ code: -1, stderr: err.message, stdout }));
     }), "runProcess");
     contentToText = /* @__PURE__ */ __name((content) => {
       if (typeof content === "string") return content;
@@ -50699,14 +52019,14 @@ var init_memoryMonitor = __esm({
 });
 
 // src/lib/openExternalUrl.ts
-import { spawn as spawn8 } from "node:child_process";
+import { spawn as spawn7 } from "node:child_process";
 import { platform } from "node:os";
 function openExternalUrl(rawUrl, dependencies = {}) {
   const url = parseSafeUrl(rawUrl);
   if (!url) {
     return false;
   }
-  const spawnFn = dependencies.spawn ?? spawn8;
+  const spawnFn = dependencies.spawn ?? spawn7;
   const platformId = dependencies.platform?.() ?? platform();
   const command = openCommand(platformId);
   if (!command) {
@@ -51496,7 +52816,7 @@ async function terminalParityHints(env2 = process.env, options) {
     hints.push({
       key: "remote",
       tone: "warn",
-      message: "SSH session detected \xB7 text clipboard can bridge via OSC52, but image clipboard and local screenshot paths still depend on the machine running Hermes"
+      message: "SSH session detected \xB7 text clipboard can bridge via OSC52, but image clipboard and local screenshot paths still depend on the machine running OpenJaw"
     });
   }
   return hints;
@@ -51601,13 +52921,13 @@ var init_setup2 = __esm({
     SETUP_REQUIRED_TITLE = "Setup Required";
     buildSetupRequiredSections = /* @__PURE__ */ __name(() => [
       {
-        text: "Hermes needs a model provider before the TUI can start a session."
+        text: "OpenJaw needs a model provider before the TUI can start a session. Run /connect to set up a provider, then /model to choose a model."
       },
       {
         rows: [
-          ["/model", "configure provider + model in-place"],
-          ["/setup", "run full first-time setup wizard in-place"],
-          ["Ctrl+C", "exit and run `hermes setup` manually"]
+          ["/connect", "set up provider credentials in-place"],
+          ["/model", "choose or switch model after connecting"],
+          ["Ctrl+C", "exit and restart OpenJaw after setup if needed"]
         ],
         title: "Actions"
       }
@@ -51910,7 +53230,7 @@ var init_reasoning2 = __esm({
 });
 
 // src/app/turnStore.ts
-import { atom as atom5 } from "nanostores";
+import { atom as atom6 } from "nanostores";
 import { useSyncExternalStore as useSyncExternalStore4 } from "react";
 var buildTurnState, $turnState, getTurnState, subscribeTurn, useTurnSelector, patchTurnState, toggleTodoCollapsed, archiveDoneTodos, archiveTodosAtTurnEnd, resetTurnState;
 var init_turnStore = __esm({
@@ -51934,7 +53254,7 @@ var init_turnStore = __esm({
       tools: [],
       turnTrail: []
     }), "buildTurnState");
-    $turnState = atom5(buildTurnState());
+    $turnState = atom6(buildTurnState());
     getTurnState = /* @__PURE__ */ __name(() => $turnState.get(), "getTurnState");
     subscribeTurn = /* @__PURE__ */ __name((cb) => $turnState.listen(() => cb()), "subscribeTurn");
     useTurnSelector = /* @__PURE__ */ __name((selector) => useSyncExternalStore4(
@@ -52534,7 +53854,9 @@ ${stripped}
             ...base,
             apiCalls: p.api_calls ?? base.apiCalls,
             costUsd: p.cost_usd ?? base.costUsd,
+            currentStep: p.current_step ?? base.currentStep,
             depth: p.depth ?? base.depth,
+            details: p.details ?? base.details,
             filesRead: p.files_read ?? base.filesRead,
             filesWritten: p.files_written ?? base.filesWritten,
             goal: p.goal || base.goal,
@@ -52548,6 +53870,9 @@ ${stripped}
             taskCount: p.task_count ?? base.taskCount,
             toolCount: p.tool_count ?? base.toolCount,
             toolsets: p.toolsets ?? base.toolsets,
+            verificationState: p.verification_state ?? base.verificationState,
+            workflowId: p.workflow_id ?? base.workflowId,
+            workerRole: p.worker_role ?? base.workerRole,
             ...patch(base)
           };
           const subagents = existing ? state.subagents.map((item) => item.id === id ? next : item) : [...state.subagents, next].sort((a, b) => a.depth - b.depth || a.index - b.index);
@@ -52634,7 +53959,7 @@ function createGatewayEventHandler(ctx) {
     setTimeout(async () => {
       let sid = getUiState().sid;
       for (let i = 0; !sid && i < 40; i += 1) {
-        await new Promise((resolve5) => setTimeout(resolve5, 100));
+        await new Promise((resolve6) => setTimeout(resolve6, 100));
         sid = getUiState().sid;
       }
       if (!sid) {
@@ -52981,6 +54306,26 @@ function createGatewayEventHandler(ctx) {
           { createIfMissing: false }
         );
         return;
+      case "workflow.start":
+      case "workflow.progress":
+        setWorkflowSnapshot(ev.payload);
+        return;
+      case "workflow.complete": {
+        setWorkflowSnapshot(ev.payload);
+        const text = String(ev.payload?.summary ?? "").trim();
+        if (text) {
+          appendMessage({ role: "assistant", text });
+        }
+        return;
+      }
+      case "workflow.error": {
+        setWorkflowSnapshot(ev.payload);
+        const text = String(ev.payload?.summary ?? "").trim();
+        if (text) {
+          sys(text);
+        }
+        return;
+      }
       case "message.delta":
         turnController.recordMessageDelta(ev.payload ?? {});
         return;
@@ -53015,7 +54360,7 @@ function createGatewayEventHandler(ctx) {
     }
   };
 }
-var NO_PROVIDER_RE, statusFromBusy, applySkin, dropBgTask, pushUnique, pushThinking, pushNote, pushTool;
+var NO_PROVIDER_RE, statusFromBusy, applySkin, dropBgTask, pushUnique2, pushThinking, pushNote, pushTool;
 var init_createGatewayEventHandler = __esm({
   "src/app/createGatewayEventHandler.ts"() {
     "use strict";
@@ -53030,6 +54375,7 @@ var init_createGatewayEventHandler = __esm({
     init_overlayStore();
     init_turnController();
     init_uiStore();
+    init_workflowStore();
     NO_PROVIDER_RE = /\bNo (?:LLM|inference) provider configured\b/i;
     statusFromBusy = /* @__PURE__ */ __name(() => getUiState().busy ? "running\u2026" : "ready", "statusFromBusy");
     applySkin = /* @__PURE__ */ __name((s) => patchUiState({
@@ -53047,10 +54393,10 @@ var init_createGatewayEventHandler = __esm({
       next.delete(taskId);
       return { ...state, bgTasks: next };
     }), "dropBgTask");
-    pushUnique = /* @__PURE__ */ __name((max) => (xs, x) => xs.at(-1) === x ? xs : [...xs, x].slice(-max), "pushUnique");
-    pushThinking = pushUnique(6);
-    pushNote = pushUnique(6);
-    pushTool = pushUnique(8);
+    pushUnique2 = /* @__PURE__ */ __name((max) => (xs, x) => xs.at(-1) === x ? xs : [...xs, x].slice(-max), "pushUnique");
+    pushThinking = pushUnique2(6);
+    pushNote = pushUnique2(6);
+    pushTool = pushUnique2(8);
     __name(createGatewayEventHandler, "createGatewayEventHandler");
   }
 });
@@ -53194,12 +54540,12 @@ var init_createSlashHandler = __esm({
 });
 
 // src/app/inputSelectionStore.ts
-import { atom as atom6 } from "nanostores";
+import { atom as atom7 } from "nanostores";
 var $inputSelection, setInputSelection, getInputSelection;
 var init_inputSelectionStore = __esm({
   "src/app/inputSelectionStore.ts"() {
     "use strict";
-    $inputSelection = atom6(null);
+    $inputSelection = atom7(null);
     setInputSelection = /* @__PURE__ */ __name((next) => $inputSelection.set(next), "setInputSelection");
     getInputSelection = /* @__PURE__ */ __name(() => $inputSelection.get(), "getInputSelection");
   }
@@ -53360,21 +54706,21 @@ var init_useCompletion = __esm({
 });
 
 // src/lib/history.ts
-import { appendFileSync as appendFileSync4, existsSync as existsSync32, mkdirSync as mkdirSync18, readFileSync as readFileSync29 } from "node:fs";
-import { homedir as homedir29 } from "node:os";
-import { join as join43 } from "node:path";
+import { appendFileSync as appendFileSync4, existsSync as existsSync33, mkdirSync as mkdirSync19, readFileSync as readFileSync30 } from "node:fs";
+import { homedir as homedir30 } from "node:os";
+import { join as join44 } from "node:path";
 function load() {
   if (cache3) {
     return cache3;
   }
   try {
-    if (!existsSync32(file)) {
+    if (!existsSync33(file)) {
       cache3 = [];
       return cache3;
     }
     const entries = [];
     let current = [];
-    for (const line of readFileSync29(file, "utf8").split("\n")) {
+    for (const line of readFileSync30(file, "utf8").split("\n")) {
       if (line.startsWith("+")) {
         current.push(line.slice(1));
       } else if (current.length) {
@@ -53405,8 +54751,8 @@ function append(line) {
     items.splice(0, items.length - MAX);
   }
   try {
-    if (!existsSync32(dir)) {
-      mkdirSync18(dir, { recursive: true });
+    if (!existsSync33(dir)) {
+      mkdirSync19(dir, { recursive: true });
     }
     const ts = (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").replace("Z", "");
     const encoded = trimmed.split("\n").map((l) => `+${l}`).join("\n");
@@ -53422,8 +54768,8 @@ var init_history = __esm({
   "src/lib/history.ts"() {
     "use strict";
     MAX = 1e3;
-    dir = process.env.OPENJAW_HOME ?? join43(homedir29(), ".openjaw-agent");
-    file = join43(dir, ".openjaw-agent_history");
+    dir = process.env.OPENJAW_HOME ?? join44(homedir30(), ".openjaw-agent");
+    file = join44(dir, ".openjaw-agent_history");
     cache3 = null;
     __name(load, "load");
     __name(append, "append");
@@ -53517,7 +54863,7 @@ var init_useQueue = __esm({
 
 // src/lib/editor.ts
 import { accessSync, constants } from "node:fs";
-import { delimiter, join as join44 } from "node:path";
+import { delimiter, join as join45 } from "node:path";
 var FALLBACKS, isExecutable, resolveEditor;
 var init_editor = __esm({
   "src/lib/editor.ts"() {
@@ -53540,7 +54886,7 @@ var init_editor = __esm({
         return ["notepad.exe"];
       }
       const dirs = (env2.PATH ?? "").split(delimiter).filter(Boolean);
-      const found = FALLBACKS.flatMap((name) => dirs.map((d) => join44(d, name))).find(isExecutable);
+      const found = FALLBACKS.flatMap((name) => dirs.map((d) => join45(d, name))).find(isExecutable);
       return [found ?? "vi"];
     }, "resolveEditor");
   }
@@ -53548,9 +54894,9 @@ var init_editor = __esm({
 
 // src/app/useComposerState.ts
 import { spawnSync } from "node:child_process";
-import { mkdtempSync, readFileSync as readFileSync30, rmSync as rmSync2, writeFileSync as writeFileSync20 } from "node:fs";
+import { mkdtempSync, readFileSync as readFileSync31, rmSync as rmSync2, writeFileSync as writeFileSync21 } from "node:fs";
 import { tmpdir as tmpdir12 } from "node:os";
-import { join as join45 } from "node:path";
+import { join as join46 } from "node:path";
 import { useStore } from "@nanostores/react";
 import { useCallback as useCallback7, useMemo as useMemo6, useState as useState12 } from "react";
 function insertAtCursor(value, cursor, text) {
@@ -53707,10 +55053,10 @@ function useComposerState({
     [handleResolvedPaste, onClipboardPaste, querier]
   );
   const openEditor = useCallback7(async () => {
-    const dir2 = mkdtempSync(join45(tmpdir12(), "hermes-"));
-    const file2 = join45(dir2, "prompt.md");
+    const dir2 = mkdtempSync(join46(tmpdir12(), "hermes-"));
+    const file2 = join46(dir2, "prompt.md");
     const [cmd, ...args] = resolveEditor();
-    writeFileSync20(file2, [...inputBuf, input].join("\n"));
+    writeFileSync21(file2, [...inputBuf, input].join("\n"));
     let exitCode = null;
     await withInkSuspended(async () => {
       exitCode = spawnSync(cmd, [...args, file2], { stdio: "inherit" }).status;
@@ -53719,7 +55065,7 @@ function useComposerState({
       if (exitCode !== 0) {
         return;
       }
-      const text = readFileSync30(file2, "utf8").trimEnd();
+      const text = readFileSync31(file2, "utf8").trimEnd();
       if (!text) {
         return;
       }
@@ -54137,11 +55483,11 @@ function applyVoiceRecordResponse(response, starting, voice, sys) {
   }
 }
 function useInputHandlers(ctx) {
-  const { actions, composer, gateway, terminal, voice, wheelStep } = ctx;
+  const { actions, composer, gateway, terminal: terminal2, voice, wheelStep } = ctx;
   const { actions: cActions, refs: cRefs, state: cState } = composer;
   const overlay = useStore2($overlayState);
   const isBlocked = useStore2($isBlocked);
-  const pagerPageSize = Math.max(5, (terminal.stdout?.rows ?? 24) - 6);
+  const pagerPageSize = Math.max(5, (terminal2.stdout?.rows ?? 24) - 6);
   const scrollIdleTimer = useRef10(null);
   const wheelAccelRef = useRef10(initWheelAccelForHost());
   const precisionWheelRef = useRef10(initPrecisionWheel());
@@ -54156,13 +55502,13 @@ function useInputHandlers(ctx) {
         turnController.relaxStreaming();
       }, TYPING_IDLE_MS);
     }
-    terminal.scrollWithSelection(delta);
+    terminal2.scrollWithSelection(delta);
   }, "scrollTranscript");
   const copySelection = /* @__PURE__ */ __name(() => {
-    terminal.selection.copySelection();
+    terminal2.selection.copySelection();
   }, "copySelection");
   const clearSelection2 = /* @__PURE__ */ __name(() => {
-    terminal.selection.clearSelection();
+    terminal2.selection.clearSelection();
   }, "clearSelection");
   const cancelOverlayFromCtrlC = /* @__PURE__ */ __name(() => {
     if (overlay.clarify) {
@@ -54361,7 +55707,7 @@ function useInputHandlers(ctx) {
       return scrollTranscript(1);
     }
     if (key.pageUp || key.pageDown) {
-      const viewport = terminal.scrollRef.current?.getViewportHeight() ?? Math.max(6, (terminal.stdout?.rows ?? 24) - 8);
+      const viewport = terminal2.scrollRef.current?.getViewportHeight() ?? Math.max(6, (terminal2.stdout?.rows ?? 24) - 8);
       const step = Math.max(4, Math.floor(viewport / 2));
       return scrollTranscript(key.pageUp ? -step : step);
     }
@@ -54371,7 +55717,7 @@ function useInputHandlers(ctx) {
     if (key.escape && cState.queueEditIdx !== null) {
       return cActions.clearIn();
     }
-    if (key.escape && terminal.hasSelection) {
+    if (key.escape && terminal2.hasSelection) {
       return clearSelection2();
     }
     if (key.escape && live.focusedPane === "transcript") {
@@ -54397,7 +55743,7 @@ function useInputHandlers(ctx) {
       }
     }
     if (isCopyShortcut(key, ch)) {
-      if (terminal.hasSelection) {
+      if (terminal2.hasSelection) {
         return copySelection();
       }
       const inputSel = getInputSelection();
@@ -54432,7 +55778,7 @@ function useInputHandlers(ctx) {
     }
     if (isAction(key, ch, "l")) {
       clearSelection2();
-      forceRedraw(terminal.stdout ?? process.stdout);
+      forceRedraw(terminal2.stdout ?? process.stdout);
       return;
     }
     if (isVoiceToggleKey(key, ch, voice.recordKey)) {
@@ -54582,7 +55928,7 @@ var init_useLongRunToolCharms = __esm({
 });
 
 // src/app/useSessionLifecycle.ts
-import { writeFileSync as writeFileSync21 } from "node:fs";
+import { writeFileSync as writeFileSync22 } from "node:fs";
 import { useCallback as useCallback8 } from "react";
 function useSessionLifecycle(opts) {
   const {
@@ -54765,7 +56111,7 @@ var init_useSessionLifecycle = __esm({
         return;
       }
       try {
-        writeFileSync21(file2, JSON.stringify({ session_id: sessionId }), { mode: 384 });
+        writeFileSync22(file2, JSON.stringify({ session_id: sessionId }), { mode: 384 });
       } catch {
       }
     }, "writeActiveSessionFile");
@@ -55622,8 +56968,13 @@ function useMainApp(gw) {
   );
   const onModelSelect = useCallback10((value) => {
     patchOverlayState({ modelPicker: false });
+    if (value === "__openjaw_connect_complete__") {
+      sys("provider connected \u2014 starting OpenJaw session\u2026");
+      session.newSession();
+      return;
+    }
     slashRef.current(`/model ${value}`);
-  }, []);
+  }, [session, sys]);
   const hasReasoning = useTurnSelector((state) => Boolean(state.reasoning.trim()));
   const anyPanelVisible = SECTION_NAMES.some(
     (s) => sectionMode(s, ui.detailsMode, ui.sections, ui.detailsModeCommandOverride) !== "hidden"
@@ -55795,9 +57146,9 @@ __export(perfPane_exports, {
   PerfPane: () => PerfPane,
   logFrameEvent: () => logFrameEvent
 });
-import { appendFileSync as appendFileSync5, mkdirSync as mkdirSync19 } from "node:fs";
-import { homedir as homedir30 } from "node:os";
-import { dirname as dirname7, join as join46 } from "node:path";
+import { appendFileSync as appendFileSync5, mkdirSync as mkdirSync20 } from "node:fs";
+import { homedir as homedir31 } from "node:os";
+import { dirname as dirname7, join as join47 } from "node:path";
 import { Profiler } from "react";
 import { jsx as jsx17 } from "react/jsx-runtime";
 function PerfPane({ children, id }) {
@@ -55813,13 +57164,13 @@ var init_perfPane = __esm({
     init_entry_exports();
     ENABLED = /^(?:1|true|yes|on)$/i.test((process.env.OPENJAW_DEV_PERF ?? "").trim());
     THRESHOLD_MS = Number(process.env.OPENJAW_DEV_PERF_MS ?? "2") || 0;
-    LOG_PATH2 = process.env.OPENJAW_DEV_PERF_LOG?.trim() || join46(homedir30(), ".openjaw-agent", "perf.log");
+    LOG_PATH2 = process.env.OPENJAW_DEV_PERF_LOG?.trim() || join47(homedir31(), ".openjaw-agent", "perf.log");
     logReady = false;
     writeRow = /* @__PURE__ */ __name((row) => {
       if (!logReady) {
         logReady = true;
         try {
-          mkdirSync19(dirname7(LOG_PATH2), { recursive: true });
+          mkdirSync20(dirname7(LOG_PATH2), { recursive: true });
         } catch {
         }
       }
@@ -56072,6 +57423,10 @@ function Detail({ id, node, t }) {
     ] }),
     /* @__PURE__ */ jsxs9(Box_default, { flexDirection: "column", marginTop: 1, children: [
       /* @__PURE__ */ jsx18(Field, { name: "depth", t, value: `${item.depth} \xB7 ${item.status}` }),
+      item.workflowId ? /* @__PURE__ */ jsx18(Field, { name: "workflow", t, value: item.workflowId }) : null,
+      item.workerRole ? /* @__PURE__ */ jsx18(Field, { name: "role", t, value: item.workerRole }) : null,
+      item.verificationState ? /* @__PURE__ */ jsx18(Field, { name: "verification", t, value: item.verificationState }) : null,
+      item.currentStep ? /* @__PURE__ */ jsx18(Field, { name: "current", t, value: item.currentStep }) : null,
       item.model ? /* @__PURE__ */ jsx18(Field, { name: "model", t, value: item.model }) : null,
       item.toolsets?.length ? /* @__PURE__ */ jsx18(Field, { name: "toolsets", t, value: item.toolsets.join(", ") }) : null,
       /* @__PURE__ */ jsx18(Field, { name: "tools", t, value: `${item.toolCount ?? 0} (subtree ${agg.totalTools})` }),
@@ -56146,7 +57501,8 @@ function Detail({ id, node, t }) {
       " ",
       line
     ] }, i)) }) : null,
-    item.summary ? /* @__PURE__ */ jsx18(OverlaySection, { defaultOpen: true, t, title: "Summary", children: /* @__PURE__ */ jsx18(Text9, { color: t.color.text, wrap: "wrap", children: item.summary }) }) : null
+    item.summary ? /* @__PURE__ */ jsx18(OverlaySection, { defaultOpen: true, t, title: "Summary", children: /* @__PURE__ */ jsx18(Text9, { color: t.color.text, wrap: "wrap", children: item.summary }) }) : null,
+    item.details && item.details !== item.summary ? /* @__PURE__ */ jsx18(OverlaySection, { defaultOpen: true, t, title: "Details", children: /* @__PURE__ */ jsx18(Text9, { color: t.color.text, wrap: "wrap", children: item.details }) }) : null
   ] });
 }
 function ListRow({
@@ -56246,12 +57602,23 @@ function DiffView({
     ] })
   ] });
 }
-function AgentsOverlay({ gw, initialHistoryIndex = 0, onClose, t }) {
-  const liveSubagents = useTurnSelector((state) => state.subagents);
+function AgentsOverlay({ gw, initialHistoryIndex = 0, onClose, t, workflowId = null }) {
+  const allLiveSubagents = useTurnSelector((state) => state.subagents);
   const delegation = useStore4($delegationState);
   const history = useStore4($spawnHistory);
   const diffPair = useStore4($spawnDiff);
+  const workflowSnapshots = useStore4($workflowSnapshots);
   const { stdout } = useStdout();
+  const liveSubagents = workflowId ? allLiveSubagents.filter((item) => item.workflowId === workflowId) : allLiveSubagents;
+  const workflowSnapshot = workflowId ? workflowSnapshots[workflowId] ?? null : null;
+  const workflowReplaySnapshot = workflowSnapshot && liveSubagents.length === 0 ? {
+    finishedAt: workflowSnapshot.finishedAt ?? Date.now(),
+    id: workflowSnapshot.id,
+    label: workflowSnapshot.goal,
+    sessionId: workflowSnapshot.id,
+    startedAt: workflowSnapshot.startedAt,
+    subagents: workflowSnapshot.workers
+  } : null;
   const [historyIndex, setHistoryIndex] = useState14(
     () => Math.max(0, Math.min(history.length, Math.floor(initialHistoryIndex)))
   );
@@ -56263,9 +57630,9 @@ function AgentsOverlay({ gw, initialHistoryIndex = 0, onClose, t }) {
   const [mode, setMode] = useState14("list");
   const detailScrollRef = useRef14(null);
   const prevLiveCountRef = useRef14(liveSubagents.length);
-  const activeSnapshot = historyIndex > 0 ? history[historyIndex - 1] : null;
-  const justFinishedSnapshot = historyIndex === 0 && liveSubagents.length === 0 ? history[0] ?? null : null;
-  const effectiveSnapshot = activeSnapshot ?? justFinishedSnapshot;
+  const activeSnapshot = !workflowId && historyIndex > 0 ? history[historyIndex - 1] : null;
+  const justFinishedSnapshot = !workflowId && historyIndex === 0 && liveSubagents.length === 0 ? history[0] ?? null : null;
+  const effectiveSnapshot = workflowReplaySnapshot ?? activeSnapshot ?? justFinishedSnapshot;
   const replayMode = effectiveSnapshot != null;
   const subagents = replayMode ? effectiveSnapshot.subagents : liveSubagents;
   const tree = useMemo8(() => buildSubagentTree(subagents), [subagents]);
@@ -56434,7 +57801,7 @@ function AgentsOverlay({ gw, initialHistoryIndex = 0, onClose, t }) {
   const capsLabel = delegation.maxSpawnDepth ? `caps d${delegation.maxSpawnDepth}/${delegation.maxConcurrentChildren ?? "?"}` : "";
   const title = replayMode && effectiveSnapshot ? `${historyIndex > 0 ? `Replay ${historyIndex}/${history.length}` : "Last turn"} \xB7 finished ${new Date(
     effectiveSnapshot.finishedAt
-  ).toLocaleTimeString()}` : `Spawn tree${delegation.paused ? " \xB7 \u23F8 paused" : ""}`;
+  ).toLocaleTimeString()}` : workflowId ? `Workflow ${workflowId}${delegation.paused ? " \xB7 \u23F8 paused" : ""}` : `Spawn tree${delegation.paused ? " \xB7 \u23F8 paused" : ""}`;
   const metaLine = [formatSummary(totals), spark, capsLabel, mix2 ? `\xB7 ${mix2}` : ""].filter(Boolean).join("  ");
   const controlsHint = replayMode ? " \xB7 controls locked" : ` \xB7 x kill \xB7 X subtree \xB7 p ${delegation.paused ? "resume" : "pause"}`;
   if (diffPair) {
@@ -56448,7 +57815,7 @@ function AgentsOverlay({ gw, initialHistoryIndex = 0, onClose, t }) {
         metaLine
       ] }) : null
     ] }) }),
-    rows.length === 0 ? /* @__PURE__ */ jsx18(Box_default, { flexDirection: "column", flexGrow: 1, children: /* @__PURE__ */ jsx18(Text9, { color: t.color.muted, children: "No subagents this turn. Trigger delegate_task to populate the tree." }) }) : mode === "list" ? /* @__PURE__ */ jsxs9(Box_default, { flexDirection: "column", flexGrow: 1, flexShrink: 1, minHeight: 0, children: [
+    rows.length === 0 ? /* @__PURE__ */ jsx18(Box_default, { flexDirection: "column", flexGrow: 1, children: /* @__PURE__ */ jsx18(Text9, { color: t.color.muted, children: workflowId ? "No workers for this workflow yet." : "No subagents this turn. Trigger delegate_task to populate the tree." }) }) : mode === "list" ? /* @__PURE__ */ jsxs9(Box_default, { flexDirection: "column", flexGrow: 1, flexShrink: 1, minHeight: 0, children: [
       /* @__PURE__ */ jsx18(GanttStrip, { cols, cursor, flatNodes: rows, maxRows: 6, now: now2, t }),
       /* @__PURE__ */ jsx18(Box_default, { flexDirection: "column", flexGrow: 0, flexShrink: 0, overflow: "hidden", children: rows.slice(listWindowStart, listWindowStart + rowsH).map((node, i) => /* @__PURE__ */ jsx18(
         ListRow,
@@ -56494,6 +57861,7 @@ var init_agentsOverlay = __esm({
     init_overlayStore();
     init_spawnHistoryStore();
     init_turnStore();
+    init_workflowStore();
     init_rpc();
     init_subagentTree();
     init_text();
@@ -58422,7 +59790,7 @@ function ModelPicker2({ gw, mode = "switch", onCancel, onSelect, sessionId, t })
           refreshProviders();
         }
         if (mode === "connect") {
-          onCancel();
+          onSelect("__openjaw_connect_complete__");
           return;
         }
         setStage("model");
@@ -58518,7 +59886,7 @@ function ModelPicker2({ gw, mode = "switch", onCancel, onSelect, sessionId, t })
           setKeyInput("");
           setKeySaving(false);
           if (mode === "connect") {
-            onCancel();
+            onSelect("__openjaw_connect_complete__");
             return;
           }
           setStage("model");
@@ -58557,7 +59925,7 @@ function ModelPicker2({ gw, mode = "switch", onCancel, onSelect, sessionId, t })
           if (r?.disconnected) {
             setProviders(
               (prev) => prev.map(
-                (p) => p.slug === provider.slug ? { ...p, authenticated: false, models: [], model_options: [], total_models: 0, warning: p.key_env ? `paste ${p.key_env} to activate` : "run `hermes model` to configure" } : p
+                (p) => p.slug === provider.slug ? { ...p, authenticated: false, models: [], model_options: [], total_models: 0, warning: p.key_env ? `paste ${p.key_env} to activate` : "run /connect to configure" } : p
               )
             );
           }
@@ -58605,7 +59973,7 @@ function ModelPicker2({ gw, mode = "switch", onCancel, onSelect, sessionId, t })
           return;
         }
         if (mode === "connect") {
-          onCancel();
+          onSelect("__openjaw_connect_complete__");
           return;
         }
         setStage("model");
@@ -58693,7 +60061,7 @@ function ModelPicker2({ gw, mode = "switch", onCancel, onSelect, sessionId, t })
         "Configure ",
         provider.name
       ] }),
-      /* @__PURE__ */ jsx25(Text9, { color: t.color.muted, wrap: "truncate-end", children: "Paste your API key below (saved to ~/.hermes/.env)" }),
+      /* @__PURE__ */ jsx25(Text9, { color: t.color.muted, wrap: "truncate-end", children: "Paste your API key below (saved to OpenJaw credentials)" }),
       /* @__PURE__ */ jsx25(Text9, { color: t.color.muted, wrap: "truncate-end", children: " " }),
       /* @__PURE__ */ jsxs13(Text9, { color: t.color.muted, wrap: "truncate-end", children: [
         provider.key_env,
@@ -59889,14 +61257,14 @@ __export(fpsStore_exports, {
   $fpsState: () => $fpsState,
   trackFrame: () => trackFrame
 });
-import { atom as atom7 } from "nanostores";
+import { atom as atom8 } from "nanostores";
 var WINDOW_SIZE, $fpsState, timestamps, totalFrames, trackFrame;
 var init_fpsStore = __esm({
   "src/lib/fpsStore.ts"() {
     "use strict";
     init_env();
     WINDOW_SIZE = 30;
-    $fpsState = atom7({ fps: 0, lastDurationMs: 0, totalFrames: 0 });
+    $fpsState = atom8({ fps: 0, lastDurationMs: 0, totalFrames: 0 });
     timestamps = [];
     totalFrames = 0;
     trackFrame = SHOW_FPS ? (durationMs) => {
@@ -61060,7 +62428,7 @@ var init_mathUnicode = __esm({
 
 // src/lib/syntax.ts
 function highlightLine(line, lang, t) {
-  const spec = resolve4(lang);
+  const spec = resolve5(lang);
   if (!spec) {
     return [["", line]];
   }
@@ -61092,7 +62460,7 @@ function highlightLine(line, lang, t) {
   }
   return tokens;
 }
-var KW, TS, PY, SH, GO, RUST, SQL, LANGS, ALIAS, resolve4, isHighlightable, TOKEN_RE;
+var KW, TS, PY, SH, GO, RUST, SQL, LANGS, ALIAS, resolve5, isHighlightable, TOKEN_RE;
 var init_syntax = __esm({
   "src/lib/syntax.ts"() {
     "use strict";
@@ -61146,8 +62514,8 @@ var init_syntax = __esm({
       yml: "yaml",
       zsh: "sh"
     };
-    resolve4 = /* @__PURE__ */ __name((lang) => LANGS[ALIAS[lang] ?? lang] ?? null, "resolve");
-    isHighlightable = /* @__PURE__ */ __name((lang) => resolve4(lang) !== null, "isHighlightable");
+    resolve5 = /* @__PURE__ */ __name((lang) => LANGS[ALIAS[lang] ?? lang] ?? null, "resolve");
+    isHighlightable = /* @__PURE__ */ __name((lang) => resolve5(lang) !== null, "isHighlightable");
     TOKEN_RE = /'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|`(?:[^`\\]|\\.)*`|\b\d+(?:\.\d+)?\b|[A-Za-z_$][\w$]*/g;
     __name(highlightLine, "highlightLine");
   }
@@ -63271,8 +64639,9 @@ var init_appLayout = __esm({
         {
           gw,
           initialHistoryIndex: overlay.agentsInitialHistoryIndex,
-          onClose: () => patchOverlayState({ agents: false, agentsInitialHistoryIndex: 0 }),
-          t: ui.theme
+          onClose: () => patchOverlayState({ agents: false, agentsInitialHistoryIndex: 0, agentsWorkflowId: null }),
+          t: ui.theme,
+          workflowId: overlay.agentsWorkflowId
         }
       );
     }, "AgentsOverlayPane"));