@charzhu/openjaw-agent 0.2.9 → 0.3.0

package/dist/main.js

@@ -2393,9 +2393,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);
         }
@@ -4008,7 +4005,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 +4031,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 +5091,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 {
@@ -5838,18 +5833,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 +5971,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 +6021,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,13 +6075,71 @@ 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") {
@@ -5975,15 +6151,23 @@ var init_browser = __esm({
         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 +6291,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 +6379,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;
@@ -6625,18 +6948,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 +7002,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 +7011,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 +7042,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 +7055,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 +7117,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: join47 } = await import("node:path");
+        const { tmpdir: tmpdir13 } = await import("node:os");
+        const { randomUUID: randomUUID14 } = await import("node:crypto");
+        const screenshotPath = join47(tmpdir13(), `openjaw-browser-${randomUUID14().slice(0, 8)}.png`);
+        const 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 +7247,7 @@ var init_browse = __esm({
   "../openjaw-mcp/dist/tools/browse.js"() {
     "use strict";
     init_browser();
+    init_url_safety();
     __name(createBrowseTools, "createBrowseTools");
   }
 });
@@ -15750,6 +16179,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 [
     {
@@ -16016,58 +16614,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 ───
@@ -16162,12 +16788,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 +16846,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 +16917,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");
   }
 });
@@ -19667,6 +20308,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 +20890,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,
@@ -20527,8 +21171,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).
@@ -26869,10 +27515,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((resolve5) => {
+        timeoutId = setTimeout(() => resolve5(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 +27557,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 +27569,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 +27577,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 +27619,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 +27654,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 +27702,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");
   }
@@ -27832,13 +28569,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 +28593,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: {
@@ -48666,26 +49403,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;
@@ -48761,32 +49486,6 @@ ${helpMessage}` : field.label;
     });
   });
   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 ?? "" };
@@ -49411,16 +50110,13 @@ ${helpMessage}` : field.label;
     }
     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)
     };
     const tokenEstimate = Math.max(1, Math.ceil(buffer.byteLength / 750));
     return {
-      attachment_id: attachmentId,
       height: 0,
       name: basename3(path3),
       remainder,
@@ -49428,13 +50124,6 @@ ${helpMessage}` : field.label;
       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();
@@ -49634,7 +50323,6 @@ var init_rpcHandlers = __esm({
     init_uiStore();
     init_catalog();
     init_clipboard();
-    init_clipboard_image();
     init_models_static();
     init_providers();
     init_types();
@@ -52896,7 +53584,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 +53601,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 +53631,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 +53683,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 +53693,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 });
           }
@@ -53067,7 +53732,6 @@ function useComposerState({
   }, [input, inputBuf, submitRef]);
   const actions = useMemo6(
     () => ({
-      clearAttachedImage,
       clearIn,
       dequeue,
       enqueue,
@@ -53078,7 +53742,6 @@ function useComposerState({
       replaceQueue: replaceQ,
       setCompIdx,
       setHistoryIdx,
-      setAttachedImage,
       setInput,
       setInputBuf,
       setPasteSnips,
@@ -53086,7 +53749,6 @@ function useComposerState({
       syncQueue
     }),
     [
-      clearAttachedImage,
       clearIn,
       dequeue,
       enqueue,
@@ -53113,7 +53775,6 @@ function useComposerState({
   );
   const state = useMemo6(
     () => ({
-      attachedImage,
       compIdx,
       compReplace,
       completions,
@@ -53124,7 +53785,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,
@@ -53713,9 +54374,6 @@ function useInputHandlers(ctx) {
     if (key.escape && terminal.hasSelection) {
       return clearSelection2();
     }
-    if (key.escape && cState.attachedImage) {
-      return cActions.clearAttachedImage();
-    }
     if (key.escape && live.focusedPane === "transcript") {
       patchUiState({ focusedPane: "composer" });
       return;
@@ -53764,7 +54422,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();
@@ -53954,7 +54612,6 @@ function useSessionLifecycle(opts) {
     setHistoryItems([]);
     setLastUserMsg("");
     setStickyPrompt("");
-    composerActions.clearAttachedImage();
     composerActions.setPasteSnips([]);
     evictInkCaches("half");
   }, [composerActions, setHistoryItems, setLastUserMsg, setStickyPrompt, setVoiceProcessing, setVoiceRecording]);
@@ -53967,7 +54624,6 @@ function useSessionLifecycle(opts) {
       setHistoryItems(info ? [introMsg(info)] : []);
       setStickyPrompt("");
       setLastUserMsg("");
-      composerActions.clearAttachedImage();
       composerActions.setPasteSnips([]);
       patchTurnState({ activity: [] });
       patchUiState({ info, usage: usageFrom(info) });
@@ -54198,7 +54854,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 +54866,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 +54892,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 +54955,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 +54976,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 +55001,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 +55019,6 @@ function useSubmission(opts) {
         }
         return sendQueued(picked);
       }
-      composerActions.clearIn({ keepAttachedImage: !!composerState.attachedImage });
       composerActions.pushHistory(full);
       if (getUiState().busy) {
         return handleBusyInput(full);
@@ -54398,7 +55029,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 +55147,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 +55201,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 +55411,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({
@@ -55035,7 +55661,6 @@ function useMainApp(gw) {
       cols,
       compIdx: composerState.compIdx,
       completions: composerState.completions,
-      attachedImage: composerState.attachedImage,
       empty,
       handleTextPaste: composerActions.handleTextPaste,
       input: composerState.input,
@@ -55092,6 +55717,7 @@ var init_useMainApp = __esm({
     init_env();
     init_limits();
     init_details();
+    init_messages();
     init_paths();
     init_useGitBranch();
     init_useVirtualHistory();
@@ -59544,7 +60170,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 +60276,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 +60292,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 +60476,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");
@@ -62396,7 +63022,6 @@ var init_appLayout = __esm({
     init_env();
     init_limits();
     init_placeholders();
-    init_messages();
     init_inputMetrics();
     init_perfPane();
     init_agentsOverlay();
@@ -62516,7 +63141,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 +63211,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 || " " })