@charzhu/openjaw-agent 0.2.8 → 0.3.0

package/dist/main.js

@@ -4005,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;
@@ -4031,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] }
@@ -5833,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");
@@ -5854,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;
       }
@@ -5900,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");
       }
       /**
@@ -5952,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") {
@@ -5970,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);
@@ -6102,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)}';
@@ -6186,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;
@@ -6620,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"
@@ -6644,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
         });
@@ -6651,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"
@@ -6674,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,
@@ -6685,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",
@@ -6729,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.",
@@ -6814,6 +7247,7 @@ var init_browse = __esm({
   "../openjaw-mcp/dist/tools/browse.js"() {
     "use strict";
     init_browser();
+    init_url_safety();
     __name(createBrowseTools, "createBrowseTools");
   }
 });
@@ -15745,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 [
     {
@@ -16011,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 ───
@@ -16157,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
                 };
               }
@@ -16213,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 } : {}
               };
             }
@@ -16282,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");
   }
 });
@@ -19662,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"],
@@ -20243,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,
@@ -20522,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).
@@ -26864,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: {
@@ -26878,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"]
@@ -26885,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();
@@ -26892,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");
@@ -26912,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 });
@@ -26920,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) };
   }
@@ -26968,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");
   }
@@ -27827,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,
@@ -27851,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: {
@@ -59428,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();
@@ -59534,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;
   }
@@ -59550,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);
   }
@@ -59734,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");