tarsk 0.5.40 → 0.5.42

package/dist/index.js

@@ -50,7 +50,7 @@ import { homedir } from "node:os";
 import { join } from "node:path";
 import { spawn, spawnSync, execSync } from "child_process";
 function delay(ms) {
-  return new Promise((resolve6) => setTimeout(resolve6, ms));
+  return new Promise((resolve7) => setTimeout(resolve7, ms));
 }
 function mergePath(parentPath, shellPath) {
   const parent = (parentPath ?? "").split(":").filter(Boolean);
@@ -1224,6 +1224,15 @@ function buildDefaultSystemPrompt(toolNames) {
   const toolList = toolNames.length > 0 ? toolNames.join(", ") : "read, bash, edit, and write";
   return `You are a helpful coding assistant. You have access to ${toolList} tools. Use them to explore and modify the codebase as needed. Skills are created and stored in .agents/skills/ . Use Mermaid for flowcharts, sequence diagrams, state diagrams, or graphs when appropriate. Do not use emojis.`;
 }
+function formatCurrentDateLine(referenceDate = /* @__PURE__ */ new Date()) {
+  const date = referenceDate.toLocaleDateString("en-US", {
+    weekday: "long",
+    year: "numeric",
+    month: "long",
+    day: "numeric"
+  });
+  return `The current date is ${date}.`;
+}
 
 // ../shared/dist/image-payload.js
 function isDataImageUrl(value) {
@@ -1287,6 +1296,7 @@ function parseGeneratedImagePayload(value) {
 function stripGeneratedImagePayload(payload) {
   const next = { ...payload };
   delete next.imageData;
+  delete next.image_data;
   if (typeof next.imageUrl === "string" && isDataImageUrl(next.imageUrl)) {
     delete next.imageUrl;
   }
@@ -1308,12 +1318,13 @@ function stripGeneratedImageText(text) {
     return text;
   }
 }
+var IMAGE_RESULT_TOOL_NAMES = /* @__PURE__ */ new Set(["generate_image", "find_images", "browser"]);
 function sanitizeToolResultBlock(block, collected) {
   if (block.type !== "tool-result") {
     return block;
   }
   const toolName = typeof block.toolName === "string" ? block.toolName : "";
-  if (toolName !== "generate_image") {
+  if (!IMAGE_RESULT_TOOL_NAMES.has(toolName)) {
     return block;
   }
   const blockRefs = parseGeneratedImagePayload(block);
@@ -1458,7 +1469,7 @@ function extractGeneratedImageFromEvents(events) {
       const parsed = JSON.parse(event.content.trim());
       const blocks = Array.isArray(parsed) ? parsed : [parsed];
       for (const block of blocks) {
-        if (block && typeof block === "object" && "type" in block && block.type === "tool-result" && block.toolName === "generate_image") {
+        if (block && typeof block === "object" && "type" in block && block.type === "tool-result" && IMAGE_RESULT_TOOL_NAMES.has(block.toolName)) {
           const refs = parseGeneratedImagePayload(block);
           if (refs?.imageUrl) {
             collected.imageUrl = refs.imageUrl;
@@ -1481,11 +1492,29 @@ function extractGeneratedImageFromEvents(events) {
   return collected;
 }
 
+// ../shared/dist/image-url.js
+function isAbsoluteHttpOrDataUrl(url) {
+  return !url || url.startsWith("data:") || /^https?:\/\//i.test(url);
+}
+function buildThreadExplorerMediaUrl(threadId, projectPath, origin = "http://localhost:641") {
+  const base = origin.replace(/\/$/, "");
+  return `${base}/api/threads/${encodeURIComponent(threadId)}/explorer/media?path=${encodeURIComponent(projectPath)}`;
+}
+function resolveAbsoluteImageUrl(imageUrl, baseUrl) {
+  if (isAbsoluteHttpOrDataUrl(imageUrl)) {
+    return imageUrl;
+  }
+  const origin = baseUrl.replace(/\/$/, "");
+  const path7 = imageUrl.startsWith("/") ? imageUrl : `/${imageUrl}`;
+  return `${origin}${path7}`;
+}
+
 // ../shared/dist/tool-display.js
 var toolDisplayRegistry = [
   { name: "agent", displayName: "Subagent", activeDisplayName: "Subagent" },
   { name: "ask_user", displayName: "Ask", activeDisplayName: "Asking" },
   { name: "bash", displayName: "Ran", activeDisplayName: "Running" },
+  { name: "browser", displayName: "Browser", activeDisplayName: "Browsing" },
   { name: "code_search", displayName: "Code Search", activeDisplayName: "Searching" },
   { name: "edit", displayName: "Edit", activeDisplayName: "Editing" },
   { name: "execute_skill_script", displayName: "Run Script", activeDisplayName: "Running Script" },
@@ -1506,6 +1535,11 @@ var toolDisplayRegistry = [
   { name: "simple_grep", displayName: "Search", activeDisplayName: "Searching" },
   { name: "todo", displayName: "Todo", activeDisplayName: "Updating" },
   { name: "tool_search", displayName: "Find Tools", activeDisplayName: "Finding Tools" },
+  {
+    name: "web_search",
+    displayName: "Web Search",
+    activeDisplayName: "Searching Web"
+  },
   { name: "write", displayName: "Write", activeDisplayName: "Writing" }
 ];
 var displayByName = new Map(toolDisplayRegistry.map((entry) => [entry.name, entry]));
@@ -1628,9 +1662,27 @@ function getExplorerFileMediaType(path7, name) {
   return null;
 }
 
+// ../shared/dist/browser-tool.js
+var BROWSER_HOST_ACTIONS = [
+  "reload",
+  "go_back",
+  "go_forward",
+  "get_state",
+  "set_viewport"
+];
+function isBrowserHostAction(action) {
+  return BROWSER_HOST_ACTIONS.includes(action);
+}
+
+// ../shared/dist/tmp-images.js
+var TARSK_TMP_IMAGES_DIR = ".tarsk/tmp-images";
+function buildTmpImagePath(filename) {
+  return `${TARSK_TMP_IMAGES_DIR}/${filename}`;
+}
+
 // src/server.ts
 import fs3 from "fs";
-import { Hono as Hono26 } from "hono";
+import { Hono as Hono27 } from "hono";
 import { cors } from "hono/cors";
 import open3 from "open";
 import path5 from "path";
@@ -2439,7 +2491,7 @@ var bashSchema = Type.Object({
 });
 var defaultBashOperations = {
   exec: (command, cwd, { onData, signal, timeout, env }) => {
-    return new Promise((resolve6, reject) => {
+    return new Promise((resolve7, reject) => {
       const { shell, args: args2 } = getShellConfig();
       if (!existsSync3(cwd)) {
         reject(new Error(`Working directory does not exist: ${cwd}`));
@@ -2488,7 +2540,7 @@ var defaultBashOperations = {
           reject(new Error(`timeout:${timeout}`));
           return;
         }
-        resolve6({ exitCode: code });
+        resolve7({ exitCode: code });
       });
     });
   }
@@ -2511,7 +2563,7 @@ ${command}` : command;
       if (shellPermissionGate) {
         await shellPermissionGate.ensureAllowed(toolCallId, resolvedCommand, "bash", signal);
       }
-      return new Promise((resolve6, reject) => {
+      return new Promise((resolve7, reject) => {
         let tempFilePath;
         let tempFileStream;
         let totalBytes = 0;
@@ -2580,7 +2632,7 @@ ${command}` : command;
 Command exited with code ${exitCode}`;
             reject(new Error(outputText));
           } else {
-            resolve6({ content: [{ type: "text", text: outputText }], details });
+            resolve7({ content: [{ type: "text", text: outputText }], details });
           }
         }).catch((err) => {
           tarskDebugLog(`[ai] bash-end: ${resolvedCommand}`);
@@ -2736,7 +2788,7 @@ function generateDiffString(oldContent, newContent, contextLines = 4) {
 
 // src/tools/tool-helpers.ts
 async function withAbortSignal(signal, operation) {
-  return new Promise((resolve6, reject) => {
+  return new Promise((resolve7, reject) => {
     if (signal?.aborted) {
       reject(new Error("Operation aborted"));
       return;
@@ -2755,7 +2807,7 @@ async function withAbortSignal(signal, operation) {
     const abortCheck = () => aborted;
     operation(abortCheck).then((result) => {
       cleanup();
-      if (!aborted) resolve6(result);
+      if (!aborted) resolve7(result);
     }).catch((error) => {
       cleanup();
       if (!aborted) reject(error);
@@ -2878,7 +2930,7 @@ function createFindTool(cwd, options) {
     description: `Search for files by glob pattern. Returns matching file paths relative to the search directory. Output truncated to ${DEFAULT_LIMIT} results or ${DEFAULT_MAX_BYTES / 1024}KB.`,
     parameters: findSchema,
     execute: async (_toolCallId, { pattern, path: searchDir, limit }, signal) => {
-      return new Promise((resolve6, reject) => {
+      return new Promise((resolve7, reject) => {
         if (signal?.aborted) {
           reject(new Error("Operation aborted"));
           return;
@@ -2911,7 +2963,7 @@ function createFindTool(cwd, options) {
             });
             signal?.removeEventListener("abort", onAbort);
             if (results.length === 0) {
-              resolve6({
+              resolve7({
                 content: [{ type: "text", text: "No files found matching pattern" }],
                 details: void 0
               });
@@ -2942,7 +2994,7 @@ function createFindTool(cwd, options) {
             if (notices.length > 0) resultOutput += `
 
 [${notices.join(". ")}]`;
-            resolve6({
+            resolve7({
               content: [{ type: "text", text: resultOutput }],
               details: Object.keys(details).length > 0 ? details : void 0
             });
@@ -2967,7 +3019,7 @@ import path2 from "path";
 // src/tools/resolve-bin.ts
 init_utils();
 function resolveBin(name) {
-  return new Promise((resolve6) => {
+  return new Promise((resolve7) => {
     const cmd = process.platform === "win32" ? "where" : "which";
     const args2 = process.platform === "win32" ? [name + ".exe", name] : [name];
     try {
@@ -2975,13 +3027,13 @@ function resolveBin(name) {
       if (result.status === 0 && result.stdout) {
         const first = (typeof result.stdout === "string" ? result.stdout : result.stdout?.toString() || "").trim().split(/\r?\n/)[0]?.trim();
         if (first) {
-          resolve6(first);
+          resolve7(first);
           return;
         }
       }
     } catch {
     }
-    resolve6(null);
+    resolve7(null);
   });
 }
 
@@ -3020,7 +3072,7 @@ function createSimpleGrepTool(cwd, options) {
     description: `Search file contents for a pattern. Returns matching lines with file paths and line numbers. Respects .gitignore. Output truncated to ${DEFAULT_LIMIT2} matches or ${DEFAULT_MAX_BYTES / 1024}KB. Long lines truncated to ${GREP_MAX_LINE_LENGTH} chars.`,
     parameters: grepSchema,
     execute: async (_toolCallId, { pattern, path: searchDir, glob: glob3, ignoreCase, literal, context, limit }, signal) => {
-      return new Promise((resolve6, reject) => {
+      return new Promise((resolve7, reject) => {
         if (signal?.aborted) {
           reject(new Error("Operation aborted"));
           return;
@@ -3169,7 +3221,7 @@ function createSimpleGrepTool(cwd, options) {
               }
               if (matchCount === 0) {
                 settle(
-                  () => resolve6({
+                  () => resolve7({
                     content: [{ type: "text", text: "No matches found" }],
                     details: void 0
                   })
@@ -3205,7 +3257,7 @@ function createSimpleGrepTool(cwd, options) {
 
 [${notices.join(". ")}]`;
               settle(
-                () => resolve6({
+                () => resolve7({
                   content: [{ type: "text", text: output }],
                   details: Object.keys(details).length > 0 ? details : void 0
                 })
@@ -4232,7 +4284,7 @@ function createLsTool(cwd, options) {
     description: `List directory contents. Returns entries sorted alphabetically, with '/' suffix for directories. Output truncated to ${DEFAULT_LIMIT4} entries or ${DEFAULT_MAX_BYTES / 1024}KB.`,
     parameters: lsSchema,
     execute: async (_toolCallId, { path: dirPathArg, limit }, signal) => {
-      return new Promise((resolve6, reject) => {
+      return new Promise((resolve7, reject) => {
         if (signal?.aborted) {
           reject(new Error("Operation aborted"));
           return;
@@ -4280,7 +4332,7 @@ function createLsTool(cwd, options) {
             }
             signal?.removeEventListener("abort", onAbort);
             if (results.length === 0) {
-              resolve6({
+              resolve7({
                 content: [{ type: "text", text: "(empty directory)" }],
                 details: void 0
               });
@@ -4304,7 +4356,7 @@ function createLsTool(cwd, options) {
             if (notices.length > 0) output += `
 
 [${notices.join(". ")}]`;
-            resolve6({
+            resolve7({
               content: [{ type: "text", text: output }],
               details: Object.keys(details).length > 0 ? details : void 0
             });
@@ -4430,7 +4482,7 @@ function createWriteTool(cwd, options) {
       validatePathWithinCwd(absolutePath, cwd);
       const dir = dirname(absolutePath);
       return new Promise(
-        (resolve6, reject) => {
+        (resolve7, reject) => {
           if (signal?.aborted) {
             reject(new Error("Operation aborted"));
             return;
@@ -4448,7 +4500,7 @@ function createWriteTool(cwd, options) {
               await ops.writeFile(absolutePath, content);
               if (aborted) return;
               if (signal) signal.removeEventListener("abort", onAbort);
-              resolve6({
+              resolve7({
                 content: [
                   { type: "text", text: `Successfully wrote ${content.length} bytes to ${path7}` }
                 ],
@@ -4500,7 +4552,7 @@ async function executeScript(scriptPath, args2, cwd, timeout = 30) {
   if (!interpreter) {
     throw new Error(`Unsupported script type: ${scriptPath}`);
   }
-  return new Promise((resolve6, reject) => {
+  return new Promise((resolve7, reject) => {
     const child = spawnProcess(interpreter.command, [...interpreter.args, ...args2], {
       cwd,
       timeout: timeout * 1e3
@@ -4532,7 +4584,7 @@ async function executeScript(scriptPath, args2, cwd, timeout = 30) {
         reject(new Error(`Script execution timed out after ${timeout}s`));
         return;
       }
-      resolve6({ stdout, stderr, exitCode: code });
+      resolve7({ stdout, stderr, exitCode: code });
     });
   });
 }
@@ -4811,9 +4863,9 @@ function createAskUserTool() {
       if (signal?.aborted) {
         throw new Error("Operation aborted");
       }
-      const answer = await new Promise((resolve6, reject) => {
+      const answer = await new Promise((resolve7, reject) => {
         pendingQuestions.set(toolCallId, {
-          resolve: resolve6,
+          resolve: resolve7,
           reject,
           question,
           options,
@@ -6541,8 +6593,46 @@ async function executeGenerateImage(options) {
 
 // src/tools/find-images.ts
 import { Type as Type15 } from "@sinclair/typebox";
+import { join as join9 } from "path";
+
+// src/core/server-origin.ts
+function getServerOrigin() {
+  const port = process.env.PORT ?? "641";
+  return `http://localhost:${port}`;
+}
+
+// src/tools/tool-image-storage.ts
 import { mkdir as fsMkdir3, writeFile as fsWriteFile4 } from "fs/promises";
 import { dirname as dirname3 } from "path";
+function decodeBase64ImageData(imageData) {
+  const binary = atob(imageData);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  return bytes;
+}
+async function saveToolImage(options) {
+  const bytes = decodeBase64ImageData(options.imageData);
+  const absolutePath = resolveToCwd(options.relativePath, options.cwd);
+  validatePathWithinCwd(absolutePath, options.cwd);
+  await fsMkdir3(dirname3(absolutePath), { recursive: true });
+  await fsWriteFile4(absolutePath, bytes);
+  const saved = {
+    savedPath: options.relativePath,
+    sizeInBytes: bytes.length
+  };
+  if (options.threadId && options.serverOrigin) {
+    saved.imageUrl = buildThreadExplorerMediaUrl(
+      options.threadId,
+      options.relativePath,
+      options.serverOrigin
+    );
+  }
+  return saved;
+}
+
+// src/tools/find-images.ts
 var findImagesSchema = Type15.Object({
   query: Type15.String({ description: "Search term for the image (e.g. 'sunset over mountains')" }),
   size: Type15.Optional(
@@ -6564,15 +6654,36 @@ var findImagesSchema = Type15.Object({
   ),
   save_to_file: Type15.Optional(
     Type15.String({
-      description: "File path relative to the project root to save the image to (e.g. 'assets/hero.jpg'). Parent directories are created automatically. If omitted the image is returned as base64 data only."
+      description: "File path relative to the project root to save the image to (e.g. 'assets/hero.jpg'). Parent directories are created automatically. If omitted the image is saved under .tarsk/tmp-images/."
     })
   )
 });
-function createFindImagesTool(cwd) {
+function extensionForContentType(contentType) {
+  if (contentType.includes("png")) {
+    return ".png";
+  }
+  if (contentType.includes("webp")) {
+    return ".webp";
+  }
+  if (contentType.includes("gif")) {
+    return ".gif";
+  }
+  if (contentType.includes("jpeg") || contentType.includes("jpg")) {
+    return ".jpg";
+  }
+  return ".jpg";
+}
+function defaultSavePath(query, contentType) {
+  const slug = query.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40) || "image";
+  const id = Math.random().toString(36).slice(2, 8);
+  return buildTmpImagePath(`${slug}-${id}${extensionForContentType(contentType)}`);
+}
+function createFindImagesTool(options = {}) {
+  const { cwd, threadId, serverOrigin = getServerOrigin() } = options;
   return {
     name: "find_images",
     label: "find_images",
-    description: "Find a stock image matching a search query. Returns the image as base64 data and optionally saves it to a file. Use this when the user needs an image and the user has not requested it be generated.",
+    description: "Find a stock image matching a search query. Returns a URL served by the Tarsk API and optionally saves the image to a file. Use this when the user needs an image and the user has not requested it be generated.",
     parameters: findImagesSchema,
     execute: async (_toolCallId, { query, size, save_to_file }, signal) => {
       return withAbortSignal(signal, async (isAborted) => {
@@ -6593,52 +6704,889 @@ function createFindImagesTool(cwd) {
           };
         }
         if (isAborted()) return { content: [], details: void 0 };
-        let savedPath;
-        if (cwd && save_to_file) {
-          try {
-            const absolutePath = resolveToCwd(save_to_file, cwd);
+        if (!cwd) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "Image search succeeded but no project directory is available to save the image."
+              }
+            ],
+            details: void 0
+          };
+        }
+        const relativePath = save_to_file ?? defaultSavePath(query, contentType);
+        let saved;
+        try {
+          if (save_to_file) {
+            const absolutePath = resolveToCwd(relativePath, cwd);
             validatePathWithinCwd(absolutePath, cwd);
-            const binary = atob(imageData);
-            const bytes = new Uint8Array(binary.length);
-            for (let i = 0; i < binary.length; i++) {
-              bytes[i] = binary.charCodeAt(i);
-            }
-            await fsMkdir3(dirname3(absolutePath), { recursive: true });
-            await fsWriteFile4(absolutePath, bytes);
-            savedPath = save_to_file;
-            console.log(`[find_images] Saved image to ${absolutePath}`);
-          } catch (saveError) {
-            const errMsg = saveError instanceof Error ? saveError.message : String(saveError);
-            return {
-              content: [
-                {
-                  type: "text",
-                  text: `Image was found but failed to save to "${save_to_file}": ${errMsg}`
-                }
-              ],
-              details: { imageData, contentType }
-            };
           }
+          saved = await saveToolImage({
+            imageData,
+            cwd,
+            relativePath,
+            threadId,
+            serverOrigin
+          });
+          console.log(`[find_images] Saved image to ${join9(cwd, saved.savedPath)}`);
+        } catch (saveError) {
+          const errMsg = saveError instanceof Error ? saveError.message : String(saveError);
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Image was found but failed to save to "${relativePath}": ${errMsg}`
+              }
+            ],
+            details: void 0
+          };
+        }
+        const resultPayload = {
+          contentType,
+          savedPath: saved.savedPath,
+          sizeInBytes: saved.sizeInBytes
+        };
+        if (saved.imageUrl) {
+          resultPayload.imageUrl = saved.imageUrl;
         }
-        const resultPayload = { imageData, contentType };
-        if (savedPath) resultPayload.savedPath = savedPath;
         return {
-          content: [{ type: "text", text: JSON.stringify(resultPayload) }],
-          details: { imageData, contentType }
+          content: [{ type: "text", text: buildGenerateImageToolText(resultPayload) }],
+          details: saved.imageUrl ? { imageUrl: saved.imageUrl } : void 0
         };
       });
     }
   };
 }
 
+// src/tools/browser.ts
+import { Type as Type16 } from "@sinclair/typebox";
+
+// src/core/browser-preview-bridge.ts
+async function invokePreviewApi(webview, method, params) {
+  if (!webview.rpc?.request?.evaluateJavascriptWithResponse) {
+    throw new Error("Browser preview webview RPC is not available");
+  }
+  const paramsLiteral = JSON.stringify(params ?? null);
+  const script = `return (async () => {
+    const api = window.__tarskBrowserPreview;
+    if (!api) {
+      throw new Error("Browser preview API is not available");
+    }
+    const fn = api[${JSON.stringify(method)}];
+    if (typeof fn !== "function") {
+      throw new Error("Unknown browser preview API method: ${method}");
+    }
+    return await fn.call(api, ${paramsLiteral});
+  })()`;
+  return webview.rpc.request.evaluateJavascriptWithResponse({ script });
+}
+
+// src/core/browser-native-screenshot.ts
+import { execFile } from "node:child_process";
+import { randomUUID as randomUUID3 } from "node:crypto";
+import { readFile as readFile5, unlink } from "node:fs/promises";
+import { tmpdir as tmpdir2 } from "node:os";
+import { join as join10 } from "node:path";
+import { setTimeout as sleep } from "node:timers/promises";
+import { promisify } from "node:util";
+
+// src/core/browser-view-access.ts
+var electrobunModule = null;
+var electrobunLoadAttempted = false;
+async function loadElectrobunBrowserView() {
+  if (electrobunLoadAttempted) {
+    return electrobunModule;
+  }
+  electrobunLoadAttempted = true;
+  try {
+    electrobunModule = await import("electrobun/bun");
+  } catch {
+    electrobunModule = null;
+  }
+  return electrobunModule;
+}
+function getBrowserViewById(webviewId) {
+  if (!electrobunModule) {
+    return null;
+  }
+  return electrobunModule.BrowserView.getById(webviewId) ?? null;
+}
+function getBrowserWindowById(windowId) {
+  if (!electrobunModule) {
+    return null;
+  }
+  return electrobunModule.BrowserWindow.getById(windowId) ?? null;
+}
+function waitForBrowserEvent(webview, eventName, timeoutMs) {
+  return new Promise((resolve7, reject) => {
+    const timeout = setTimeout(() => {
+      reject(new Error(`Timed out waiting for ${eventName} after ${timeoutMs}ms`));
+    }, timeoutMs);
+    webview.on(eventName, () => {
+      clearTimeout(timeout);
+      resolve7();
+    });
+  });
+}
+
+// src/core/browser-native-screenshot.ts
+var execFileAsync = promisify(execFile);
+var NATIVE_FOCUS_DELAY_MS = 75;
+var PNG_SIGNATURE = Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]);
+var SCREEN_RECORDING_HINT = "Grant Screen Recording permission to Tarsk in System Settings \u2192 Privacy & Security \u2192 Screen Recording, then restart Tarsk.";
+function parsePngDimensions(bytes) {
+  if (bytes.length < 24 || !bytes.subarray(0, 8).equals(PNG_SIGNATURE)) {
+    return null;
+  }
+  return {
+    width: bytes.readUInt32BE(16),
+    height: bytes.readUInt32BE(20)
+  };
+}
+function pngHasImageData(bytes) {
+  return bytes.includes(Buffer.from("IDAT")) && bytes.includes(Buffer.from("IEND"));
+}
+function parseJpegDimensions(bytes) {
+  if (bytes.length < 4 || bytes[0] !== 255 || bytes[1] !== 216) {
+    return null;
+  }
+  let offset = 2;
+  while (offset + 9 < bytes.length) {
+    if (bytes[offset] !== 255) {
+      return null;
+    }
+    const marker = bytes[offset + 1];
+    if (marker === 217) {
+      break;
+    }
+    const segmentLength = bytes.readUInt16BE(offset + 2);
+    if (segmentLength < 2 || offset + 2 + segmentLength > bytes.length) {
+      return null;
+    }
+    const isStartOfFrame = marker === 192 || marker === 193 || marker === 194 || marker === 195;
+    if (isStartOfFrame) {
+      return {
+        height: bytes.readUInt16BE(offset + 5),
+        width: bytes.readUInt16BE(offset + 7)
+      };
+    }
+    offset += 2 + segmentLength;
+  }
+  return null;
+}
+function isTruncatedCapture(bytes, width, height) {
+  if (width >= 64 || height >= 64) {
+    return bytes.length < 1024;
+  }
+  return bytes.length < 68;
+}
+function validateCapturedImage(bytes, format) {
+  if (bytes.length === 0) {
+    return { error: "macOS screencapture produced an empty image file." };
+  }
+  if (format === "png") {
+    const dimensions2 = parsePngDimensions(bytes);
+    if (!dimensions2) {
+      return { error: "macOS screencapture produced an invalid PNG file." };
+    }
+    if (!pngHasImageData(bytes) || isTruncatedCapture(bytes, dimensions2.width, dimensions2.height)) {
+      return {
+        error: `macOS screencapture wrote a truncated PNG (${bytes.length} bytes for ${dimensions2.width}x${dimensions2.height}). ` + SCREEN_RECORDING_HINT
+      };
+    }
+    return { ...dimensions2, format: "png" };
+  }
+  const dimensions = parseJpegDimensions(bytes);
+  if (!dimensions) {
+    return { error: "macOS screencapture produced an invalid JPEG file." };
+  }
+  if (isTruncatedCapture(bytes, dimensions.width, dimensions.height)) {
+    return {
+      error: `macOS screencapture wrote a truncated JPEG (${bytes.length} bytes for ${dimensions.width}x${dimensions.height}). ` + SCREEN_RECORDING_HINT
+    };
+  }
+  return { ...dimensions, format: "jpeg" };
+}
+function isValidRect(rect) {
+  return Number.isFinite(rect.x) && Number.isFinite(rect.y) && rect.width > 0 && rect.height > 0;
+}
+async function resolveViewFrame(view) {
+  if (view.getFrame) {
+    return await view.getFrame();
+  }
+  if (view.frame) {
+    return view.frame;
+  }
+  return { x: 0, y: 0, width: 0, height: 0 };
+}
+async function captureMacOSRect(options) {
+  const formatFlag = options.format === "jpeg" ? "jpg" : "png";
+  const region = `${Math.round(options.rect.x)},${Math.round(options.rect.y)},${Math.round(options.rect.width)},${Math.round(options.rect.height)}`;
+  await execFileAsync("screencapture", ["-x", "-t", formatFlag, "-R", region, options.path]);
+}
+async function resolveCaptureRect(webviewId) {
+  const view = getBrowserViewById(webviewId);
+  if (!view) {
+    throw new Error(`Browser preview webview ${webviewId} is not available`);
+  }
+  const window = getBrowserWindowById(view.windowId);
+  if (!window) {
+    throw new Error(`Electrobun window ${view.windowId} is not available for screenshot capture`);
+  }
+  const windowFrame = window.getFrame();
+  const viewFrame = await resolveViewFrame(view);
+  if (!isValidRect(windowFrame)) {
+    throw new Error(`Window ${window.id} does not expose a usable frame for screenshots`);
+  }
+  if (!isValidRect(viewFrame)) {
+    throw new Error(`View ${view.id} does not expose a usable frame for screenshots`);
+  }
+  return {
+    rect: {
+      x: windowFrame.x + viewFrame.x,
+      y: windowFrame.y + viewFrame.y,
+      width: viewFrame.width,
+      height: viewFrame.height
+    },
+    viewId: view.id,
+    windowId: window.id
+  };
+}
+async function captureNativeBrowserScreenshot(webviewId, format) {
+  if (process.platform !== "darwin") {
+    return {
+      ok: false,
+      reason: "Native Electrobun screenshots are only supported on macOS."
+    };
+  }
+  const outputPath = join10(
+    tmpdir2(),
+    `tarsk-browser-screenshot-${randomUUID3()}.${format === "jpeg" ? "jpg" : "png"}`
+  );
+  try {
+    const target = await resolveCaptureRect(webviewId);
+    const window = getBrowserWindowById(target.windowId);
+    window?.focus();
+    await sleep(NATIVE_FOCUS_DELAY_MS);
+    await captureMacOSRect({
+      format,
+      path: outputPath,
+      rect: target.rect
+    });
+    const imageBytes = await readFile5(outputPath);
+    const validated = validateCapturedImage(imageBytes, format);
+    if ("error" in validated) {
+      return {
+        ok: false,
+        reason: validated.error
+      };
+    }
+    return {
+      ok: true,
+      result: {
+        format: validated.format,
+        width: validated.width,
+        height: validated.height,
+        image_data: imageBytes.toString("base64"),
+        capture_method: "native-screencapture",
+        window_id: target.windowId,
+        view_id: target.viewId
+      }
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      ok: false,
+      reason: `${message} Native screenshots require a visible on-screen preview. ${SCREEN_RECORDING_HINT}`
+    };
+  } finally {
+    await unlink(outputPath).catch(() => void 0);
+  }
+}
+
+// src/tools/browser.ts
+var browserSchema = Type16.Object({
+  action: Type16.Union(
+    [
+      Type16.Literal("open_url"),
+      Type16.Literal("evaluate_javascript"),
+      Type16.Literal("find_in_page"),
+      Type16.Literal("stop_find_in_page"),
+      Type16.Literal("reload"),
+      Type16.Literal("go_back"),
+      Type16.Literal("go_forward"),
+      Type16.Literal("get_state"),
+      Type16.Literal("screenshot"),
+      Type16.Literal("set_viewport"),
+      Type16.Literal("snapshot"),
+      Type16.Literal("click"),
+      Type16.Literal("fill"),
+      Type16.Literal("press"),
+      Type16.Literal("hover"),
+      Type16.Literal("wait_for"),
+      Type16.Literal("get_console_logs")
+    ],
+    {
+      description: "Browser action. Navigation: open_url, reload, go_back, go_forward, get_state. Inspection: snapshot, screenshot, get_console_logs, find_in_page, stop_find_in_page. Interaction: click, fill, press, hover, wait_for, evaluate_javascript. Layout: set_viewport."
+    }
+  ),
+  url: Type16.Optional(
+    Type16.String({
+      description: "URL to open in the Browser tab preview (required for open_url)."
+    })
+  ),
+  script: Type16.Optional(
+    Type16.String({
+      description: "JavaScript to execute in the preview page context (required for evaluate_javascript)."
+    })
+  ),
+  text: Type16.Optional(
+    Type16.String({
+      description: "Text to find in the page (required for find_in_page)."
+    })
+  ),
+  forward: Type16.Optional(
+    Type16.Boolean({
+      description: "Search forward through matches for find_in_page (default true)."
+    })
+  ),
+  match_case: Type16.Optional(
+    Type16.Boolean({
+      description: "Case-sensitive search for find_in_page (default false)."
+    })
+  ),
+  wait_for_load_ms: Type16.Optional(
+    Type16.Number({
+      description: "Milliseconds to wait for the dom-ready event after navigation (default 5000, max 30000)."
+    })
+  ),
+  preset: Type16.Optional(
+    Type16.Union([Type16.Literal("desktop"), Type16.Literal("tablet"), Type16.Literal("mobile")], {
+      description: "Viewport preset for set_viewport."
+    })
+  ),
+  format: Type16.Optional(
+    Type16.Union([Type16.Literal("png"), Type16.Literal("jpeg")], {
+      description: "Image format for screenshot (default png)."
+    })
+  ),
+  ref: Type16.Optional(
+    Type16.String({
+      description: "Element ref from snapshot for click, fill, or hover (e.g. @e1)."
+    })
+  ),
+  value: Type16.Optional(
+    Type16.String({
+      description: "Value to type for fill."
+    })
+  ),
+  key: Type16.Optional(
+    Type16.String({
+      description: "Key to press for press (e.g. Enter, Tab, Escape)."
+    })
+  ),
+  selector: Type16.Optional(
+    Type16.String({
+      description: "CSS selector to wait for in wait_for."
+    })
+  ),
+  timeout_ms: Type16.Optional(
+    Type16.Number({
+      description: "Timeout in milliseconds for wait_for (default 10000, max 60000)."
+    })
+  ),
+  interactive_only: Type16.Optional(
+    Type16.Boolean({
+      description: "Only include interactive elements in snapshot (default false)."
+    })
+  ),
+  max_depth: Type16.Optional(
+    Type16.Number({
+      description: "Maximum DOM depth for snapshot (default 15)."
+    })
+  ),
+  since_ms: Type16.Optional(
+    Type16.Number({
+      description: "Only return console logs from the last N milliseconds for get_console_logs."
+    })
+  ),
+  levels: Type16.Optional(
+    Type16.Array(Type16.String(), {
+      description: 'Console levels to include for get_console_logs (e.g. ["error", "warn"]).'
+    })
+  ),
+  clear: Type16.Optional(
+    Type16.Boolean({
+      description: "Clear buffered console logs after reading for get_console_logs (default false)."
+    })
+  )
+});
+var pendingBrowserTasks = /* @__PURE__ */ new Map();
+var bufferedWebviewIds = /* @__PURE__ */ new Map();
+var pendingBrowserActionResults = /* @__PURE__ */ new Map();
+var bufferedBrowserActionResults = /* @__PURE__ */ new Map();
+var DEFAULT_WAIT_FOR_LOAD_MS = 5e3;
+var MAX_WAIT_FOR_LOAD_MS = 3e4;
+var DEFAULT_WEBVIEW_READY_TIMEOUT_MS = 2e4;
+var DEFAULT_WAIT_FOR_TIMEOUT_MS = 1e4;
+var MAX_WAIT_FOR_TIMEOUT_MS = 6e4;
+var DEFAULT_BROWSER_ACTION_TIMEOUT_MS = 2e4;
+function submitBrowserWebviewReady(toolCallId, webviewId) {
+  const pending = pendingBrowserTasks.get(toolCallId);
+  if (pending) {
+    pending.resolve(webviewId);
+    pendingBrowserTasks.delete(toolCallId);
+    return true;
+  }
+  bufferedWebviewIds.set(toolCallId, webviewId);
+  return true;
+}
+function submitBrowserActionResult(toolCallId, result) {
+  const pending = pendingBrowserActionResults.get(toolCallId);
+  if (pending) {
+    pending.resolve(result);
+    pendingBrowserActionResults.delete(toolCallId);
+    return true;
+  }
+  bufferedBrowserActionResults.set(toolCallId, result);
+  return true;
+}
+function cancelPendingBrowserTask(toolCallId) {
+  const pending = pendingBrowserTasks.get(toolCallId);
+  if (!pending) return false;
+  pending.reject(new Error("Browser tool execution cancelled"));
+  pendingBrowserTasks.delete(toolCallId);
+  return true;
+}
+function cancelPendingBrowserActionResult(toolCallId) {
+  const pending = pendingBrowserActionResults.get(toolCallId);
+  if (!pending) return false;
+  pending.reject(new Error("Browser tool execution cancelled"));
+  pendingBrowserActionResults.delete(toolCallId);
+  return true;
+}
+function normalizeUrl(url) {
+  const trimmed = url.trim();
+  if (!trimmed) {
+    throw new Error("url must not be empty");
+  }
+  if (trimmed.startsWith("http://") || trimmed.startsWith("https://")) {
+    return trimmed;
+  }
+  return `http://${trimmed}`;
+}
+function waitForPreviewWebview(toolCallId, signal, timeoutMs = DEFAULT_WEBVIEW_READY_TIMEOUT_MS) {
+  const buffered = bufferedWebviewIds.get(toolCallId);
+  if (buffered !== void 0) {
+    bufferedWebviewIds.delete(toolCallId);
+    return Promise.resolve(buffered);
+  }
+  return new Promise((resolve7, reject) => {
+    if (signal?.aborted) {
+      reject(new Error("Operation aborted"));
+      return;
+    }
+    let timeoutHandle = null;
+    const pending = pendingBrowserTasks.get(toolCallId);
+    const onAbort = () => {
+      cancelPendingBrowserTask(toolCallId);
+    };
+    function cleanup() {
+      signal?.removeEventListener("abort", onAbort);
+      if (timeoutHandle) {
+        clearTimeout(timeoutHandle);
+      }
+    }
+    const wrappedResolve = (webviewId) => {
+      cleanup();
+      resolve7(webviewId);
+    };
+    const wrappedReject = (error) => {
+      cleanup();
+      reject(error);
+    };
+    if (pending) {
+      pending.resolve = wrappedResolve;
+      pending.reject = wrappedReject;
+    } else {
+      pendingBrowserTasks.set(toolCallId, {
+        resolve: wrappedResolve,
+        reject: wrappedReject
+      });
+    }
+    signal?.addEventListener("abort", onAbort, { once: true });
+    timeoutHandle = setTimeout(() => {
+      if (!pendingBrowserTasks.has(toolCallId)) return;
+      pendingBrowserTasks.delete(toolCallId);
+      wrappedReject(
+        new Error(
+          `browser tool timed out after ${timeoutMs}ms waiting for the Browser tab preview webview`
+        )
+      );
+    }, timeoutMs);
+  });
+}
+function waitForBrowserActionResult(toolCallId, signal, timeoutMs = DEFAULT_BROWSER_ACTION_TIMEOUT_MS) {
+  const buffered = bufferedBrowserActionResults.get(toolCallId);
+  if (buffered) {
+    bufferedBrowserActionResults.delete(toolCallId);
+    return Promise.resolve(buffered);
+  }
+  return new Promise((resolve7, reject) => {
+    if (signal?.aborted) {
+      reject(new Error("Operation aborted"));
+      return;
+    }
+    let timeoutHandle = null;
+    const onAbort = () => {
+      cancelPendingBrowserActionResult(toolCallId);
+    };
+    function cleanup() {
+      signal?.removeEventListener("abort", onAbort);
+      if (timeoutHandle) {
+        clearTimeout(timeoutHandle);
+      }
+    }
+    const wrappedResolve = (result) => {
+      cleanup();
+      resolve7(result);
+    };
+    const wrappedReject = (error) => {
+      cleanup();
+      reject(error);
+    };
+    pendingBrowserActionResults.set(toolCallId, {
+      resolve: wrappedResolve,
+      reject: wrappedReject
+    });
+    signal?.addEventListener("abort", onAbort, { once: true });
+    timeoutHandle = setTimeout(() => {
+      if (!pendingBrowserActionResults.has(toolCallId)) return;
+      pendingBrowserActionResults.delete(toolCallId);
+      wrappedReject(
+        new Error(
+          `browser tool timed out after ${timeoutMs}ms waiting for the Browser tab host action`
+        )
+      );
+    }, timeoutMs);
+  });
+}
+function logBrowserPreviewFailure(action, webviewId, webview, error, context) {
+  console.error(`[browser] ${action} failed`, {
+    webview_id: webviewId,
+    current_url: webview.url,
+    ...context,
+    error: error instanceof Error ? error.message : String(error),
+    stack: error instanceof Error ? error.stack : void 0
+  });
+}
+async function executeBrowserAction(webviewId, input) {
+  const webview = getBrowserViewById(webviewId);
+  if (!webview) {
+    throw new Error(`Browser preview webview ${webviewId} is not available`);
+  }
+  switch (input.action) {
+    case "open_url": {
+      if (!input.url?.trim()) {
+        throw new Error("url is required for open_url");
+      }
+      const url = normalizeUrl(input.url);
+      const waitMs = Math.min(
+        Math.max(input.wait_for_load_ms ?? DEFAULT_WAIT_FOR_LOAD_MS, 0),
+        MAX_WAIT_FOR_LOAD_MS
+      );
+      const domReadyPromise = waitForBrowserEvent(webview, "dom-ready", waitMs);
+      webview.loadURL(url);
+      let domReady = false;
+      try {
+        await domReadyPromise;
+        domReady = true;
+      } catch {
+      }
+      return {
+        action: "open_url",
+        url,
+        webview_id: webviewId,
+        current_url: webview.url,
+        dom_ready: domReady
+      };
+    }
+    case "evaluate_javascript": {
+      if (!input.script?.trim()) {
+        throw new Error("script is required for evaluate_javascript");
+      }
+      if (!webview.rpc?.request?.evaluateJavascriptWithResponse) {
+        throw new Error("Browser preview webview RPC is not available for JavaScript execution");
+      }
+      const result = await webview.rpc.request.evaluateJavascriptWithResponse({
+        script: input.script
+      });
+      return {
+        action: "evaluate_javascript",
+        webview_id: webviewId,
+        result
+      };
+    }
+    case "find_in_page": {
+      if (!input.text?.trim()) {
+        throw new Error("text is required for find_in_page");
+      }
+      webview.findInPage(input.text, {
+        forward: input.forward ?? true,
+        matchCase: input.match_case ?? false
+      });
+      return {
+        action: "find_in_page",
+        webview_id: webviewId,
+        text: input.text,
+        forward: input.forward ?? true,
+        match_case: input.match_case ?? false
+      };
+    }
+    case "stop_find_in_page": {
+      webview.stopFindInPage();
+      return {
+        action: "stop_find_in_page",
+        webview_id: webviewId
+      };
+    }
+    case "snapshot": {
+      const result = await invokePreviewApi(webview, "snapshot", {
+        interactive_only: input.interactive_only ?? false,
+        max_depth: input.max_depth ?? 15
+      });
+      return {
+        action: "snapshot",
+        webview_id: webviewId,
+        ...typeof result === "object" && result !== null ? result : { result }
+      };
+    }
+    case "click": {
+      if (!input.ref?.trim()) {
+        throw new Error("ref is required for click");
+      }
+      const result = await invokePreviewApi(webview, "click", { ref: input.ref });
+      return {
+        action: "click",
+        webview_id: webviewId,
+        ref: input.ref,
+        result
+      };
+    }
+    case "fill": {
+      if (!input.ref?.trim()) {
+        throw new Error("ref is required for fill");
+      }
+      if (input.value === void 0) {
+        throw new Error("value is required for fill");
+      }
+      const result = await invokePreviewApi(webview, "fill", {
+        ref: input.ref,
+        value: input.value
+      });
+      return {
+        action: "fill",
+        webview_id: webviewId,
+        ref: input.ref,
+        value: input.value,
+        result
+      };
+    }
+    case "press": {
+      if (!input.key?.trim()) {
+        throw new Error("key is required for press");
+      }
+      const result = await invokePreviewApi(webview, "press", { key: input.key });
+      return {
+        action: "press",
+        webview_id: webviewId,
+        key: input.key,
+        result
+      };
+    }
+    case "hover": {
+      if (!input.ref?.trim()) {
+        throw new Error("ref is required for hover");
+      }
+      const result = await invokePreviewApi(webview, "hover", { ref: input.ref });
+      return {
+        action: "hover",
+        webview_id: webviewId,
+        ref: input.ref,
+        result
+      };
+    }
+    case "wait_for": {
+      if (!input.selector?.trim() && !input.text?.trim()) {
+        throw new Error("selector or text is required for wait_for");
+      }
+      const timeoutMs = Math.min(
+        Math.max(input.timeout_ms ?? DEFAULT_WAIT_FOR_TIMEOUT_MS, 0),
+        MAX_WAIT_FOR_TIMEOUT_MS
+      );
+      const result = await invokePreviewApi(webview, "waitFor", {
+        selector: input.selector,
+        text: input.text,
+        timeout_ms: timeoutMs
+      });
+      return {
+        action: "wait_for",
+        webview_id: webviewId,
+        selector: input.selector,
+        text: input.text,
+        timeout_ms: timeoutMs,
+        result
+      };
+    }
+    case "get_console_logs": {
+      const result = await invokePreviewApi(webview, "getConsoleLogs", {
+        since_ms: input.since_ms ?? 0,
+        levels: input.levels,
+        clear: input.clear ?? false
+      });
+      return {
+        action: "get_console_logs",
+        webview_id: webviewId,
+        ...typeof result === "object" && result !== null ? result : { result }
+      };
+    }
+    case "screenshot": {
+      const format = input.format ?? "png";
+      const nativeCapture = await captureNativeBrowserScreenshot(webviewId, format);
+      if (nativeCapture.ok) {
+        return {
+          action: "screenshot",
+          webview_id: webviewId,
+          ...nativeCapture.result
+        };
+      }
+      try {
+        const result = await invokePreviewApi(webview, "takeScreenshot", { format });
+        return {
+          action: "screenshot",
+          webview_id: webviewId,
+          capture_method: "svg-foreign-object",
+          native_capture_unavailable: nativeCapture.reason,
+          ...typeof result === "object" && result !== null ? result : { result }
+        };
+      } catch (error) {
+        logBrowserPreviewFailure("screenshot", webviewId, webview, error, {
+          format,
+          capture_method: "svg-foreign-object",
+          native_capture_unavailable: nativeCapture.reason,
+          troubleshooting: "Native macOS capture uses screencapture on the visible preview rect. If native capture fails, grant Screen Recording permission to Tarsk and restart the app. SVG fallback can fail on large third-party pages. Check tarsk-logs.txt for [browser-preview] takeScreenshot failed entries."
+        });
+        throw error;
+      }
+    }
+    default:
+      throw new Error(`Unsupported browser action: ${String(input.action)}`);
+  }
+}
+function formatBrowserResult(payload) {
+  if (payload.action === "screenshot") {
+    const display = stripScreenshotPayload(payload);
+    return {
+      text: buildGenerateImageToolText(display),
+      details: payload
+    };
+  }
+  return {
+    text: JSON.stringify(payload, null, 2),
+    details: payload
+  };
+}
+function stripScreenshotPayload(payload) {
+  const display = {};
+  for (const [key, value] of Object.entries(payload)) {
+    if (key === "image_data") continue;
+    if (typeof value === "string" || typeof value === "number") {
+      display[key] = value;
+    }
+  }
+  return display;
+}
+async function persistScreenshotResult(payload, options) {
+  const imageData = payload.image_data;
+  if (typeof imageData !== "string" || !imageData) {
+    return payload;
+  }
+  const sizeInBytes = decodeBase64ImageData(imageData).length;
+  const { image_data: _removed, ...rest } = payload;
+  if (!options.cwd) {
+    return { ...rest, sizeInBytes };
+  }
+  const format = payload.format === "jpeg" ? "jpeg" : "png";
+  const extension = format === "jpeg" ? "jpg" : "png";
+  const id = Math.random().toString(36).slice(2, 8);
+  const relativePath = buildTmpImagePath(`screenshot-${id}.${extension}`);
+  const saved = await saveToolImage({
+    imageData,
+    cwd: options.cwd,
+    relativePath,
+    threadId: options.threadId,
+    serverOrigin: options.serverOrigin
+  });
+  return {
+    ...rest,
+    savedPath: saved.savedPath,
+    sizeInBytes: saved.sizeInBytes,
+    ...saved.imageUrl ? { imageUrl: saved.imageUrl } : {}
+  };
+}
+var BROWSER_TOOL_DESCRIPTION = "Control the in-app Browser. Use to read information from websites \u2014 open_url then snapshot for page content and structure, get_state for URL/title, find_in_page to locate text, evaluate_javascript to extract data, or screenshot for visual reference. Also use for interacting with pages: click, fill, press, hover, wait_for. Actions: open_url, reload, go_back, go_forward, get_state, set_viewport, screenshot, snapshot, click, fill, press, hover, wait_for, get_console_logs, evaluate_javascript, find_in_page, stop_find_in_page. Use snapshot to get @eN element refs, then click/fill/hover by ref. The Browser tab opens automatically. Start the dev server first when testing localhost apps.";
+function createBrowserTool(options = {}) {
+  const serverOrigin = options.serverOrigin ?? getServerOrigin();
+  return {
+    name: "browser",
+    label: "browser",
+    description: BROWSER_TOOL_DESCRIPTION,
+    parameters: browserSchema,
+    execute: async (toolCallId, input, signal) => {
+      return withAbortSignal(signal, async () => {
+        const electrobun = await loadElectrobunBrowserView();
+        if (!electrobun) {
+          throw new Error(
+            "browser tool is only available in the Tarsk desktop app (Electrobun), not in server-only mode"
+          );
+        }
+        if (isBrowserHostAction(input.action)) {
+          const result2 = await waitForBrowserActionResult(toolCallId, signal);
+          const formatted2 = formatBrowserResult(result2);
+          return {
+            content: [{ type: "text", text: formatted2.text }],
+            details: formatted2.details
+          };
+        }
+        const webviewId = await waitForPreviewWebview(toolCallId, signal);
+        let result = await executeBrowserAction(webviewId, input);
+        if (input.action === "screenshot") {
+          result = await persistScreenshotResult(result, {
+            cwd: options.cwd,
+            threadId: options.threadId,
+            serverOrigin
+          });
+        }
+        const formatted = formatBrowserResult(result);
+        return {
+          content: [{ type: "text", text: formatted.text }],
+          details: typeof formatted.details.imageUrl === "string" ? { imageUrl: formatted.details.imageUrl } : formatted.details
+        };
+      });
+    }
+  };
+}
+var browserTool = createBrowserTool();
+
 // src/tools/execute-browser-js.ts
 init_tarsk_debug();
-import { Type as Type16 } from "@sinclair/typebox";
-var runWebWorkerSchema = Type16.Object({
-  intention: Type16.String({
+import { Type as Type17 } from "@sinclair/typebox";
+var runWebWorkerSchema = Type17.Object({
+  intention: Type17.String({
     description: "A short description of what this code execution is trying to accomplish."
   }),
-  code: Type16.String({
+  code: Type17.String({
     description: "The javascript code to execute in browser context(not nodejs). The environment provides an async function `callTool(toolName, params)` which allows calling any of the other available tools by name. callTool always returns `{ text: string | null, error: string | null }`. On success `text` contains the result and `error` is null. On failure `error` contains the error message and `text` is null. Example: `const r = await callTool('read', { path: 'foo.ts' }); if (r.error) return r.error; return r.text;`."
   })
 });
@@ -6685,11 +7633,11 @@ function createRunWebWorkerTool(options) {
       if (signal?.aborted) {
         throw new Error("Operation aborted");
       }
-      const result = await new Promise((resolve6, reject) => {
+      const result = await new Promise((resolve7, reject) => {
         const earlyResult = bufferedResults.get(toolCallId);
         if (earlyResult !== void 0) {
           bufferedResults.delete(toolCallId);
-          resolve6(earlyResult);
+          resolve7(earlyResult);
           return;
         }
         let timeoutHandle = null;
@@ -6704,7 +7652,7 @@ function createRunWebWorkerTool(options) {
         }
         const wrappedResolve = (value) => {
           cleanup();
-          resolve6(value);
+          resolve7(value);
         };
         const wrappedReject = (error) => {
           cleanup();
@@ -6772,7 +7720,7 @@ function looksLikeMissingReturn(code) {
 var runWebWorkerTool = createRunWebWorkerTool();
 
 // src/tools/fetch.ts
-import { Type as Type17 } from "@sinclair/typebox";
+import { Type as Type18 } from "@sinclair/typebox";
 
 // src/features/web-fetch/content-processor.ts
 import { completeSimple as completeSimple2 } from "@earendil-works/pi-ai";
@@ -6803,7 +7751,7 @@ function runCommandTimed(stepName, command, args2, cwd) {
   let tFirstIo = null;
   let tExit = null;
   logSubprocessMark(scope, stepName, "spawn-call", 0);
-  return new Promise((resolve6, reject) => {
+  return new Promise((resolve7, reject) => {
     const proc = spawnProcess(command, args2, { cwd });
     proc.on("spawn", () => {
       tSpawnEvent = Date.now();
@@ -6842,7 +7790,7 @@ function runCommandTimed(stepName, command, args2, cwd) {
       console.log(
         `${GITOPS_TIMING_PREFIX} subprocess ${scope} step=${stepName} summary total=${tClose - t0}ms` + (preSpawnMs !== null ? ` pre-spawn=${preSpawnMs}ms` : "") + (processActiveMs !== null ? ` process-active=${processActiveMs}ms` : "") + (exitToCloseMs !== null ? ` exit-to-close=${exitToCloseMs}ms` : "") + ` cmd=${command} ${args2.join(" ")}`
       );
-      resolve6({ code, stdout, stderr });
+      resolve7({ code, stdout, stderr });
     });
     proc.on("error", (error) => {
       logSubprocessMark(scope, stepName, "spawn-error", Date.now() - t0);
@@ -6875,13 +7823,13 @@ function startEventLoopLagMonitor(threadId) {
 
 // src/features/git/git.utils.ts
 import { existsSync as existsSync8, readFileSync as readFileSync3, statSync as statSync5 } from "fs";
-import { isAbsolute as isAbsolute2, normalize as normalize2, resolve, join as join10 } from "path";
+import { isAbsolute as isAbsolute2, normalize as normalize2, resolve, join as join12 } from "path";
 
 // src/core/paths.ts
-import { join as join9 } from "path";
+import { join as join11 } from "path";
 import { homedir as homedir4 } from "os";
-var APP_SUPPORT_DIR = join9(homedir4(), "Library", "Application Support", "Tarsk");
-var DATA_DIR = join9(APP_SUPPORT_DIR, "data");
+var APP_SUPPORT_DIR = join11(homedir4(), "Library", "Application Support", "Tarsk");
+var DATA_DIR = join11(APP_SUPPORT_DIR, "data");
 function getDataDir() {
   return DATA_DIR;
 }
@@ -7149,7 +8097,7 @@ async function getCurrentBranch(gitRoot) {
     ]);
     return result.stdout.trim();
   }
-  return new Promise((resolve6) => {
+  return new Promise((resolve7) => {
     const proc = spawnProcess("git", ["rev-parse", "--abbrev-ref", "HEAD"], { cwd: gitRoot });
     let out = "";
     if (proc.stdout) {
@@ -7158,9 +8106,9 @@ async function getCurrentBranch(gitRoot) {
       });
     }
     proc.on("close", () => {
-      resolve6(out.trim());
+      resolve7(out.trim());
     });
-    proc.on("error", () => resolve6(""));
+    proc.on("error", () => resolve7(""));
   });
 }
 async function getGitDiff(gitRoot) {
@@ -7237,7 +8185,7 @@ async function getUntrackedFilesDiff(gitRoot) {
   const parts = [];
   const maxFileSize = 1e5;
   for (const relPath of untrackedPaths) {
-    const fullPath = join10(gitRoot, relPath);
+    const fullPath = join12(gitRoot, relPath);
     if (!existsSync8(fullPath)) continue;
     try {
       if (statSync5(fullPath).isDirectory()) continue;
@@ -7270,7 +8218,7 @@ async function getGitStatus(gitRoot) {
     ]);
     return result.stdout;
   }
-  return new Promise((resolve6) => {
+  return new Promise((resolve7) => {
     const proc = spawnProcess("git", ["status", "--porcelain", "--untracked-files=all"], {
       cwd: gitRoot
     });
@@ -7280,15 +8228,15 @@ async function getGitStatus(gitRoot) {
         out += d.toString();
       });
     }
-    proc.on("close", () => resolve6(out));
-    proc.on("error", () => resolve6(""));
+    proc.on("close", () => resolve7(out));
+    proc.on("error", () => resolve7(""));
   });
 }
 function runGit(stepName, gitRoot, args2) {
   if (isGitSubprocessTimingEnabled()) {
     return runGitCommandTimed(stepName, gitRoot, args2);
   }
-  return new Promise((resolve6) => {
+  return new Promise((resolve7) => {
     const proc = spawnProcess("git", args2, { cwd: gitRoot });
     let stdout = "";
     let stderr = "";
@@ -7302,8 +8250,8 @@ function runGit(stepName, gitRoot, args2) {
         stderr += d.toString();
       });
     }
-    proc.on("close", (code) => resolve6({ code, stdout, stderr }));
-    proc.on("error", () => resolve6({ code: -1, stdout, stderr }));
+    proc.on("close", (code) => resolve7({ code, stdout, stderr }));
+    proc.on("error", () => resolve7({ code: -1, stdout, stderr }));
   });
 }
 async function getStatusPorcelainV2(gitRoot) {
@@ -7401,7 +8349,7 @@ async function fetchRemoteRefs(gitRoot, refs) {
   await runGit("fetch-remote-refs", gitRoot, ["fetch", "--no-tags", "origin", ...refs]);
 }
 function hasUnpushedCommits(gitRoot, currentBranch) {
-  return new Promise((resolve6) => {
+  return new Promise((resolve7) => {
     const proc = spawnProcess("git", ["log", `origin/${currentBranch}..HEAD`, "--oneline"], {
       cwd: gitRoot
     });
@@ -7412,13 +8360,13 @@ function hasUnpushedCommits(gitRoot, currentBranch) {
       });
     }
     proc.on("close", () => {
-      resolve6(out.trim().length > 0);
+      resolve7(out.trim().length > 0);
     });
-    proc.on("error", () => resolve6(false));
+    proc.on("error", () => resolve7(false));
   });
 }
 function hasCommitsAheadOfDefault(gitRoot, defaultBranch) {
-  return new Promise((resolve6) => {
+  return new Promise((resolve7) => {
     const proc = spawnProcess("git", ["rev-list", "--count", `origin/${defaultBranch}..HEAD`], {
       cwd: gitRoot
     });
@@ -7430,12 +8378,12 @@ function hasCommitsAheadOfDefault(gitRoot, defaultBranch) {
     }
     proc.on("close", (code) => {
       if (code === 0) {
-        resolve6(parseInt(out.trim(), 10) > 0);
+        resolve7(parseInt(out.trim(), 10) > 0);
       } else {
-        resolve6(false);
+        resolve7(false);
       }
     });
-    proc.on("error", () => resolve6(false));
+    proc.on("error", () => resolve7(false));
   });
 }
 async function getRemoteOrigin(gitRoot) {
@@ -7450,7 +8398,7 @@ async function getRemoteOrigin(gitRoot) {
     }
     return "";
   }
-  return new Promise((resolve6) => {
+  return new Promise((resolve7) => {
     const proc = spawnProcess("git", ["remote", "get-url", "origin"], { cwd: gitRoot });
     let out = "";
     if (proc.stdout) {
@@ -7460,12 +8408,12 @@ async function getRemoteOrigin(gitRoot) {
     }
     proc.on("close", (code) => {
       if (code === 0) {
-        resolve6(out.trim());
+        resolve7(out.trim());
       } else {
-        resolve6("");
+        resolve7("");
       }
     });
-    proc.on("error", () => resolve6(""));
+    proc.on("error", () => resolve7(""));
   });
 }
 async function getGitSyncStatus(gitRoot, branch, options) {
@@ -7473,20 +8421,20 @@ async function getGitSyncStatus(gitRoot, branch, options) {
   console.log(`[git-status] Checking sync status for branch: ${branch}`);
   if (fetchRemote) {
     console.log(`[git-status] Fetching from origin...`);
-    await new Promise((resolve6) => {
+    await new Promise((resolve7) => {
       const fetchProc = spawnProcess("git", ["fetch", "origin"], { cwd: gitRoot });
       fetchProc.on("close", () => {
         console.log(`[git-status] \u2713 Fetch completed`);
-        resolve6();
+        resolve7();
       });
       fetchProc.on("error", () => {
         console.log(`[git-status] Fetch error (continuing anyway)`);
-        resolve6();
+        resolve7();
       });
     });
   }
   console.log(`[git-status] Checking status against remote tracking branch...`);
-  return new Promise((resolve6) => {
+  return new Promise((resolve7) => {
     const statusProc = spawnProcess("git", ["status", "-sb"], { cwd: gitRoot });
     let statusOut = "";
     let statusErr = "";
@@ -7506,49 +8454,49 @@ async function getGitSyncStatus(gitRoot, branch, options) {
       const firstLine = output.split("\n")[0] ?? "";
       if (!firstLine.includes(branch)) {
         console.log(`[git-status] Branch name not found in status output, returning 'Up to date'`);
-        resolve6("Up to date");
+        resolve7("Up to date");
         return;
       }
       if (!firstLine.includes("...")) {
         console.log(`[git-status] No upstream tracking branch detected, returning 'Up to date'`);
-        resolve6("Up to date");
+        resolve7("Up to date");
         return;
       }
       if (firstLine.includes("ahead") && firstLine.includes("behind")) {
         console.log(`[git-status] \u2713 Status: Diverged`);
-        resolve6("Diverged");
+        resolve7("Diverged");
       } else if (firstLine.includes("behind")) {
         console.log(`[git-status] \u2713 Status: Behind`);
-        resolve6("Behind");
+        resolve7("Behind");
       } else if (firstLine.includes("ahead")) {
         console.log(`[git-status] \u2713 Status: Ahead`);
-        resolve6("Ahead");
+        resolve7("Ahead");
       } else {
         console.log(`[git-status] \u2713 Status: Up to date`);
-        resolve6("Up to date");
+        resolve7("Up to date");
       }
     });
     statusProc.on("error", () => {
       console.log(`[git-status] Error getting status, defaulting to 'Up to date'`);
-      resolve6("Up to date");
+      resolve7("Up to date");
     });
   });
 }
 async function hasRemoteBranch(gitRoot, branch) {
-  return new Promise((resolve6) => {
+  return new Promise((resolve7) => {
     const proc = spawnProcess("git", ["rev-parse", "--verify", `origin/${branch}`], {
       cwd: gitRoot
     });
     proc.on("close", (code) => {
-      resolve6(code === 0);
+      resolve7(code === 0);
     });
     proc.on("error", () => {
-      resolve6(false);
+      resolve7(false);
     });
   });
 }
 function getDefaultBranch(gitRoot) {
-  return new Promise((resolve6) => {
+  return new Promise((resolve7) => {
     const proc = spawnProcess("git", ["symbolic-ref", "refs/remotes/origin/HEAD"], {
       cwd: gitRoot
     });
@@ -7561,12 +8509,12 @@ function getDefaultBranch(gitRoot) {
     proc.on("close", (code) => {
       if (code === 0 && out.trim()) {
         const match = out.trim().match(/refs\/remotes\/origin\/(.+)/);
-        resolve6(match ? match[1] : null);
+        resolve7(match ? match[1] : null);
       } else {
-        resolve6(null);
+        resolve7(null);
       }
     });
-    proc.on("error", () => resolve6(null));
+    proc.on("error", () => resolve7(null));
   });
 }
 async function findDefaultBranch(gitRoot) {
@@ -7586,7 +8534,7 @@ async function resolvePrCommitLogRange(gitRoot, baseBranch, currentBranch) {
 }
 async function getPrBranchDiff(gitRoot, baseBranch) {
   const diffRange = await hasRemoteBranch(gitRoot, baseBranch) ? `origin/${baseBranch}...HEAD` : `${baseBranch}...HEAD`;
-  return new Promise((resolve6) => {
+  return new Promise((resolve7) => {
     const proc = spawnProcess("git", ["diff", diffRange], { cwd: gitRoot });
     let out = "";
     if (proc.stdout) {
@@ -7594,13 +8542,13 @@ async function getPrBranchDiff(gitRoot, baseBranch) {
         out += d.toString();
       });
     }
-    proc.on("close", () => resolve6(out.trim()));
-    proc.on("error", () => resolve6(""));
+    proc.on("close", () => resolve7(out.trim()));
+    proc.on("error", () => resolve7(""));
   });
 }
 async function getCommitLog(gitRoot, baseBranch, currentBranch) {
   const range = await resolvePrCommitLogRange(gitRoot, baseBranch, currentBranch);
-  return new Promise((resolve6) => {
+  return new Promise((resolve7) => {
     const proc = spawnProcess("git", ["log", "--oneline", range], {
       cwd: gitRoot
     });
@@ -7610,13 +8558,13 @@ async function getCommitLog(gitRoot, baseBranch, currentBranch) {
         out += d.toString();
       });
     }
-    proc.on("close", () => resolve6(out.trim()));
-    proc.on("error", () => resolve6(""));
+    proc.on("close", () => resolve7(out.trim()));
+    proc.on("error", () => resolve7(""));
   });
 }
 async function getDetailedCommits(gitRoot, baseBranch, currentBranch) {
   const range = await resolvePrCommitLogRange(gitRoot, baseBranch, currentBranch);
-  return new Promise((resolve6) => {
+  return new Promise((resolve7) => {
     const proc = spawnProcess("git", ["log", range, "--format=%h %s%n%b%n---"], { cwd: gitRoot });
     let out = "";
     if (proc.stdout) {
@@ -7625,14 +8573,14 @@ async function getDetailedCommits(gitRoot, baseBranch, currentBranch) {
       });
     }
     proc.on("close", () => {
-      resolve6(out.length > 2e3 ? out.substring(0, 2e3) + "\n...(more commits)" : out);
+      resolve7(out.length > 2e3 ? out.substring(0, 2e3) + "\n...(more commits)" : out);
     });
-    proc.on("error", () => resolve6(""));
+    proc.on("error", () => resolve7(""));
   });
 }
 function getGitLog(gitRoot, limit) {
   return new Promise(
-    (resolve6, reject) => {
+    (resolve7, reject) => {
       const proc = spawnProcess(
         "git",
         ["log", "--oneline", "-n", limit.toString(), "--format=%H|%s|%an|%ai"],
@@ -7662,7 +8610,7 @@ function getGitLog(gitRoot, limit) {
               date: parts[3] || ""
             };
           });
-          resolve6(parsed);
+          resolve7(parsed);
         } else {
           reject(new Error(err || "Failed to get git log"));
         }
@@ -7672,27 +8620,27 @@ function getGitLog(gitRoot, limit) {
   );
 }
 function stageAllChanges(gitRoot) {
-  return new Promise((resolve6, reject) => {
+  return new Promise((resolve7, reject) => {
     const proc = spawnProcess("git", ["add", "-A"], { cwd: gitRoot });
     proc.on("close", (code) => {
-      if (code === 0) resolve6();
+      if (code === 0) resolve7();
       else reject(new Error("Failed to stage changes"));
     });
     proc.on("error", reject);
   });
 }
 function commitChanges(gitRoot, message) {
-  return new Promise((resolve6, reject) => {
+  return new Promise((resolve7, reject) => {
     const proc = spawnProcess("git", ["commit", "-m", message], { cwd: gitRoot });
     proc.on("close", (code) => {
-      if (code === 0) resolve6();
+      if (code === 0) resolve7();
       else reject(new Error("Failed to commit changes"));
     });
     proc.on("error", reject);
   });
 }
 function pushToOrigin(gitRoot, currentBranch) {
-  return new Promise((resolve6, reject) => {
+  return new Promise((resolve7, reject) => {
     console.log(`[git-push] Executing: git push -u origin ${currentBranch}`);
     const proc = spawnProcess("git", ["push", "-u", "origin", currentBranch], { cwd: gitRoot });
     let err = "";
@@ -7713,7 +8661,7 @@ function pushToOrigin(gitRoot, currentBranch) {
       console.log(`[git-push] git push exited with code: ${code}`);
       if (code === 0) {
         console.log(`[git-push] \u2713 Push completed successfully`);
-        resolve6();
+        resolve7();
       } else {
         console.log(`[git-push] \u2717 Push failed with error: ${err || "Unknown error"}`);
         reject(new Error(err || "Failed to push changes"));
@@ -7728,7 +8676,7 @@ function pushToOrigin(gitRoot, currentBranch) {
   });
 }
 function fetchFromOrigin(gitRoot) {
-  return new Promise((resolve6, reject) => {
+  return new Promise((resolve7, reject) => {
     const proc = spawnProcess("git", ["fetch", "origin"], { cwd: gitRoot });
     let err = "";
     if (proc.stderr) {
@@ -7737,14 +8685,14 @@ function fetchFromOrigin(gitRoot) {
       });
     }
     proc.on("close", (code) => {
-      if (code === 0) resolve6();
+      if (code === 0) resolve7();
       else reject(new Error(err || "Failed to fetch from origin"));
     });
     proc.on("error", reject);
   });
 }
 function pullFromOrigin(gitRoot) {
-  return new Promise((resolve6, reject) => {
+  return new Promise((resolve7, reject) => {
     const proc = spawnProcess("git", ["pull"], { cwd: gitRoot });
     let err = "";
     if (proc.stderr) {
@@ -7753,14 +8701,14 @@ function pullFromOrigin(gitRoot) {
       });
     }
     proc.on("close", (code) => {
-      if (code === 0) resolve6();
+      if (code === 0) resolve7();
       else reject(new Error(err || "Failed to pull from origin"));
     });
     proc.on("error", reject);
   });
 }
 function createGitHubRepo(gitRoot, repoName, description, isPrivate) {
-  return new Promise((resolve6, reject) => {
+  return new Promise((resolve7, reject) => {
     const args2 = ["repo", "create"];
     if (repoName) {
       args2.push(repoName);
@@ -7791,7 +8739,7 @@ function createGitHubRepo(gitRoot, repoName, description, isPrivate) {
       if (code === 0) {
         invalidateRepoInfoCache(gitRoot);
         const urlMatch = out.match(/https:\/\/[^\s]+/);
-        resolve6(urlMatch ? urlMatch[0] : out.trim());
+        resolve7(urlMatch ? urlMatch[0] : out.trim());
       } else {
         reject(new Error(err || "Failed to create repository"));
       }
@@ -7803,7 +8751,7 @@ function createGitHubRepo(gitRoot, repoName, description, isPrivate) {
   });
 }
 function createPullRequest(gitRoot, title, description) {
-  return new Promise((resolve6, reject) => {
+  return new Promise((resolve7, reject) => {
     const args2 = ["pr", "create", "--title", title ?? "", "--body", description ?? ""];
     console.log(`[git-create-pr] Executing: gh ${args2.join(" ")}`);
     const proc = spawnProcess("gh", args2, { cwd: gitRoot });
@@ -7828,7 +8776,7 @@ function createPullRequest(gitRoot, title, description) {
         const urlMatch = out.match(/https:\/\/[^\s]+/);
         const prUrl = urlMatch ? urlMatch[0] : out.trim();
         console.log(`[git-create-pr] \u2713 PR URL extracted: ${prUrl}`);
-        resolve6(prUrl);
+        resolve7(prUrl);
       } else {
         console.log(`[git-create-pr] \u2717 gh pr create failed with error: ${err || "Unknown error"}`);
         reject(new Error(err || "Failed to create PR"));
@@ -7867,7 +8815,7 @@ async function getPullRequestStatus(gitRoot) {
     }
     throw new Error(result.stderr || "Failed to check PR status");
   }
-  return new Promise((resolve6, reject) => {
+  return new Promise((resolve7, reject) => {
     const args2 = ["pr", "view", "--json", "url,state"];
     const proc = spawnProcess("gh", args2, { cwd: gitRoot });
     let out = "";
@@ -7886,7 +8834,7 @@ async function getPullRequestStatus(gitRoot) {
       if (code === 0) {
         try {
           const prData = JSON.parse(out.trim());
-          resolve6({
+          resolve7({
             exists: true,
             url: prData.url,
             state: prData.state
@@ -7896,7 +8844,7 @@ async function getPullRequestStatus(gitRoot) {
         }
       } else {
         if (err.includes("no pull requests") || err.includes("not found")) {
-          resolve6({ exists: false });
+          resolve7({ exists: false });
         } else {
           reject(new Error(err || "Failed to check PR status"));
         }
@@ -8083,7 +9031,7 @@ function buildCrossHostRedirectResult(redirectUrl) {
 
 // src/features/web-fetch/web-fetch.client.ts
 import { mkdir, writeFile as writeFile2 } from "fs/promises";
-import { join as join11, extname as extname3 } from "path";
+import { join as join13, extname as extname3 } from "path";
 import { createHash as createHash2 } from "crypto";
 
 // src/features/web-fetch/web-fetch-cache.ts
@@ -8188,7 +9136,7 @@ async function readResponseBody(response, signal) {
   return { body, bytes: body.length };
 }
 async function saveBinaryContent(body, contentType, url) {
-  const downloadsDir = join11(getDataDir(), "fetch-downloads");
+  const downloadsDir = join13(getDataDir(), "fetch-downloads");
   await mkdir(downloadsDir, { recursive: true });
   const hash = createHash2("sha256").update(url).digest("hex").slice(0, 12);
   let extension = extname3(new URL(url).pathname);
@@ -8203,7 +9151,7 @@ async function saveBinaryContent(body, contentType, url) {
   if (!extension) {
     extension = ".bin";
   }
-  const filePath = join11(downloadsDir, `${hash}${extension}`);
+  const filePath = join13(downloadsDir, `${hash}${extension}`);
   await writeFile2(filePath, body);
   return filePath;
 }
@@ -8364,9 +9312,9 @@ function truncateFetchUrl(url, maxLength = 80) {
 }
 
 // src/tools/fetch.ts
-var fetchSchema = Type17.Object({
-  url: Type17.String({ description: "Fully qualified URL to fetch (http or https)" }),
-  prompt: Type17.String({
+var fetchSchema = Type18.Object({
+  url: Type18.String({ description: "Fully qualified URL to fetch (http or https)" }),
+  prompt: Type18.String({
     description: "What to extract or summarize from the page content"
   })
 });
@@ -8446,13 +9394,187 @@ function createFetchTool(options) {
           });
         }
         const details = {
-          url: fetchResult.finalUrl,
-          bytes: fetchResult.bytes,
-          code: fetchResult.code,
-          codeText: fetchResult.codeText,
-          durationMs: fetchResult.durationMs
+          url: fetchResult.finalUrl,
+          bytes: fetchResult.bytes,
+          code: fetchResult.code,
+          codeText: fetchResult.codeText,
+          durationMs: fetchResult.durationMs
+        };
+        const output = JSON.stringify({ ...details, result });
+        return {
+          content: [{ type: "text", text: output }],
+          details
+        };
+      });
+    }
+  };
+}
+
+// src/tools/web-search.ts
+import { Type as Type19 } from "@sinclair/typebox";
+
+// src/features/web-search/web-search.client.ts
+var WEB_SEARCH_API = "https://api.webnative.dev/websearch";
+function clampNumResults(numResults) {
+  if (numResults === void 0) return 10;
+  return Math.min(100, Math.max(1, Math.round(numResults)));
+}
+function normalizeResultItem(raw) {
+  const highlights = Array.isArray(raw.highlights) ? raw.highlights.filter((item) => typeof item === "string") : void 0;
+  return {
+    title: typeof raw.title === "string" ? raw.title : "Untitled",
+    url: typeof raw.url === "string" ? raw.url : typeof raw.id === "string" ? raw.id : "",
+    publishedDate: typeof raw.publishedDate === "string" || raw.publishedDate === null ? raw.publishedDate : void 0,
+    author: typeof raw.author === "string" || raw.author === null ? raw.author : void 0,
+    highlights
+  };
+}
+function parseSearchErrorMessage(status, body) {
+  try {
+    const parsed = JSON.parse(body);
+    const message = typeof parsed.error === "string" && parsed.error || typeof parsed.message === "string" && parsed.message;
+    if (message) return `Web search failed (${status}): ${message}`;
+  } catch {
+  }
+  return `Web search failed (${status}): ${body || "Unknown error"}`;
+}
+async function searchWeb(options) {
+  const payload = {
+    query: options.query,
+    type: options.type ?? "auto",
+    numResults: clampNumResults(options.numResults),
+    contents: {
+      highlights: true
+    }
+  };
+  if (options.includeDomains?.length) {
+    payload.includeDomains = options.includeDomains;
+  }
+  if (options.excludeDomains?.length) {
+    payload.excludeDomains = options.excludeDomains;
+  }
+  const response = await fetch(WEB_SEARCH_API, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(payload),
+    signal: options.signal
+  });
+  const body = await response.text();
+  if (!response.ok) {
+    throw new Error(parseSearchErrorMessage(response.status, body));
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(body);
+  } catch {
+    throw new Error("Web search failed: invalid JSON response");
+  }
+  const rawResults = Array.isArray(parsed.results) ? parsed.results : [];
+  const results = rawResults.filter((item) => item !== null && typeof item === "object").map(normalizeResultItem);
+  return {
+    requestId: typeof parsed.requestId === "string" ? parsed.requestId : void 0,
+    searchType: typeof parsed.searchType === "string" ? parsed.searchType : void 0,
+    results
+  };
+}
+
+// src/tools/web-search.ts
+var searchTypeSchema = Type19.Union([
+  Type19.Literal("auto"),
+  Type19.Literal("fast"),
+  Type19.Literal("instant"),
+  Type19.Literal("deep-lite"),
+  Type19.Literal("deep"),
+  Type19.Literal("deep-reasoning")
+]);
+var webSearchSchema = Type19.Object({
+  query: Type19.String({
+    description: "Natural language search query (e.g. 'Next.js route handler authentication example')"
+  }),
+  numResults: Type19.Optional(
+    Type19.Number({
+      description: "Number of results to return (1-100, default 10)",
+      minimum: 1,
+      maximum: 100
+    })
+  ),
+  type: Type19.Optional(
+    Type19.Union([searchTypeSchema], {
+      description: "Search depth/latency tradeoff. Use auto (default) for most queries; fast/instant for low latency; deep variants for research."
+    })
+  ),
+  includeDomains: Type19.Optional(
+    Type19.Array(Type19.String(), {
+      description: "Only return results from these domains (e.g. ['docs.github.com', 'nodejs.org'])"
+    })
+  ),
+  excludeDomains: Type19.Optional(
+    Type19.Array(Type19.String(), {
+      description: "Exclude results from these domains"
+    })
+  )
+});
+function createWebSearchTool() {
+  return {
+    name: "web_search",
+    label: "web_search",
+    description: "Search the web for current information, documentation, API references, and code examples. Returns titles, URLs, and query-relevant highlights for each result. Use fetch to read a specific URL in full after finding it.",
+    parameters: webSearchSchema,
+    execute: async (_toolCallId, { query, numResults, type, includeDomains, excludeDomains }, signal, onUpdate) => {
+      return withAbortSignal(signal, async (isAborted) => {
+        onUpdate?.({
+          content: [{ type: "text", text: `Searching the web for "${query}"\u2026` }],
+          details: void 0
+        });
+        let response;
+        try {
+          response = await searchWeb({
+            query,
+            numResults,
+            type,
+            includeDomains,
+            excludeDomains,
+            signal
+          });
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          return {
+            content: [{ type: "text", text: message }],
+            details: void 0
+          };
+        }
+        if (isAborted()) {
+          return { content: [], details: void 0 };
+        }
+        const payload = {
+          query,
+          searchType: response.searchType ?? type ?? "auto",
+          requestId: response.requestId,
+          resultCount: response.results.length,
+          results: response.results.map((result) => ({
+            title: result.title,
+            url: result.url,
+            publishedDate: result.publishedDate ?? void 0,
+            author: result.author ?? void 0,
+            highlights: result.highlights ?? []
+          }))
+        };
+        const serialized = JSON.stringify(payload, null, 2);
+        const truncated = truncateHead(serialized, { maxLines: 500, maxBytes: 50 * 1024 });
+        let output = truncated.content;
+        if (truncated.truncated) {
+          output += `
+
+[Output truncated: showing ${truncated.outputLines}/${truncated.totalLines} lines]`;
+        }
+        const details = {
+          query,
+          searchType: payload.searchType,
+          resultCount: payload.resultCount,
+          requestId: response.requestId
         };
-        const output = JSON.stringify({ ...details, result });
         return {
           content: [{ type: "text", text: output }],
           details
@@ -8463,13 +9585,13 @@ function createFetchTool(options) {
 }
 
 // src/tools/tool-search.ts
-import { Type as Type18 } from "@sinclair/typebox";
-var toolSearchSchema = Type18.Object({
-  query: Type18.String({
+import { Type as Type20 } from "@sinclair/typebox";
+var toolSearchSchema = Type20.Object({
+  query: Type20.String({
     description: 'Search query to find tools. Use "select:name1,name2" to fetch exact tools by name, or keywords to search by description.'
   }),
-  max_results: Type18.Optional(
-    Type18.Number({
+  max_results: Type20.Optional(
+    Type20.Number({
       description: "Maximum number of results to return (default: 5)"
     })
   )
@@ -8597,6 +9719,7 @@ var toolRegistry = [
   { name: "agent", enabled: true, displayName: "Subagent", activeDisplayName: "Subagent" },
   { name: "ask_user", enabled: true, displayName: "Ask", activeDisplayName: "Asking" },
   { name: "bash", enabled: true, displayName: "Ran", activeDisplayName: "Running" },
+  { name: "browser", enabled: true, displayName: "Browser", activeDisplayName: "Browsing" },
   {
     name: "code_search",
     enabled: false,
@@ -8648,6 +9771,12 @@ var toolRegistry = [
     displayName: "Find Tools",
     activeDisplayName: "Finding Tools"
   },
+  {
+    name: "web_search",
+    enabled: true,
+    displayName: "Web Search",
+    activeDisplayName: "Searching Web"
+  },
   { name: "write", enabled: true, displayName: "Write", activeDisplayName: "Writing" }
 ];
 var registryByName = new Map(toolRegistry.map((entry) => [entry.name, entry]));
@@ -8671,6 +9800,9 @@ function resolveRegistryEntry(toolName) {
   if (lowerName === "fetch" || lowerName.includes("web_fetch")) {
     return registryByName.get("fetch");
   }
+  if (lowerName === "web_search") {
+    return registryByName.get("web_search");
+  }
   if (lowerName.includes("read")) {
     return registryByName.get("read");
   }
@@ -8774,7 +9906,7 @@ var WebFetchPermissionGate = class {
       wildcardOptions: buildWildcardOptions2(normalized)
     };
     this.config.onPermissionRequired?.(request);
-    return new Promise((resolve6, reject) => {
+    return new Promise((resolve7, reject) => {
       const cleanup = () => {
         pendingPermissions.delete(toolCallId);
         signal?.removeEventListener("abort", onAbort);
@@ -8792,7 +9924,7 @@ var WebFetchPermissionGate = class {
       pendingPermissions.set(toolCallId, {
         resolve: (decision) => {
           cleanup();
-          void this.applyDecision(decision, normalized).then(() => resolve6(decision));
+          void this.applyDecision(decision, normalized).then(() => resolve7(decision));
         },
         reject: (error) => {
           cleanup();
@@ -8932,12 +10064,16 @@ async function createCodingTools(cwd, options) {
     createFetchTool({
       metadataManager: options?.metadataManager,
       webFetchPermissionGate: options?.webFetchPermissionGate
-    })
+    }),
+    createWebSearchTool()
   ]);
   if (options?.metadataManager && isToolEnabled("generate_image")) {
     coreTools.push(createGenerateImageTool({ metadataManager: options.metadataManager, cwd }));
   }
-  const optionalTools = filterEnabledTools([createFindImagesTool(cwd)]);
+  const optionalTools = filterEnabledTools([
+    createFindImagesTool({ cwd, threadId: options?.threadId }),
+    createBrowserTool({ cwd, threadId: options?.threadId })
+  ]);
   if (options?.skills && options.skills.length > 0) {
     optionalTools.push(
       ...filterEnabledTools([
@@ -9016,7 +10152,7 @@ function createAllTools(cwd, options) {
     });
   }
   if (isToolEnabled("find_images")) {
-    tools.find_images = createFindImagesTool(cwd);
+    tools.find_images = createFindImagesTool({ cwd, threadId: options?.threadId });
   }
   if (options?.threadId) {
     for (const [name, tool] of Object.entries(tools)) {
@@ -9050,10 +10186,10 @@ async function* loadCodingToolsWithMcpStatus(cwd, options) {
     if (completed) {
       break;
     }
-    await new Promise((resolve6) => {
-      notify = resolve6;
+    await new Promise((resolve7) => {
+      notify = resolve7;
       if (completed) {
-        resolve6();
+        resolve7();
       }
     });
     notify = null;
@@ -9065,7 +10201,7 @@ async function* loadCodingToolsWithMcpStatus(cwd, options) {
 }
 
 // src/tools/agent-tool.ts
-import { Type as Type19 } from "@sinclair/typebox";
+import { Type as Type21 } from "@sinclair/typebox";
 
 // src/agent/agent.subagent-executor.ts
 import { Agent } from "@earendil-works/pi-agent-core";
@@ -9183,7 +10319,7 @@ var EventQueue = class {
         content: resultContent,
         isError: event.isError
       };
-      if (event.toolName === "generate_image") {
+      if (event.toolName === "generate_image" || event.toolName === "find_images" || event.toolName === "browser") {
         toolResultBlock.content = stripGeneratedImageText(resultContent);
         const details = event.result?.details;
         if (details?.imageUrl) {
@@ -9224,6 +10360,7 @@ var EventQueue = class {
    */
   push(event) {
     this.queue.push(event);
+    this.notify();
   }
   /**
    * Removes and returns the next event from the queue
@@ -9389,8 +10526,8 @@ async function executeSubagent(options) {
         const e = eventQueue.shift();
         if (e) onEvent(e);
       } else {
-        await new Promise((resolve6) => {
-          eventQueue.setResolver(resolve6);
+        await new Promise((resolve7) => {
+          eventQueue.setResolver(resolve7);
         });
       }
     }
@@ -9414,15 +10551,15 @@ async function executeSubagent(options) {
 }
 
 // src/tools/agent-tool.ts
-var agentToolSchema = Type19.Object({
-  prompt: Type19.String({ description: "The task or question for the subagent to work on" }),
-  agentName: Type19.Optional(
-    Type19.String({
+var agentToolSchema = Type21.Object({
+  prompt: Type21.String({ description: "The task or question for the subagent to work on" }),
+  agentName: Type21.Optional(
+    Type21.String({
       description: "Name of a defined agent (from AGENT.md) to use. If omitted, a general-purpose subagent is created."
     })
   ),
-  description: Type19.Optional(
-    Type19.String({
+  description: Type21.Optional(
+    Type21.String({
       description: "A short (3-5 word) label describing what the subagent will do"
     })
   )
@@ -9450,7 +10587,7 @@ function createAgentTool(options) {
     label: "agent",
     description: "Launch a specialized subagent to handle a focused subtask in an isolated context. The subagent runs autonomously and returns its result. Use this to delegate research, analysis, or parallel work without polluting the current context. If agentName is provided, that agent's system prompt and tool restrictions are applied.",
     parameters: agentToolSchema,
-    execute: async (_toolCallId, { prompt, agentName, description }) => {
+    execute: async (toolCallId, { prompt, agentName, description }) => {
       const agentDef = agentName ? agents.find((a) => a.name === agentName && !a.disableModelInvocation) : void 0;
       if (agentName && !agentDef) {
         const available = agents.filter((a) => !a.disableModelInvocation).map((a) => a.name).join(", ");
@@ -9474,6 +10611,7 @@ function createAgentTool(options) {
       );
       onEvent({
         type: "subagent_start",
+        toolCallId,
         subagentName: label,
         subagentDescription: agentDef?.description,
         subagentPrompt: prompt
@@ -9490,6 +10628,7 @@ function createAgentTool(options) {
           onEvent: (event) => {
             onEvent({
               type: "subagent_event",
+              toolCallId,
               subagentName: label,
               subagentEvent: event
             });
@@ -9501,6 +10640,7 @@ function createAgentTool(options) {
         console.error(`[agent-tool] Subagent '${label}' failed:`, message);
         onEvent({
           type: "subagent_complete",
+          toolCallId,
           subagentName: label,
           subagentResult: `Error: ${message}`
         });
@@ -9511,6 +10651,7 @@ function createAgentTool(options) {
       }
       onEvent({
         type: "subagent_complete",
+        toolCallId,
         subagentName: label,
         subagentResult: result
       });
@@ -9529,7 +10670,7 @@ import { readFileSync as readFileSync5 } from "fs";
 
 // src/project-analyzer.ts
 import { readFileSync as readFileSync4, existsSync as existsSync9 } from "fs";
-import { join as join12 } from "path";
+import { join as join14 } from "path";
 var ProjectAnalyzer = class {
   projectPath;
   constructor(projectPath = process.cwd()) {
@@ -9540,7 +10681,7 @@ var ProjectAnalyzer = class {
     return this.generateDescription(info);
   }
   getProjectInfo() {
-    const packageJsonPath = join12(this.projectPath, "package.json");
+    const packageJsonPath = join14(this.projectPath, "package.json");
     const info = { description: "" };
     if (existsSync9(packageJsonPath)) {
       const packageJson = JSON.parse(readFileSync4(packageJsonPath, "utf-8"));
@@ -9582,15 +10723,15 @@ var ProjectAnalyzer = class {
     }
   }
   detectBuildTool(_scripts = {}, deps, info) {
-    if (deps.vite || existsSync9(join12(this.projectPath, "vite.config.js")) || existsSync9(join12(this.projectPath, "vite.config.ts"))) {
+    if (deps.vite || existsSync9(join14(this.projectPath, "vite.config.js")) || existsSync9(join14(this.projectPath, "vite.config.ts"))) {
       info.buildTool = "Vite";
       return;
     }
-    if (deps.webpack || existsSync9(join12(this.projectPath, "webpack.config.js"))) {
+    if (deps.webpack || existsSync9(join14(this.projectPath, "webpack.config.js"))) {
       info.buildTool = "Webpack";
       return;
     }
-    if (deps.rollup || existsSync9(join12(this.projectPath, "rollup.config.js"))) {
+    if (deps.rollup || existsSync9(join14(this.projectPath, "rollup.config.js"))) {
       info.buildTool = "Rollup";
       return;
     }
@@ -9640,40 +10781,40 @@ var ProjectAnalyzer = class {
     info.uiLibraries = [...new Set(uiLibs)].filter(Boolean);
   }
   detectProjectType(info) {
-    if (existsSync9(join12(this.projectPath, ".xcodeproj")) || existsSync9(join12(this.projectPath, ".xcworkspace")) || existsSync9(join12(this.projectPath, "project.pbxproj"))) {
+    if (existsSync9(join14(this.projectPath, ".xcodeproj")) || existsSync9(join14(this.projectPath, ".xcworkspace")) || existsSync9(join14(this.projectPath, "project.pbxproj"))) {
       info.projectType = "Xcode";
-    } else if (existsSync9(join12(this.projectPath, "build.gradle")) || existsSync9(join12(this.projectPath, "build.gradle.kts")) || existsSync9(join12(this.projectPath, "app/build.gradle")) || existsSync9(join12(this.projectPath, "settings.gradle"))) {
+    } else if (existsSync9(join14(this.projectPath, "build.gradle")) || existsSync9(join14(this.projectPath, "build.gradle.kts")) || existsSync9(join14(this.projectPath, "app/build.gradle")) || existsSync9(join14(this.projectPath, "settings.gradle"))) {
       info.projectType = "Android Studio";
-    } else if (existsSync9(join12(this.projectPath, "pubspec.yaml"))) {
+    } else if (existsSync9(join14(this.projectPath, "pubspec.yaml"))) {
       info.projectType = "Flutter";
-    } else if (existsSync9(join12(this.projectPath, "go.mod"))) {
+    } else if (existsSync9(join14(this.projectPath, "go.mod"))) {
       info.projectType = "Go";
-    } else if (existsSync9(join12(this.projectPath, "Cargo.toml"))) {
+    } else if (existsSync9(join14(this.projectPath, "Cargo.toml"))) {
       info.projectType = "Rust";
-    } else if (existsSync9(join12(this.projectPath, "requirements.txt")) || existsSync9(join12(this.projectPath, "pyproject.toml")) || existsSync9(join12(this.projectPath, "setup.py"))) {
+    } else if (existsSync9(join14(this.projectPath, "requirements.txt")) || existsSync9(join14(this.projectPath, "pyproject.toml")) || existsSync9(join14(this.projectPath, "setup.py"))) {
       info.projectType = "Python";
-    } else if (existsSync9(join12(this.projectPath, "Gemfile"))) {
+    } else if (existsSync9(join14(this.projectPath, "Gemfile"))) {
       info.projectType = "Ruby";
-    } else if (existsSync9(join12(this.projectPath, "composer.json"))) {
+    } else if (existsSync9(join14(this.projectPath, "composer.json"))) {
       info.projectType = "PHP";
-    } else if (existsSync9(join12(this.projectPath, "pom.xml")) || existsSync9(join12(this.projectPath, "build.xml"))) {
+    } else if (existsSync9(join14(this.projectPath, "pom.xml")) || existsSync9(join14(this.projectPath, "build.xml"))) {
       info.projectType = "Java";
-    } else if (existsSync9(join12(this.projectPath, ".csproj")) || existsSync9(join12(this.projectPath, "project.json"))) {
+    } else if (existsSync9(join14(this.projectPath, ".csproj")) || existsSync9(join14(this.projectPath, "project.json"))) {
       info.projectType = ".NET";
     }
   }
   detectPackageManager(info) {
-    if (existsSync9(join12(this.projectPath, "bun.lockb"))) {
+    if (existsSync9(join14(this.projectPath, "bun.lockb"))) {
       info.packageManager = "Bun";
-    } else if (existsSync9(join12(this.projectPath, "bun.lock"))) {
+    } else if (existsSync9(join14(this.projectPath, "bun.lock"))) {
       info.packageManager = "Bun";
-    } else if (existsSync9(join12(this.projectPath, "pnpm-lock.yaml"))) {
+    } else if (existsSync9(join14(this.projectPath, "pnpm-lock.yaml"))) {
       info.packageManager = "pnpm";
-    } else if (existsSync9(join12(this.projectPath, "yarn.lock"))) {
+    } else if (existsSync9(join14(this.projectPath, "yarn.lock"))) {
       info.packageManager = "Yarn";
-    } else if (existsSync9(join12(this.projectPath, "package-lock.json"))) {
+    } else if (existsSync9(join14(this.projectPath, "package-lock.json"))) {
       info.packageManager = "npm";
-    } else if (existsSync9(join12(this.projectPath, "npm-shrinkwrap.json"))) {
+    } else if (existsSync9(join14(this.projectPath, "npm-shrinkwrap.json"))) {
       info.packageManager = "npm";
     }
   }
@@ -9735,8 +10876,8 @@ function analyzeProject(projectPath) {
 }
 
 // src/features/rules/rules.manager.ts
-import { readdir as readdir3, readFile as readFile5 } from "fs/promises";
-import { join as join13, relative as relative4 } from "path";
+import { readdir as readdir3, readFile as readFile6 } from "fs/promises";
+import { join as join15, relative as relative4 } from "path";
 import { existsSync as existsSync10 } from "fs";
 import { homedir as homedir5 } from "os";
 function parseRuleFrontmatter(markdown) {
@@ -9780,10 +10921,10 @@ function parseRuleFrontmatter(markdown) {
   return { metadata, content };
 }
 function getGlobalRulesDir() {
-  return join13(homedir5(), ".agents", "rules");
+  return join15(homedir5(), ".agents", "rules");
 }
 function getProjectRulesDir(threadPath) {
-  return join13(threadPath, ".agents", "rules");
+  return join15(threadPath, ".agents", "rules");
 }
 var RuleManager = class {
   /**
@@ -9816,13 +10957,13 @@ var RuleManager = class {
     try {
       const entries = await readdir3(dir, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = join13(dir, entry.name);
+        const fullPath = join15(dir, entry.name);
         if (entry.isDirectory()) {
           const subRules = await this.loadRulesFromDir(fullPath, threadPath, scope);
           rules.push(...subRules);
         } else if (entry.isFile() && (entry.name.endsWith(".md") || entry.name.endsWith(".mdc"))) {
           try {
-            const fileContent = await readFile5(fullPath, "utf-8");
+            const fileContent = await readFile6(fullPath, "utf-8");
             const { metadata, content } = parseRuleFrontmatter(fileContent);
             const ruleName = entry.name.replace(/\.(md|mdc)$/, "");
             const relativePath = relative4(threadPath, fullPath);
@@ -9951,6 +11092,12 @@ init_tarsk_debug();
 function buildDefaultPrompt(tools) {
   return buildDefaultSystemPrompt(tools.map((tool) => tool.name));
 }
+function resolveBaseSystemPrompt(tools, overrideOptions) {
+  const base = resolveEffectiveSystemPrompt(buildDefaultPrompt(tools), overrideOptions);
+  return `${base}
+
+${formatCurrentDateLine()}`;
+}
 var PLAN_MODE_INSTRUCTIONS = `
 
 # Plan Mode (ACTIVE)
@@ -10119,7 +11266,7 @@ function resolveEffectiveSystemPrompt(generatedPrompt, options) {
   return generatedPrompt;
 }
 async function loadPromptSections(threadPath, tools, skills, planMode, agents, deferredTools, ralphMode, overrideOptions) {
-  let systemPrompt = resolveEffectiveSystemPrompt(buildDefaultPrompt(tools), overrideOptions);
+  let systemPrompt = resolveBaseSystemPrompt(tools, overrideOptions);
   const agentsContent = loadDeveloperContext(threadPath);
   if (agentsContent) {
     systemPrompt += "\n\n# Developer Context\n\n" + agentsContent;
@@ -10201,7 +11348,7 @@ function formatAgentsSection(agents) {
   return section;
 }
 async function loadAgentSystemPrompt(threadPath, tools, skills, planMode, agents, deferredTools, ralphMode, overrideOptions) {
-  let prompt = resolveEffectiveSystemPrompt(buildDefaultPrompt(tools), overrideOptions);
+  let prompt = resolveBaseSystemPrompt(tools, overrideOptions);
   const agentsContent = loadDeveloperContext(threadPath);
   if (agentsContent) {
     prompt += "\n\n# Developer Context\n\n" + agentsContent;
@@ -10318,7 +11465,7 @@ var ShellPermissionGate = class {
       wildcardOptions: buildWildcardOptions(command)
     };
     this.config.onPermissionRequired?.(request);
-    return new Promise((resolve6, reject) => {
+    return new Promise((resolve7, reject) => {
       const cleanup = () => {
         pendingPermissions2.delete(toolCallId);
         signal?.removeEventListener("abort", onAbort);
@@ -10336,7 +11483,7 @@ var ShellPermissionGate = class {
       pendingPermissions2.set(toolCallId, {
         resolve: (decision, pattern) => {
           cleanup();
-          void this.applyDecision(decision, command, pattern).then(() => resolve6(decision));
+          void this.applyDecision(decision, command, pattern).then(() => resolve7(decision));
         },
         reject: (error) => {
           cleanup();
@@ -10765,8 +11912,8 @@ ${userPrompt}`;
           if (eventQueue.length > 0) {
             yield eventQueue.shift();
           } else {
-            await new Promise((resolve6) => {
-              eventQueue.setResolver(resolve6);
+            await new Promise((resolve7) => {
+              eventQueue.setResolver(resolve7);
             });
           }
         }
@@ -10922,14 +12069,14 @@ var ProcessingStateManagerImpl = class {
 
 // src/core/env-manager.ts
 import { promises as fs } from "fs";
-import { join as join14 } from "path";
+import { join as join16 } from "path";
 function updateRuntimeEnv(values) {
   for (const [key, value] of Object.entries(values)) {
     process.env[key] = value;
   }
 }
 async function updateEnvFile(keyNames) {
-  const envPath = join14(process.cwd(), ".env");
+  const envPath = join16(process.cwd(), ".env");
   let content = "";
   try {
     content = await fs.readFile(envPath, "utf-8");
@@ -10958,7 +12105,7 @@ async function updateEnvFile(keyNames) {
   await fs.writeFile(envPath, newLines.join("\n") + "\n", "utf-8");
 }
 async function readEnvFile() {
-  const envPath = join14(process.cwd(), ".env");
+  const envPath = join16(process.cwd(), ".env");
   const envMap = {};
   try {
     const content = await fs.readFile(envPath, "utf-8");
@@ -10981,7 +12128,7 @@ async function readEnvFile() {
 import { Hono } from "hono";
 
 // src/agent/agent-run-guard.ts
-import { randomUUID as randomUUID3 } from "crypto";
+import { randomUUID as randomUUID4 } from "crypto";
 var DEFAULT_LONG_RUNNING_TURN_LIMIT = 50;
 var LONG_RUNNING_CONFIRMATION_QUESTION = "The agent has been working for a long time. Do you want to continue?";
 var LONG_RUNNING_CONFIRMATION_OPTIONS = ["Yes", "No"];
@@ -11023,7 +12170,7 @@ function shouldPromptForLongRunningConfirmation(state) {
   return state.turnCount >= state.maximumTurnCount;
 }
 function createLongRunningConfirmationRequest(maximumTurnCount) {
-  const toolCallId = `long-running-confirmation-${randomUUID3()}`;
+  const toolCallId = `long-running-confirmation-${randomUUID4()}`;
   const event = {
     type: "long_running_confirmation",
     prompt: {
@@ -11049,7 +12196,7 @@ function createLongRunningConfirmationRequest(maximumTurnCount) {
     toolCallId,
     event,
     waitForAnswer: (signal) => {
-      return new Promise((resolve6, reject) => {
+      return new Promise((resolve7, reject) => {
         const resolvers = getLongRunningResolvers();
         const cleanup = () => {
           resolvers.delete(toolCallId);
@@ -11072,7 +12219,7 @@ function createLongRunningConfirmationRequest(maximumTurnCount) {
         resolvers.set(toolCallId, {
           resolve: (answer) => {
             cleanup();
-            resolve6(answer);
+            resolve7(answer);
           },
           reject: (error) => {
             cleanup();
@@ -11399,11 +12546,11 @@ function createWebFetchPermissionRoutes() {
 import { Hono as Hono4 } from "hono";
 
 // src/features/chat/chat-post.route.ts
-import { randomUUID as randomUUID6 } from "crypto";
+import { randomUUID as randomUUID7 } from "crypto";
 
 // src/features/skills/skills.manager.ts
-import { readdir as readdir4, readFile as readFile6 } from "fs/promises";
-import { join as join15 } from "path";
+import { readdir as readdir4, readFile as readFile7 } from "fs/promises";
+import { join as join17 } from "path";
 import { existsSync as existsSync11 } from "fs";
 import { homedir as homedir6 } from "os";
 function parseFrontmatter(markdown) {
@@ -11451,10 +12598,10 @@ function parseFrontmatter(markdown) {
   return { metadata, content };
 }
 function getGlobalSkillsDir() {
-  return join15(homedir6(), ".agents", "skills");
+  return join17(homedir6(), ".agents", "skills");
 }
 function getProjectSkillsDir(threadPath) {
-  return join15(threadPath, ".agents", "skills");
+  return join17(threadPath, ".agents", "skills");
 }
 function validateSkillName(name) {
   if (!name || name.length === 0 || name.length > 64) {
@@ -11507,14 +12654,14 @@ var SkillManager = class {
       for (const entry of entries) {
         if (!entry.isDirectory()) continue;
         const skillDirName = entry.name;
-        const skillPath = join15(dir, skillDirName);
-        const skillFilePath = join15(skillPath, "SKILL.md");
+        const skillPath = join17(dir, skillDirName);
+        const skillFilePath = join17(skillPath, "SKILL.md");
         if (!existsSync11(skillFilePath)) {
           console.warn(`Skipping skill directory ${skillDirName}: SKILL.md not found`);
           continue;
         }
         try {
-          const fileContent = await readFile6(skillFilePath, "utf-8");
+          const fileContent = await readFile7(skillFilePath, "utf-8");
           const { metadata, content } = parseFrontmatter(fileContent);
           if (!metadata.name) {
             console.warn(`Skipping skill in ${skillDirName}: missing 'name' in frontmatter`);
@@ -11687,8 +12834,8 @@ async function activateSkills(allSkills, taskDescription, thread, options) {
 }
 
 // src/features/agents/agents.manager.ts
-import { readdir as readdir5, readFile as readFile7 } from "fs/promises";
-import { join as join16 } from "path";
+import { readdir as readdir5, readFile as readFile8 } from "fs/promises";
+import { join as join18 } from "path";
 import { existsSync as existsSync12 } from "fs";
 import { homedir as homedir7 } from "os";
 function parseFrontmatter2(markdown) {
@@ -11746,10 +12893,10 @@ function validateDescription2(description) {
   return !!description && description.length > 0 && description.length <= 1024;
 }
 function getGlobalAgentsDir() {
-  return join16(homedir7(), ".agents", "agents");
+  return join18(homedir7(), ".agents", "agents");
 }
 function getProjectAgentsDir(threadPath) {
-  return join16(threadPath, ".agents", "agents");
+  return join18(threadPath, ".agents", "agents");
 }
 var AgentsManager = class {
   /**
@@ -11781,14 +12928,14 @@ var AgentsManager = class {
       for (const entry of entries) {
         if (!entry.isDirectory()) continue;
         const agentDirName = entry.name;
-        const agentPath = join16(dir, agentDirName);
-        const agentFilePath = join16(agentPath, "AGENT.md");
+        const agentPath = join18(dir, agentDirName);
+        const agentFilePath = join18(agentPath, "AGENT.md");
         if (!existsSync12(agentFilePath)) {
           console.warn(`[agents] Skipping agent directory ${agentDirName}: AGENT.md not found`);
           continue;
         }
         try {
-          const fileContent = await readFile7(agentFilePath, "utf-8");
+          const fileContent = await readFile8(agentFilePath, "utf-8");
           const { metadata, content } = parseFrontmatter2(fileContent);
           if (!metadata.name) {
             console.warn(
@@ -11971,12 +13118,12 @@ function extractAssistantContent(events, fallback) {
 
 // src/features/chat/chat-post.route.ts
 init_database();
-import { readFile as readFile8, unlink } from "fs/promises";
-import { join as join17 } from "path";
+import { readFile as readFile9, unlink as unlink2 } from "fs/promises";
+import { join as join19 } from "path";
 
 // src/features/project-todos/project-todos.database.ts
 init_database();
-import { randomUUID as randomUUID4 } from "crypto";
+import { randomUUID as randomUUID5 } from "crypto";
 function serializeTodo(row) {
   return {
     ...row,
@@ -12001,7 +13148,7 @@ async function getTodoById(db, todoId) {
 }
 async function insertTodo(projectId, title, description) {
   const db = await getDatabase();
-  const id = randomUUID4();
+  const id = randomUUID5();
   const now = (/* @__PURE__ */ new Date()).toISOString();
   await db.execute({
     sql: `INSERT INTO project_todos (id, projectId, title, description, status, working, createdAt, updatedAt)
@@ -12123,7 +13270,7 @@ async function invalidateGitStatusCache(db, threadId) {
 
 // src/features/account/account-get-info.route.ts
 init_database();
-import { randomUUID as randomUUID5 } from "crypto";
+import { randomUUID as randomUUID6 } from "crypto";
 var KEY_BALANCE = "PromptBalance";
 var KEY_VERIFICATION = "PromptBalanceVerification";
 var KEY_PLAN = "Plan";
@@ -12169,7 +13316,7 @@ async function getOrCreateClientReferenceId() {
   if (existing !== null && existing !== void 0) {
     return existing;
   }
-  const id = randomUUID5();
+  const id = randomUUID6();
   await setState(db, KEY_CLIENT_REFERENCE_ID, id);
   return id;
 }
@@ -12450,7 +13597,7 @@ async function deserializeProject(db, row) {
 // src/features/chat/chat-post.route.ts
 init_utils();
 function runValidationScript(script, cwd) {
-  return new Promise((resolve6) => {
+  return new Promise((resolve7) => {
     const child = spawnShell(script, { cwd, stdio: ["pipe", "pipe", "pipe"] });
     let output = "";
     const stdoutDecoder = new TextDecoder();
@@ -12464,12 +13611,12 @@ function runValidationScript(script, cwd) {
     child.on("close", (code) => {
       output += stdoutDecoder.decode();
       output += stderrDecoder.decode();
-      resolve6({ exitCode: code ?? 1, output: output.trim() });
+      resolve7({ exitCode: code ?? 1, output: output.trim() });
     });
     child.on("error", (err) => {
       output += stdoutDecoder.decode();
       output += stderrDecoder.decode();
-      resolve6({
+      resolve7({
         exitCode: 1,
         output: `${output}${output ? "\n" : ""}${err.message}`.trim()
       });
@@ -12586,7 +13733,7 @@ async function postChatMessage(c, threadManager, agentExecutor, conversationMana
     }
     let conversationId = thread.currentConversationId;
     if (!conversationId) {
-      conversationId = randomUUID6();
+      conversationId = randomUUID7();
       const db2 = await getDatabase();
       await db2.execute({
         sql: "DELETE FROM todos WHERE threadId = ?",
@@ -12896,7 +14043,7 @@ ${result.output}`;
             };
             processingStateManager.pushEvent(threadId, iterationEvent);
             yield iterationEvent;
-            const newConversationId = randomUUID6();
+            const newConversationId = randomUUID7();
             await threadManager.updateThread(threadId, {
               currentConversationId: newConversationId
             });
@@ -12988,11 +14135,11 @@ ${result.output}`;
           try {
             const todo = await getTodoByThreadId(db2, threadId);
             if (todo && todo.status === "Plan") {
-              const planFilePath = join17(threadPath, `${todo.id}-plan.md`);
+              const planFilePath = join19(threadPath, `${todo.id}-plan.md`);
               try {
-                const planContent = await readFile8(planFilePath, "utf-8");
+                const planContent = await readFile9(planFilePath, "utf-8");
                 await updateTodo(db2, todo.id, { description: planContent.trim() });
-                await unlink(planFilePath);
+                await unlink2(planFilePath);
               } catch {
               }
             }
@@ -13329,7 +14476,7 @@ ${summary}`;
 }
 
 // src/features/chat/chat-delete.route.ts
-import { randomUUID as randomUUID7 } from "crypto";
+import { randomUUID as randomUUID8 } from "crypto";
 init_database();
 async function deleteChat(c, threadManager) {
   try {
@@ -13351,7 +14498,7 @@ async function deleteChat(c, threadManager) {
       sql: "DELETE FROM todos WHERE threadId = ?",
       args: [threadId]
     });
-    const newConversationId = randomUUID7();
+    const newConversationId = randomUUID8();
     await threadManager.updateThread(threadId, { currentConversationId: newConversationId });
     return successResponse(
       c,
@@ -13380,7 +14527,7 @@ function subscribeToChatStream(c, processingStateManager) {
     return c.json({ error: "Thread is not currently processing" }, 404);
   }
   return stream2(c, async (writer) => {
-    let resolve6 = null;
+    let resolve7 = null;
     const queue = [];
     let done = false;
     const replay = processingStateManager.getBufferedEvents(threadId).slice();
@@ -13391,18 +14538,18 @@ function subscribeToChatStream(c, processingStateManager) {
       } else {
         queue.push(event);
       }
-      if (resolve6) {
-        resolve6();
-        resolve6 = null;
+      if (resolve7) {
+        resolve7();
+        resolve7 = null;
       }
     });
     const finishedBeforeSubscribe = !processingStateManager.isProcessing(threadId);
     writer.onAbort(() => {
       done = true;
       unsubscribe();
-      if (resolve6) {
-        resolve6();
-        resolve6 = null;
+      if (resolve7) {
+        resolve7();
+        resolve7 = null;
       }
     });
     try {
@@ -13427,7 +14574,7 @@ function subscribeToChatStream(c, processingStateManager) {
         }
         if (!done) {
           await new Promise((r) => {
-            resolve6 = r;
+            resolve7 = r;
           });
         }
       }
@@ -13475,10 +14622,10 @@ function createChatRoutes(threadManager, agentExecutor, conversationManager, pro
 init_database();
 
 // src/features/conversations/conversations.database.ts
-import { randomUUID as randomUUID8 } from "crypto";
+import { randomUUID as randomUUID9 } from "crypto";
 async function insertMessage(db, threadId, conversationId, message, model, attachments, planMode, imageMode, ralphMode, checkpointRef) {
   try {
-    const messageId = randomUUID8();
+    const messageId = randomUUID9();
     const timestamp = (/* @__PURE__ */ new Date()).toISOString();
     await db.execute(
       `
@@ -15777,17 +16924,17 @@ async function getOnboardingStatus(c, metadataManager) {
 init_utils();
 async function getGitCheck(c) {
   try {
-    const gitInstalled = await new Promise((resolve6) => {
+    const gitInstalled = await new Promise((resolve7) => {
       const proc = spawnProcess("git", ["--version"]);
       let _err = "";
       proc.stderr?.on("data", (d) => {
         _err += d.toString();
       });
       proc.on("close", (code) => {
-        resolve6(code === 0);
+        resolve7(code === 0);
       });
       proc.on("error", () => {
-        resolve6(false);
+        resolve7(false);
       });
     });
     return c.json({ gitInstalled });
@@ -15821,13 +16968,13 @@ async function postOnboardingReset(c, metadataManager) {
 
 // src/features/onboarding/onboarding-get-recommended-models.route.ts
 import { readFileSync as readFileSync6, existsSync as existsSync13 } from "fs";
-import { join as join18, dirname as dirname4 } from "path";
+import { join as join20, dirname as dirname4 } from "path";
 import { fileURLToPath } from "url";
 function getRecommendedModelsFilePath() {
   const moduleDir = dirname4(fileURLToPath(import.meta.url));
   const candidates = [
-    join18(moduleDir, "../../../recommended-models.txt"),
-    join18(moduleDir, "recommended-models.txt")
+    join20(moduleDir, "../../../recommended-models.txt"),
+    join20(moduleDir, "recommended-models.txt")
   ];
   for (const candidate of candidates) {
     if (existsSync13(candidate)) {
@@ -16482,12 +17629,12 @@ async function handleCheckRunning(c, projectManager) {
 }
 
 // src/core/run-command-detector.ts
-import { readFile as readFile9 } from "fs/promises";
-import { join as join19 } from "path";
+import { readFile as readFile10 } from "fs/promises";
+import { join as join21 } from "path";
 async function detectPackageManager(projectPath) {
   try {
-    const packageJsonPath = join19(projectPath, "package.json");
-    const content = await readFile9(packageJsonPath, "utf-8");
+    const packageJsonPath = join21(projectPath, "package.json");
+    const content = await readFile10(packageJsonPath, "utf-8");
     const packageJson = JSON.parse(content);
     if (packageJson.packageManager) {
       const pm = packageJson.packageManager.split("@")[0];
@@ -16502,8 +17649,8 @@ async function detectPackageManager(projectPath) {
 }
 async function detectRunScripts(projectPath) {
   try {
-    const packageJsonPath = join19(projectPath, "package.json");
-    const content = await readFile9(packageJsonPath, "utf-8");
+    const packageJsonPath = join21(projectPath, "package.json");
+    const content = await readFile10(packageJsonPath, "utf-8");
     const packageJson = JSON.parse(content);
     const scripts = packageJson.scripts ?? {};
     return {
@@ -16548,8 +17695,8 @@ async function suggestRunCommand(projectPath) {
 }
 
 // src/features/projects/projects-package-scripts.route.ts
-import { readFile as readFile10 } from "fs/promises";
-import { join as join20 } from "path";
+import { readFile as readFile11 } from "fs/promises";
+import { join as join22 } from "path";
 import { glob } from "glob";
 function formatScriptName(scriptName) {
   return scriptName.replace(/[-:_]/g, " ").replace(/\b\w/g, (l) => l.toUpperCase());
@@ -16577,8 +17724,8 @@ async function findPackageScripts(projectPath) {
     const packageManager = await detectPackageManager(projectPath);
     for (const filePath of packageJsonFiles) {
       try {
-        const fullPath = join20(projectPath, filePath);
-        const content = await readFile10(fullPath, "utf-8");
+        const fullPath = join22(projectPath, filePath);
+        const content = await readFile11(fullPath, "utf-8");
         const packageJson = JSON.parse(content);
         if (packageJson.scripts) {
           for (const [scriptName] of Object.entries(packageJson.scripts)) {
@@ -16625,8 +17772,8 @@ async function handleGetPackageScripts(c, projectManager) {
 }
 
 // src/features/projects/projects-ai-files.route.ts
-import { readdir as readdir6, readFile as readFile11, writeFile as writeFile3, mkdir as mkdir2, access as access2, rm } from "fs/promises";
-import { join as join21, extname as extname4, basename } from "path";
+import { readdir as readdir6, readFile as readFile12, writeFile as writeFile3, mkdir as mkdir2, access as access2, rm } from "fs/promises";
+import { join as join23, extname as extname4, basename } from "path";
 import { existsSync as existsSync14 } from "fs";
 var IGNORED_DIRS = /* @__PURE__ */ new Set([
   ".git",
@@ -16645,8 +17792,8 @@ async function buildFullTree(dirPath, relativeDirPath) {
   try {
     const entries = await readdir6(dirPath, { withFileTypes: true });
     for (const entry of entries) {
-      const entryRelPath = join21(relativeDirPath, entry.name);
-      const entryAbsPath = join21(dirPath, entry.name);
+      const entryRelPath = join23(relativeDirPath, entry.name);
+      const entryAbsPath = join23(dirPath, entry.name);
       if (entry.isDirectory()) {
         const children = await buildFullTree(entryAbsPath, entryRelPath);
         nodes.push({
@@ -16674,8 +17821,8 @@ async function buildMarkdownFilteredTree(dirPath, relativeDirPath) {
   try {
     const entries = await readdir6(dirPath, { withFileTypes: true });
     for (const entry of entries) {
-      const entryRelPath = join21(relativeDirPath, entry.name);
-      const entryAbsPath = join21(dirPath, entry.name);
+      const entryRelPath = join23(relativeDirPath, entry.name);
+      const entryAbsPath = join23(dirPath, entry.name);
       if (entry.isDirectory()) {
         if (IGNORED_DIRS.has(entry.name)) continue;
         const children = await buildMarkdownFilteredTree(entryAbsPath, entryRelPath);
@@ -16710,8 +17857,8 @@ async function buildAIFileTree(projectPath) {
     { key: "agents", label: "Agents" }
   ];
   for (const { key, label } of agentsFolders) {
-    const relPath = join21(".agents", key);
-    const absPath = join21(projectPath, relPath);
+    const relPath = join23(".agents", key);
+    const absPath = join23(projectPath, relPath);
     const exists = existsSync14(absPath);
     if (exists) {
       const children = await buildFullTree(absPath, relPath);
@@ -16746,7 +17893,7 @@ async function buildAIFileTree(projectPath) {
       if (entry.name === ".agents" || entry.name === "AGENTS.md" || IGNORED_DIRS.has(entry.name))
         continue;
       const entryRelPath = entry.name;
-      const entryAbsPath = join21(projectPath, entry.name);
+      const entryAbsPath = join23(projectPath, entry.name);
       if (entry.isFile() && MARKDOWN_EXTS.has(extname4(entry.name))) {
         nodes.push({
           id: entryRelPath,
@@ -16773,7 +17920,7 @@ async function buildAIFileTree(projectPath) {
 }
 function validateFilePath(projectPath, filePath) {
   if (!filePath) return null;
-  const abs = join21(projectPath, filePath);
+  const abs = join23(projectPath, filePath);
   if (!abs.startsWith(projectPath + "/") && abs !== projectPath) return null;
   return abs;
 }
@@ -16860,7 +18007,7 @@ Links to important documentation, tools, or references.
     } catch {
       return c.json({ error: { code: "NOT_FOUND", message: `File not found: ${filePath}` } }, 404);
     }
-    const content = await readFile11(absPath, "utf-8");
+    const content = await readFile12(absPath, "utf-8");
     return c.json({ content, path: filePath });
   } catch (error) {
     return errorResponse(
@@ -16899,7 +18046,7 @@ async function handleSaveAIFile(c, projectManager) {
     if (!absPath) {
       return c.json({ error: { code: "BAD_REQUEST", message: "Invalid file path" } }, 400);
     }
-    const parentDir = join21(absPath, "..");
+    const parentDir = join23(absPath, "..");
     await mkdir2(parentDir, { recursive: true });
     await writeFile3(absPath, content, "utf-8");
     return c.json({ success: true, path: filePath });
@@ -16999,10 +18146,10 @@ async function handleCreateSkill(c, projectManager) {
     if (!project) {
       return errorResponse(c, ErrorCodes.PROJECT_NOT_FOUND, `Project not found: ${projectId}`, 404);
     }
-    const skillRelPath = join21(".agents", "skills", name);
-    const skillAbsPath = join21(project.path, skillRelPath);
-    const skillFileRelPath = join21(skillRelPath, "SKILL.md");
-    const skillFileAbsPath = join21(skillAbsPath, "SKILL.md");
+    const skillRelPath = join23(".agents", "skills", name);
+    const skillAbsPath = join23(project.path, skillRelPath);
+    const skillFileRelPath = join23(skillRelPath, "SKILL.md");
+    const skillFileAbsPath = join23(skillAbsPath, "SKILL.md");
     if (existsSync14(skillAbsPath)) {
       return c.json(
         { error: { code: "CONFLICT", message: `Skill '${name}' already exists` } },
@@ -17074,11 +18221,14 @@ async function handleGetProjectEnvVars(c, projectManager) {
       return errorResponse(c, ErrorCodes.PROJECT_NOT_FOUND, `Project not found: ${projectId}`, 404);
     }
     const db = await getDatabase();
-    const rows = await listProjectEnvVarNames(db, projectId);
-    const vars = rows.map((row) => ({
-      name: row.name,
-      hasValue: true
-    }));
+    const rows = await listProjectEnvVars(db, projectId);
+    const vars = await Promise.all(
+      rows.map(async (row) => ({
+        name: row.name,
+        hasValue: true,
+        value: await decryptProviderKey(row.encryptedValue)
+      }))
+    );
     return c.json({ vars });
   } catch (error) {
     return errorResponse(
@@ -17248,7 +18398,7 @@ function createProjectRoutes(projectManager, threadManager) {
 
 // src/features/projects/projects.manager.ts
 init_utils();
-import { join as join24 } from "path";
+import { join as join26 } from "path";
 import { realpathSync as realpathSync2 } from "fs";
 import { rm as rm4 } from "fs/promises";
 
@@ -17315,13 +18465,13 @@ var ProcessManager = class extends EventEmitter {
       }
     };
     const waitForQueue = () => {
-      return new Promise((resolve6) => {
+      return new Promise((resolve7) => {
         const queue = this.queues.get(projectId);
         if (queue && queue.length > 0) {
-          resolve6();
+          resolve7();
         } else {
           const res = this.resolvers.get(projectId);
-          if (res) res.push(resolve6);
+          if (res) res.push(resolve7);
         }
       });
     };
@@ -17469,14 +18619,14 @@ var ProcessManager = class extends EventEmitter {
 
 // src/features/projects/projects.creator.ts
 init_utils();
-import { randomUUID as randomUUID9 } from "crypto";
-import { basename as basename2, join as join23, relative as relative5 } from "path";
+import { randomUUID as randomUUID10 } from "crypto";
+import { basename as basename2, join as join25, relative as relative5 } from "path";
 import { access as access3, mkdir as mkdir4, rm as rm3, stat as stat3, readdir as readdir8 } from "fs/promises";
 
 // src/features/scaffold/scaffold.runner.ts
 init_utils();
 import { existsSync as existsSync15 } from "fs";
-import { join as join22 } from "path";
+import { join as join24 } from "path";
 import { mkdir as mkdir3, readdir as readdir7, stat as stat2, rename, rm as rm2, writeFile as writeFile4 } from "fs/promises";
 import { createInterface as createInterface2 } from "readline";
 
@@ -18198,7 +19348,7 @@ function loadCatalog() {
 }
 async function writeAgentsMd(projectPath, agentsMd) {
   if (!agentsMd) return;
-  const agentsPath = join22(projectPath, "AGENTS.md");
+  const agentsPath = join24(projectPath, "AGENTS.md");
   if (existsSync15(agentsPath)) return;
   await writeFile4(agentsPath, agentsMd, "utf-8");
 }
@@ -18356,7 +19506,7 @@ async function* runCommandStreaming(cwd, command) {
   }
 }
 async function* createScaffoldedProjectStreaming(options) {
-  const projectPath = join22(options.parentDir, options.threadId);
+  const projectPath = join24(options.parentDir, options.threadId);
   if (!existsSync15(options.parentDir)) {
     yield {
       type: "result",
@@ -18446,7 +19596,7 @@ async function* createScaffoldedProjectStreaming(options) {
   }
   try {
     const projectName2 = getProjectName(options.projectName);
-    const projectSubDir = join22(projectPath, projectName2);
+    const projectSubDir = join24(projectPath, projectName2);
     try {
       const subDirStat = await stat2(projectSubDir);
       if (subDirStat.isDirectory()) {
@@ -18456,8 +19606,8 @@ async function* createScaffoldedProjectStreaming(options) {
         };
         const items = await readdir7(projectSubDir);
         for (const item of items) {
-          const oldPath = join22(projectSubDir, item);
-          const newPath = join22(projectPath, item);
+          const oldPath = join24(projectSubDir, item);
+          const newPath = join24(projectPath, item);
           await rename(oldPath, newPath);
         }
         await rm2(projectSubDir, { recursive: true, force: true });
@@ -18655,14 +19805,14 @@ var ProjectCreator = class {
     }
     let initialThreadId;
     try {
-      const projectId = randomUUID9();
+      const projectId = randomUUID10();
       const existingProjects = await this.metadataManager.loadProjects();
       const existingNames = existingProjects.map((p) => p.name);
       const projectName = this.ensureUniqueProjectName(
         this.deriveProjectName(gitUrl),
         existingNames
       );
-      initialThreadId = randomUUID9();
+      initialThreadId = randomUUID10();
       const initialThreadTitle = generateRandomThreadName();
       const baseFolderName = this.toFolderName(this.deriveProjectName(gitUrl));
       if (!baseFolderName) {
@@ -18673,7 +19823,7 @@ var ProjectCreator = class {
         return;
       }
       const uniqueFolderName = await this.ensureUniqueFolderName(baseFolderName);
-      const firstThreadPath = join23(this.rootFolder, uniqueFolderName);
+      const firstThreadPath = join25(this.rootFolder, uniqueFolderName);
       this.processingStateManager?.setProcessing(initialThreadId);
       yield {
         type: "progress",
@@ -18811,8 +19961,8 @@ var ProjectCreator = class {
       };
       return;
     }
-    const projectId = randomUUID9();
-    const initialThreadId = randomUUID9();
+    const projectId = randomUUID10();
+    const initialThreadId = randomUUID10();
     const initialThreadTitle = generateRandomThreadName();
     this.processingStateManager?.setProcessing(initialThreadId);
     try {
@@ -18923,15 +20073,15 @@ var ProjectCreator = class {
       };
       return;
     }
-    const projectId = randomUUID9();
-    const initialThreadId = randomUUID9();
+    const projectId = randomUUID10();
+    const initialThreadId = randomUUID10();
     const initialThreadTitle = generateRandomThreadName();
     let folderPath;
     let projectMetadataSaved = false;
     this.processingStateManager?.setProcessing(initialThreadId);
     try {
       const uniqueFolderName = await this.ensureUniqueFolderName(folderName);
-      folderPath = join23(this.rootFolder, uniqueFolderName);
+      folderPath = join25(this.rootFolder, uniqueFolderName);
       yield {
         type: "progress",
         message: `Creating folder "${uniqueFolderName}"...`,
@@ -19018,7 +20168,7 @@ var ProjectCreator = class {
     return name;
   }
   generateThreadPath(_projectId, threadId) {
-    return join23(this.rootFolder, threadId);
+    return join25(this.rootFolder, threadId);
   }
   toFolderName(name) {
     return name.trim().toLowerCase().replace(/[\\/]+/g, " ").replace(/[^a-z0-9._ -]+/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
@@ -19034,7 +20184,7 @@ var ProjectCreator = class {
   async ensureUniqueFolderName(baseFolderName) {
     let candidate = baseFolderName;
     let counter = 1;
-    while (await this.folderExists(join23(this.rootFolder, candidate))) {
+    while (await this.folderExists(join25(this.rootFolder, candidate))) {
       candidate = `${baseFolderName}-${counter}`;
       counter++;
     }
@@ -19066,8 +20216,8 @@ var ProjectCreator = class {
       yield { type: "error", message: `Cannot access folder: ${folderPath}` };
       return;
     }
-    const projectId = randomUUID9();
-    const initialThreadId = randomUUID9();
+    const projectId = randomUUID10();
+    const initialThreadId = randomUUID10();
     const initialThreadTitle = generateRandomThreadName();
     this.processingStateManager?.setProcessing(initialThreadId);
     try {
@@ -19188,19 +20338,19 @@ var ProjectCreator = class {
   }
   async findAllPackageJsonFiles(rootPath, currentPath, setupScripts) {
     try {
-      await access3(join23(currentPath, "package.json"));
+      await access3(join25(currentPath, "package.json"));
       const relativePath = relative5(rootPath, currentPath);
       let installCommand = "";
       try {
-        await access3(join23(currentPath, "yarn.lock"));
+        await access3(join25(currentPath, "yarn.lock"));
         installCommand = "yarn install";
       } catch {
         try {
-          await access3(join23(currentPath, "bun.lock"));
+          await access3(join25(currentPath, "bun.lock"));
           installCommand = "bun install";
         } catch {
           try {
-            await access3(join23(currentPath, "pnpm-lock.yaml"));
+            await access3(join25(currentPath, "pnpm-lock.yaml"));
             installCommand = "pnpm install";
           } catch {
             installCommand = "npm install";
@@ -19217,7 +20367,7 @@ var ProjectCreator = class {
     try {
       const entries = await readdir8(currentPath);
       for (const entry of entries) {
-        const entryPath = join23(currentPath, entry);
+        const entryPath = join25(currentPath, entry);
         try {
           const stats = await stat3(entryPath);
           if (stats.isDirectory() && !entry.startsWith(".") && entry !== "node_modules") {
@@ -19563,7 +20713,7 @@ var ProjectManagerImpl = class {
     const session = this.terminalSessionManager.getOrCreateSession(threadId, thread.path);
     let workingDir;
     if (cwd) {
-      workingDir = cwd.startsWith("/") ? cwd : join24(thread.path, cwd);
+      workingDir = cwd.startsWith("/") ? cwd : join26(thread.path, cwd);
       this.terminalSessionManager.updateWorkingDirectory(threadId, workingDir);
     } else {
       workingDir = session.currentWorkingDirectory;
@@ -19619,7 +20769,7 @@ ___CWD___%s
       if (outputBuffer.length > 0) {
         yield outputBuffer.shift();
       } else {
-        await new Promise((resolve6) => setTimeout(resolve6, 50));
+        await new Promise((resolve7) => setTimeout(resolve7, 50));
       }
     }
   }
@@ -20354,8 +21504,8 @@ function createScaffoldRoutes(projectManager) {
 }
 
 // src/features/slash-commands/slash-commands.manager.ts
-import { readdir as readdir9, readFile as readFile12, mkdir as mkdir5, writeFile as writeFile5, unlink as unlink2 } from "fs/promises";
-import { join as join25, basename as basename3, extname as extname5, relative as relative6 } from "path";
+import { readdir as readdir9, readFile as readFile13, mkdir as mkdir5, writeFile as writeFile5, unlink as unlink3 } from "fs/promises";
+import { join as join27, basename as basename3, extname as extname5, relative as relative6 } from "path";
 import { existsSync as existsSync16 } from "fs";
 import { homedir as homedir8 } from "os";
 function slugify(filename) {
@@ -20401,10 +21551,10 @@ function parseFrontmatter3(markdown) {
   return { metadata, content };
 }
 function getGlobalCommandsDir() {
-  return join25(homedir8(), ".agents", "commands");
+  return join27(homedir8(), ".agents", "commands");
 }
 function getProjectCommandsDir(threadPath) {
-  return join25(threadPath, ".agents", "commands");
+  return join27(threadPath, ".agents", "commands");
 }
 var SlashCommandManager = class _SlashCommandManager {
   /**
@@ -20477,8 +21627,8 @@ var SlashCommandManager = class _SlashCommandManager {
       const files = await readdir9(dir);
       for (const file of files) {
         if (!file.endsWith(".md")) continue;
-        const filePath = join25(dir, file);
-        const fileContent = await readFile12(filePath, "utf-8");
+        const filePath = join27(dir, file);
+        const fileContent = await readFile13(filePath, "utf-8");
         const { metadata, content } = parseFrontmatter3(fileContent);
         const nameWithoutExt = basename3(file, extname5(file));
         const commandName = slugify(nameWithoutExt);
@@ -20512,7 +21662,7 @@ var SlashCommandManager = class _SlashCommandManager {
       await mkdir5(dir, { recursive: true });
     }
     const filename = `${name}.md`;
-    const filePath = join25(dir, filename);
+    const filePath = join27(dir, filename);
     if (existsSync16(filePath)) {
       throw new Error(`Command already exists: ${name}`);
     }
@@ -20577,7 +21727,7 @@ var SlashCommandManager = class _SlashCommandManager {
     if (!existsSync16(filePath)) {
       throw new Error(`Command file not found: ${filePath}`);
     }
-    await unlink2(filePath);
+    await unlink3(filePath);
   }
   /**
    * Get a specific command by name
@@ -21106,8 +22256,8 @@ function createRuleRoutes(router, projectManager) {
 
 // src/features/threads/threads.manager.ts
 init_utils();
-import { randomUUID as randomUUID10 } from "crypto";
-import { join as join26 } from "path";
+import { randomUUID as randomUUID11 } from "crypto";
+import { join as join28 } from "path";
 import { execSync as execSync3 } from "child_process";
 import { rm as rm5, stat as stat4, mkdir as mkdir6 } from "fs/promises";
 init_database();
@@ -21173,7 +22323,7 @@ var ThreadManagerImpl = class {
       } catch {
         await mkdir6(project.path, { recursive: true });
       }
-      threadId = randomUUID10();
+      threadId = randomUUID11();
       const threadPath = this.generateThreadPath(projectId, threadId);
       const existingThreads = await this.metadataManager.loadThreads();
       const existingTitles = new Set(
@@ -21497,8 +22647,8 @@ var ThreadManagerImpl = class {
       isDone = true;
       resolveNext();
     });
-    const waitForData = () => new Promise((resolve6) => {
-      resolveNext = resolve6;
+    const waitForData = () => new Promise((resolve7) => {
+      resolveNext = resolve7;
     });
     while (!isDone || outputQueue.length > 0 || errorQueue.length > 0) {
       if (outputQueue.length > 0) {
@@ -21531,7 +22681,7 @@ var ThreadManagerImpl = class {
    * - 7.4 - THE CLI SHALL ensure each Thread clone is stored in a unique directory path
    */
   generateThreadPath(_projectId, threadId) {
-    return join26(this.rootFolder, threadId);
+    return join28(this.rootFolder, threadId);
   }
   /**
    * Generates a thread title if not provided
@@ -21561,7 +22711,7 @@ var ThreadManagerImpl = class {
     if (!thread) {
       throw new Error(`Thread not found: ${threadId}`);
     }
-    return new Promise((resolve6, reject) => {
+    return new Promise((resolve7, reject) => {
       const gitProcess = spawnProcess(
         "git",
         ["ls-files", "--cached", "--others", "--exclude-standard"],
@@ -21580,7 +22730,7 @@ var ThreadManagerImpl = class {
       gitProcess.on("close", (code) => {
         if (code === 0) {
           const files = output.split("\n").map((line) => line.trim()).filter((line) => line.length > 0);
-          resolve6(files);
+          resolve7(files);
         } else {
           reject(new Error(`git ls-files failed with code ${code}: ${errorOutput}`));
         }
@@ -21724,14 +22874,14 @@ async function handleDeleteThread(c, threadManager) {
 }
 
 // src/core/project-inspector.ts
-import { readFile as readFile13, readdir as readdir10 } from "fs/promises";
+import { readFile as readFile14, readdir as readdir10 } from "fs/promises";
 import { existsSync as existsSync17 } from "fs";
-import { join as join27, basename as basename4, relative as relative7 } from "path";
+import { join as join29, basename as basename4, relative as relative7 } from "path";
 import { glob as glob2 } from "glob";
 
 // src/features/project-scripts/project-scripts.database.ts
 init_database();
-import { randomUUID as randomUUID11 } from "crypto";
+import { randomUUID as randomUUID12 } from "crypto";
 async function getScriptsByProject(db, projectId) {
   const result = await db.execute({
     sql: `SELECT id, projectId, workspace, name, command, friendlyName, updatedAt
@@ -21748,7 +22898,7 @@ async function upsertProjectScripts(projectId, scripts) {
       sql: `INSERT OR REPLACE INTO project_scripts (id, projectId, workspace, name, command, friendlyName, updatedAt)
             VALUES (?, ?, ?, ?, ?, ?, ?)`,
       args: [
-        randomUUID11(),
+        randomUUID12(),
         projectId,
         script.workspace,
         script.name,
@@ -21770,13 +22920,13 @@ async function inspectProject(projectPath, projectId) {
   return scripts;
 }
 async function detectPackageManager2(projectPath) {
-  if (existsSync17(join27(projectPath, "bun.lockb")) || existsSync17(join27(projectPath, "bun.lock"))) {
+  if (existsSync17(join29(projectPath, "bun.lockb")) || existsSync17(join29(projectPath, "bun.lock"))) {
     return "bun";
   }
-  if (existsSync17(join27(projectPath, "pnpm-lock.yaml"))) {
+  if (existsSync17(join29(projectPath, "pnpm-lock.yaml"))) {
     return "pnpm";
   }
-  if (existsSync17(join27(projectPath, "yarn.lock"))) {
+  if (existsSync17(join29(projectPath, "yarn.lock"))) {
     return "yarn";
   }
   try {
@@ -21795,8 +22945,8 @@ async function detectPackageManager2(projectPath) {
   return "npm";
 }
 async function detectMonoRepoType(projectPath) {
-  const hasPnpmWorkspace = existsSync17(join27(projectPath, "pnpm-workspace.yaml"));
-  if (existsSync17(join27(projectPath, "nx.json"))) {
+  const hasPnpmWorkspace = existsSync17(join29(projectPath, "pnpm-workspace.yaml"));
+  if (existsSync17(join29(projectPath, "nx.json"))) {
     return "nx";
   }
   const pkg = await readPackageJson(projectPath);
@@ -21810,10 +22960,10 @@ async function detectMonoRepoType(projectPath) {
   if (hasPnpmWorkspace) {
     return "pnpm";
   }
-  if (existsSync17(join27(projectPath, "lerna.json"))) {
+  if (existsSync17(join29(projectPath, "lerna.json"))) {
     return "lerna";
   }
-  if (existsSync17(join27(projectPath, "turbo.json"))) {
+  if (existsSync17(join29(projectPath, "turbo.json"))) {
     return "turbo";
   }
   const folderWorkspaces = await detectFolderBasedWorkspaces(projectPath);
@@ -21854,8 +23004,8 @@ async function resolvePackageJsonWorkspaces(projectPath) {
   });
   const workspaces = [];
   for (const folder of folders) {
-    const absPath = join27(projectPath, folder);
-    if (existsSync17(join27(absPath, "package.json"))) {
+    const absPath = join29(projectPath, folder);
+    if (existsSync17(join29(absPath, "package.json"))) {
       workspaces.push({
         name: basename4(folder),
         folder: absPath,
@@ -21870,12 +23020,12 @@ async function resolvePackageJsonWorkspaces(projectPath) {
   return workspaces;
 }
 async function resolvePnpmWorkspaces(projectPath) {
-  const yamlPath = join27(projectPath, "pnpm-workspace.yaml");
+  const yamlPath = join29(projectPath, "pnpm-workspace.yaml");
   if (!existsSync17(yamlPath)) {
     return [{ name: "root", folder: projectPath, relativePath: "." }];
   }
   try {
-    const yaml = await readFile13(yamlPath, "utf-8");
+    const yaml = await readFile14(yamlPath, "utf-8");
     const patterns = [];
     for (const line of yaml.split("\n")) {
       const trimmed = line.trim();
@@ -21896,8 +23046,8 @@ async function resolvePnpmWorkspaces(projectPath) {
     });
     const workspaces = [];
     for (const folder of folders) {
-      const absPath = join27(projectPath, folder);
-      if (existsSync17(join27(absPath, "package.json"))) {
+      const absPath = join29(projectPath, folder);
+      if (existsSync17(join29(absPath, "package.json"))) {
         const wsPkg = await readPackageJson(absPath);
         workspaces.push({
           name: wsPkg?.name ?? basename4(folder),
@@ -21916,12 +23066,12 @@ async function resolvePnpmWorkspaces(projectPath) {
   }
 }
 async function resolveLernaWorkspaces(projectPath) {
-  const lernaPath = join27(projectPath, "lerna.json");
+  const lernaPath = join29(projectPath, "lerna.json");
   if (!existsSync17(lernaPath)) {
     return [{ name: "root", folder: projectPath, relativePath: "." }];
   }
   try {
-    const content = await readFile13(lernaPath, "utf-8");
+    const content = await readFile14(lernaPath, "utf-8");
     const lerna = JSON.parse(content);
     const patterns = lerna.packages ?? ["packages/*"];
     const folders = await glob2(patterns, {
@@ -21930,8 +23080,8 @@ async function resolveLernaWorkspaces(projectPath) {
     });
     const workspaces = [];
     for (const folder of folders) {
-      const absPath = join27(projectPath, folder);
-      if (existsSync17(join27(absPath, "package.json"))) {
+      const absPath = join29(projectPath, folder);
+      if (existsSync17(join29(absPath, "package.json"))) {
         const wsPkg = await readPackageJson(absPath);
         workspaces.push({
           name: wsPkg?.name ?? basename4(folder),
@@ -21951,17 +23101,17 @@ async function resolveLernaWorkspaces(projectPath) {
 }
 async function resolveNxWorkspaces(projectPath) {
   const workspaces = [];
-  const workspaceJsonPath = join27(projectPath, "workspace.json");
+  const workspaceJsonPath = join29(projectPath, "workspace.json");
   if (existsSync17(workspaceJsonPath)) {
     try {
-      const content = await readFile13(workspaceJsonPath, "utf-8");
+      const content = await readFile14(workspaceJsonPath, "utf-8");
       const wsJson = JSON.parse(content);
       for (const [name, value] of Object.entries(wsJson.projects ?? {})) {
         const folder = typeof value === "string" ? value : value.root;
         if (folder) {
           workspaces.push({
             name,
-            folder: join27(projectPath, folder),
+            folder: join29(projectPath, folder),
             relativePath: folder
           });
         }
@@ -21976,13 +23126,13 @@ async function resolveNxWorkspaces(projectPath) {
   });
   for (const file of projectJsonFiles) {
     try {
-      const content = await readFile13(join27(projectPath, file), "utf-8");
+      const content = await readFile14(join29(projectPath, file), "utf-8");
       const project = JSON.parse(content);
       if (project.name) {
         const folder = file.replace(/\/project\.json$/, "");
         workspaces.push({
           name: project.name,
-          folder: join27(projectPath, folder),
+          folder: join29(projectPath, folder),
           relativePath: folder
         });
       }
@@ -21990,15 +23140,15 @@ async function resolveNxWorkspaces(projectPath) {
     }
   }
   if (workspaces.length > 0) return workspaces;
-  const appsDir = join27(projectPath, "apps");
+  const appsDir = join29(projectPath, "apps");
   if (existsSync17(appsDir)) {
     const entries = await readdir10(appsDir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isDirectory() && !entry.name.startsWith(".")) {
-        const folder = join27("apps", entry.name);
+        const folder = join29("apps", entry.name);
         workspaces.push({
           name: entry.name,
-          folder: join27(projectPath, folder),
+          folder: join29(projectPath, folder),
           relativePath: folder
         });
       }
@@ -22032,13 +23182,13 @@ async function detectFolderBasedWorkspaces(projectPath) {
     const results = [];
     for (const entry of entries) {
       if (entry.isDirectory() && !entry.name.startsWith(".") && entry.name !== "node_modules" && entry.name !== "dist" && entry.name !== "build") {
-        const pkgPath = join27(projectPath, entry.name, "package.json");
+        const pkgPath = join29(projectPath, entry.name, "package.json");
         if (existsSync17(pkgPath)) {
           try {
-            const content = await readFile13(pkgPath, "utf-8");
+            const content = await readFile14(pkgPath, "utf-8");
             const pkg = JSON.parse(content);
             if (pkg.dependencies || pkg.devDependencies || pkg.scripts) {
-              results.push({ name: entry.name, absPath: join27(projectPath, entry.name) });
+              results.push({ name: entry.name, absPath: join29(projectPath, entry.name) });
             }
           } catch {
           }
@@ -22094,7 +23244,7 @@ function pmRunCommand(packageManager, scriptName) {
 }
 async function readPackageJson(dir) {
   try {
-    const content = await readFile13(join27(dir, "package.json"), "utf-8");
+    const content = await readFile14(join29(dir, "package.json"), "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -22286,8 +23436,8 @@ async function handleListThreadFiles(c, threadManager) {
 }
 
 // src/features/threads/threads-explorer.route.ts
-import { readdir as readdir11, readFile as readFile14, rename as rename2, writeFile as writeFile6, mkdir as mkdir7, rm as rm6, access as access4 } from "fs/promises";
-import { join as join28 } from "path";
+import { readdir as readdir11, readFile as readFile15, rename as rename2, writeFile as writeFile6, mkdir as mkdir7, rm as rm6, access as access4 } from "fs/promises";
+import { join as join30 } from "path";
 import { spawn as spawn2 } from "child_process";
 var Utils3 = null;
 var utilsLoaded3 = false;
@@ -22302,7 +23452,7 @@ async function loadUtils3() {
 }
 async function getIgnoredPaths(repoPath, relativePaths) {
   if (relativePaths.length === 0) return /* @__PURE__ */ new Set();
-  return new Promise((resolve6) => {
+  return new Promise((resolve7) => {
     const proc = spawn2("git", ["check-ignore", "--stdin"], { cwd: repoPath });
     let output = "";
     proc.stdout?.on("data", (d) => {
@@ -22314,16 +23464,16 @@ async function getIgnoredPaths(repoPath, relativePaths) {
       const ignored = new Set(
         output.split("\n").map((l) => l.trim()).filter(Boolean)
       );
-      resolve6(ignored);
+      resolve7(ignored);
     });
-    proc.on("error", () => resolve6(/* @__PURE__ */ new Set()));
+    proc.on("error", () => resolve7(/* @__PURE__ */ new Set()));
   });
 }
 async function listExplorerEntriesRecursive(rootPath, currentPath, relativePath) {
   const dirents = await readdir11(currentPath, { withFileTypes: true });
   const isRoot = relativePath.length === 0;
   const entries = dirents.filter((d) => !(isRoot && d.name === ".git") && d.name !== "node_modules").map((d) => {
-    const entryPath = relativePath ? join28(relativePath, d.name) : d.name;
+    const entryPath = relativePath ? join30(relativePath, d.name) : d.name;
     return {
       name: d.name,
       type: d.isDirectory() ? "folder" : "file",
@@ -22335,7 +23485,7 @@ async function listExplorerEntriesRecursive(rootPath, currentPath, relativePath)
   });
   const nestedEntries = await Promise.all(
     entries.filter((entry) => entry.type === "folder").map(
-      (entry) => listExplorerEntriesRecursive(rootPath, join28(rootPath, entry.path), entry.path)
+      (entry) => listExplorerEntriesRecursive(rootPath, join30(rootPath, entry.path), entry.path)
     )
   );
   return [...entries, ...nestedEntries.flat()];
@@ -22371,7 +23521,7 @@ async function handleListThreadExplorerDir(c, threadManager) {
     const entries = recursive ? await listExplorerEntriesRecursive(thread.path, absDir, queryPath) : dirents.filter((d) => !(!queryPath && d.name === ".git")).map((d) => ({
       name: d.name,
       type: d.isDirectory() ? "folder" : "file",
-      path: queryPath ? join28(queryPath, d.name) : d.name
+      path: queryPath ? join30(queryPath, d.name) : d.name
     })).sort((a, b) => {
       if (a.type !== b.type) return a.type === "folder" ? -1 : 1;
       return a.name.localeCompare(b.name);
@@ -22517,7 +23667,7 @@ async function handleCreateExplorerFile(c, threadManager) {
       absParent = validated;
     }
     await mkdir7(absParent, { recursive: true });
-    await writeFile6(join28(absParent, name), "", "utf-8");
+    await writeFile6(join30(absParent, name), "", "utf-8");
     const relPath = dirPath ? `${dirPath}/${name}` : name;
     return c.json({ success: true, path: relPath });
   } catch (error) {
@@ -22559,7 +23709,7 @@ async function handleGetExplorerMedia(c, threadManager) {
     }
     const ext = getFileExtension(filePath);
     const contentType = MEDIA_MIME_TYPES[ext] ?? "application/octet-stream";
-    const data = await readFile14(absPath);
+    const data = await readFile15(absPath);
     return new Response(data, {
       headers: {
         "Content-Type": contentType,
@@ -22609,7 +23759,7 @@ async function handleCreateExplorerFolder(c, threadManager) {
       }
       absParent = validated;
     }
-    await mkdir7(join28(absParent, name), { recursive: true });
+    await mkdir7(join30(absParent, name), { recursive: true });
     const relPath = dirPath ? `${dirPath}/${name}` : name;
     return c.json({ success: true, path: relPath });
   } catch (error) {
@@ -22782,13 +23932,13 @@ async function handleFixComments(c, threadManager) {
 }
 
 // src/features/threads/threads-ai-files.route.ts
-import { readFile as readFile15, writeFile as writeFile8, mkdir as mkdir9, access as access5, rm as rm7, stat as stat5 } from "fs/promises";
-import { join as join30 } from "path";
+import { readFile as readFile16, writeFile as writeFile8, mkdir as mkdir9, access as access5, rm as rm7, stat as stat5 } from "fs/promises";
+import { join as join32 } from "path";
 import { existsSync as existsSync18 } from "fs";
 
 // src/features/git/git-download-folder.ts
 import { mkdir as mkdir8, writeFile as writeFile7 } from "fs/promises";
-import { join as join29, dirname as dirname5 } from "path";
+import { join as join31, dirname as dirname5 } from "path";
 async function downloadGithubFolder(repoUrl, srcPath, destPath, options = {}) {
   const { token, ref } = options;
   const match = repoUrl.replace(/\.git$/, "").match(/github\.com\/([^/]+)\/([^/]+)/);
@@ -22824,7 +23974,7 @@ async function downloadGithubFolder(repoUrl, srcPath, destPath, options = {}) {
   await Promise.all(
     files.map(async (file) => {
       const relativePath = file.path.slice(prefix.length);
-      const localPath = join29(destPath, relativePath);
+      const localPath = join31(destPath, relativePath);
       await mkdir8(dirname5(localPath), { recursive: true });
       const rawUrl = `https://raw.githubusercontent.com/${owner}/${repo}/${refParam}/${file.path}`;
       const fileRes = await fetch(rawUrl, { headers });
@@ -22942,7 +24092,7 @@ Links to important documentation, tools, or references.
         400
       );
     }
-    const content = await readFile15(absPath, "utf-8");
+    const content = await readFile16(absPath, "utf-8");
     return c.json({ content, path: filePath });
   } catch (error) {
     return errorResponse(
@@ -22981,7 +24131,7 @@ async function handleSaveThreadAIFile(c, threadManager) {
     if (!absPath) {
       return c.json({ error: { code: "BAD_REQUEST", message: "Invalid file path" } }, 400);
     }
-    const parentDir = join30(absPath, "..");
+    const parentDir = join32(absPath, "..");
     await mkdir9(parentDir, { recursive: true });
     await writeFile8(absPath, content, "utf-8");
     return c.json({ success: true, path: filePath });
@@ -23070,10 +24220,10 @@ async function handleCreateThreadAgent(c, threadManager) {
     if (!thread) {
       return errorResponse(c, ErrorCodes.THREAD_NOT_FOUND, `Thread not found: ${threadId}`, 404);
     }
-    const agentRelPath = join30(".agents", "agents", name);
-    const agentAbsPath = join30(thread.path, agentRelPath);
-    const agentFileRelPath = join30(agentRelPath, "AGENT.md");
-    const agentFileAbsPath = join30(agentAbsPath, "AGENT.md");
+    const agentRelPath = join32(".agents", "agents", name);
+    const agentAbsPath = join32(thread.path, agentRelPath);
+    const agentFileRelPath = join32(agentRelPath, "AGENT.md");
+    const agentFileAbsPath = join32(agentAbsPath, "AGENT.md");
     if (existsSync18(agentAbsPath)) {
       return c.json(
         { error: { code: "CONFLICT", message: `Agent '${name}' already exists` } },
@@ -23140,10 +24290,10 @@ async function handleCreateThreadSkill(c, threadManager) {
     if (!thread) {
       return errorResponse(c, ErrorCodes.THREAD_NOT_FOUND, `Thread not found: ${threadId}`, 404);
     }
-    const skillRelPath = join30(".agents", "skills", name);
-    const skillAbsPath = join30(thread.path, skillRelPath);
-    const skillFileRelPath = join30(skillRelPath, "SKILL.md");
-    const skillFileAbsPath = join30(skillAbsPath, "SKILL.md");
+    const skillRelPath = join32(".agents", "skills", name);
+    const skillAbsPath = join32(thread.path, skillRelPath);
+    const skillFileRelPath = join32(skillRelPath, "SKILL.md");
+    const skillFileAbsPath = join32(skillAbsPath, "SKILL.md");
     if (existsSync18(skillAbsPath)) {
       return c.json(
         { error: { code: "CONFLICT", message: `Skill '${name}' already exists` } },
@@ -23274,7 +24424,7 @@ var ScriptProcessManager = class {
         if (outputBuffer.length > 0) {
           yield outputBuffer.shift();
         } else {
-          await new Promise((resolve6) => setTimeout(resolve6, 50));
+          await new Promise((resolve7) => setTimeout(resolve7, 50));
         }
       }
     } finally {
@@ -23608,7 +24758,7 @@ var GitManagerImpl = class {
             yield event;
           }
         } else {
-          await new Promise((resolve6) => setTimeout(resolve6, 10));
+          await new Promise((resolve7) => setTimeout(resolve7, 10));
         }
       }
       if (processError) {
@@ -23671,7 +24821,7 @@ var GitManagerImpl = class {
    * @returns true if the branch exists, false otherwise
    */
   async checkBranchExists(repoPath, branchName) {
-    return new Promise((resolve6) => {
+    return new Promise((resolve7) => {
       const gitProcess = spawnProcess(
         "git",
         ["show-ref", "--verify", "--quiet", `refs/heads/${branchName}`],
@@ -23680,10 +24830,10 @@ var GitManagerImpl = class {
         }
       );
       gitProcess.on("close", (code) => {
-        resolve6(code === 0);
+        resolve7(code === 0);
       });
       gitProcess.on("error", () => {
-        resolve6(false);
+        resolve7(false);
       });
     });
   }
@@ -23741,7 +24891,7 @@ var GitManagerImpl = class {
             yield event;
           }
         } else {
-          await new Promise((resolve6) => setTimeout(resolve6, 10));
+          await new Promise((resolve7) => setTimeout(resolve7, 10));
         }
       }
       if (processError) {
@@ -23797,7 +24947,7 @@ import { Hono as Hono13 } from "hono";
 // src/features/git/git-user.route.ts
 init_utils();
 function readGitConfigValue(key) {
-  return new Promise((resolve6) => {
+  return new Promise((resolve7) => {
     const proc = spawnProcess("git", ["config", key]);
     let out = "";
     proc.stdout?.on("data", (d) => {
@@ -23805,12 +24955,12 @@ function readGitConfigValue(key) {
     });
     proc.on("close", (code) => {
       if (code === 0) {
-        resolve6(out.trim());
+        resolve7(out.trim());
       } else {
-        resolve6("");
+        resolve7("");
       }
     });
-    proc.on("error", () => resolve6(""));
+    proc.on("error", () => resolve7(""));
   });
 }
 async function gitUserHandler(c) {
@@ -23855,14 +25005,14 @@ async function gitStatusHandler(c, metadataManager) {
         400
       );
     }
-    const { hasChanges, changedFilesCount } = await new Promise((resolve6) => {
+    const { hasChanges, changedFilesCount } = await new Promise((resolve7) => {
       getGitStatus(gitRoot).then((statusOutput) => {
         const lines = statusOutput.trim().split("\n").filter((line) => line.length > 0);
-        resolve6({
+        resolve7({
           hasChanges: lines.length > 0,
           changedFilesCount: lines.length
         });
-      }).catch(() => resolve6({ hasChanges: false, changedFilesCount: 0 }));
+      }).catch(() => resolve7({ hasChanges: false, changedFilesCount: 0 }));
     });
     const currentBranch = await getCurrentBranch(gitRoot);
     const hasUnpushed = await hasUnpushedCommits(gitRoot, currentBranch);
@@ -23929,15 +25079,26 @@ async function gitDiffHandler(c, metadataManager) {
       let oldContent = "";
       let newContent = "";
       const hunks = [];
+      const isBinary = getExplorerFileMediaType(file.path) !== null;
+      if (isBinary) {
+        filesWithDiff.push({
+          ...file,
+          oldContent: "",
+          newContent: "",
+          isBinary: true,
+          hunks: []
+        });
+        continue;
+      }
       if (file.status === "deleted") {
-        const content = await new Promise((resolve6) => {
+        const content = await new Promise((resolve7) => {
           const proc = spawnProcess("git", ["show", `HEAD:${file.path}`], { cwd: gitRoot });
           let out = "";
           proc.stdout?.on("data", (d) => {
             out += d.toString();
           });
-          proc.on("close", () => resolve6(out));
-          proc.on("error", () => resolve6(""));
+          proc.on("close", () => resolve7(out));
+          proc.on("error", () => resolve7(""));
         });
         oldContent = content;
       } else if (file.status === "added" && file.path.startsWith("(new)")) {
@@ -23947,7 +25108,7 @@ async function gitDiffHandler(c, metadataManager) {
           newContent = "";
         }
       } else {
-        const diffOutput = await new Promise((resolve6) => {
+        const diffOutput = await new Promise((resolve7) => {
           const proc = spawnProcess(
             "git",
             file.status === "added" ? ["diff", "--cached", "--", file.path] : ["diff", "HEAD", "--", file.path],
@@ -23957,21 +25118,21 @@ async function gitDiffHandler(c, metadataManager) {
           proc.stdout?.on("data", (d) => {
             out += d.toString();
           });
-          proc.on("close", () => resolve6(out));
-          proc.on("error", () => resolve6(""));
+          proc.on("close", () => resolve7(out));
+          proc.on("error", () => resolve7(""));
         });
         const lines = diffOutput.split("\n");
         let currentHunk = null;
         let oldLineNum = 0;
         let newLineNum = 0;
-        const oldContentOutput = await new Promise((resolve6) => {
+        const oldContentOutput = await new Promise((resolve7) => {
           const proc = spawnProcess("git", ["show", `HEAD:${file.path}`], { cwd: gitRoot });
           let out = "";
           proc.stdout?.on("data", (d) => {
             out += d.toString();
           });
-          proc.on("close", () => resolve6(out));
-          proc.on("error", () => resolve6(""));
+          proc.on("close", () => resolve7(out));
+          proc.on("error", () => resolve7(""));
         });
         oldContent = oldContentOutput;
         try {
@@ -24028,6 +25189,7 @@ async function gitDiffHandler(c, metadataManager) {
         ...file,
         oldContent,
         newContent,
+        isBinary: false,
         hunks
       });
     }
@@ -24807,7 +25969,7 @@ function sanitizeBranchName(name) {
   return name.trim().toLowerCase().replace(/\s+/g, "-").replace(/[^a-zA-Z0-9\-_/.]/g, "").replace(/^[/.]+|[/.]+$/g, "").replace(/-+/g, "-") || "branch";
 }
 function checkBranchExists(gitRoot, branchName) {
-  return new Promise((resolve6) => {
+  return new Promise((resolve7) => {
     const proc = spawnProcess(
       "git",
       ["show-ref", "--verify", "--quiet", `refs/heads/${branchName}`],
@@ -24816,15 +25978,15 @@ function checkBranchExists(gitRoot, branchName) {
       }
     );
     proc.on("close", (code) => {
-      resolve6(code === 0);
+      resolve7(code === 0);
     });
     proc.on("error", () => {
-      resolve6(false);
+      resolve7(false);
     });
   });
 }
 function createAndCheckoutBranch(gitRoot, branchName) {
-  return new Promise((resolve6, reject) => {
+  return new Promise((resolve7, reject) => {
     const proc = spawnProcess("git", ["checkout", "-b", branchName], {
       cwd: gitRoot
     });
@@ -24836,7 +25998,7 @@ function createAndCheckoutBranch(gitRoot, branchName) {
     }
     proc.on("close", (code) => {
       if (code === 0) {
-        resolve6();
+        resolve7();
       } else {
         reject(new Error(err || `Failed to create branch "${branchName}"`));
       }
@@ -24929,7 +26091,7 @@ function sanitizeBranchName2(name) {
   return name.trim().toLowerCase().replace(/\s+/g, "-").replace(/[^a-zA-Z0-9\-_/.]/g, "").replace(/^[/.]+|[/.]+$/g, "").replace(/-+/g, "-") || "branch";
 }
 function checkBranchExists2(gitRoot, branchName) {
-  return new Promise((resolve6) => {
+  return new Promise((resolve7) => {
     const proc = spawnProcess(
       "git",
       ["show-ref", "--verify", "--quiet", `refs/heads/${branchName}`],
@@ -24938,16 +26100,16 @@ function checkBranchExists2(gitRoot, branchName) {
       }
     );
     proc.on("close", (code) => {
-      resolve6(code === 0);
+      resolve7(code === 0);
     });
     proc.on("error", () => {
-      resolve6(false);
+      resolve7(false);
     });
   });
 }
 function createAndCheckoutBranch2(gitRoot, branchName, baseBranch) {
   const args2 = baseBranch ? ["checkout", "-b", branchName, `origin/${baseBranch}`] : ["checkout", "-b", branchName];
-  return new Promise((resolve6, reject) => {
+  return new Promise((resolve7, reject) => {
     const proc = spawnProcess("git", args2, {
       cwd: gitRoot
     });
@@ -24959,7 +26121,7 @@ function createAndCheckoutBranch2(gitRoot, branchName, baseBranch) {
     }
     proc.on("close", (code) => {
       if (code === 0) {
-        resolve6();
+        resolve7();
       } else {
         reject(new Error(err || `Failed to create branch "${branchName}"`));
       }
@@ -25074,14 +26236,14 @@ async function gitSyncBranchHandler(c, metadataManager) {
       );
     }
     const { spawnProcess: spawnProcess2 } = await Promise.resolve().then(() => (init_utils(), utils_exports));
-    return new Promise((resolve6) => {
+    return new Promise((resolve7) => {
       console.log(`[sync-branch] Checking branch status...`);
       const statusProc = spawnProcess2("git", ["status", "-sb"], { cwd: gitRoot });
       let statusOutput = "";
       statusProc.on("close", (statusCode) => {
         if (statusCode !== 0) {
           console.log(`[sync-branch] Failed to get git status: code ${statusCode}`);
-          resolve6(
+          resolve7(
             c.json(
               {
                 error: "Failed to check git status",
@@ -25115,7 +26277,7 @@ async function gitSyncBranchHandler(c, metadataManager) {
           pushProc.on("close", (pushCode) => {
             if (pushCode !== 0) {
               console.log(`[sync-branch] Failed to push commits: code ${pushCode}`);
-              resolve6(
+              resolve7(
                 c.json(
                   {
                     error: `Failed to push commits before sync: ${pushErr || pushOut}`,
@@ -25133,7 +26295,7 @@ async function gitSyncBranchHandler(c, metadataManager) {
             console.log(
               `[sync-branch] \u2717 Push process error: ${error instanceof Error ? error.message : String(error)}`
             );
-            resolve6(
+            resolve7(
               c.json(
                 {
                   error: `Failed to push commits: ${error instanceof Error ? error.message : String(error)}`
@@ -25161,7 +26323,7 @@ async function gitSyncBranchHandler(c, metadataManager) {
         console.log(
           `[sync-branch] \u2717 Status process error: ${error instanceof Error ? error.message : String(error)}`
         );
-        resolve6(
+        resolve7(
           c.json(
             {
               error: `Failed to check git status: ${error instanceof Error ? error.message : String(error)}`
@@ -25176,7 +26338,7 @@ async function gitSyncBranchHandler(c, metadataManager) {
         configProc.on("close", (configCode) => {
           if (configCode !== 0) {
             console.log(`[sync-branch] Failed to configure git: code ${configCode}`);
-            resolve6(
+            resolve7(
               c.json(
                 {
                   error: "Failed to configure git pull strategy",
@@ -25210,7 +26372,7 @@ async function gitSyncBranchHandler(c, metadataManager) {
             if (code === 0) {
               const message = currentBranch === defaultBranch ? `Successfully pulled latest changes from origin/${defaultBranch}` : `Successfully synced ${currentBranch} with ${defaultBranch}`;
               console.log(`[sync-branch] \u2713 ${message}`);
-              resolve6(
+              resolve7(
                 c.json({
                   success: true,
                   message,
@@ -25221,7 +26383,7 @@ async function gitSyncBranchHandler(c, metadataManager) {
             } else {
               console.log(`[sync-branch] \u2717 Failed to sync with exit code ${code}`);
               console.log(`[sync-branch] Error output: ${err || out}`);
-              resolve6(
+              resolve7(
                 c.json(
                   {
                     error: `Failed to sync with ${defaultBranch}: ${err || out}`,
@@ -25236,7 +26398,7 @@ async function gitSyncBranchHandler(c, metadataManager) {
             console.log(
               `[sync-branch] \u2717 Process error: ${error instanceof Error ? error.message : String(error)}`
             );
-            resolve6(
+            resolve7(
               c.json(
                 {
                   error: `Failed to sync branch: ${error instanceof Error ? error.message : String(error)}`
@@ -25250,7 +26412,7 @@ async function gitSyncBranchHandler(c, metadataManager) {
           console.log(
             `[sync-branch] \u2717 Config process error: ${error instanceof Error ? error.message : String(error)}`
           );
-          resolve6(
+          resolve7(
             c.json(
               {
                 error: `Failed to configure git: ${error instanceof Error ? error.message : String(error)}`
@@ -25271,7 +26433,7 @@ async function gitSyncBranchHandler(c, metadataManager) {
 // src/features/git/git-list-branches.route.ts
 init_utils();
 function listLocalBranches(gitRoot) {
-  return new Promise((resolve6) => {
+  return new Promise((resolve7) => {
     const proc = spawnProcess("git", ["branch", "--format=%(refname:short)"], { cwd: gitRoot });
     let out = "";
     if (proc.stdout) {
@@ -25281,9 +26443,9 @@ function listLocalBranches(gitRoot) {
     }
     proc.on("close", () => {
       const branches = out.split("\n").map((b) => b.trim()).filter(Boolean);
-      resolve6(branches);
+      resolve7(branches);
     });
-    proc.on("error", () => resolve6([]));
+    proc.on("error", () => resolve7([]));
   });
 }
 async function gitListBranchesHandler(c, metadataManager) {
@@ -25315,7 +26477,7 @@ async function gitListBranchesHandler(c, metadataManager) {
 // src/features/git/git-checkout-branch.route.ts
 init_utils();
 function checkoutBranch(gitRoot, branchName) {
-  return new Promise((resolve6, reject) => {
+  return new Promise((resolve7, reject) => {
     const proc = spawnProcess("git", ["checkout", branchName], { cwd: gitRoot });
     let err = "";
     if (proc.stderr) {
@@ -25325,7 +26487,7 @@ function checkoutBranch(gitRoot, branchName) {
     }
     proc.on("close", (code) => {
       if (code === 0) {
-        resolve6();
+        resolve7();
       } else {
         reject(new Error(err.trim() || `Failed to checkout branch "${branchName}"`));
       }
@@ -25375,7 +26537,7 @@ import { unlinkSync } from "fs";
 import { resolve as resolve5 } from "path";
 init_utils();
 function runGit2(args2, cwd) {
-  return new Promise((resolve6, reject) => {
+  return new Promise((resolve7, reject) => {
     const proc = spawnProcess("git", args2, { cwd });
     let out = "";
     let err = "";
@@ -25386,7 +26548,7 @@ function runGit2(args2, cwd) {
       err += d.toString();
     });
     proc.on("close", (code) => {
-      if (code === 0) resolve6(out.trim());
+      if (code === 0) resolve7(out.trim());
       else reject(new Error(err.trim() || `git ${args2[0]} failed with code ${code}`));
     });
     proc.on("error", reject);
@@ -25438,7 +26600,7 @@ async function gitRevertFileHandler(c, metadataManager) {
 // src/features/git/git-checkpoint.route.ts
 init_utils();
 function stashWithLabel(gitRoot, label) {
-  return new Promise((resolve6, reject) => {
+  return new Promise((resolve7, reject) => {
     const proc = spawnProcess("git", ["stash", "push", "--include-untracked", "-m", label], {
       cwd: gitRoot
     });
@@ -25458,7 +26620,7 @@ function stashWithLabel(gitRoot, label) {
       if (code === 0) {
         const nothingSaved = out.includes("No local changes to save");
         if (nothingSaved) {
-          resolve6(false);
+          resolve7(false);
           return;
         }
         const apply = spawnProcess("git", ["stash", "apply", "--index"], { cwd: gitRoot });
@@ -25470,7 +26632,7 @@ function stashWithLabel(gitRoot, label) {
         }
         apply.on("close", (applyCode) => {
           if (applyCode === 0) {
-            resolve6(true);
+            resolve7(true);
           } else {
             reject(new Error(applyErr || "Failed to re-apply stash after checkpoint"));
           }
@@ -25519,7 +26681,7 @@ async function gitCheckpointHandler(c, metadataManager) {
 // src/features/git/git-checkpoint-restore.route.ts
 init_utils();
 function listStashes(gitRoot) {
-  return new Promise((resolve6, reject) => {
+  return new Promise((resolve7, reject) => {
     const proc = spawnProcess("git", ["stash", "list", "--format=%gd %s"], { cwd: gitRoot });
     let out = "";
     let err = "";
@@ -25543,18 +26705,18 @@ function listStashes(gitRoot) {
         if (!match) return null;
         return { index: parseInt(match[1], 10), label: match[2].trim() };
       }).filter((e) => e !== null);
-      resolve6(entries);
+      resolve7(entries);
     });
     proc.on("error", reject);
   });
 }
 function discardWorkingChanges(gitRoot) {
-  return new Promise((resolve6, reject) => {
+  return new Promise((resolve7, reject) => {
     const proc = spawnProcess("git", ["checkout", "--", "."], { cwd: gitRoot });
     proc.on("close", () => {
       const clean = spawnProcess("git", ["clean", "-fd"], { cwd: gitRoot });
       clean.on("close", (code) => {
-        if (code === 0) resolve6();
+        if (code === 0) resolve7();
         else reject(new Error("Failed to clean working tree"));
       });
       clean.on("error", reject);
@@ -25563,7 +26725,7 @@ function discardWorkingChanges(gitRoot) {
   });
 }
 function applyStash(gitRoot, index) {
-  return new Promise((resolve6, reject) => {
+  return new Promise((resolve7, reject) => {
     const proc = spawnProcess("git", ["stash", "apply", `stash@{${index}}`], { cwd: gitRoot });
     let err = "";
     if (proc.stderr) {
@@ -25572,7 +26734,7 @@ function applyStash(gitRoot, index) {
       });
     }
     proc.on("close", (code) => {
-      if (code === 0) resolve6();
+      if (code === 0) resolve7();
       else reject(new Error(err || "Failed to apply stash"));
     });
     proc.on("error", reject);
@@ -25616,6 +26778,175 @@ async function gitCheckpointRestoreHandler(c, metadataManager) {
   }
 }
 
+// src/features/git/git-rename-branch.route.ts
+init_utils();
+function sanitizeBranchName3(name) {
+  if (!name || typeof name !== "string") {
+    return "";
+  }
+  return name.trim().toLowerCase().replace(/\s+/g, "-").replace(/[^a-zA-Z0-9\-_/.]/g, "").replace(/^[/.]+|[/.]+$/g, "").replace(/-+/g, "-") || "";
+}
+function checkBranchExists3(gitRoot, branchName) {
+  return new Promise((resolve7) => {
+    const proc = spawnProcess(
+      "git",
+      ["show-ref", "--verify", "--quiet", `refs/heads/${branchName}`],
+      {
+        cwd: gitRoot
+      }
+    );
+    proc.on("close", (code) => {
+      resolve7(code === 0);
+    });
+    proc.on("error", () => {
+      resolve7(false);
+    });
+  });
+}
+function renameBranch(gitRoot, newBranchName) {
+  return new Promise((resolve7, reject) => {
+    const proc = spawnProcess("git", ["branch", "-m", newBranchName], {
+      cwd: gitRoot
+    });
+    let err = "";
+    if (proc.stderr) {
+      proc.stderr.on("data", (d) => {
+        err += d.toString();
+      });
+    }
+    proc.on("close", (code) => {
+      if (code === 0) {
+        resolve7();
+      } else {
+        reject(new Error(err || `Failed to rename branch to "${newBranchName}"`));
+      }
+    });
+    proc.on("error", reject);
+  });
+}
+async function gitRenameBranchHandler(c, metadataManager) {
+  try {
+    const threadId = c.req.param("threadId");
+    const thread = await metadataManager.loadThreads().then((threads2) => threads2.find((t) => t.id === threadId));
+    if (!thread) {
+      return c.json({ error: "Thread not found" }, 404);
+    }
+    const repoPath = thread.path;
+    if (!repoPath) {
+      return c.json({ error: "Thread path not found" }, 404);
+    }
+    const body = await c.req.json().catch(() => ({}));
+    const rawName = body.newBranchName?.trim();
+    if (!rawName) {
+      return c.json({ error: "newBranchName is required" }, 400);
+    }
+    const newBranchName = sanitizeBranchName3(rawName);
+    if (!newBranchName) {
+      return c.json({ error: "Invalid branch name" }, 400);
+    }
+    const absolutePath = resolveThreadPath(repoPath);
+    let gitRoot;
+    try {
+      gitRoot = await getGitRoot(absolutePath);
+    } catch {
+      return c.json({ error: `Path is not a git repository: ${absolutePath}` }, 400);
+    }
+    const branchExists = await checkBranchExists3(gitRoot, newBranchName);
+    if (branchExists) {
+      return c.json({ error: `Branch "${newBranchName}" already exists` }, 409);
+    }
+    await renameBranch(gitRoot, newBranchName);
+    const threads = await metadataManager.loadThreads();
+    const threadIndex = threads.findIndex((t) => t.id === threadId);
+    if (threadIndex !== -1) {
+      threads[threadIndex].currentBranch = newBranchName;
+      await metadataManager.saveThreads(threads);
+    }
+    return c.json({ success: true, branchName: newBranchName });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Failed to rename branch";
+    return c.json({ error: message }, 500);
+  }
+}
+
+// src/features/git/git-media.route.ts
+import { readFileSync as readFileSync8, existsSync as existsSync23 } from "fs";
+import { resolve as resolve6 } from "path";
+import { spawn as spawn3 } from "child_process";
+function spawnBinary(command, args2, cwd) {
+  return new Promise((resolve7, reject) => {
+    const proc = spawn3(command, args2, { cwd });
+    const chunks = [];
+    proc.stdout?.on("data", (d) => {
+      chunks.push(Buffer.from(d));
+    });
+    proc.on("close", (code) => {
+      if (code === 0) {
+        resolve7(Buffer.concat(chunks));
+      } else {
+        reject(new Error(`Process exited with code ${code}`));
+      }
+    });
+    proc.on("error", reject);
+  });
+}
+async function gitMediaHandler(c, metadataManager) {
+  try {
+    const threadId = c.req.param("threadId");
+    const filePath = c.req.query("path");
+    const version = c.req.query("version");
+    if (!threadId) {
+      return c.json({ error: "Thread ID is required" }, 400);
+    }
+    if (!filePath) {
+      return c.json({ error: "path query parameter is required" }, 400);
+    }
+    if (version !== "old" && version !== "new") {
+      return c.json({ error: "version query parameter must be 'old' or 'new'" }, 400);
+    }
+    const thread = await metadataManager.loadThreads().then((threads) => threads.find((t) => t.id === threadId));
+    if (!thread) {
+      return c.json({ error: "Thread not found" }, 404);
+    }
+    const repoPath = thread.path;
+    if (!repoPath) {
+      return c.json({ error: "Thread path not found" }, 404);
+    }
+    const absolutePath = resolveThreadPath(repoPath);
+    let gitRoot;
+    try {
+      gitRoot = await getGitRoot(absolutePath);
+    } catch {
+      return c.json({ error: `Path is not a git repository: ${absolutePath}` }, 400);
+    }
+    const ext = getFileExtension(filePath);
+    const contentType = EXPLORER_MEDIA_MIME_TYPES[ext] ?? "application/octet-stream";
+    let data;
+    if (version === "old") {
+      try {
+        data = await spawnBinary("git", ["show", `HEAD:${filePath}`], gitRoot);
+      } catch {
+        return c.json({ error: `File not found in HEAD: ${filePath}` }, 404);
+      }
+    } else {
+      const absFilePath = resolve6(gitRoot, filePath);
+      if (!existsSync23(absFilePath)) {
+        return c.json({ error: `File not found in working directory: ${filePath}` }, 404);
+      }
+      data = readFileSync8(absFilePath);
+    }
+    return new Response(data.buffer, {
+      headers: {
+        "Content-Type": contentType,
+        "Cross-Origin-Resource-Policy": "cross-origin"
+      }
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Failed to get git media";
+    return c.json({ error: message }, 500);
+  }
+}
+
 // src/features/git/git.routes.ts
 function createGitRoutes(metadataManager) {
   const router = new Hono13();
@@ -25638,6 +26969,9 @@ function createGitRoutes(metadataManager) {
   router.get("/diff/:threadId", async (c) => {
     return gitDiffHandler(c, metadataManager);
   });
+  router.get("/media/:threadId", async (c) => {
+    return gitMediaHandler(c, metadataManager);
+  });
   router.post("/generate-commit-message/:threadId", async (c) => {
     return gitGenerateCommitMessageHandler(c, metadataManager);
   });
@@ -25702,6 +27036,11 @@ function createGitRoutes(metadataManager) {
     await invalidateGitStatusCache(db, c.req.param("threadId"));
     return gitCheckoutBranchHandler(c, metadataManager);
   });
+  router.post("/rename-branch/:threadId", async (c) => {
+    const db = await getDatabase();
+    await invalidateGitStatusCache(db, c.req.param("threadId"));
+    return gitRenameBranchHandler(c, metadataManager);
+  });
   router.post("/revert-file/:threadId", async (c) => {
     const db = await getDatabase();
     await invalidateGitStatusCache(db, c.req.param("threadId"));
@@ -25757,8 +27096,8 @@ function createUpdateRoutes(updater) {
 
 // src/features/mcp/mcp.routes.ts
 import { Hono as Hono15 } from "hono";
-import { readFile as readFile16, writeFile as writeFile9, mkdir as mkdir11, access as access6 } from "fs/promises";
-import { join as join31, dirname as dirname7 } from "path";
+import { readFile as readFile17, writeFile as writeFile9, mkdir as mkdir11, access as access6 } from "fs/promises";
+import { join as join33, dirname as dirname7 } from "path";
 
 // src/features/mcp/mcp.popular.json
 var mcp_popular_default = [
@@ -25880,10 +27219,10 @@ var mcp_popular_default = [
 var MCP_CONFIG_PATHS2 = [".agents/mcp.json", "mcp.json"];
 async function readMCPConfig(projectPath) {
   for (const configPath of MCP_CONFIG_PATHS2) {
-    const fullPath = join31(projectPath, configPath);
+    const fullPath = join33(projectPath, configPath);
     try {
       await access6(fullPath);
-      const content = await readFile16(fullPath, "utf-8");
+      const content = await readFile17(fullPath, "utf-8");
       const config = JSON.parse(content);
       return { config, filePath: fullPath };
     } catch {
@@ -25894,7 +27233,7 @@ async function readMCPConfig(projectPath) {
 }
 async function writeMCPConfig(projectPath, config) {
   const existing = await readMCPConfig(projectPath);
-  const targetPath = existing?.filePath ?? join31(projectPath, ".agents/mcp.json");
+  const targetPath = existing?.filePath ?? join33(projectPath, ".agents/mcp.json");
   await mkdir11(dirname7(targetPath), { recursive: true });
   await writeFile9(targetPath, JSON.stringify(config, null, 2), "utf-8");
 }
@@ -26310,8 +27649,8 @@ function getLocalNetworkAddresses() {
 }
 
 // src/core/server-bind-mode-store.ts
-import { existsSync as existsSync23, mkdirSync as mkdirSync2, readFileSync as readFileSync8, writeFileSync } from "fs";
-import { join as join32 } from "path";
+import { existsSync as existsSync24, mkdirSync as mkdirSync2, readFileSync as readFileSync9, writeFileSync } from "fs";
+import { join as join34 } from "path";
 
 // src/core/server-bind-mode.ts
 var DEFAULT_SERVER_BIND_MODE = "local";
@@ -26323,16 +27662,16 @@ function getServerBindHostname(mode) {
 }
 
 // src/core/server-bind-mode-store.ts
-var SERVER_BIND_MODE_FILE = join32(DATA_DIR, "server-bind-mode.json");
+var SERVER_BIND_MODE_FILE = join34(DATA_DIR, "server-bind-mode.json");
 function hasServerBindModeFile() {
-  return existsSync23(SERVER_BIND_MODE_FILE);
+  return existsSync24(SERVER_BIND_MODE_FILE);
 }
 function readServerBindMode() {
   try {
-    if (!existsSync23(SERVER_BIND_MODE_FILE)) {
+    if (!existsSync24(SERVER_BIND_MODE_FILE)) {
       return DEFAULT_SERVER_BIND_MODE;
     }
-    const raw = readFileSync8(SERVER_BIND_MODE_FILE, "utf8");
+    const raw = readFileSync9(SERVER_BIND_MODE_FILE, "utf8");
     const parsed = JSON.parse(raw);
     return normalizeServerBindMode(parsed.serverBindMode);
   } catch {
@@ -26656,7 +27995,8 @@ async function clipboardWriteImage(c) {
         pngData[i] = binary.charCodeAt(i);
       }
     } else if (imageUrl) {
-      const res = await fetch(imageUrl);
+      const fetchUrl2 = resolveAbsoluteImageUrl(imageUrl, new URL(c.req.url).origin);
+      const res = await fetch(fetchUrl2);
       if (!res.ok) {
         return c.json({ error: `Failed to fetch image: ${res.status}` }, 400);
       }
@@ -26673,7 +28013,7 @@ async function clipboardWriteImage(c) {
 }
 
 // src/features/image/image-save.route.ts
-import { join as join33 } from "path";
+import { join as join35 } from "path";
 var Utils5 = null;
 var utilsLoaded5 = false;
 async function loadUtils5() {
@@ -26701,7 +28041,8 @@ async function saveImage(c) {
         data[i] = binary.charCodeAt(i);
       }
     } else if (imageUrl) {
-      const res = await fetch(imageUrl);
+      const fetchUrl2 = resolveAbsoluteImageUrl(imageUrl, new URL(c.req.url).origin);
+      const res = await fetch(fetchUrl2);
       if (!res.ok) {
         return c.json({ error: `Failed to fetch image: ${res.status}` }, 400);
       }
@@ -26710,7 +28051,7 @@ async function saveImage(c) {
       return c.json({ error: "imageUrl or imageData is required" }, 400);
     }
     const name = filename ?? `generated-image-${Date.now()}.png`;
-    const savePath = join33(Utils5.paths.downloads, name);
+    const savePath = join35(Utils5.paths.downloads, name);
     await Bun.write(savePath, data);
     return c.json({ success: true, path: savePath });
   } catch (error) {
@@ -26802,7 +28143,7 @@ function createBrowserJsRoutes(threadManager, projectManager, processingStateMan
           });
         }
       }) : void 0;
-      const tools = createAllTools(thread.path, { shellPermissionGate });
+      const tools = createAllTools(thread.path, { shellPermissionGate, threadId });
       const tool = tools[toolName];
       if (!tool) {
         return errorResponse(c, ErrorCodes.INVALID_REQUEST, `Tool ${toolName} not found`, 404);
@@ -26818,8 +28159,79 @@ function createBrowserJsRoutes(threadManager, projectManager, processingStateMan
   return router;
 }
 
-// src/features/voice-model/voice-model.routes.ts
+// src/features/browser/browser.routes.ts
 import { Hono as Hono23 } from "hono";
+function createBrowserRoutes() {
+  const router = new Hono23();
+  router.post("/ready", async (c) => {
+    try {
+      const body = await c.req.json();
+      const { toolCallId, webviewId } = body;
+      if (!toolCallId || typeof toolCallId !== "string") {
+        return errorResponse(
+          c,
+          ErrorCodes.INVALID_REQUEST,
+          "toolCallId is required and must be a string",
+          400
+        );
+      }
+      if (typeof webviewId !== "number" || !Number.isFinite(webviewId)) {
+        return errorResponse(
+          c,
+          ErrorCodes.INVALID_REQUEST,
+          "webviewId is required and must be a number",
+          400
+        );
+      }
+      submitBrowserWebviewReady(toolCallId, webviewId);
+      return c.json({ success: true });
+    } catch (error) {
+      return errorResponse(
+        c,
+        ErrorCodes.REQUEST_PARSE_ERROR,
+        "Failed to parse request body",
+        400,
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+  });
+  router.post("/action-result", async (c) => {
+    try {
+      const body = await c.req.json();
+      const { toolCallId, result } = body;
+      if (!toolCallId || typeof toolCallId !== "string") {
+        return errorResponse(
+          c,
+          ErrorCodes.INVALID_REQUEST,
+          "toolCallId is required and must be a string",
+          400
+        );
+      }
+      if (!result || typeof result !== "object" || Array.isArray(result)) {
+        return errorResponse(
+          c,
+          ErrorCodes.INVALID_REQUEST,
+          "result is required and must be an object",
+          400
+        );
+      }
+      submitBrowserActionResult(toolCallId, result);
+      return c.json({ success: true });
+    } catch (error) {
+      return errorResponse(
+        c,
+        ErrorCodes.REQUEST_PARSE_ERROR,
+        "Failed to parse request body",
+        400,
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+  });
+  return router;
+}
+
+// src/features/voice-model/voice-model.routes.ts
+import { Hono as Hono24 } from "hono";
 var VOICE_MODEL_URLS = {
   default: "https://install.tarsk.io/voice-models/ggml-tiny.en.bin",
   tiny: "https://install.tarsk.io/voice-models/ggml-tiny.en-q5_1.bin"
@@ -26831,7 +28243,7 @@ function getVoiceModelUrl(model) {
   return VOICE_MODEL_URLS.default;
 }
 function createVoiceModelRoutes() {
-  const router = new Hono23();
+  const router = new Hono24();
   router.get("/download", async (c) => {
     const selectedModel = c.req.query("model");
     const modelUrl = getVoiceModelUrl(selectedModel);
@@ -26872,9 +28284,9 @@ function createVoiceModelRoutes() {
 }
 
 // src/features/logs/logs.routes.ts
-import { Hono as Hono24 } from "hono";
+import { Hono as Hono25 } from "hono";
 function createLogsRoutes() {
-  const router = new Hono24();
+  const router = new Hono25();
   router.post("/", async (c) => {
     let body = {};
     try {
@@ -26912,11 +28324,11 @@ function createLogsRoutes() {
 
 // src/features/user-tasks/user-tasks.routes.ts
 init_database();
-import { Hono as Hono25 } from "hono";
+import { Hono as Hono26 } from "hono";
 
 // src/features/user-tasks/user-tasks.database.ts
 init_database();
-import { randomUUID as randomUUID12 } from "crypto";
+import { randomUUID as randomUUID13 } from "crypto";
 async function getUserTasksByThread(db, threadId) {
   const result = await db.execute({
     sql: `SELECT id, threadId, content, createdAt, updatedAt
@@ -26929,7 +28341,7 @@ async function getUserTasksByThread(db, threadId) {
 }
 async function insertUserTask(threadId, content) {
   const db = await getDatabase();
-  const id = randomUUID12();
+  const id = randomUUID13();
   const now = (/* @__PURE__ */ new Date()).toISOString();
   await db.execute({
     sql: `INSERT INTO user_tasks (id, threadId, content, createdAt, updatedAt)
@@ -26953,7 +28365,7 @@ async function deleteUserTaskById(db, id) {
 
 // src/features/user-tasks/user-tasks.routes.ts
 function createUserTaskRoutes() {
-  const router = new Hono25();
+  const router = new Hono26();
   router.get("/:threadId/user-tasks", async (c) => {
     const threadId = c.req.param("threadId");
     const db = await getDatabase();
@@ -26993,7 +28405,7 @@ async function startTarskServer(options) {
 async function startTarskServerInternal(options) {
   const { isDebug: isDebug2, publicDir: publicDirOverride } = options;
   const port = isDebug2 ? 462 : process.env.PORT ? parseInt(process.env.PORT) : 641;
-  const app = new Hono26();
+  const app = new Hono27();
   app.use("/*", cors());
   app.use("/*", async (c, next) => {
     c.header("Cross-Origin-Opener-Policy", "same-origin");
@@ -27086,6 +28498,7 @@ async function startTarskServerInternal(options) {
     "/api/browser-js",
     createBrowserJsRoutes(threadManager, projectManager, processingStateManager)
   );
+  app.route("/api/browser", createBrowserRoutes());
   app.route("/api/voice-model", createVoiceModelRoutes());
   app.route("/api/logs", createLogsRoutes());
   app.route("/api/update", createUpdateRoutes(options.updater));
@@ -27157,10 +28570,10 @@ async function listenForTarskServer(options) {
     hostname: options.hostname,
     port: options.port
   });
-  return new Promise((resolve6, reject) => {
+  return new Promise((resolve7, reject) => {
     server.once("error", (error) => {
       if (error.code === "EADDRINUSE") {
-        resolve6(false);
+        resolve7(false);
         return;
       }
       startPromise = null;
@@ -27168,7 +28581,7 @@ async function listenForTarskServer(options) {
     });
     function onListening() {
       options.onListening();
-      resolve6(true);
+      resolve7(true);
     }
     if (options.hostname) {
       server.listen(options.port, options.hostname, onListening);