@charzhu/openjaw-agent 0.2.9 → 0.3.1

package/dist/main.js

@@ -137,7 +137,11 @@ function loadAgentConfig() {
     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 +203,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 +868,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() {
@@ -2393,9 +2405,6 @@ var init_copilot = __esm({
       }
       async chat(options) {
         const modelInfo = await this.resolveModelInfo(this.config.model);
-        if (hasImageContent(options.messages) && modelInfo?.supportsVision === false) {
-          throw new Error(`model ${this.config.model} does not support image input; switch to a vision-capable model before submitting an image`);
-        }
         if (this.shouldRouteToResponses(modelInfo)) {
           return this.chatResponses(options, modelInfo);
         }
@@ -2554,7 +2563,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(() => {
@@ -2568,7 +2577,7 @@ var init_copilot = __esm({
             settled = true;
             clearTimeout(timeout);
             ws.close();
-            resolve5(value);
+            resolve6(value);
           }, "finish");
           const fail = /* @__PURE__ */ __name((error) => {
             if (settled) return;
@@ -4008,7 +4017,7 @@ function categoryForTool(toolName) {
   if (toolName.startsWith("word_") || toolName.startsWith("excel_") || toolName.startsWith("powerpoint_") || toolName.startsWith("office_")) return "office";
   if (toolName.startsWith("memory_") || toolName === "todo_write") return "memory";
   if (toolName.startsWith("file_") || toolName.startsWith("image_") || toolName === "grep" || toolName === "glob") return "files";
-  if (toolName.startsWith("system_") || toolName.startsWith("clipboard_") || ["code_execute", "web_fetch", "web_search", "notify", "sleep", "ask_user", "config"].includes(toolName)) return "system";
+  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";
 }
 var DEFAULT_OPENAI_MAX_TOOLS, MCP_AUTO_GROW_HARD_CAP, BUILTIN_HEADROOM, FOUNDATION_TOOL_NAMES, PROFILE_CATEGORIES, CATEGORY_KEYWORDS;
@@ -4034,9 +4043,9 @@ 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|search online)\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: "system", patterns: [/\b(shell|command|terminal|run|execute|clipboard|notify|sleep|web search|fetch url)\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: "wechat", patterns: [/\b(wechat|weixin)\b/i] },
       { category: "memory", patterns: [/\b(memory|remember|recall|todo|preference)\b/i] }
@@ -5094,9 +5103,7 @@ ${summary}
           if (imageData) {
             const contentBlocks = [
               { type: "image", source: { type: "base64", media_type: imageData.mimeType, data: imageData.base64 } },
-              { type: "text", text: `${taskText}
-
-[ATTACHED IMAGE]: The image is attached as visual input in this message. Inspect it directly; do not search the filesystem for an uploaded image path unless the user explicitly asks for a file.` }
+              { type: "text", text: taskText }
             ];
             this.conversationHistory.push({ role: "user", content: contentBlocks });
           } else {
@@ -5477,18 +5484,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);
                     });
@@ -5838,18 +5845,135 @@ var init_logger = __esm({
   }
 });
 
+// ../openjaw-mcp/dist/tools/url-safety.js
+import { isIP } from "node:net";
+function hasTokenLikeSecret(value) {
+  const decoded = safeDecode(value);
+  return TOKEN_PATTERNS.some((pattern) => pattern.test(value) || pattern.test(decoded));
+}
+function safeDecode(value) {
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return value;
+  }
+}
+function normalizeHostname(hostname) {
+  return hostname.replace(/^\[|\]$/g, "").replace(/\.+$/g, "").toLowerCase();
+}
+function isPrivateIPv4(host) {
+  const parts = host.split(".").map((part) => Number(part));
+  if (parts.length !== 4 || parts.some((part) => !Number.isInteger(part) || part < 0 || part > 255))
+    return false;
+  const [a, b] = parts;
+  return a === 10 || a === 172 && b >= 16 && b <= 31 || a === 192 && b === 168 || a === 127 || a === 169 && b === 254 || a === 0;
+}
+function ipv4FromMappedIPv6(host) {
+  const lower = host.toLowerCase();
+  const dotted = /^::ffff:(\d{1,3}(?:\.\d{1,3}){3})$/.exec(lower);
+  if (dotted)
+    return dotted[1];
+  const hex = /^::ffff:([0-9a-f]{1,4}):([0-9a-f]{1,4})$/.exec(lower);
+  if (!hex)
+    return void 0;
+  const high = Number.parseInt(hex[1], 16);
+  const low = Number.parseInt(hex[2], 16);
+  if (!Number.isFinite(high) || !Number.isFinite(low))
+    return void 0;
+  return [high >> 8, high & 255, low >> 8, low & 255].join(".");
+}
+function isPrivateIPv6(host) {
+  const lower = host.toLowerCase();
+  const mapped = ipv4FromMappedIPv6(lower);
+  if (mapped)
+    return isPrivateIPv4(mapped);
+  return lower === "::1" || lower.startsWith("fc") || lower.startsWith("fd") || lower.startsWith("fe80:");
+}
+function isMetadataUrl(input) {
+  const url = typeof input === "string" ? new URL(input) : input;
+  const host = normalizeHostname(url.hostname);
+  const mapped = ipv4FromMappedIPv6(host);
+  return METADATA_HOSTS.has(host) || METADATA_IPS.has(host) || (mapped ? METADATA_IPS.has(mapped) : false);
+}
+function isPrivateHost(hostname) {
+  const host = normalizeHostname(hostname);
+  if (host === "localhost" || host.endsWith(".localhost"))
+    return true;
+  const ipKind = isIP(host);
+  if (ipKind === 4)
+    return isPrivateIPv4(host);
+  if (ipKind === 6)
+    return isPrivateIPv6(host);
+  return false;
+}
+function validateHttpUrl(input, options = {}) {
+  let url;
+  try {
+    url = new URL(input);
+  } catch {
+    return { ok: false, error: "Invalid URL" };
+  }
+  if (url.protocol !== "http:" && url.protocol !== "https:") {
+    return { ok: false, error: "Only http:// and https:// URLs are supported" };
+  }
+  if (url.username || url.password) {
+    return { ok: false, error: "Blocked: URL contains embedded credentials" };
+  }
+  if (hasTokenLikeSecret(url.href)) {
+    return { ok: false, error: "Blocked: URL contains what appears to be an API key, token, password, or secret" };
+  }
+  if (isMetadataUrl(url)) {
+    return { ok: false, error: "Blocked: URL targets a cloud metadata endpoint" };
+  }
+  if (!options.allowPrivate && isPrivateHost(url.hostname)) {
+    return { ok: false, error: "Blocked: URL targets a private, loopback, or internal network address" };
+  }
+  return { ok: true, url };
+}
+var TOKEN_PATTERNS, METADATA_HOSTS, METADATA_IPS;
+var init_url_safety = __esm({
+  "../openjaw-mcp/dist/tools/url-safety.js"() {
+    "use strict";
+    TOKEN_PATTERNS = [
+      /\b(?:sk|ghp|github_pat|gho|ghu|ghs|glpat|xox[baprs]|ya29|AIza)[A-Za-z0-9_\-]{12,}\b/i,
+      /(?:api[_-]?key|access[_-]?token|auth[_-]?token|bearer|secret|password|passwd|pwd|token)=([^&\s]{8,})/i
+    ];
+    METADATA_HOSTS = /* @__PURE__ */ new Set([
+      "metadata.google.internal",
+      "metadata.azure.internal"
+    ]);
+    METADATA_IPS = /* @__PURE__ */ new Set([
+      "169.254.169.254",
+      "100.100.100.200"
+    ]);
+    __name(hasTokenLikeSecret, "hasTokenLikeSecret");
+    __name(safeDecode, "safeDecode");
+    __name(normalizeHostname, "normalizeHostname");
+    __name(isPrivateIPv4, "isPrivateIPv4");
+    __name(ipv4FromMappedIPv6, "ipv4FromMappedIPv6");
+    __name(isPrivateIPv6, "isPrivateIPv6");
+    __name(isMetadataUrl, "isMetadataUrl");
+    __name(isPrivateHost, "isPrivateHost");
+    __name(validateHttpUrl, "validateHttpUrl");
+  }
+});
+
 // ../openjaw-mcp/dist/channels/browser.js
 import * as chromeLauncher from "chrome-launcher";
 import CDP from "chrome-remote-interface";
 function escapeForJs(str) {
   return str.replace(/\\/g, "\\\\").replace(/'/g, "\\'").replace(/"/g, '\\"').replace(/`/g, "\\`").replace(/\$/g, "\\$").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\0/g, "\\0").replace(/</g, "\\x3c").replace(/>/g, "\\x3e");
 }
-var BrowserChannel;
+var MAX_CONSOLE_MESSAGES, MAX_JS_ERRORS, MAX_CONSOLE_TEXT, BrowserChannel;
 var init_browser = __esm({
   "../openjaw-mcp/dist/channels/browser.js"() {
     "use strict";
     init_logger();
+    init_url_safety();
     __name(escapeForJs, "escapeForJs");
+    MAX_CONSOLE_MESSAGES = 200;
+    MAX_JS_ERRORS = 100;
+    MAX_CONSOLE_TEXT = 4e3;
     BrowserChannel = class {
       static {
         __name(this, "BrowserChannel");
@@ -5859,6 +5983,10 @@ var init_browser = __esm({
       client = null;
       page = null;
       launchPromise = null;
+      currentSnapshotId = null;
+      currentRefs = /* @__PURE__ */ new Map();
+      consoleBuffer = [];
+      jsErrorBuffer = [];
       constructor(config) {
         this.config = config;
       }
@@ -5905,6 +6033,8 @@ var init_browser = __esm({
         this.client = null;
         this.page = null;
         this.launchPromise = null;
+        this.consoleBuffer = [];
+        this.jsErrorBuffer = [];
         logger_default.info("Browser connection state reset");
       }
       /**
@@ -5957,33 +6087,99 @@ var init_browser = __esm({
           DOM.enable(),
           Network.enable()
         ]);
+        this.attachRuntimeEventBuffers(Runtime);
+        await this.attachRequestSafetyInterception(this.client.Fetch);
         this.page = { Runtime, Page, DOM, Input };
         logger_default.info("Browser launched", { port: this.chrome.port });
       }
+      async attachRequestSafetyInterception(Fetch) {
+        const fetchDomain = Fetch;
+        if (!fetchDomain?.enable || !fetchDomain.requestPaused || !fetchDomain.failRequest || !fetchDomain.continueRequest) {
+          logger_default.debug("Browser Fetch domain unavailable; navigation safety falls back to pre/final URL checks");
+          return;
+        }
+        fetchDomain.requestPaused((event) => {
+          void (async () => {
+            try {
+              const url = new URL(event.request.url);
+              if (url.protocol === "http:" || url.protocol === "https:") {
+                const safety = validateHttpUrl(url.href, { allowPrivate: true });
+                if (!safety.ok) {
+                  await fetchDomain.failRequest({ requestId: event.requestId, errorReason: "BlockedByClient" });
+                  return;
+                }
+              }
+              await fetchDomain.continueRequest({ requestId: event.requestId });
+            } catch {
+              await fetchDomain.continueRequest({ requestId: event.requestId }).catch(() => void 0);
+            }
+          })();
+        });
+        await fetchDomain.enable({ patterns: [{ urlPattern: "*", requestStage: "Request" }] });
+      }
+      attachRuntimeEventBuffers(Runtime) {
+        const runtime = Runtime;
+        runtime.consoleAPICalled?.((event) => {
+          const text = (event.args ?? []).map((arg) => String(arg.value ?? arg.description ?? "")).join(" ").slice(0, MAX_CONSOLE_TEXT);
+          this.consoleBuffer.push({
+            type: event.type ?? "log",
+            text,
+            timestamp: event.timestamp ?? Date.now()
+          });
+          if (this.consoleBuffer.length > MAX_CONSOLE_MESSAGES) {
+            this.consoleBuffer.splice(0, this.consoleBuffer.length - MAX_CONSOLE_MESSAGES);
+          }
+        });
+        runtime.exceptionThrown?.((event) => {
+          const details = event.exceptionDetails ?? {};
+          this.jsErrorBuffer.push({
+            message: String(details.exception?.description ?? details.exception?.value ?? details.text ?? "JavaScript exception").slice(0, MAX_CONSOLE_TEXT),
+            url: details.url,
+            line: details.lineNumber,
+            column: details.columnNumber,
+            timestamp: event.timestamp ?? Date.now()
+          });
+          if (this.jsErrorBuffer.length > MAX_JS_ERRORS) {
+            this.jsErrorBuffer.splice(0, this.jsErrorBuffer.length - MAX_JS_ERRORS);
+          }
+        });
+      }
       async navigate(options) {
         await this.ensureBrowser();
         const { Page, Runtime } = this.page;
-        await Page.navigate({ url: options.url });
+        const initialSafety = validateHttpUrl(options.url, { allowPrivate: true });
+        if (!initialSafety.ok) {
+          return { url: options.url, title: "", snapshot: "", error: initialSafety.error };
+        }
+        await Page.navigate({ url: initialSafety.url.href });
         if (options.waitFor === "load") {
           await Page.loadEventFired();
         } else if (options.waitFor === "domcontentloaded") {
           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"
         });
-        return {
-          url: options.url,
-          title: result.result.value
-        };
+        const url = await this.getCurrentUrl() ?? initialSafety.url.href;
+        const finalSafety = validateHttpUrl(url, { allowPrivate: true });
+        if (!finalSafety.ok) {
+          return { url, title: result.result.value, snapshot: "", error: `Blocked final URL: ${finalSafety.error}` };
+        }
+        const title = result.result.value;
+        const snapshot = await this.snapshot({ full: false });
+        return { ...snapshot, url, title };
       }
       async click(options) {
         await this.ensureBrowser();
         const { Runtime } = this.page;
-        const findExpr = options.selector ? `document.querySelector('${escapeForJs(options.selector)}')` : options.text ? `(() => {
+        const resolvedSelector = options.ref ? this.resolveRef(options.ref, options.snapshotId) : options.selector;
+        if (options.ref && !resolvedSelector) {
+          return { success: false, element: `stale or unknown ref ${options.ref}; call browser_snapshot again` };
+        }
+        const findExpr = resolvedSelector ? `document.querySelector('${escapeForJs(resolvedSelector)}')` : options.text ? `(() => {
             const isVis = (e) => {
               if (!e.offsetParent && e.tagName !== 'BODY' && e.tagName !== 'HTML') return false;
               const s = getComputedStyle(e);
@@ -6107,9 +6303,13 @@ var init_browser = __esm({
       async type(options) {
         await this.ensureBrowser();
         const { Runtime } = this.page;
+        const resolvedSelector = options.ref ? this.resolveRef(options.ref, options.snapshotId) : options.selector;
+        if (!resolvedSelector) {
+          return { success: false, error: options.ref ? `stale or unknown ref ${options.ref}; call browser_snapshot again` : "No selector or ref provided" };
+        }
         const script = `
       (() => {
-        const el = document.querySelector('${escapeForJs(options.selector)}');
+        const el = document.querySelector('${escapeForJs(resolvedSelector)}');
         if (el) {
           ${options.clear ? "el.value = '';" : ""}
           el.value = '${escapeForJs(options.text)}';
@@ -6191,6 +6391,141 @@ var init_browser = __esm({
         const result = await Runtime.evaluate({ expression: script, returnByValue: true });
         return { content: result.result.value };
       }
+      async snapshot(options) {
+        await this.ensureBrowser();
+        const { Runtime } = this.page;
+        const scope = options?.selector ? `'${escapeForJs(options.selector)}'` : `'body'`;
+        const maxElements = Math.min(Math.max(options?.maxElements ?? 80, 1), 200);
+        const textLimit = options?.full ? 8e3 : 1200;
+        const script = `(() => {
+      const root = document.querySelector(${scope});
+      const cssEscape = (value) => globalThis.CSS?.escape
+        ? globalThis.CSS.escape(String(value))
+        : String(value).replace(/[^a-zA-Z0-9_-]/g, ch => '\\\\' + ch.charCodeAt(0).toString(16) + ' ');
+      const selectorFor = (el) => {
+        if (el.id) return '#' + cssEscape(el.id);
+        const parts = [];
+        let cur = el;
+        while (cur && cur.nodeType === 1 && cur !== document.body) {
+          let part = cur.tagName.toLowerCase();
+          const parent = cur.parentElement;
+          if (!parent) break;
+          const same = Array.from(parent.children).filter(child => child.tagName === cur.tagName);
+          if (same.length > 1) part += ':nth-of-type(' + (same.indexOf(cur) + 1) + ')';
+          parts.unshift(part);
+          cur = parent;
+        }
+        return parts.length ? parts.join(' > ') : 'body';
+      };
+      const isVisible = (el) => {
+        const rect = el.getBoundingClientRect();
+        const style = getComputedStyle(el);
+        return rect.width > 0 && rect.height > 0 && style.display !== 'none' && style.visibility !== 'hidden' && style.opacity !== '0';
+      };
+      const disabled = (el) => Boolean(el.disabled || el.getAttribute('aria-disabled') === 'true');
+      if (!root) return JSON.stringify({ url: location.href, title: document.title, elements: [], text: '' });
+      const nodes = Array.from(root.querySelectorAll('button, a[href], input, select, textarea, summary, [role="button"], [role="link"], [role="textbox"], [onclick], [tabindex]'));
+      const elements = [];
+      for (const el of nodes) {
+        if (elements.length >= ${maxElements}) break;
+        const tag = el.tagName.toLowerCase();
+        const type = el.getAttribute('type') || '';
+        const role = el.getAttribute('role') || (type ? tag + '[' + type + ']' : tag);
+        const text = (el.innerText || el.textContent || '').replace(/s+/g, ' ').trim().slice(0, 120);
+        const label = (el.getAttribute('aria-label') || el.getAttribute('title') || el.getAttribute('placeholder') || text || el.getAttribute('value') || '').replace(/s+/g, ' ').trim().slice(0, 120);
+        elements.push({
+          ref: '@e' + (elements.length + 1),
+          selector: selectorFor(el),
+          role,
+          tag,
+          label,
+          text,
+          visible: isVisible(el),
+          disabled: disabled(el),
+        });
+      }
+      const pageText = (root.innerText || root.textContent || '').replace(/s+/g, ' ').trim().slice(0, ${textLimit});
+      return JSON.stringify({ url: location.href, title: document.title, elements, text: pageText });
+    })()`;
+        const result = await Runtime.evaluate({ expression: script, returnByValue: true });
+        const parsed = JSON.parse(result.result.value || "{}");
+        const snapshotId = `snap_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
+        const elements = parsed.elements ?? [];
+        const refs = {};
+        this.currentRefs.clear();
+        for (const element of elements) {
+          refs[element.ref] = element.selector;
+          this.currentRefs.set(element.ref, element.selector);
+        }
+        this.currentSnapshotId = snapshotId;
+        const lines = [
+          `URL: ${parsed.url ?? ""}`,
+          `Title: ${parsed.title ?? ""}`,
+          `Snapshot: ${snapshotId}`,
+          "",
+          `Interactive elements (${elements.length}):`,
+          ...elements.map((element) => `${element.ref} <${element.role}>${element.visible ? "" : " [hidden]"}${element.disabled ? " [disabled]" : ""} ${JSON.stringify(element.label || element.text || element.selector)}`),
+          "",
+          "Visible text:",
+          parsed.text ?? ""
+        ];
+        return {
+          url: parsed.url ?? "",
+          title: parsed.title ?? "",
+          snapshot: lines.join("\n").trim(),
+          snapshot_id: snapshotId,
+          refs,
+          elements,
+          text: parsed.text ?? "",
+          element_count: elements.length
+        };
+      }
+      resolveRef(ref, snapshotId) {
+        if (snapshotId && this.currentSnapshotId && snapshotId !== this.currentSnapshotId)
+          return void 0;
+        return this.currentRefs.get(ref);
+      }
+      async back() {
+        await this.ensureBrowser();
+        const { Page, Runtime } = this.page;
+        const history = await Page.getNavigationHistory();
+        if (history.currentIndex > 0) {
+          await Page.navigateToHistoryEntry({ entryId: history.entries[history.currentIndex - 1].id });
+          await Page.loadEventFired().catch(() => void 0);
+        }
+        const title = await Runtime.evaluate({ expression: "document.title", returnByValue: true });
+        return { url: await this.getCurrentUrl(), title: title.result.value };
+      }
+      async press(key) {
+        await this.sendKey(key);
+        return { success: true, key };
+      }
+      async getImages() {
+        await this.ensureBrowser();
+        const { Runtime } = this.page;
+        const script = `JSON.stringify(Array.from(document.images).slice(0, 100).map(img => {
+      const rect = img.getBoundingClientRect();
+      return { src: img.currentSrc || img.src, alt: img.alt || '', width: img.naturalWidth || rect.width || 0, height: img.naturalHeight || rect.height || 0, visible: rect.width > 0 && rect.height > 0 };
+    }).filter(img => img.src && !img.src.startsWith('data:')))`;
+        const result = await Runtime.evaluate({ expression: script, returnByValue: true });
+        const images = JSON.parse(result.result.value || "[]");
+        return { images, count: images.length };
+      }
+      async consoleMessages(clear2 = false) {
+        const consoleMessages = [...this.consoleBuffer];
+        const jsErrors = [...this.jsErrorBuffer];
+        if (clear2) {
+          this.consoleBuffer = [];
+          this.jsErrorBuffer = [];
+        }
+        return {
+          console_messages: consoleMessages,
+          js_errors: jsErrors,
+          total_messages: consoleMessages.length,
+          total_errors: jsErrors.length,
+          note: clear2 ? "Returned and cleared buffered console messages." : "Returned buffered console messages."
+        };
+      }
       async evaluate(script) {
         await this.ensureBrowser();
         const { Runtime } = this.page;
@@ -6594,7 +6929,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;
       }
@@ -6625,18 +6960,48 @@ function createBrowseTools(config, sharedBrowser) {
         required: ["url"]
       },
       execute: /* @__PURE__ */ __name(async (input) => {
+        const safety = validateHttpUrl(input.url, { allowPrivate: true });
+        if (!safety.ok)
+          return { error: safety.error, url: input.url };
         return await browser.navigate({
           url: input.url,
           waitFor: input.wait_for ?? "load"
         });
       }, "execute")
     },
+    {
+      name: "browser_snapshot",
+      description: "Get a compact snapshot of the current page with stable refs like @e1 for browser_click and browser_type. Use after navigation or after interactions that changed the page.",
+      parameters: {
+        type: "object",
+        properties: {
+          full: { type: "boolean", description: "Include more visible page text (default false)", default: false },
+          selector: { type: "string", description: "Optional CSS selector to scope the snapshot" },
+          max_elements: { type: "number", description: "Maximum interactive elements to include (default 80, max 200)" }
+        }
+      },
+      execute: /* @__PURE__ */ __name(async (input) => {
+        return await browser.snapshot({
+          full: input.full === true,
+          selector: input.selector,
+          maxElements: input.max_elements
+        });
+      }, "execute")
+    },
     {
       name: "browser_click",
-      description: "Click an element on the page",
+      description: "Click an element on the page. Prefer ref from browser_snapshot (e.g. @e5). Legacy selector/text targeting is still supported.",
       parameters: {
         type: "object",
         properties: {
+          ref: {
+            type: "string",
+            description: "Element ref from browser_snapshot, e.g. @e5"
+          },
+          snapshot_id: {
+            type: "string",
+            description: "Optional snapshot_id associated with the ref. If stale, refresh with browser_snapshot."
+          },
           selector: {
             type: "string",
             description: "CSS selector of element to click"
@@ -6649,6 +7014,8 @@ function createBrowseTools(config, sharedBrowser) {
       },
       execute: /* @__PURE__ */ __name(async (input) => {
         return await browser.click({
+          ref: input.ref,
+          snapshotId: input.snapshot_id,
           selector: input.selector,
           text: input.text
         });
@@ -6656,10 +7023,18 @@ function createBrowseTools(config, sharedBrowser) {
     },
     {
       name: "browser_type",
-      description: "Type text into an input element",
+      description: "Type text into an input element. Prefer ref from browser_snapshot (e.g. @e3). Legacy selector targeting is still supported.",
       parameters: {
         type: "object",
         properties: {
+          ref: {
+            type: "string",
+            description: "Element ref from browser_snapshot, e.g. @e3"
+          },
+          snapshot_id: {
+            type: "string",
+            description: "Optional snapshot_id associated with the ref. If stale, refresh with browser_snapshot."
+          },
           selector: {
             type: "string",
             description: "CSS selector of input element"
@@ -6679,10 +7054,12 @@ function createBrowseTools(config, sharedBrowser) {
             default: false
           }
         },
-        required: ["selector", "text"]
+        required: ["text"]
       },
       execute: /* @__PURE__ */ __name(async (input) => {
         return await browser.type({
+          ref: input.ref,
+          snapshotId: input.snapshot_id,
           selector: input.selector,
           text: input.text,
           clear: input.clear ?? true,
@@ -6690,6 +7067,24 @@ function createBrowseTools(config, sharedBrowser) {
         });
       }, "execute")
     },
+    {
+      name: "browser_back",
+      description: "Navigate back to the previous page in browser history.",
+      parameters: { type: "object", properties: {} },
+      execute: /* @__PURE__ */ __name(async () => await browser.back(), "execute")
+    },
+    {
+      name: "browser_press",
+      description: "Press a keyboard key in the browser, e.g. Enter, Tab, Escape, ArrowDown.",
+      parameters: {
+        type: "object",
+        properties: {
+          key: { type: "string", description: "Key to press, e.g. Enter, Tab, Escape, ArrowDown" }
+        },
+        required: ["key"]
+      },
+      execute: /* @__PURE__ */ __name(async (input) => await browser.press(input.key), "execute")
+    },
     {
       name: "browser_extract",
       description: "Extract text content from the page",
@@ -6734,6 +7129,51 @@ function createBrowseTools(config, sharedBrowser) {
         return await browser.evaluate(input.script);
       }, "execute")
     },
+    {
+      name: "browser_console",
+      description: "Read browser console logs and JavaScript errors. This tool is read-only; use browser_evaluate for JavaScript execution.",
+      parameters: {
+        type: "object",
+        properties: {
+          clear: { type: "boolean", description: "Clear buffered logs after reading, if buffering is active", default: false }
+        }
+      },
+      execute: /* @__PURE__ */ __name(async (input) => await browser.consoleMessages(input.clear === true), "execute")
+    },
+    {
+      name: "browser_get_images",
+      description: "List images on the current page with URLs, alt text, dimensions, and visibility. Use before visual analysis or downloading images.",
+      parameters: { type: "object", properties: {} },
+      execute: /* @__PURE__ */ __name(async () => await browser.getImages(), "execute")
+    },
+    {
+      name: "browser_vision",
+      description: "Take a browser screenshot for visual inspection. Returns a screenshot path plus page metadata. Use for visual layouts, CAPTCHAs, screenshots, or image-heavy pages.",
+      parameters: {
+        type: "object",
+        properties: {
+          question: { type: "string", description: "What you want to inspect visually" },
+          annotate: { type: "boolean", description: "Reserved for future ref overlays; currently returns a normal screenshot", default: false }
+        }
+      },
+      execute: /* @__PURE__ */ __name(async (input) => {
+        const { join: join48 } = await import("node:path");
+        const { tmpdir: tmpdir13 } = await import("node:os");
+        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 {
+          message: "Browser screenshot captured for visual inspection",
+          question: input.question,
+          snapshot_id: snapshot.snapshot_id,
+          url: snapshot.url,
+          title: snapshot.title,
+          screenshotPath: screenshot.path ?? screenshotPath,
+          imagePayload: "not_attached: screenshot path returned to avoid sending images to non-vision providers"
+        };
+      }, "execute")
+    },
     {
       name: "browser_wait",
       description: "Wait for an element to appear, text to change, or element to hide. Use before interacting with dynamic/slow-loading pages.",
@@ -6819,6 +7259,7 @@ var init_browse = __esm({
   "../openjaw-mcp/dist/tools/browse.js"() {
     "use strict";
     init_browser();
+    init_url_safety();
     __name(createBrowseTools, "createBrowseTools");
   }
 });
@@ -7414,7 +7855,7 @@ var init_outlook_desktop = __esm({
         }
       }
       sleep(ms) {
-        return new Promise((resolve5) => setTimeout(resolve5, ms));
+        return new Promise((resolve6) => setTimeout(resolve6, ms));
       }
     };
   }
@@ -8012,7 +8453,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));
       }
     };
   }
@@ -8246,8 +8687,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;
@@ -8427,7 +8868,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();
@@ -8544,19 +8985,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({
@@ -8570,18 +9011,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();
@@ -8601,14 +9042,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([]);
               }
             }
           });
@@ -8624,11 +9065,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({
@@ -8642,7 +9083,7 @@ var init_cdp_token_extractor = __esm({
             if (resp.id === 1) {
               clearTimeout(timer);
               ws.close();
-              resolve5();
+              resolve6();
             }
           });
           ws.on("error", (err) => {
@@ -10303,13 +10744,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
 
@@ -11630,7 +12071,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
@@ -12497,7 +12938,7 @@ var init_teams_web = __esm({
         }
       }
       sleep(ms) {
-        return new Promise((resolve5) => setTimeout(resolve5, ms));
+        return new Promise((resolve6) => setTimeout(resolve6, ms));
       }
     };
   }
@@ -13895,7 +14336,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.
@@ -14682,7 +15123,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();
@@ -14691,7 +15132,7 @@ ${lines.join("\n")}`;
                     if (!seenIds.has(msgId) && msg.sender !== currentUserName) {
                       clearInterval(timer2);
                       seenIds.add(msgId);
-                      resolve5({
+                      resolve6({
                         success: true,
                         channel: channelType,
                         sync: true,
@@ -14768,7 +15209,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();
@@ -14777,7 +15218,7 @@ ${lines.join("\n")}`;
                     if (!seenIds.has(msgId) && msg.sender !== currentUserName) {
                       clearInterval(timer2);
                       seenIds.add(msgId);
-                      resolve5({
+                      resolve6({
                         success: true,
                         channel: channelType,
                         sync: true,
@@ -15135,7 +15576,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({
@@ -15750,6 +16191,175 @@ function urlMatchesDomain(url, domain) {
     return false;
   }
 }
+function normalizeSearchResults(results, limit) {
+  return results.slice(0, limit).map((result, index) => ({
+    ...result,
+    snippet: result.snippet ?? "",
+    description: result.snippet ?? "",
+    position: index + 1
+  }));
+}
+function clampNumber(value, fallback, min, max) {
+  const numberValue = typeof value === "number" ? value : Number(value);
+  if (!Number.isFinite(numberValue))
+    return fallback;
+  return Math.min(Math.max(Math.trunc(numberValue), min), max);
+}
+function extractHtmlTitle(html) {
+  const match = /<title[^>]*>([\s\S]*?)<\/title>/i.exec(html);
+  if (!match)
+    return void 0;
+  return DECODE_ENTITIES(match[1].replace(/\s+/g, " ").trim()) || void 0;
+}
+function cleanHtmlForMarkdown(html) {
+  return html.replace(/<script[^>]*>[\s\S]*?<\/script>/gi, "").replace(/<style[^>]*>[\s\S]*?<\/style>/gi, "").replace(/<noscript[^>]*>[\s\S]*?<\/noscript>/gi, "").replace(/<svg[^>]*>[\s\S]*?<\/svg>/gi, "").replace(/<nav[^>]*>[\s\S]*?<\/nav>/gi, "").replace(/<footer[^>]*>[\s\S]*?<\/footer>/gi, "").replace(/<header[^>]*>[\s\S]*?<\/header>/gi, "");
+}
+function htmlToText(html) {
+  return DECODE_ENTITIES(cleanHtmlForMarkdown(html).replace(/<br\s*\/?>/gi, "\n").replace(/<\/p>/gi, "\n\n").replace(/<\/h[1-6]>/gi, "\n\n").replace(/<[^>]+>/g, " ").replace(/[ \t]+/g, " ").replace(/\n\s+/g, "\n").replace(/\n{3,}/g, "\n\n").trim());
+}
+function isPdfLike(url, contentType) {
+  if (/application\/pdf/i.test(contentType))
+    return true;
+  try {
+    return new URL(url).pathname.toLowerCase().endsWith(".pdf");
+  } catch {
+    return /\.pdf(?:$|[?#])/i.test(url);
+  }
+}
+async function htmlToMarkdown(html) {
+  try {
+    const TurndownModule = await import("turndown");
+    const TurndownService = TurndownModule.default || TurndownModule;
+    const turndown = new TurndownService({ headingStyle: "atx", codeBlockStyle: "fenced" });
+    return turndown.turndown(cleanHtmlForMarkdown(html));
+  } catch {
+    return cleanHtmlForMarkdown(html).replace(/<[^>]+>/g, " ").replace(/\s+/g, " ").trim();
+  }
+}
+function paginateContent(text, startIndex, maxLength) {
+  const safeStart = clampNumber(startIndex, 0, 0, Math.max(0, text.length));
+  const safeMax = clampNumber(maxLength, 8e3, 1, 1e5);
+  const content = text.slice(safeStart, safeStart + safeMax);
+  const nextStartIndex = safeStart + content.length < text.length ? safeStart + content.length : void 0;
+  return {
+    content,
+    contentLength: text.length,
+    truncated: nextStartIndex !== void 0,
+    startIndex: safeStart,
+    ...nextStartIndex !== void 0 && { nextStartIndex }
+  };
+}
+async function fetchWithValidatedRedirects(startUrl, options) {
+  let current = startUrl;
+  const maxRedirects = options.maxRedirects ?? 10;
+  for (let redirects = 0; redirects <= maxRedirects; redirects++) {
+    const response = await fetch(current.href, {
+      signal: options.signal,
+      headers: options.headers,
+      redirect: "manual"
+    });
+    if (response.status < 300 || response.status >= 400) {
+      return { response, finalUrl: current.href };
+    }
+    const location = response.headers.get("location");
+    if (!location) {
+      return { response, finalUrl: current.href };
+    }
+    const nextUrl = new URL(location, current.href);
+    const nextSafety = validateHttpUrl(nextUrl.href, { allowPrivate: options.allowPrivate });
+    if (!nextSafety.ok) {
+      return { finalUrl: nextUrl.href, error: `Blocked redirect: ${nextSafety.error}` };
+    }
+    current = nextSafety.url;
+  }
+  return { finalUrl: current.href, error: `Too many redirects (>${maxRedirects})` };
+}
+async function extractUrlContent(inputUrl, options) {
+  const initial = validateHttpUrl(inputUrl, { allowPrivate: options.allowPrivate });
+  if (!initial.ok) {
+    return {
+      url: inputUrl,
+      finalUrl: inputUrl,
+      contentType: "",
+      content: "",
+      contentLength: 0,
+      truncated: false,
+      startIndex: options.startIndex,
+      error: initial.error
+    };
+  }
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), options.timeoutMs ?? 2e4);
+  try {
+    const fetched = await fetchWithValidatedRedirects(initial.url, {
+      signal: controller.signal,
+      headers: { "User-Agent": "OpenJaw-Agent/1.0" },
+      allowPrivate: options.allowPrivate
+    });
+    const finalUrl = fetched.finalUrl;
+    if (fetched.error || !fetched.response) {
+      return {
+        url: inputUrl,
+        finalUrl,
+        contentType: "",
+        content: "",
+        contentLength: 0,
+        truncated: false,
+        startIndex: options.startIndex,
+        error: fetched.error ?? "Fetch failed before response"
+      };
+    }
+    const response = fetched.response;
+    if (!response.ok) {
+      return {
+        url: inputUrl,
+        finalUrl,
+        contentType: response.headers.get("content-type") || "",
+        content: "",
+        contentLength: 0,
+        truncated: false,
+        startIndex: options.startIndex,
+        error: `HTTP ${response.status}: ${response.statusText}`
+      };
+    }
+    const contentType = response.headers.get("content-type") || "";
+    if (isPdfLike(finalUrl, contentType)) {
+      return {
+        url: inputUrl,
+        finalUrl,
+        contentType,
+        content: "",
+        contentLength: 0,
+        truncated: false,
+        startIndex: options.startIndex,
+        error: "PDF extraction is not yet supported"
+      };
+    }
+    const rawText = await response.text();
+    const title = contentType.includes("html") ? extractHtmlTitle(rawText) : void 0;
+    const text = contentType.includes("html") ? options.format === "text" ? htmlToText(rawText) : await htmlToMarkdown(rawText) : rawText;
+    return {
+      url: inputUrl,
+      finalUrl,
+      title,
+      contentType,
+      ...paginateContent(text, options.startIndex, options.maxLength)
+    };
+  } catch (err) {
+    return {
+      url: inputUrl,
+      finalUrl: inputUrl,
+      contentType: "",
+      content: "",
+      contentLength: 0,
+      truncated: false,
+      startIndex: options.startIndex,
+      error: `Fetch failed: ${err instanceof Error ? err.message : String(err)}`
+    };
+  } finally {
+    clearTimeout(timeout);
+  }
+}
 function createShellTools(_config, hooks) {
   return [
     {
@@ -15790,11 +16400,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,
@@ -15814,7 +16424,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,
@@ -15832,7 +16442,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,
@@ -15843,7 +16453,7 @@ function createShellTools(_config, hooks) {
             });
           });
           proc.on("error", (error) => {
-            resolve5({
+            resolve6({
               command,
               exitCode: -1,
               stdout: "",
@@ -15877,10 +16487,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;
@@ -15897,14 +16507,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;
@@ -15997,7 +16607,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,
@@ -16005,9 +16615,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 });
             }
           });
         });
@@ -16016,58 +16626,86 @@ function createShellTools(_config, hooks) {
     // ─── Web Fetch tool (headless URL content extraction) ───
     {
       name: "web_fetch",
-      description: "Fetch content from a URL and return it as text. Use this for quick content retrieval without opening a browser. Supports HTML pages (converted to markdown), JSON APIs, and plain text.",
+      description: "Fetch raw content from a URL. Use for APIs, JSON, plain text, and small pages. For articles/docs/pages that need cleanup, prefer web_extract.",
       parameters: {
         type: "object",
         properties: {
           url: { type: "string", description: "The URL to fetch" },
           max_length: { type: "number", description: "Maximum characters to return (default: 5000)" },
-          start_index: { type: "number", description: "Start index for content pagination (default: 0). Use to continue reading truncated content." }
+          start_index: { type: "number", description: "Start index for content pagination (default: 0). Use to continue reading truncated content." },
+          allow_private: { type: "boolean", description: "Allow private, loopback, or internal network URLs. Default false." }
         },
         required: ["url"]
       },
       execute: /* @__PURE__ */ __name(async (input) => {
         const url = input.url;
-        const maxLength = input.max_length || 5e3;
-        const startIndex = input.start_index || 0;
-        try {
-          const controller = new AbortController();
-          const timeout = setTimeout(() => controller.abort(), 15e3);
-          const response = await fetch(url, {
-            signal: controller.signal,
-            headers: { "User-Agent": "OpenJaw-Agent/1.0" }
-          });
-          clearTimeout(timeout);
-          if (!response.ok) {
-            return { error: `HTTP ${response.status}: ${response.statusText}`, url };
-          }
-          const contentType = response.headers.get("content-type") || "";
-          let text = await response.text();
-          if (contentType.includes("html")) {
-            try {
-              const TurndownModule = await import("turndown");
-              const TurndownService = TurndownModule.default || TurndownModule;
-              const turndown = new TurndownService({
-                headingStyle: "atx",
-                codeBlockStyle: "fenced"
-              });
-              const cleaned = text.replace(/<script[^>]*>[\s\S]*?<\/script>/gi, "").replace(/<style[^>]*>[\s\S]*?<\/style>/gi, "").replace(/<nav[^>]*>[\s\S]*?<\/nav>/gi, "").replace(/<footer[^>]*>[\s\S]*?<\/footer>/gi, "");
-              text = turndown.turndown(cleaned);
-            } catch {
-              text = text.replace(/<script[^>]*>[\s\S]*?<\/script>/gi, "").replace(/<style[^>]*>[\s\S]*?<\/style>/gi, "").replace(/<[^>]+>/g, " ").replace(/\s+/g, " ").trim();
-            }
-          }
-          if (startIndex > 0) {
-            text = text.slice(startIndex);
-          }
-          if (text.length > maxLength) {
-            text = text.slice(0, maxLength);
-            return { url, contentType, length: text.length, content: text, truncated: true, nextIndex: startIndex + maxLength, hint: `Content truncated. Use start_index: ${startIndex + maxLength} to continue reading.` };
+        const maxLength = clampNumber(input.max_length, 5e3, 1, 1e5);
+        const startIndex = clampNumber(input.start_index, 0, 0, Number.MAX_SAFE_INTEGER);
+        const allowPrivate = input.allow_private === true;
+        const extracted = await extractUrlContent(url, { maxLength, startIndex, allowPrivate, timeoutMs: 15e3, format: "markdown" });
+        if (extracted.error)
+          return { error: extracted.error, url: extracted.url, finalUrl: extracted.finalUrl };
+        return {
+          url: extracted.url,
+          finalUrl: extracted.finalUrl,
+          contentType: extracted.contentType,
+          title: extracted.title,
+          length: extracted.content.length,
+          contentLength: extracted.contentLength,
+          content: extracted.content,
+          truncated: extracted.truncated,
+          ...extracted.nextStartIndex !== void 0 && {
+            nextIndex: extracted.nextStartIndex,
+            nextStartIndex: extracted.nextStartIndex,
+            hint: `Content truncated. Use start_index: ${extracted.nextStartIndex} to continue reading.`
           }
-          return { url, contentType, length: text.length, content: text };
-        } catch (err) {
-          return { error: `Fetch failed: ${err instanceof Error ? err.message : String(err)}`, url };
-        }
+        };
+      }, "execute")
+    },
+    // ─── Web Extract tool (selected-source reading) ───
+    {
+      name: "web_extract",
+      description: "Extract readable content from selected web page URLs. Use after web_search when you need to read source pages, articles, docs, or papers. Returns markdown/text with metadata and pagination. For raw APIs or plain JSON, web_fetch is lighter.",
+      parameters: {
+        type: "object",
+        properties: {
+          urls: { type: "array", items: { type: "string" }, description: "List of URLs to extract content from (max 5)" },
+          format: { type: "string", enum: ["markdown", "text"], description: "Output format. HTML is converted to markdown by default.", default: "markdown" },
+          max_length: { type: "number", description: "Maximum characters per URL to return (default: 8000, max: 100000)" },
+          start_index: { type: "number", description: "Start index for content pagination (default: 0). Applies to each URL." },
+          allow_private: { type: "boolean", description: "Allow private, loopback, or internal network URLs. Default false." },
+          use_llm_processing: { type: "boolean", description: "Reserved for future LLM summarization. Currently deterministic extraction only." }
+        },
+        required: ["urls"]
+      },
+      execute: /* @__PURE__ */ __name(async (input) => {
+        const rawUrls = Array.isArray(input.urls) ? input.urls.filter((url) => typeof url === "string") : [];
+        const urls = rawUrls.slice(0, 5);
+        if (urls.length === 0)
+          return { error: "web_extract requires at least one URL", results: [] };
+        const maxLength = clampNumber(input.max_length, 8e3, 1, 1e5);
+        const startIndex = clampNumber(input.start_index, 0, 0, Number.MAX_SAFE_INTEGER);
+        const allowPrivate = input.allow_private === true;
+        const format2 = input.format === "text" ? "text" : "markdown";
+        const results = await Promise.all(urls.map((url) => extractUrlContent(url, { maxLength, startIndex, allowPrivate, format: format2 })));
+        return {
+          results: results.map((result) => ({
+            url: result.url,
+            finalUrl: result.finalUrl,
+            title: result.title,
+            contentType: result.contentType,
+            format: format2,
+            content: result.content,
+            contentLength: result.contentLength,
+            truncated: result.truncated,
+            startIndex: result.startIndex,
+            ...result.nextStartIndex !== void 0 && { nextStartIndex: result.nextStartIndex },
+            ...result.error && { error: result.error }
+          })),
+          count: results.length,
+          ...rawUrls.length > urls.length && { warning: `Only the first ${urls.length} URLs were extracted (max 5 per call).` },
+          ...input.use_llm_processing === true && { llmProcessing: "unavailable: deterministic extraction only in this build" }
+        };
       }, "execute")
     },
     // ─── Sleep tool ───
@@ -16083,7 +16721,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")
     },
@@ -16162,12 +16800,14 @@ function createShellTools(_config, hooks) {
                 signal: controller.signal
               });
               if (native && Array.isArray(native.results) && native.results.length > 0) {
+                const results = normalizeSearchResults(native.results, maxResults);
                 return {
                   query,
-                  resultCount: native.results.length,
-                  results: native.results,
+                  resultCount: results.length,
+                  results,
                   summary: native.summary,
                   provider: native.provider,
+                  backend: native.provider,
                   durationSeconds: native.durationSeconds
                 };
               }
@@ -16218,11 +16858,13 @@ function createShellTools(_config, hooks) {
               results = results.filter((r) => !blockedDomains.some((d) => urlMatchesDomain(r.url, d)));
             }
             if (results.length > 0) {
+              const normalizedResults = normalizeSearchResults(results, maxResults);
               return {
                 query,
-                resultCount: results.length,
-                results,
+                resultCount: normalizedResults.length,
+                results: normalizedResults,
                 provider: `duckduckgo-${ep.kind}`,
+                backend: `duckduckgo-${ep.kind}`,
                 ...nativeError ? { nativeSearchError: nativeError } : {}
               };
             }
@@ -16287,12 +16929,23 @@ var init_shell = __esm({
   "../openjaw-mcp/dist/tools/shell.js"() {
     "use strict";
     init_web_search_types();
+    init_url_safety();
     __name(truncateOutput, "truncateOutput");
     DECODE_ENTITIES = /* @__PURE__ */ __name((s) => s.replace(/&amp;/g, "&").replace(/&nbsp;/g, " ").replace(/&#x27;/g, "'").replace(/&quot;/g, '"').replace(/&lt;/g, "<").replace(/&gt;/g, ">"), "DECODE_ENTITIES");
     __name(parseLiteResults, "parseLiteResults");
     __name(parseHtmlResults, "parseHtmlResults");
     __name(isAnomalyPage, "isAnomalyPage");
     __name(urlMatchesDomain, "urlMatchesDomain");
+    __name(normalizeSearchResults, "normalizeSearchResults");
+    __name(clampNumber, "clampNumber");
+    __name(extractHtmlTitle, "extractHtmlTitle");
+    __name(cleanHtmlForMarkdown, "cleanHtmlForMarkdown");
+    __name(htmlToText, "htmlToText");
+    __name(isPdfLike, "isPdfLike");
+    __name(htmlToMarkdown, "htmlToMarkdown");
+    __name(paginateContent, "paginateContent");
+    __name(fetchWithValidatedRedirects, "fetchWithValidatedRedirects");
+    __name(extractUrlContent, "extractUrlContent");
     __name(createShellTools, "createShellTools");
   }
 });
@@ -17180,7 +17833,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));
       }
     };
   }
@@ -18861,7 +19514,7 @@ public class Win32Send {
         }
       }
       sleep(ms) {
-        return new Promise((resolve5) => setTimeout(resolve5, ms));
+        return new Promise((resolve6) => setTimeout(resolve6, ms));
       }
     };
   }
@@ -18926,7 +19579,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);
@@ -19667,6 +20320,7 @@ var init_categories = __esm({
       ["clipboard_", "system"],
       ["web_fetch", "system"],
       ["web_search", "system"],
+      ["web_extract", "system"],
       ["notify", "system"],
       ["sleep", "system"],
       ["ask_user", "system"],
@@ -20248,6 +20902,8 @@ function parseSkillFile(content, filename) {
         whenToUse: meta.whenToUse || meta.when_to_use,
         tools: Array.isArray(meta.tools) ? meta.tools : meta.tools ? parseYamlArray(meta.tools) : void 0,
         model: meta.model,
+        execution: meta.execution === "fork" ? "fork" : meta.execution === "inline" ? "inline" : void 0,
+        timeoutMs: typeof meta.timeoutMs === "number" ? meta.timeoutMs : typeof meta.timeout_ms === "number" ? meta.timeout_ms : void 0,
         version: meta.version,
         author: meta.author,
         platforms: Array.isArray(meta.platforms) ? meta.platforms : void 0,
@@ -20396,11 +21052,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);
   }
 }
@@ -20413,7 +21069,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;
@@ -20424,7 +21080,7 @@ function parseSkillAtPath(filePath, rootDir, entrypoint, source, fallbackFilenam
       name,
       meta: { ...parsed.meta, name },
       filePath,
-      rootDir,
+      rootDir: rootDir2,
       entrypoint,
       source,
       hasFrontmatter: parsed.hasFrontmatter
@@ -20527,8 +21183,10 @@ function getSkillsSection() {
   const content = `# Available Skills
 
 Use the \`invoke_skill\` tool to execute any skill listed below.
-When a skill matches the user's request, invoke it instead of doing the task manually.
-Skills run in an isolated context with their own conversation \u2014 they won't pollute your main conversation.
+Skills are for specialized, multi-step workflows that materially benefit from the skill's process.
+Do NOT invoke a skill for simple one-off questions, quick factual/current-info lookups, basic summaries, or tasks a visible built-in/MCP tool can answer in 1-2 calls.
+For news/latest/current events, use \`web_search\` directly. For selected URLs, use \`web_extract\` directly.
+When a skill truly matches a complex workflow, invoke it. Most skills load inline into the current turn so you can continue with visible tools. Only skills marked for fork execution run as isolated sub-agents and may take longer than ordinary tools.
 
 To create new skills or improve existing ones, use \`invoke_skill("skill-creator")\`.
 New skills must be saved to \`~/.openjaw-agent/skills/\` (user skills directory).
@@ -21079,12 +21737,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);
                   });
@@ -21682,7 +22340,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);
@@ -23737,7 +24395,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
@@ -23752,22 +24410,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);
@@ -24104,6 +24762,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" },
@@ -24136,6 +24795,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" },
@@ -25339,8 +26004,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;
 }
@@ -25458,34 +26123,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 = [];
@@ -25497,14 +26162,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) {
@@ -26005,13 +26670,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()}`,
@@ -26230,9 +26895,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
               });
@@ -26272,7 +26937,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()) {
@@ -26586,14 +27251,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);
                 });
@@ -26869,10 +27534,38 @@ __export(skill_tool_exports, {
   createSkillTool: () => createSkillTool
 });
 import { readFileSync as readFileSync23, writeFileSync as writeFileSync15 } from "node:fs";
+function resolveSkillTimeoutMs() {
+  const raw = process.env["OPENJAW_SKILL_TIMEOUT_MS"];
+  const parsed = raw ? Number(raw) : NaN;
+  if (Number.isFinite(parsed) && parsed > 0) {
+    return Math.min(Math.max(Math.floor(parsed), 1e4), 6e5);
+  }
+  return DEFAULT_SKILL_TIMEOUT_MS;
+}
+function resolveForkTimeoutMs(skill) {
+  const configured = skill.meta.timeoutMs;
+  if (typeof configured === "number" && Number.isFinite(configured) && configured > 0) {
+    return Math.min(Math.max(Math.floor(configured), 1e4), 6e5);
+  }
+  return resolveSkillTimeoutMs();
+}
+async function withTimeout(promise, ms) {
+  let timeoutId;
+  try {
+    return await Promise.race([
+      promise,
+      new Promise((resolve6) => {
+        timeoutId = setTimeout(() => resolve6(SKILL_TIMEOUT), ms);
+      })
+    ]);
+  } finally {
+    if (timeoutId) clearTimeout(timeoutId);
+  }
+}
 function createSkillTool(config, toolRegistry, systemPromptFn) {
   return {
     name: "invoke_skill",
-    description: "Execute a skill from the available skills list. Skills provide specialized multi-step workflows. Use this when the user's request matches a listed skill.",
+    description: "Execute a skill from the available skills list. Skills are for specialized multi-step workflows. Do not use for simple one-off lookups, quick current-news/factual questions, or tasks a direct built-in tool can answer in 1-2 calls.",
     parameters: {
       type: "object",
       properties: {
@@ -26883,6 +27576,11 @@ function createSkillTool(config, toolRegistry, systemPromptFn) {
         args: {
           type: "string",
           description: "Optional arguments or context for the skill"
+        },
+        mode: {
+          type: "string",
+          enum: ["inline", "fork"],
+          description: "Execution mode. Default inline loads instructions into this turn; fork runs an isolated sub-agent for skills that explicitly support long-running execution."
         }
       },
       required: ["skill"]
@@ -26890,6 +27588,7 @@ function createSkillTool(config, toolRegistry, systemPromptFn) {
     execute: /* @__PURE__ */ __name(async (input) => {
       const skillName = input.skill.trim().replace(/^\//, "");
       const args = input.args || "";
+      const requestedMode = input.mode === "fork" ? "fork" : input.mode === "inline" ? "inline" : void 0;
       const skill = findSkill(skillName);
       if (!skill) {
         clearSkillRegistry();
@@ -26897,17 +27596,39 @@ function createSkillTool(config, toolRegistry, systemPromptFn) {
         if (!retrySkill) {
           return { success: false, error: `Skill "${skillName}" not found. Check /skills for available skills.` };
         }
-        return await executeSkill(retrySkill.name, args, config, toolRegistry, systemPromptFn);
+        return await executeSkill(retrySkill, args, requestedMode, config, toolRegistry, systemPromptFn);
       }
-      return await executeSkill(skill.name, args, config, toolRegistry, systemPromptFn);
+      return await executeSkill(skill, args, requestedMode, config, toolRegistry, systemPromptFn);
     }, "execute")
   };
 }
-async function executeSkill(skillName, args, config, toolRegistry, systemPromptFn) {
+async function executeSkill(skill, args, requestedMode, config, toolRegistry, systemPromptFn) {
+  const skillName = skill.name;
   const body = loadSkillPrompt(skillName);
   if (!body) {
     return { success: false, error: `Could not load skill content for "${skillName}"` };
   }
+  const mode = requestedMode ?? skill.meta.execution ?? "inline";
+  if (mode === "fork") {
+    return await executeForkedSkill(skill, body, args, config, toolRegistry, systemPromptFn);
+  }
+  return loadInlineSkill(skill, body, args);
+}
+function loadInlineSkill(skill, body, args) {
+  const skillBlock = args ? `${body}
+
+# User instructions for this skill
+${args}` : body;
+  return {
+    success: true,
+    skill: skill.name,
+    mode: "inline",
+    message: "Skill instructions loaded inline. Continue the task in the current conversation using these instructions and visible tools.",
+    instructions: skillBlock
+  };
+}
+async function executeForkedSkill(skill, body, args, config, toolRegistry, systemPromptFn) {
+  const skillName = skill.name;
   const baseSections = await systemPromptFn();
   const staticSections = baseSections.slice(0, 4).filter(Boolean);
   const skillPrompt = [...staticSections, body].join("\n\n");
@@ -26917,7 +27638,34 @@ async function executeSkill(skillName, args, config, toolRegistry, systemPromptF
     let lastAnswer = "";
     let thinking = "";
     const allChunks = [];
-    for await (const chunk of forkLoop.run(userMessage, skillPrompt)) {
+    const timeoutMs = resolveForkTimeoutMs(skill);
+    const deadline = Date.now() + timeoutMs;
+    const iterator = forkLoop.run(userMessage, skillPrompt)[Symbol.asyncIterator]();
+    while (true) {
+      const remaining = deadline - Date.now();
+      if (remaining <= 0) {
+        forkLoop.abort();
+        return {
+          success: false,
+          skill: skillName,
+          timeoutMs,
+          error: `Skill "${skillName}" exceeded ${Math.round(timeoutMs / 1e3)}s. Use direct tools for simple requests, or rerun with narrower instructions.`,
+          partial: lastAnswer || thinking || void 0
+        };
+      }
+      const next = await withTimeout(iterator.next(), remaining);
+      if (next === SKILL_TIMEOUT) {
+        forkLoop.abort();
+        return {
+          success: false,
+          skill: skillName,
+          timeoutMs,
+          error: `Skill "${skillName}" exceeded ${Math.round(timeoutMs / 1e3)}s. Use direct tools for simple requests, or rerun with narrower instructions.`,
+          partial: lastAnswer || thinking || void 0
+        };
+      }
+      if (next.done) break;
+      const chunk = next.value;
       if (chunk.type === "answer" && chunk.content) lastAnswer = chunk.content;
       if (chunk.type === "thinking" && chunk.content) thinking += chunk.content;
       allChunks.push({ type: chunk.type, content: chunk.content });
@@ -26925,14 +27673,14 @@ async function executeSkill(skillName, args, config, toolRegistry, systemPromptF
     const result = lastAnswer || thinking || "Skill completed (no output)";
     const compressed = result.length > 2e3 ? result.slice(0, 2e3) + `
 ...(${result.length} chars total, truncated)` : result;
-    const skill = findSkill(skillName);
-    if (skill?.filePath && skill.source === "user") {
+    const currentSkill = findSkill(skillName);
+    if (currentSkill?.filePath && currentSkill.source === "user") {
       const lessons = extractLessons(allChunks);
       if (lessons) {
-        appendLessonsLearned(skill.filePath, lessons);
+        appendLessonsLearned(currentSkill.filePath, lessons);
       }
     }
-    return { success: true, skill: skillName, result: compressed };
+    return { success: true, skill: skillName, mode: "fork", result: compressed };
   } catch (err) {
     return { success: false, skill: skillName, error: err instanceof Error ? err.message : String(err) };
   }
@@ -26973,13 +27721,21 @@ function appendLessonsLearned(skillPath, lessons) {
   } catch {
   }
 }
+var DEFAULT_SKILL_TIMEOUT_MS, SKILL_TIMEOUT;
 var init_skill_tool = __esm({
   "src/tools/skill-tool.ts"() {
     "use strict";
     init_agent_loop();
     init_registry2();
+    DEFAULT_SKILL_TIMEOUT_MS = 12e4;
+    SKILL_TIMEOUT = /* @__PURE__ */ Symbol("skill-timeout");
+    __name(resolveSkillTimeoutMs, "resolveSkillTimeoutMs");
+    __name(resolveForkTimeoutMs, "resolveForkTimeoutMs");
+    __name(withTimeout, "withTimeout");
     __name(createSkillTool, "createSkillTool");
     __name(executeSkill, "executeSkill");
+    __name(loadInlineSkill, "loadInlineSkill");
+    __name(executeForkedSkill, "executeForkedSkill");
     __name(extractLessons, "extractLessons");
     __name(appendLessonsLearned, "appendLessonsLearned");
   }
@@ -27409,12 +28165,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);
                 });
@@ -27832,13 +28588,13 @@ var init_feishu = __esm({
                 if (stat2.isFile() && stat2.size < 30 * 1024 * 1024) {
                   const fileType = this.getFeishuFileType(fileName);
                   this.emit({ type: "system", content: `\u{1F4E4} Uploading to Feishu: ${fileName} (${(stat2.size / 1024).toFixed(0)}KB, type=${fileType})` });
-                  const withTimeout = /* @__PURE__ */ __name((promise, ms, label) => Promise.race([
+                  const withTimeout2 = /* @__PURE__ */ __name((promise, ms, label) => Promise.race([
                     promise,
                     new Promise((_, reject) => setTimeout(() => reject(new Error(`${label} timed out after ${ms / 1e3}s`)), ms))
                   ]), "withTimeout");
                   const { createReadStream: crs } = await import("node:fs");
                   const t0 = Date.now();
-                  const uploadResp = await withTimeout(
+                  const uploadResp = await withTimeout2(
                     this.client.im.file.create({
                       data: {
                         file_type: fileType,
@@ -27856,7 +28612,7 @@ var init_feishu = __esm({
                   this.emit({ type: "system", content: `\u{1F4E4} Upload done in ${(uploadMs / 1e3).toFixed(1)}s: code=${respCode}, file_key=${fileKey ? "\u2713" : "\u2717"}` });
                   if (fileKey) {
                     const t1 = Date.now();
-                    const sendResp = await withTimeout(
+                    const sendResp = await withTimeout2(
                       this.client.im.message.create({
                         params: { receive_id_type: "chat_id" },
                         data: {
@@ -27898,12 +28654,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);
         });
@@ -28194,9 +28950,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);
             }
@@ -28462,12 +29218,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);
                 });
@@ -29968,8 +30724,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");
@@ -30949,11 +31705,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,
@@ -30976,13 +31732,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);
@@ -31014,7 +31770,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;
   }
@@ -31024,7 +31780,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}`;
@@ -32460,7 +33216,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 };
   }
@@ -32505,7 +33261,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 = {}) {
@@ -35955,8 +36711,8 @@ function setTerminalFocused(v) {
     cb();
   }
   if (!v) {
-    for (const resolve5 of resolvers) {
-      resolve5();
+    for (const resolve6 of resolvers) {
+      resolve6();
     }
     resolvers.clear();
   }
@@ -42194,11 +42950,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);
         });
@@ -42213,8 +42969,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);
         });
       }
@@ -44694,8 +45450,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;
@@ -45186,10 +45942,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) {
@@ -45248,8 +46004,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(),
@@ -45406,12 +46162,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,
@@ -45606,6 +46362,7 @@ var init_overlayStore = __esm({
     buildOverlayState = /* @__PURE__ */ __name(() => ({
       agents: false,
       agentsInitialHistoryIndex: 0,
+      agentsWorkflowId: null,
       approval: null,
       clarify: null,
       confirm: null,
@@ -45628,6 +46385,7 @@ var init_overlayStore = __esm({
       ...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,
@@ -46427,13 +47185,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) => {
@@ -46473,6 +47243,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");
@@ -46494,6 +47272,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")
@@ -46587,6 +47369,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",
@@ -46719,7 +47565,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"() {
@@ -46730,10 +47576,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;
@@ -46759,7 +47605,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"}`;
@@ -46802,8 +47648,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");
@@ -47113,15 +47959,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`);
           }
@@ -47994,76 +48840,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")
       }
     ];
   }
@@ -48219,17 +49009,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) => {
@@ -48248,7 +49877,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"
     });
@@ -48257,7 +49886,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 {
@@ -48605,12 +50234,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()}`,
@@ -48623,7 +50252,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", () => {
@@ -48640,8 +50269,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 };
@@ -48666,26 +50295,14 @@ ${helpMessage}` : field.label;
     bus.log("info", `session.steer ${String(params.text ?? "").slice(0, 200)}`);
     return { status: "queued", text: String(params.text ?? "") };
   });
-  let pendingImageSeq = 0;
   let pendingImage = null;
-  const nextImageAttachmentId = /* @__PURE__ */ __name(() => `img-${Date.now().toString(36)}-${++pendingImageSeq}`, "nextImageAttachmentId");
   bus.registerRpc("prompt.submit", async (params) => {
     const text = String(params.text ?? "");
     if (!text) return { ok: false };
     const systemPromptArr = await systemPromptFn();
     const systemPrompt = systemPromptArr.join("\n\n");
-    const requestedImageId = String(params.image_attachment_id ?? "");
-    const imageForSubmit = pendingImage && (!requestedImageId || pendingImage.attachmentId === requestedImageId) ? pendingImage : null;
-    if (imageForSubmit) {
-      const modelInfo = agentLoop.getActiveModelMetadata() ?? await agentLoop.listModels().then(() => agentLoop.getActiveModelMetadata()).catch(() => void 0);
-      if (modelInfo?.supportsVision === false) {
-        throw new Error(`model ${agentLoop.model} does not support image input; switch to a vision-capable model before submitting an image`);
-      }
-    }
-    const imageData = imageForSubmit ? { base64: imageForSubmit.base64, mimeType: imageForSubmit.mimeType } : void 0;
-    if (imageForSubmit) {
-      pendingImage = null;
-    }
+    const imageData = pendingImage ? { base64: pendingImage.base64, mimeType: pendingImage.mimeType } : void 0;
+    pendingImage = null;
     currentRun = { abort: /* @__PURE__ */ __name(() => agentLoop.abort(), "abort") };
     void streamAgentRun({ agentLoop, bus, systemPrompt, text, imageData }).finally(() => {
       currentRun = null;
@@ -48726,11 +50343,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;
@@ -48753,40 +50370,14 @@ ${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 });
       });
     });
   });
   bus.registerRpc("clipboard.paste", async () => {
-    try {
-      if (clipboardHasImage()) {
-        const img = readClipboardImage();
-        if (img) {
-          const attachmentId = nextImageAttachmentId();
-          pendingImage = {
-            attachmentId,
-            base64: img.base64,
-            mimeType: img.mimeType,
-            name: "clipboard.png"
-          };
-          const byteLength = Math.ceil(img.base64.length * 3 / 4);
-          const tokenEstimate = Math.max(1, Math.ceil(byteLength / 750));
-          return {
-            attached: true,
-            attachment_id: attachmentId,
-            count: 1,
-            height: img.height,
-            name: "clipboard.png",
-            token_estimate: tokenEstimate,
-            width: img.width
-          };
-        }
-      }
-    } catch {
-    }
     try {
       const text = await readClipboardText();
       return { attached: false, message: text ?? "" };
@@ -48904,7 +50495,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);
@@ -49068,7 +50659,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();
@@ -49128,6 +50719,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();
@@ -49398,43 +51015,33 @@ ${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)}`);
     }
     const ext = extname4(path3).toLowerCase().replace(/^\./, "");
     const mimeType = ext === "png" ? "image/png" : ext === "jpg" || ext === "jpeg" ? "image/jpeg" : ext === "gif" ? "image/gif" : ext === "webp" ? "image/webp" : "image/png";
-    const attachmentId = nextImageAttachmentId();
     pendingImage = {
-      attachmentId,
       base64: buffer.toString("base64"),
       mimeType,
-      name: basename3(path3)
+      name: basename4(path3)
     };
     const tokenEstimate = Math.max(1, Math.ceil(buffer.byteLength / 750));
     return {
-      attachment_id: attachmentId,
       height: 0,
-      name: basename3(path3),
+      name: basename4(path3),
       remainder,
       token_estimate: tokenEstimate,
       width: 0
     };
   });
-  bus.registerRpc("image.clear", (params) => {
-    const attachmentId = String(params.attachment_id ?? "");
-    if (!attachmentId || pendingImage?.attachmentId === attachmentId) {
-      pendingImage = null;
-    }
-    return { ok: true };
-  });
   bus.registerRpc("process.stop", () => {
     const wasRunning = agentLoop.isRunning;
     agentLoop.abort();
@@ -49460,13 +51067,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;
@@ -49506,8 +51113,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();
@@ -49591,9 +51215,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),
@@ -49634,7 +51268,6 @@ var init_rpcHandlers = __esm({
     init_uiStore();
     init_catalog();
     init_clipboard();
-    init_clipboard_image();
     init_models_static();
     init_providers();
     init_types();
@@ -49642,6 +51275,8 @@ var init_rpcHandlers = __esm({
     init_registry2();
     init_usage();
     init_usageSnapshot();
+    init_manager();
+    init_persistence();
     init_registry3();
     PROVIDERS2 = ["anthropic", "openai", "github-copilot"];
     PROVIDER_LABELS = {
@@ -49827,8 +51462,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;
@@ -49851,9 +51486,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;
@@ -50011,14 +51646,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) {
@@ -50808,7 +52443,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;
@@ -50913,13 +52548,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"
       }
@@ -51222,7 +52857,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({
@@ -51246,7 +52881,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(
@@ -51846,7 +53481,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,
@@ -51860,6 +53497,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);
@@ -51946,7 +53586,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) {
@@ -52293,6 +53933,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;
@@ -52327,7 +53987,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";
@@ -52342,6 +54002,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({
@@ -52359,10 +54020,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");
   }
 });
@@ -52506,12 +54167,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");
   }
@@ -52672,21 +54333,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) {
@@ -52717,8 +54378,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");
@@ -52734,8 +54395,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");
@@ -52829,7 +54490,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"() {
@@ -52852,7 +54513,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");
   }
@@ -52860,9 +54521,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) {
@@ -52896,7 +54557,6 @@ function useComposerState({
 }) {
   const [input, setInput] = useState12("");
   const [inputBuf, setInputBuf] = useState12([]);
-  const [attachedImage, setAttachedImage] = useState12(null);
   const [pasteSnips, setPasteSnips] = useState12([]);
   const isBlocked = useStore($isBlocked);
   const { querier } = use_stdin_default();
@@ -52914,25 +54574,14 @@ function useComposerState({
   } = useQueue();
   const { historyRef, historyIdx, setHistoryIdx, historyDraftRef, pushHistory } = useInputHistory();
   const { completions, compIdx, setCompIdx, compReplace } = useCompletion(input, isBlocked, gw);
-  const clearAttachedImage = useCallback7(() => {
-    const attachmentId = attachedImage?.attachment_id;
-    setAttachedImage(null);
-    if (attachmentId) {
-      void gw.request("image.clear", { attachment_id: attachmentId }).catch(() => {
-      });
-    }
-  }, [attachedImage?.attachment_id, gw]);
-  const clearIn = useCallback7((options = {}) => {
+  const clearIn = useCallback7(() => {
     setInput("");
     setInputBuf([]);
     setPasteSnips([]);
-    if (!options.keepAttachedImage) {
-      clearAttachedImage();
-    }
     setQueueEdit(null);
     setHistoryIdx(null);
     historyDraftRef.current = "";
-  }, [clearAttachedImage, historyDraftRef, setQueueEdit, setHistoryIdx]);
+  }, [historyDraftRef, setQueueEdit, setHistoryIdx]);
   const handleResolvedPaste = useCallback7(
     async ({
       bracketed,
@@ -52955,13 +54604,6 @@ function useComposerState({
             session_id: sid
           });
           if (attached?.name) {
-            setAttachedImage({
-              attachment_id: attached.attachment_id,
-              height: attached.height,
-              name: attached.name,
-              token_estimate: attached.token_estimate,
-              width: attached.width
-            });
             onImageAttached?.(attached);
             const remainder = attached.remainder?.trim() ?? "";
             if (!remainder) {
@@ -53014,7 +54656,7 @@ function useComposerState({
     }) => {
       if (hotkey) {
         const preferOsc52 = isRemoteShellSession(process.env);
-        const readPreferredText = /* @__PURE__ */ __name(() => preferOsc52 ? readOsc52Clipboard(querier).then(async (osc52Text) => {
+        const readPreferredText = preferOsc52 ? readOsc52Clipboard(querier).then(async (osc52Text) => {
           if (isUsableClipboardText(osc52Text)) {
             return osc52Text;
           }
@@ -53024,12 +54666,8 @@ function useComposerState({
             return clipText;
           }
           return readOsc52Clipboard(querier);
-        }), "readPreferredText");
-        return Promise.resolve(onClipboardPaste(true)).then(async (imageAttached) => {
-          if (imageAttached) {
-            return null;
-          }
-          const preferredText = await readPreferredText();
+        });
+        return readPreferredText.then(async (preferredText) => {
           if (isUsableClipboardText(preferredText)) {
             return handleResolvedPaste({ bracketed: false, cursor, text: preferredText, value });
           }
@@ -53042,10 +54680,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;
@@ -53054,7 +54692,7 @@ function useComposerState({
       if (exitCode !== 0) {
         return;
       }
-      const text = readFileSync30(file2, "utf8").trimEnd();
+      const text = readFileSync31(file2, "utf8").trimEnd();
       if (!text) {
         return;
       }
@@ -53067,7 +54705,6 @@ function useComposerState({
   }, [input, inputBuf, submitRef]);
   const actions = useMemo6(
     () => ({
-      clearAttachedImage,
       clearIn,
       dequeue,
       enqueue,
@@ -53078,7 +54715,6 @@ function useComposerState({
       replaceQueue: replaceQ,
       setCompIdx,
       setHistoryIdx,
-      setAttachedImage,
       setInput,
       setInputBuf,
       setPasteSnips,
@@ -53086,7 +54722,6 @@ function useComposerState({
       syncQueue
     }),
     [
-      clearAttachedImage,
       clearIn,
       dequeue,
       enqueue,
@@ -53113,7 +54748,6 @@ function useComposerState({
   );
   const state = useMemo6(
     () => ({
-      attachedImage,
       compIdx,
       compReplace,
       completions,
@@ -53124,7 +54758,7 @@ function useComposerState({
       queueEditIdx,
       queuedDisplay
     }),
-    [attachedImage, compIdx, compReplace, completions, historyIdx, input, inputBuf, pasteSnips, queueEditIdx, queuedDisplay]
+    [compIdx, compReplace, completions, historyIdx, input, inputBuf, pasteSnips, queueEditIdx, queuedDisplay]
   );
   return {
     actions,
@@ -53476,11 +55110,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());
@@ -53495,13 +55129,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) {
@@ -53700,7 +55334,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);
     }
@@ -53710,12 +55344,9 @@ 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 && cState.attachedImage) {
-      return cActions.clearAttachedImage();
-    }
     if (key.escape && live.focusedPane === "transcript") {
       patchUiState({ focusedPane: "composer" });
       return;
@@ -53739,7 +55370,7 @@ function useInputHandlers(ctx) {
       }
     }
     if (isCopyShortcut(key, ch)) {
-      if (terminal.hasSelection) {
+      if (terminal2.hasSelection) {
         return copySelection();
       }
       const inputSel = getInputSelection();
@@ -53764,7 +55395,7 @@ function useInputHandlers(ctx) {
           sys: actions.sys
         });
       }
-      if (cState.input || cState.inputBuf.length || cState.attachedImage) {
+      if (cState.input || cState.inputBuf.length) {
         return cActions.clearIn();
       }
       return actions.die();
@@ -53774,7 +55405,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)) {
@@ -53924,7 +55555,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 {
@@ -53954,7 +55585,6 @@ function useSessionLifecycle(opts) {
     setHistoryItems([]);
     setLastUserMsg("");
     setStickyPrompt("");
-    composerActions.clearAttachedImage();
     composerActions.setPasteSnips([]);
     evictInkCaches("half");
   }, [composerActions, setHistoryItems, setLastUserMsg, setStickyPrompt, setVoiceProcessing, setVoiceRecording]);
@@ -53967,7 +55597,6 @@ function useSessionLifecycle(opts) {
       setHistoryItems(info ? [introMsg(info)] : []);
       setStickyPrompt("");
       setLastUserMsg("");
-      composerActions.clearAttachedImage();
       composerActions.setPasteSnips([]);
       patchTurnState({ activity: [] });
       patchUiState({ info, usage: usageFrom(info) });
@@ -54109,7 +55738,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");
@@ -54198,7 +55827,6 @@ function useSubmission(opts) {
       const expand = expandSnips(composerState.pasteSnips);
       const startSubmit = /* @__PURE__ */ __name((displayText, submitText, showUserMessage2 = true) => {
         const sid2 = getUiState().sid;
-        const imageAttachment = composerState.attachedImage;
         if (!sid2) {
           return sys("session not ready yet");
         }
@@ -54211,20 +55839,7 @@ function useSubmission(opts) {
         patchUiState({ busy: true, status: "running\u2026" });
         turnController.bufRef = "";
         turnController.interrupted = false;
-        const submitParams = { session_id: sid2, text: submitText };
-        if (imageAttachment?.attachment_id) {
-          submitParams.image_attachment_id = imageAttachment.attachment_id;
-        }
-        if (imageAttachment) {
-          composerActions.setAttachedImage(null);
-        }
-        gw.request("prompt.submit", submitParams).catch((e) => {
-          if (imageAttachment) {
-            composerActions.setAttachedImage(imageAttachment);
-            sys(`error: ${e.message}`);
-            patchUiState({ busy: false, status: "ready" });
-            return;
-          }
+        gw.request("prompt.submit", { session_id: sid2, text: submitText }).catch((e) => {
           if (isSessionBusyError(e)) {
             composerActions.enqueue(submitText);
             patchUiState({ busy: true, status: "queued for next turn" });
@@ -54250,7 +55865,7 @@ function useSubmission(opts) {
         startSubmit(r.text || text, expand(r.text || text), showUserMessage);
       }).catch(() => startSubmit(text, expand(text), showUserMessage));
     },
-    [appendMessage, composerActions, composerState.attachedImage, composerState.pasteSnips, gw, maybeGoodVibes, setLastUserMsg, sys]
+    [appendMessage, composerActions, composerState.pasteSnips, gw, maybeGoodVibes, setLastUserMsg, sys]
   );
   const shellExec = useCallback9(
     (cmd) => {
@@ -54313,16 +55928,6 @@ function useSubmission(opts) {
         }
         sys(note);
       }, "fallback");
-      if (composerState.attachedImage) {
-        if (live.sid) {
-          turnController.interruptTurn({ appendMessage, gw, sid: live.sid, sys });
-        }
-        if (hasInterpolation(full)) {
-          patchUiState({ busy: true });
-          return interpolate(full, send);
-        }
-        return send(full);
-      }
       if (mode === "queue") {
         return composerActions.enqueue(full);
       }
@@ -54344,7 +55949,7 @@ function useSubmission(opts) {
       }
       send(full);
     },
-    [appendMessage, composerActions, composerRefs, composerState.attachedImage, gw, interpolate, send, sys]
+    [appendMessage, composerActions, composerRefs, gw, interpolate, send, sys]
   );
   const dispatchSubmission = useCallback9(
     (full) => {
@@ -54369,8 +55974,8 @@ function useSubmission(opts) {
         return;
       }
       const editIdx = composerRefs.queueEditRef.current;
+      composerActions.clearIn();
       if (editIdx !== null) {
-        composerActions.clearIn();
         composerActions.replaceQueue(editIdx, full);
         const picked = composerRefs.queueRef.current.splice(editIdx, 1)[0];
         composerActions.syncQueue();
@@ -54387,7 +55992,6 @@ function useSubmission(opts) {
         }
         return sendQueued(picked);
       }
-      composerActions.clearIn({ keepAttachedImage: !!composerState.attachedImage });
       composerActions.pushHistory(full);
       if (getUiState().busy) {
         return handleBusyInput(full);
@@ -54398,7 +56002,7 @@ function useSubmission(opts) {
       }
       send(full);
     },
-    [appendMessage, composerActions, composerRefs, composerState.attachedImage, handleBusyInput, interpolate, send, sendQueued, shellExec, slashRef]
+    [appendMessage, composerActions, composerRefs, handleBusyInput, interpolate, send, sendQueued, shellExec, slashRef]
   );
   const submit = useCallback9(
     (value) => {
@@ -54516,7 +56120,8 @@ function useMainApp(gw) {
   const scrollRef = useRef13(null);
   const onEventRef = useRef13(() => {
   });
-  const clipboardPasteRef = useRef13(() => false);
+  const clipboardPasteRef = useRef13(() => {
+  });
   const submitRef = useRef13(() => {
   });
   const terminalHintsShownRef = useRef13(/* @__PURE__ */ new Set());
@@ -54569,7 +56174,9 @@ function useMainApp(gw) {
   const composer = useComposerState({
     gw,
     onClipboardPaste: /* @__PURE__ */ __name((quiet) => clipboardPasteRef.current(quiet), "onClipboardPaste"),
-    onImageAttached: /* @__PURE__ */ __name(() => patchUiState({ status: "image attached" }), "onImageAttached"),
+    onImageAttached: /* @__PURE__ */ __name((info) => {
+      sys(attachedImageNotice(info));
+    }, "onImageAttached"),
     submitRef
   });
   const { actions: composerActions, refs: composerRefs, state: composerState } = composer;
@@ -54777,25 +56384,17 @@ function useMainApp(gw) {
   const paste2 = useCallback10(
     (quiet = false) => rpc("clipboard.paste", { session_id: getUiState().sid }).then((r) => {
       if (!r) {
-        return false;
+        return;
       }
       if (r.attached) {
-        composerActions.setAttachedImage({
-          attachment_id: r.attachment_id,
-          height: r.height,
-          name: r.name ?? `Image #${r.count ?? 1}`,
-          token_estimate: r.token_estimate,
-          width: r.width
-        });
-        patchUiState({ status: "image attached" });
-        return true;
+        const meta = imageTokenMeta(r);
+        return sys(`\u{1F4CE} Image #${r.count} attached from clipboard${meta ? ` \xB7 ${meta}` : ""}`);
       }
       if (!quiet) {
         sys(r.message || "No image found in clipboard");
       }
-      return false;
     }),
-    [composerActions, rpc, sys]
+    [rpc, sys]
   );
   clipboardPasteRef.current = paste2;
   const { dispatchSubmission, send, sendQueued, submit } = useSubmission({
@@ -54996,8 +56595,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"
@@ -55035,7 +56639,6 @@ function useMainApp(gw) {
       cols,
       compIdx: composerState.compIdx,
       completions: composerState.completions,
-      attachedImage: composerState.attachedImage,
       empty,
       handleTextPaste: composerActions.handleTextPaste,
       input: composerState.input,
@@ -55092,6 +56695,7 @@ var init_useMainApp = __esm({
     init_env();
     init_limits();
     init_details();
+    init_messages();
     init_paths();
     init_useGitBranch();
     init_useVirtualHistory();
@@ -55169,9 +56773,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 }) {
@@ -55187,13 +56791,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 {
         }
       }
@@ -55446,6 +57050,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})` }),
@@ -55520,7 +57128,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({
@@ -55620,12 +57229,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)))
   );
@@ -55637,9 +57257,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]);
@@ -55808,7 +57428,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) {
@@ -55822,7 +57442,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,
@@ -55868,6 +57488,7 @@ var init_agentsOverlay = __esm({
     init_overlayStore();
     init_spawnHistoryStore();
     init_turnStore();
+    init_workflowStore();
     init_rpc();
     init_subagentTree();
     init_text();
@@ -57796,7 +59417,7 @@ function ModelPicker2({ gw, mode = "switch", onCancel, onSelect, sessionId, t })
           refreshProviders();
         }
         if (mode === "connect") {
-          onCancel();
+          onSelect("__openjaw_connect_complete__");
           return;
         }
         setStage("model");
@@ -57892,7 +59513,7 @@ function ModelPicker2({ gw, mode = "switch", onCancel, onSelect, sessionId, t })
           setKeyInput("");
           setKeySaving(false);
           if (mode === "connect") {
-            onCancel();
+            onSelect("__openjaw_connect_complete__");
             return;
           }
           setStage("model");
@@ -57931,7 +59552,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
               )
             );
           }
@@ -57979,7 +59600,7 @@ function ModelPicker2({ gw, mode = "switch", onCancel, onSelect, sessionId, t })
           return;
         }
         if (mode === "connect") {
-          onCancel();
+          onSelect("__openjaw_connect_complete__");
           return;
         }
         setStage("model");
@@ -58067,7 +59688,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,
@@ -59263,14 +60884,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) => {
@@ -59544,7 +61165,7 @@ var init_emoji = __esm({
 });
 
 // src/lib/externalLink.ts
-import { isIP } from "node:net";
+import { isIP as isIP2 } from "node:net";
 import { useEffect as useEffect21, useMemo as useMemo13, useState as useState25 } from "react";
 function normalizeExternalUrl(value) {
   const trimmed = value.trim();
@@ -59650,13 +61271,13 @@ function isPrivateIpv6(value) {
   }
   return false;
 }
-function normalizeHostname(value) {
+function normalizeHostname2(value) {
   const withoutBrackets = value.replace(/^\[/, "").replace(/\]$/, "");
   const withoutZoneId = withoutBrackets.split("%", 1)[0];
   return withoutZoneId.replace(/\.$/, "").toLowerCase();
 }
 function isPrivateOrLocalHost(hostname) {
-  const normalized = normalizeHostname(hostname);
+  const normalized = normalizeHostname2(hostname);
   if (!normalized) {
     return true;
   }
@@ -59666,7 +61287,7 @@ function isPrivateOrLocalHost(hostname) {
   if (LOCAL_HOST_SUFFIXES.some((suffix) => normalized.endsWith(suffix))) {
     return true;
   }
-  const ipVersion = isIP(normalized);
+  const ipVersion = isIP2(normalized);
   if (ipVersion === 4) {
     return isPrivateIpv4(normalized);
   }
@@ -59850,7 +61471,7 @@ var init_externalLink = __esm({
     __name(parseIpv4Octets, "parseIpv4Octets");
     __name(isPrivateIpv4, "isPrivateIpv4");
     __name(isPrivateIpv6, "isPrivateIpv6");
-    __name(normalizeHostname, "normalizeHostname");
+    __name(normalizeHostname2, "normalizeHostname");
     __name(isPrivateOrLocalHost, "isPrivateOrLocalHost");
     __name(isTitleFetchable, "isTitleFetchable");
     __name(decodeHtmlEntities, "decodeHtmlEntities");
@@ -60434,7 +62055,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]];
   }
@@ -60466,7 +62087,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";
@@ -60520,8 +62141,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");
   }
@@ -62396,7 +64017,6 @@ var init_appLayout = __esm({
     init_env();
     init_limits();
     init_placeholders();
-    init_messages();
     init_inputMetrics();
     init_perfPane();
     init_agentsOverlay();
@@ -62516,7 +64136,6 @@ var init_appLayout = __esm({
       const inputColumns = stableComposerColumns(composer.cols, promptWidth);
       const inputHeight = inputVisualHeight(composer.input, inputColumns);
       const inputMouseRef = useRef19(null);
-      const attachedImageMeta = composer.attachedImage ? imageTokenMeta(composer.attachedImage) : "";
       const captureInputDrag = /* @__PURE__ */ __name((e) => {
         if (e.button !== 0) {
           return;
@@ -62587,12 +64206,6 @@ var init_appLayout = __esm({
               ),
               composer.input === "?" && !composer.inputBuf.length && /* @__PURE__ */ jsx41(HelpHint, { t: ui.theme }),
               !isBlocked && /* @__PURE__ */ jsxs28(Fragment11, { children: [
-                composer.attachedImage && /* @__PURE__ */ jsx41(Box_default, { width: Math.max(1, composer.cols - 2), children: /* @__PURE__ */ jsxs28(Text9, { color: ui.theme.color.systemNote, wrap: "truncate-end", children: [
-                  "\u{1F4CE} ",
-                  composer.attachedImage.name,
-                  attachedImageMeta ? ` \xB7 ${attachedImageMeta}` : "",
-                  /* @__PURE__ */ jsx41(Text9, { color: ui.theme.color.muted, children: " \xB7 Esc to remove" })
-                ] }) }),
                 composer.inputBuf.map((line, i) => /* @__PURE__ */ jsxs28(Box_default, { children: [
                   /* @__PURE__ */ jsx41(Box_default, { width: promptWidth, children: i === 0 ? /* @__PURE__ */ jsx41(PromptPrefix, { color: ui.theme.color.muted, promptText, width: promptWidth }) : /* @__PURE__ */ jsx41(Text9, { color: ui.theme.color.muted, children: promptBlank }) }),
                   /* @__PURE__ */ jsx41(Text9, { color: ui.theme.color.composeText, children: line || " " })
@@ -62653,8 +64266,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"));