@swifty.js/swifty 0.0.32 → 0.0.33

package/dist/lib/index.js

@@ -1,3 +1,9 @@
+import {
+  SeatbeltSandbox
+} from "./chunk-VUD72RTY.js";
+import {
+  version
+} from "./chunk-GTHYQZRL.js";
 import {
   Agent,
   AutoCompactTrackingState,
@@ -14,6 +20,7 @@ import {
   buildPlanModeReminder,
   buildSummaryInstructions,
   buildSummaryPrompt,
+  captureTelemetryError,
   cleanExpiredSessions,
   computeCompactThreshold,
   computeKeepStartIndex,
@@ -34,25 +41,28 @@ import {
   persistLargeResult,
   planExists,
   rebuildFromSession,
+  registerLlmClient,
   replaceToolResultContent,
   resetPlanPath,
   saveCompactBoundary,
   saveMessage,
   savePlan,
+  shutdownTelemetry,
   toDisplayPreview,
   toolResultsToRecords,
   toolUsesToRecords
-} from "./chunk-UH5M7FDP.js";
+} from "./chunk-AFYPVA5C.js";
 import {
   PathSandbox,
   PermissionChecker,
   RuleEngine,
   canonicalPath,
+  compactPath,
   evaluateRules,
   extractContent,
   isPathWithin,
   isSafeCommand
-} from "./chunk-SOOSTGHI.js";
+} from "./chunk-CFYAZWDA.js";
 import {
   AnthropicClient,
   CHARS_PER_TOKEN,
@@ -160,13 +170,10 @@ import {
   ToolRegistry,
   cloneRegistryForFork,
   filterToolsForAgent
-} from "./chunk-4BPKIIQD.js";
+} from "./chunk-LDWFI6MR.js";
 import {
   BwrapSandbox
 } from "./chunk-ORSYNBMM.js";
-import {
-  SeatbeltSandbox
-} from "./chunk-VUD72RTY.js";
 
 // src/bootstrap/interaction-summary.ts
 function formatDuration(milliseconds) {
@@ -721,6 +728,10 @@ var GREP_DESCRIPTION = `Search file content with a case-insensitive, line-by-lin
 - include is an optional glob: "*.ts" matches names at any depth; patterns with "/" match working-directory-relative paths. A direct file path is searched without this filter.
 - Traversal includes dotfiles but skips fixed directories such as .git, .agents, .swifty, node_modules, dist, and __pycache__, not .gitignore rules. Binary/unreadable files are skipped; directory symlinks are not traversed.
 - At most 500 matching lines. Narrow searches; never search the filesystem root. Use ReadFile for context and this tool instead of shell grep/rg.`;
+var WEB_FETCH_DESCRIPTION = `Fetch a URL over HTTP(S) and return its content as Markdown. Use it to retrieve and analyze web pages.
+- url must be a fully-formed http or https URL; redirects are followed automatically and the final URL is reported when it differs.
+- HTML is converted to Markdown; other text formats (plain text, JSON, XML, Markdown) are returned as-is. Binary content (images, PDFs, archives) is rejected.
+- Responses over 10MB are rejected and results are truncated at 100K characters. Successful fetches are cached for 15 minutes.`;
 
 // src/tools/exit-code-hints.ts
 function extractBaseCmd(command) {
@@ -1217,8 +1228,9 @@ import { setTimeout as delay } from "timers/promises";
 import sharp2 from "sharp";
 import { safeParse, z as z3 } from "zod";
 
-// raw-import:/Users/hangtiancheng/github/swifty-code/apps/swifty/src/tools/snippets/macos.swift
-var macos_default = `import AppKit
+// src/tools/snippets.ts
+var MACOS_SNIPPET = `
+import AppKit
 import ApplicationServices
 import Foundation
 
@@ -1242,7 +1254,7 @@ let keyCodes: [String: CGKeyCode] = [
   "Y": 16, "T": 17, "1": 18, "2": 19, "3": 20, "4": 21, "6": 22,
   "5": 23, "=": 24, "9": 25, "7": 26, "-": 27, "8": 28, "0": 29,
   "]": 30, "O": 31, "U": 32, "[": 33, "I": 34, "P": 35, "RETURN": 36,
-  "ENTER": 36, "L": 37, "J": 38, "'": 39, "K": 40, ";": 41, "\\\\": 42,
+  "ENTER": 36, "L": 37, "J": 38, "'": 39, "K": 40, ";": 41, "\\": 42,
   ",": 43, "/": 44, "N": 45, "M": 46, ".": 47, "TAB": 48, "SPACE": 49,
   "GRAVE": 50, "BACKTICK": 50, "BACKSPACE": 51, "DELETE": 51, "ESC": 53, "ESCAPE": 53,
   "CMD": 55, "COMMAND": 55, "META": 55, "SHIFT": 56, "CAPSLOCK": 57,
@@ -1394,38 +1406,86 @@ default:
   fail("Unsupported action: " + action)
 }
 `;
-
-// raw-import:/Users/hangtiancheng/github/swifty-code/apps/swifty/src/tools/snippets/win32-script.ps1
-var win32_script_default = `$ErrorActionPreference = 'Stop';
-
+var WINDOWS_PWSH_SNIPPET = `
+$ErrorActionPreference = 'Stop';
 Add-Type -AssemblyName System.Drawing;
-
 Add-Type -AssemblyName System.Windows.Forms;
-
 $bounds = [System.Windows.Forms.Screen]::PrimaryScreen.Bounds;
-
 $bitmap = New-Object System.Drawing.Bitmap $bounds.Width, $bounds.Height;
-
 $graphics = [System.Drawing.Graphics]::FromImage($bitmap);
-
 $graphics.CopyFromScreen($bounds.X, $bounds.Y, 0, 0, $bounds.Size);
-
 $bitmap.Save($env:SWIFTY_SCREENSHOT_PATH, [System.Drawing.Imaging.ImageFormat]::Png);
-
 $graphics.Dispose(); $bitmap.Dispose();
-
 Write-Output "$($bounds.Width),$($bounds.Height)"
 `;
+var WINDOWS_CSHARP_SNIPPET = `
+using System;
+using System.Drawing;
+using System.Runtime.InteropServices;
+using System.Windows.Forms;
+
+public static class SwiftyComputer
+{
+  [StructLayout(LayoutKind.Sequential)]
+  private struct INPUT { public uint type; public InputUnion value; }
+  [StructLayout(LayoutKind.Explicit)]
+  private struct InputUnion { [FieldOffset(0)] public KEYBDINPUT keyboard; }
+  [StructLayout(LayoutKind.Sequential)]
+  private struct KEYBDINPUT
+  {
+    public ushort virtualKey;
+    public ushort scanCode;
+    public uint flags;
+    public uint time;
+    public UIntPtr extraInfo;
+  }
 
-// raw-import:/Users/hangtiancheng/github/swifty-code/apps/swifty/src/tools/snippets/windows.cs
-var windows_default = 'using System;\nusing System.Drawing;\nusing System.Runtime.InteropServices;\nusing System.Windows.Forms;\n\npublic static class SwiftyComputer\n{\n  [StructLayout(LayoutKind.Sequential)]\n  private struct INPUT { public uint type; public InputUnion value; }\n  [StructLayout(LayoutKind.Explicit)]\n  private struct InputUnion { [FieldOffset(0)] public KEYBDINPUT keyboard; }\n  [StructLayout(LayoutKind.Sequential)]\n  private struct KEYBDINPUT\n  {\n    public ushort virtualKey;\n    public ushort scanCode;\n    public uint flags;\n    public uint time;\n    public UIntPtr extraInfo;\n  }\n\n  [DllImport("user32.dll")]\n  private static extern void mouse_event(uint flags, uint dx, uint dy, int data, UIntPtr extraInfo);\n  [DllImport("user32.dll", SetLastError = true)]\n  private static extern uint SendInput(uint count, INPUT[] inputs, int size);\n\n  private static void SendKeyboard(ushort virtualKey, ushort scanCode, uint flags)\n  {\n    var inputs = new[] {\n      new INPUT {\n        type = 1,\n        value = new InputUnion {\n          keyboard = new KEYBDINPUT {\n            virtualKey = virtualKey,\n            scanCode = scanCode,\n            flags = flags,\n            extraInfo = UIntPtr.Zero\n          }\n        }\n      }\n    };\n    if (SendInput(1, inputs, Marshal.SizeOf(typeof(INPUT))) != 1)\n    {\n      throw new InvalidOperationException("SendInput failed.");\n    }\n  }\n\n  public static void Move(int x, int y) { Cursor.Position = new Point(x, y); }\n  public static Point Position() { return Cursor.Position; }\n  public static void Mouse(uint flags, int data = 0) { mouse_event(flags, 0, 0, data, UIntPtr.Zero); }\n  public static void Key(int virtualKey, bool down) { SendKeyboard((ushort)virtualKey, 0, down ? 0u : 2u); }\n  public static void Text(string text)\n  {\n    foreach (char value in text)\n    {\n      SendKeyboard(0, value, 4u);\n      SendKeyboard(0, value, 6u);\n    }\n  }\n}\n';
+  [DllImport("user32.dll")]
+  private static extern void mouse_event(uint flags, uint dx, uint dy, int data, UIntPtr extraInfo);
+  [DllImport("user32.dll", SetLastError = true)]
+  private static extern uint SendInput(uint count, INPUT[] inputs, int size);
 
-// raw-import:/Users/hangtiancheng/github/swifty-code/apps/swifty/src/tools/snippets/windows.ps1
-var windows_default2 = `$ErrorActionPreference = 'Stop'
+  private static void SendKeyboard(ushort virtualKey, ushort scanCode, uint flags)
+  {
+    var inputs = new[] {
+      new INPUT {
+        type = 1,
+        value = new InputUnion {
+          keyboard = new KEYBDINPUT {
+            virtualKey = virtualKey,
+            scanCode = scanCode,
+            flags = flags,
+            extraInfo = UIntPtr.Zero
+          }
+        }
+      }
+    };
+    if (SendInput(1, inputs, Marshal.SizeOf(typeof(INPUT))) != 1)
+    {
+      throw new InvalidOperationException("SendInput failed.");
+    }
+  }
+
+  public static void Move(int x, int y) { Cursor.Position = new Point(x, y); }
+  public static Point Position() { return Cursor.Position; }
+  public static void Mouse(uint flags, int data = 0) { mouse_event(flags, 0, 0, data, UIntPtr.Zero); }
+  public static void Key(int virtualKey, bool down) { SendKeyboard((ushort)virtualKey, 0, down ? 0u : 2u); }
+  public static void Text(string text)
+  {
+    foreach (char value in text)
+    {
+      SendKeyboard(0, value, 4u);
+      SendKeyboard(0, value, 6u);
+    }
+  }
+}
+`;
+var WINDOWS_PWSH_INCLUDES_CSHARP_SNIPPET = `
+$ErrorActionPreference = 'Stop'
 Add-Type -AssemblyName System.Drawing
 Add-Type -AssemblyName System.Windows.Forms
 Add-Type -TypeDefinition @'
-\${WINDOWS.CS}
+${WINDOWS_CSHARP_SNIPPET}
 '@
 
 $payload = [Text.Encoding]::UTF8.GetString([Convert]::FromBase64String($env:SWIFTY_COMPUTER_INPUT)) | ConvertFrom-Json
@@ -1541,11 +1601,11 @@ var mediaType = {
   ".gif": "image/gif",
   ".webp": "image/webp"
 };
-function getMediaType(path2) {
-  return mediaType[extname(path2).toLowerCase()] ?? null;
+function getMediaType(path) {
+  return mediaType[extname(path).toLowerCase()] ?? null;
 }
-function isImagePath(path2) {
-  return getMediaType(path2) !== null;
+function isImagePath(path) {
+  return getMediaType(path) !== null;
 }
 function sniffMediaType(buf) {
   if (buf.length >= 8 && buf[0] === 137 && buf[1] === 80 && buf[2] === 78 && buf[3] === 71) {
@@ -1969,7 +2029,6 @@ function openaiActionToFlat(item) {
       return { action: "wait" };
   }
 }
-var WINDOWS_POWERSHELL = windows_default2.replace("${WINDOWS.CS}", () => windows_default);
 function commandError(command, result) {
   return new Error(
     `${command} failed: ${result.stderr || result.stdout.toString("utf8").trim() || `exit ${String(result.code)}`}`
@@ -2366,7 +2425,7 @@ var ComputerUseTool = class {
     const sourcePath = join2(directory, "main.swift");
     const executablePath = join2(directory, "computer-helper");
     try {
-      await writeFile(sourcePath, macos_default, "utf8");
+      await writeFile(sourcePath, MACOS_SNIPPET, "utf8");
       const result = await this.run(
         "/usr/bin/xcrun",
         ["swiftc", "-O", sourcePath, "-o", executablePath],
@@ -2384,7 +2443,7 @@ var ComputerUseTool = class {
   async executeWindows(action, signal) {
     const result = await this.run(
       "powershell.exe",
-      ["-NoProfile", "-NonInteractive", "-Sta", "-Command", WINDOWS_POWERSHELL],
+      ["-NoProfile", "-NonInteractive", "-Sta", "-Command", WINDOWS_PWSH_INCLUDES_CSHARP_SNIPPET],
       {
         env: {
           ...process.env,
@@ -2466,15 +2525,15 @@ var ComputerUseTool = class {
         return "";
       }
       case "left_click_drag": {
-        const path2 = action.path ?? [];
-        if (path2.length < 2) {
+        const path = action.path ?? [];
+        if (path.length < 2) {
           throw new Error("Drag path must contain at least two points.");
         }
         await withKeys(async () => {
-          await runXdotool(["mousemove", "--sync", String(path2[0].x), String(path2[0].y)]);
+          await runXdotool(["mousemove", "--sync", String(path[0].x), String(path[0].y)]);
           await runXdotool(["mousedown", "1"]);
           try {
-            for (const point of path2.slice(1)) {
+            for (const point of path.slice(1)) {
               await runXdotool(["mousemove", "--sync", String(point.x), String(point.y)]);
             }
           } finally {
@@ -2607,7 +2666,7 @@ var ComputerUseTool = class {
         case "win32": {
           const capture = await this.run(
             "powershell.exe",
-            ["-NoProfile", "-NonInteractive", "-Sta", "-Command", win32_script_default],
+            ["-NoProfile", "-NonInteractive", "-Sta", "-Command", WINDOWS_PWSH_SNIPPET],
             {
               env: { ...process.env, SWIFTY_SCREENSHOT_PATH: screenshotPath },
               signal
@@ -2858,7 +2917,8 @@ var EditFileTool = class {
           isError: true
         };
       }
-      const newContent = replaceAll ? content.replaceAll(oldString, newString) : content.replace(oldString, newString);
+      const literal = () => newString;
+      const newContent = replaceAll ? content.replaceAll(oldString, literal) : content.replace(oldString, literal);
       try {
         await writeFile2(filePath, newContent, "utf-8");
         ctx.fileStateCache?.update(filePath);
@@ -2901,9 +2961,9 @@ function isSafeRefName(name) {
   }
   return SAFE_REF_RE.test(name);
 }
-async function pathExists(path2) {
+async function pathExists(path) {
   try {
-    await access(path2);
+    await access(path);
     return true;
   } catch (err) {
     log4.error({ err }, "worktree operation failed");
@@ -3100,21 +3160,21 @@ async function createAgentWorktree(slug, gitRoot) {
     gitRoot: root
   };
 }
-async function removeAgentWorktree(path2, branch, gitRoot) {
-  await execFileAsync("git", ["worktree", "remove", "--", path2], {
+async function removeAgentWorktree(path, branch, gitRoot) {
+  await execFileAsync("git", ["worktree", "remove", "--", path], {
     cwd: gitRoot
   });
   await execFileAsync("git", ["branch", "-d", "--", branch], { cwd: gitRoot });
 }
-async function hasWorktreeChanges(path2, headCommit) {
+async function hasWorktreeChanges(path, headCommit) {
   try {
     const { stdout: status } = await execFileAsync("git", ["status", "--porcelain"], {
-      cwd: path2
+      cwd: path
     });
     if (status.trim()) {
       return true;
     }
-    const currentHead = await readWorktreeHeadSha(path2) || (await execFileAsync("git", ["rev-parse", "HEAD"], { cwd: path2 })).stdout.trim();
+    const currentHead = await readWorktreeHeadSha(path) || (await execFileAsync("git", ["rev-parse", "HEAD"], { cwd: path })).stdout.trim();
     return currentHead !== headCommit;
   } catch (err) {
     log4.error({ err }, "worktree operation failed");
@@ -3401,11 +3461,11 @@ var ExitWorktreeTool = class {
     };
   }
   async execute(ctx, args) {
-    const path2 = strArg(args, "path");
+    const path = strArg(args, "path");
     const branch = strArg(args, "branch");
     const gitRoot = strArg(args, "git_root");
     const headCommit = strArg(args, "head_commit");
-    if (!path2 || !branch || !gitRoot) {
+    if (!path || !branch || !gitRoot) {
       return {
         output: "Error: path, branch and git_root are required",
         isError: true
@@ -3413,17 +3473,17 @@ var ExitWorktreeTool = class {
     }
     if (!headCommit) {
       return {
-        output: `Original head_commit was not provided; worktree kept at: ${path2}
+        output: `Original head_commit was not provided; worktree kept at: ${path}
 Branch: ${branch}`,
         isError: false
       };
     }
-    const hasChanges = await hasWorktreeChanges(path2, headCommit);
+    const hasChanges = await hasWorktreeChanges(path, headCommit);
     if (!hasChanges) {
       try {
-        await removeAgentWorktree(path2, branch, gitRoot);
+        await removeAgentWorktree(path, branch, gitRoot);
         return {
-          output: `Worktree cleaned up (no changes): ${path2}`,
+          output: `Worktree cleaned up (no changes): ${path}`,
           isError: false
         };
       } catch (err) {
@@ -3435,7 +3495,7 @@ Branch: ${branch}`,
       }
     }
     return {
-      output: `Worktree has changes, kept at: ${path2}
+      output: `Worktree has changes, kept at: ${path}
 Branch: ${branch}`,
       isError: false
     };
@@ -4209,10 +4269,211 @@ var ToolSearchTool = class {
   }
 };
 
+// src/tools/web-fetch.ts
+var log10 = createChildLogger({ module: "tools" });
+var MAX_CONTENT_BYTES = 10 * 1024 * 1024;
+var FETCH_TIMEOUT_MS = 6e4;
+var MAX_MARKDOWN_LENGTH = 1e5;
+var CACHE_TTL_MS = 15 * 60 * 1e3;
+var MAX_CACHE_SIZE_BYTES = 50 * 1024 * 1024;
+var urlCache = /* @__PURE__ */ new Map();
+var urlCacheBytes = 0;
+function cacheGet(url) {
+  const entry = urlCache.get(url);
+  if (!entry) {
+    return void 0;
+  }
+  if (entry.expiresAt <= Date.now()) {
+    urlCache.delete(url);
+    urlCacheBytes -= entry.size;
+    return void 0;
+  }
+  return entry;
+}
+function cacheSet(url, markdown, finalUrl) {
+  const existing = urlCache.get(url);
+  if (existing) {
+    urlCacheBytes -= existing.size;
+  }
+  const size = Math.max(1, Buffer.byteLength(markdown));
+  urlCache.set(url, { markdown, finalUrl, expiresAt: Date.now() + CACHE_TTL_MS, size });
+  urlCacheBytes += size;
+  for (const key of urlCache.keys()) {
+    if (urlCacheBytes <= MAX_CACHE_SIZE_BYTES) {
+      break;
+    }
+    const evicted = urlCache.get(key);
+    urlCache.delete(key);
+    if (evicted) {
+      urlCacheBytes -= evicted.size;
+    }
+  }
+}
+var turndownServicePromise;
+function getTurndownService() {
+  return turndownServicePromise ??= import("turndown").then(
+    // Strip <script>/<style>: turndown's default rules keep their text content,
+    // which pollutes the markdown with JS/CSS noise.
+    (mod) => new mod.default().remove(["script", "style"])
+  );
+}
+function isBinaryContentType(contentType) {
+  if (!contentType) {
+    return false;
+  }
+  const mt = (contentType.split(";")[0] ?? "").trim().toLowerCase();
+  if (mt.startsWith("text/")) {
+    return false;
+  }
+  if (mt.endsWith("+json") || mt === "application/json") {
+    return false;
+  }
+  if (mt.endsWith("+xml") || mt === "application/xml") {
+    return false;
+  }
+  if (mt.startsWith("application/javascript")) {
+    return false;
+  }
+  if (mt === "application/x-www-form-urlencoded") {
+    return false;
+  }
+  return true;
+}
+function truncateMarkdown(content) {
+  if (content.length <= MAX_MARKDOWN_LENGTH) {
+    return content;
+  }
+  return `${content.slice(0, MAX_MARKDOWN_LENGTH)}
+
+[Content truncated due to length...]`;
+}
+function formatResult(markdown, requestedUrl, finalUrl) {
+  const content = truncateMarkdown(markdown);
+  if (finalUrl && finalUrl !== requestedUrl) {
+    return `[Redirected to ${finalUrl}]
+
+${content}`;
+  }
+  return content;
+}
+var WebFetchTool = class {
+  // Use a hardcoded string instead of WebFetchTool.name.replace("Tool", "")
+  // because class names are not stable after minification — bundlers like
+  // Terser/esbuild may rename or mangle them, producing incorrect tool names at runtime.
+  name = "WebFetch";
+  description = WEB_FETCH_DESCRIPTION;
+  category = "read";
+  schema() {
+    const inputSchema = {
+      type: "object",
+      properties: {
+        url: {
+          type: "string",
+          description: "The http or https URL to fetch content from."
+        }
+      },
+      required: ["url"]
+    };
+    return {
+      name: this.name,
+      description: this.description,
+      input_schema: inputSchema
+    };
+  }
+  async execute(ctx, args) {
+    const url = strArg(args, "url");
+    if (!url) {
+      return { output: "Error: url is required", isError: true };
+    }
+    let parsed;
+    try {
+      parsed = new URL(url);
+    } catch {
+      return { output: `Error: invalid URL "${url}"`, isError: true };
+    }
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+      return {
+        output: `Error: unsupported protocol "${parsed.protocol}" \u2014 only http and https URLs can be fetched`,
+        isError: true
+      };
+    }
+    const cached = cacheGet(url);
+    if (cached) {
+      return { output: formatResult(cached.markdown, url, cached.finalUrl), isError: false };
+    }
+    const timeoutSignal = AbortSignal.timeout(FETCH_TIMEOUT_MS);
+    const signal = ctx.abortSignal ? AbortSignal.any([ctx.abortSignal, timeoutSignal]) : timeoutSignal;
+    let response;
+    try {
+      response = await fetch(url, {
+        signal,
+        redirect: "follow",
+        headers: {
+          Accept: "text/markdown, text/html, */*"
+          // "User-Agent": `swifty/${version}`,
+        }
+      });
+    } catch (err) {
+      log10.error({ err, url }, "web fetch failed");
+      return { output: `Error: fetch failed: ${asErrorString(err)}`, isError: true };
+    }
+    if (!response.ok) {
+      return {
+        output: `Error: HTTP ${String(response.status)} ${response.statusText} for ${url}`,
+        isError: true
+      };
+    }
+    const declaredBytes = Number.parseInt(response.headers.get("content-length") ?? "", 10);
+    if (!Number.isNaN(declaredBytes) && declaredBytes > MAX_CONTENT_BYTES) {
+      return {
+        output: `Error: response is ${String(declaredBytes)} bytes, over the ${String(MAX_CONTENT_BYTES)}-byte limit`,
+        isError: true
+      };
+    }
+    const contentType = response.headers.get("content-type") ?? "";
+    if (isBinaryContentType(contentType)) {
+      return {
+        output: `Error: binary content (${contentType}) is not supported; only text content can be fetched`,
+        isError: true
+      };
+    }
+    let body;
+    try {
+      body = await response.arrayBuffer();
+    } catch (err) {
+      log10.error({ err, url }, "reading response body failed");
+      return {
+        output: `Error: reading response body failed: ${asErrorString(err)}`,
+        isError: true
+      };
+    }
+    if (body.byteLength > MAX_CONTENT_BYTES) {
+      return {
+        output: `Error: response is ${String(body.byteLength)} bytes, over the ${String(MAX_CONTENT_BYTES)}-byte limit`,
+        isError: true
+      };
+    }
+    const raw = Buffer.from(body).toString("utf-8");
+    let markdown;
+    try {
+      markdown = contentType.includes("text/html") ? (await getTurndownService()).turndown(raw) : raw;
+    } catch (err) {
+      log10.error({ err, url }, "HTML to Markdown conversion failed");
+      return {
+        output: `Error: HTML to Markdown conversion failed: ${asErrorString(err)}`,
+        isError: true
+      };
+    }
+    const finalUrl = response.url || url;
+    cacheSet(url, markdown, finalUrl);
+    return { output: formatResult(markdown, url, finalUrl), isError: false };
+  }
+};
+
 // src/tools/write-file.ts
 import { existsSync as existsSync3, mkdirSync, writeFileSync } from "fs";
 import { dirname as dirname3, resolve as resolve6 } from "path";
-var log10 = createChildLogger({ module: "tools" });
+var log11 = createChildLogger({ module: "tools" });
 var WriteFileTool = class {
   // Use a hardcoded string instead of WriteFileTool.name.replace("Tool", "")
   // because class names are not stable after minification — bundlers like
@@ -4281,7 +4542,7 @@ var WriteFileTool = class {
           isError: false
         });
       } catch (err) {
-        log10.error({ err }, "tool operation failed");
+        log11.error({ err }, "tool operation failed");
         return Promise.resolve({
           output: `Error writing file: ${asErrorString(err)}`,
           isError: true
@@ -4321,6 +4582,7 @@ function createToolRegistry(workDir, taskList) {
   registry.register(new WriteFileTool());
   registry.register(new GlobTool());
   registry.register(new GrepTool());
+  registry.register(new WebFetchTool());
   return registry;
 }
 function wireSkillsToRegistry(catalog, commandRegistry, skillHost) {
@@ -4352,7 +4614,7 @@ function buildComposedToolFilter(coordinator, skillFilter) {
 }
 
 // src/code-review/session.ts
-var log11 = createChildLogger({ module: "code-review" });
+var log12 = createChildLogger({ module: "code-review" });
 function isCriticEvaluation(str) {
   return str === "reasonable" || str === "unreasonable" || str === "partially-reasonable";
 }
@@ -4360,7 +4622,7 @@ function asCriticEvaluation(str) {
   if (isCriticEvaluation(str)) {
     return str;
   } else {
-    log11.error({ str }, "code-review operation failed");
+    log12.error({ str }, "code-review operation failed");
     throw new Error(str);
   }
 }
@@ -4771,7 +5033,7 @@ Created: ${new Date(request.createdAt).toLocaleString()}`;
 };
 
 // src/code-review/handler.ts
-var log12 = createChildLogger({ module: "code-review" });
+var log13 = createChildLogger({ module: "code-review" });
 function handleCodeReviewCommand(ctx, manager, session) {
   const args = ctx.args.trim().split(/\s+/);
   const command = args[0]?.toLowerCase();
@@ -4818,7 +5080,7 @@ function handleCodeReviewCommand(ctx, manager, session) {
         return showCodeReviewHelp();
     }
   } catch (err) {
-    log12.error({ err }, "code-review operation failed");
+    log13.error({ err }, "code-review operation failed");
     return `Error: ${err instanceof Error ? err.message : String(err)}`;
   }
 }
@@ -5070,7 +5332,7 @@ import z4 from "zod";
 
 // src/teams/backend.ts
 import { execSync, spawn as spawn4 } from "child_process";
-var log13 = createChildLogger({ module: "teams" });
+var log14 = createChildLogger({ module: "teams" });
 function detectBackend() {
   if (process.platform === "win32") {
     return "in-process";
@@ -5117,7 +5379,7 @@ function spawnTeammate(config) {
           stdio: ["pipe", "pipe", "pipe"]
         });
       } catch (err) {
-        log13.error({ err }, "teams operation failed");
+        log14.error({ err }, "teams operation failed");
         execSync(`tmux new-session -d -s "${sessionName}" -n teammate "${cmd}"`, {
           cwd: config.cwd,
           encoding: "utf-8",
@@ -5131,7 +5393,7 @@ function spawnTeammate(config) {
               stdio: ["pipe", "pipe", "pipe"]
             });
           } catch (err) {
-            log13.error({ err }, "teams operation failed");
+            log14.error({ err }, "teams operation failed");
           }
         },
         paneId: sessionName
@@ -5166,7 +5428,7 @@ function spawnTeammate(config) {
 }
 
 // src/code-review/manager.ts
-var log14 = createChildLogger({ module: "code-review" });
+var log15 = createChildLogger({ module: "code-review" });
 var CodeReviewMemberSchema = z4.object({
   name: z4.string(),
   email: z4.string(),
@@ -5201,7 +5463,7 @@ var CodeReviewManager = class {
           this.teams.set(team.name, team);
         }
       } catch (err) {
-        log14.error({ err }, "code-review operation failed");
+        log15.error({ err }, "code-review operation failed");
       }
     }
   }
@@ -5752,7 +6014,7 @@ ${args}`;
 import { readFileSync as readFileSync6, writeFileSync as writeFileSync3, mkdirSync as mkdirSync3, existsSync as existsSync6 } from "fs";
 import { join as join9, dirname as dirname4 } from "path";
 import { safeParse as safeParse2, z as z6 } from "zod";
-var log15 = createChildLogger({ module: "commands" });
+var log16 = createChildLogger({ module: "commands" });
 var UsageEntrySchema = z6.object({
   usageCount: z6.coerce.number(),
   lastUsedAt: z6.coerce.number()
@@ -5808,7 +6070,7 @@ var CommandUsageTracker = class {
       mkdirSync3(dirname4(this.filePath), { recursive: true });
       writeFileSync3(this.filePath, JSON.stringify(Object.fromEntries(this.usage), null, 2));
     } catch (err) {
-      log15.error({ err }, "commands operation failed");
+      log16.error({ err }, "commands operation failed");
     }
   }
 };
@@ -5848,20 +6110,20 @@ var ProviderLoginSchema = ProviderConfigSchema.extend({
   ...provider,
   thinking: getThinkingLevel(provider)
 }));
-function readConfigRaw(path2) {
-  if (!existsSync7(path2)) {
+function readConfigRaw(path) {
+  if (!existsSync7(path)) {
     return {};
   }
   let raw;
   try {
-    raw = yaml3.load(readFileSync7(path2, "utf-8"));
+    raw = yaml3.load(readFileSync7(path, "utf-8"));
   } catch {
-    throw new Error(`Unable to read existing ${path2}; it has not been changed.`);
+    throw new Error(`Unable to read existing ${path}; it has not been changed.`);
   }
   return z7.record(z7.string(), z7.unknown()).parse(raw ?? {});
 }
-function writeConfigAtomic(path2, raw) {
-  const directory = dirname5(path2);
+function writeConfigAtomic(path, raw) {
+  const directory = dirname5(path);
   mkdirSync4(directory, { recursive: true });
   const temporary = join10(directory, `.config-${randomUUID()}.tmp`);
   try {
@@ -5870,7 +6132,7 @@ function writeConfigAtomic(path2, raw) {
       mode: 384,
       flag: "wx"
     });
-    renameSync(temporary, path2);
+    renameSync(temporary, path);
   } finally {
     if (existsSync7(temporary)) {
       unlinkSync(temporary);
@@ -5879,8 +6141,8 @@ function writeConfigAtomic(path2, raw) {
 }
 function saveProvider(input, available) {
   const provider = ProviderLoginSchema.parse(input);
-  const path2 = globalConfigPath();
-  const config = readConfigRaw(path2);
+  const path = globalConfigPath();
+  const config = readConfigRaw(path);
   const existing = z7.array(z7.record(z7.string(), z7.unknown())).parse(config.providers ?? []);
   const current = [...existing];
   for (const entry of available) {
@@ -5905,16 +6167,16 @@ function saveProvider(input, available) {
     stored.push(provider);
   }
   const providers = stored.map((entry) => ProviderConfigSchema.parse(entry));
-  writeConfigAtomic(path2, { ...config, providers: stored });
-  return { provider, providers, replaced, path: path2 };
+  writeConfigAtomic(path, { ...config, providers: stored });
+  return { provider, providers, replaced, path };
 }
 function persistThinkingLevel(baseUrl, level) {
-  const path2 = globalConfigPath();
-  const config = readConfigRaw(path2);
+  const path = globalConfigPath();
+  const config = readConfigRaw(path);
   const providers = z7.array(z7.record(z7.string(), z7.unknown())).parse(config.providers ?? []);
   const targets = providers.filter((entry) => entry.base_url === baseUrl);
   if (targets.length === 0) {
-    throw new Error(`Provider with base URL "${baseUrl}" not found in ${path2}.`);
+    throw new Error(`Provider with base URL "${baseUrl}" not found in ${path}.`);
   }
   const changed = targets.filter((entry) => entry.thinking !== level);
   if (changed.length === 0) {
@@ -5923,13 +6185,13 @@ function persistThinkingLevel(baseUrl, level) {
   for (const entry of changed) {
     entry.thinking = level;
   }
-  writeConfigAtomic(path2, { ...config, providers });
+  writeConfigAtomic(path, { ...config, providers });
 }
 
 // src/conversation/at-expand.ts
 import { readFileSync as readFileSync8, statSync as statSync6 } from "fs";
 import { isAbsolute as isAbsolute2, join as join11 } from "path";
-var log16 = createChildLogger({ module: "tui" });
+var log17 = createChildLogger({ module: "tui" });
 var MAX_INLINE_BYTES = 1e5;
 var MAX_RANGE_FILE_BYTES = 1e7;
 function parseRef(ref) {
@@ -5994,7 +6256,7 @@ ${readFileSync8(p, "utf-8")}
 </file>`;
       }
     } catch (err) {
-      log16.error({ err }, "TUI operation failed");
+      log17.error({ err }, "TUI operation failed");
     }
   }
   return appendix ? text + appendix : text;
@@ -6040,7 +6302,7 @@ Error: too many images attached (limit ${String(MAX_IMAGES_PER_MESSAGE)} per mes
 
 <image type="base64" media_type="${attachment.mediaType}" path="${refPath}" />`;
         } catch (err) {
-          log16.error({ err }, "TUI operation failed");
+          log17.error({ err }, "TUI operation failed");
         }
       } else if (lineStart !== void 0 && lineEnd !== void 0) {
         if (st.size <= MAX_RANGE_FILE_BYTES) {
@@ -6061,7 +6323,7 @@ ${readFileSync8(p, "utf-8")}
 </file>`;
       }
     } catch (err) {
-      log16.error({ err }, "TUI operation failed");
+      log17.error({ err }, "TUI operation failed");
     }
   }
   const expanded = appendix ? text + appendix : text;
@@ -6075,7 +6337,7 @@ ${readFileSync8(p, "utf-8")}
 import { createHash } from "crypto";
 import { existsSync as existsSync8, mkdirSync as mkdirSync5, readFileSync as readFileSync9, unlinkSync as unlinkSync2, writeFileSync as writeFileSync5 } from "fs";
 import { join as join12, resolve as resolve7 } from "path";
-var log17 = createChildLogger({ module: "file-history" });
+var log18 = createChildLogger({ module: "file-history" });
 var MAX_SNAPSHOTS = 100;
 var MAX_SUMMARY_TEXT_LENGTH = 60;
 function getBackupName(filePath, version2) {
@@ -6094,8 +6356,8 @@ var FileHistory = class {
     this.sessionDir = fileHistoryDir(baseDir, sessionID);
     mkdirSync5(this.sessionDir, { recursive: true });
   }
-  trackEdit(path2) {
-    const absPath = resolve7(path2);
+  trackEdit(path) {
+    const absPath = resolve7(path);
     const version2 = this.trackedFiles.get(absPath) ?? 0;
     const newVersion = version2 + 1;
     if (existsSync8(absPath)) {
@@ -6104,7 +6366,7 @@ var FileHistory = class {
         const backupName = getBackupName(absPath, newVersion);
         writeFileSync5(join12(this.sessionDir, backupName), content);
       } catch (err) {
-        log17.error({ err }, "file-history operation failed");
+        log18.error({ err }, "file-history operation failed");
       }
     }
     this.trackedFiles.set(absPath, newVersion);
@@ -6122,7 +6384,7 @@ var FileHistory = class {
         try {
           writeFileSync5(backupPath, readFileSync9(filePath));
         } catch (err) {
-          log17.error({ err }, "file-history operation failed");
+          log18.error({ err }, "file-history operation failed");
         }
       }
       backups[filePath] = {
@@ -6152,12 +6414,12 @@ var FileHistory = class {
       try {
         backupData = readFileSync9(backup.backupPath);
       } catch (err) {
-        log17.error({ err }, "file-history operation failed");
+        log18.error({ err }, "file-history operation failed");
         if (existsSync8(filePath)) {
           try {
             unlinkSync2(filePath);
           } catch (err2) {
-            log17.error({ err: err2 }, "file-history operation failed");
+            log18.error({ err: err2 }, "file-history operation failed");
           }
         }
         continue;
@@ -6166,7 +6428,7 @@ var FileHistory = class {
       try {
         currentData = readFileSync9(filePath);
       } catch (err) {
-        log17.error({ err }, "file-history operation failed");
+        log18.error({ err }, "file-history operation failed");
       }
       const backupStr = backupData.toString();
       const currentStr = currentData?.toString();
@@ -6175,7 +6437,7 @@ var FileHistory = class {
           writeFileSync5(filePath, backupData);
           changed.push(filePath);
         } catch (err) {
-          log17.error({ err }, "file-history operation failed");
+          log18.error({ err }, "file-history operation failed");
         }
       }
     }
@@ -6212,7 +6474,7 @@ var FileHistory = class {
 import { readFileSync as readFileSync10, writeFileSync as writeFileSync6, mkdirSync as mkdirSync6, existsSync as existsSync9 } from "fs";
 import { join as join13 } from "path";
 import { parse as parse3, z as z8 } from "zod";
-var log18 = createChildLogger({ module: "history" });
+var log19 = createChildLogger({ module: "history" });
 var MAX_HISTORY_ENTRIES = 200;
 var FILENAME = "prompt_history.jsonl";
 var JSONLSchema = z8.looseObject({ text: z8.string() });
@@ -6229,12 +6491,12 @@ function load(dir) {
         const { text } = parse3(JSONLSchema, entry);
         return text;
       } catch (err) {
-        log18.error({ err }, "parse history line failed");
+        log19.error({ err }, "parse history line failed");
         return "";
       }
     }).filter(Boolean).slice(-MAX_HISTORY_ENTRIES);
   } catch (err2) {
-    log18.error({ err: err2 }, "load history failed");
+    log19.error({ err: err2 }, "load history failed");
     return [];
   }
 }
@@ -6253,7 +6515,7 @@ function append(dir, text) {
 
 // src/hooks/hooks.ts
 import { exec } from "child_process";
-var log19 = createChildLogger({ module: "hooks" });
+var log20 = createChildLogger({ module: "hooks" });
 function execHookAsync(command, opts) {
   return new Promise((resolve12, reject) => {
     exec(
@@ -6332,7 +6594,7 @@ var HookEngine = class {
           break;
         }
       } catch (err) {
-        log19.error({ err }, "hooks operation failed");
+        log20.error({ err }, "hooks operation failed");
         const onError = hook.on_error ?? "ignore";
         if (onError === "fail") {
           const msg = `Hook error: ${asErrorString(err)}`;
@@ -6386,7 +6648,7 @@ var HookEngine = class {
             reject: hook.reject ?? false
           };
         } catch (err) {
-          log19.error({ err }, "hooks operation failed");
+          log20.error({ err }, "hooks operation failed");
           throw err;
         }
       }
@@ -6418,7 +6680,7 @@ var HookEngine = class {
             reject: hook.reject ?? false
           };
         } catch (err) {
-          log19.error({ err }, "hooks operation failed");
+          log20.error({ err }, "hooks operation failed");
           throw err;
         }
       }
@@ -6431,7 +6693,7 @@ var HookEngine = class {
           const output = await this.agentRunner(prompt, context);
           return { output, success: true, reject: hook.reject ?? false };
         } catch (err) {
-          log19.error({ err }, "hooks operation failed");
+          log20.error({ err }, "hooks operation failed");
           throw err;
         }
       }
@@ -6482,7 +6744,7 @@ function evaluateSingleCondition(expr, ctx) {
     try {
       return new RegExp(regexMatch[2]).test(value);
     } catch (err) {
-      log19.error({ err }, "hooks operation failed");
+      log20.error({ err }, "hooks operation failed");
       return false;
     }
   }
@@ -6506,7 +6768,7 @@ function evaluateSingleCondition(expr, ctx) {
     try {
       return new RegExp(`^${pattern}$`).test(value);
     } catch (err) {
-      log19.error({ err }, "hooks operation failed");
+      log20.error({ err }, "hooks operation failed");
       return false;
     }
   }
@@ -6615,9 +6877,9 @@ async function storeClipboardImage(workDir, sessionId, bytes) {
   }
   const dir = fileHistoryDir(workDir, sessionId);
   await mkdir2(dir, { recursive: true });
-  const path2 = join14(dir, clipboardImageFileName(bytes));
-  await writeFile3(path2, bytes);
-  return path2;
+  const path = join14(dir, clipboardImageFileName(bytes));
+  await writeFile3(path, bytes);
+  return path;
 }
 function run(command, args, extraEnv) {
   return new Promise((resolvePromise, rejectPromise) => {
@@ -6815,15 +7077,24 @@ async function createClient(config, systemPrompt) {
   switch (config.protocol) {
     case "anthropic": {
       const { AnthropicClient: AnthropicClient2 } = await import("./anthropic-B33M2AVN.js");
-      return new AnthropicClient2(config, systemPrompt);
+      return registerLlmClient(new AnthropicClient2(config, systemPrompt), {
+        model: config.model,
+        protocol: config.protocol
+      });
     }
     case "openai": {
       const { OpenAIClient: OpenAIClient2 } = await import("./openai-C2PZFGJ2.js");
-      return new OpenAIClient2(config, systemPrompt);
+      return registerLlmClient(new OpenAIClient2(config, systemPrompt), {
+        model: config.model,
+        protocol: config.protocol
+      });
     }
     case "openai-compat": {
       const { OpenAICompatClient: OpenAICompatClient2 } = await import("./openai-C2PZFGJ2.js");
-      return new OpenAICompatClient2(config, systemPrompt);
+      return registerLlmClient(new OpenAICompatClient2(config, systemPrompt), {
+        model: config.model,
+        protocol: config.protocol
+      });
     }
     default:
       throw new Error(`Unknown protocol: ${String(config.protocol)}`);
@@ -6854,12 +7125,12 @@ function modelListUrl(protocol, baseUrl) {
   if (!["http:", "https:"].includes(url.protocol) || url.username || url.password) {
     return void 0;
   }
-  let path2 = url.pathname.replace(/\/+$/, "");
-  path2 = path2.replace(/\/(?:chat\/completions|completions|responses|messages|models)$/, "");
-  if (!path2 || protocol === "anthropic" && !path2.endsWith("/v1")) {
-    path2 += "/v1";
+  let path = url.pathname.replace(/\/+$/, "");
+  path = path.replace(/\/(?:chat\/completions|completions|responses|messages|models)$/, "");
+  if (!path || protocol === "anthropic" && !path.endsWith("/v1")) {
+    path += "/v1";
   }
-  url.pathname = `${path2}/models`;
+  url.pathname = `${path}/models`;
   url.search = "";
   url.hash = "";
   return url.toString();
@@ -6962,37 +7233,7 @@ import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js"
 import {
   StreamableHTTPClientTransport
 } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
-
-// src/version.ts
-import { readFileSync as readFileSync11 } from "fs";
-import path from "path";
-import { fileURLToPath } from "url";
-import { z as z10 } from "zod";
-var PackageJsonSchema = z10.object({
-  version: z10.string()
-});
-function resolveVersion() {
-  if (true) {
-    return "0.0.32";
-  }
-  const here = path.dirname(fileURLToPath(import.meta.url));
-  for (const levels of ["..", "../.."]) {
-    const candidate = path.resolve(here, levels, "package.json");
-    try {
-      const raw = JSON.parse(readFileSync11(candidate, "utf-8"));
-      const parsed = PackageJsonSchema.safeParse(raw);
-      if (parsed.success) {
-        return parsed.data.version;
-      }
-    } catch {
-    }
-  }
-  throw new Error("Could not resolve package version");
-}
-var version = resolveVersion();
-
-// src/mcp/client.ts
-var log20 = createChildLogger({ module: "mcp" });
+var log21 = createChildLogger({ module: "mcp" });
 function expandEnv(value, environment) {
   return value.replace(
     /\$\{([A-Za-z_]\w*)(?::-([^}]*))?\}|\$([A-Za-z_]\w*)/g,
@@ -7058,7 +7299,7 @@ async function mcpContentToToolOutput(content) {
         hasImage = true;
         continue;
       } catch (err) {
-        log20.warn({ err }, "mcp image dropped (too large to fit the API limit)");
+        log21.warn({ err }, "mcp image dropped (too large to fit the API limit)");
         const note = "[note: an image returned by the tool was too large and was dropped]";
         textParts.push(note);
         contentBlocks.push({ type: "text", text: note });
@@ -7163,7 +7404,7 @@ var MCPClient = class {
     try {
       await this.client?.close();
     } catch (err) {
-      log20.error({ err }, "mcp operation failed");
+      log21.error({ err }, "mcp operation failed");
     }
     this.client = null;
     this.transport = null;
@@ -7215,7 +7456,7 @@ ${removed.join("\n")}`
 
 // src/mcp/manager.ts
 import { isDeepStrictEqual } from "util";
-var log21 = createChildLogger({ module: "mcp" });
+var log22 = createChildLogger({ module: "mcp" });
 var MCPManager = class {
   clients = /* @__PURE__ */ new Map();
   configs = /* @__PURE__ */ new Map();
@@ -7270,7 +7511,7 @@ var MCPManager = class {
           });
         }
       } catch (err) {
-        log21.error({ err }, "mcp operation failed");
+        log22.error({ err }, "mcp operation failed");
         result.errors.push({
           serverName: cfg.name,
           error: asErrorString(err)
@@ -7356,7 +7597,7 @@ var MCPManager = class {
 import {
   existsSync as existsSync10,
   statSync as statSync8,
-  readFileSync as readFileSync12,
+  readFileSync as readFileSync11,
   writeFileSync as writeFileSync7,
   mkdirSync as mkdirSync7,
   unlinkSync as unlinkSync3,
@@ -7389,15 +7630,15 @@ var MemoryPermissionChecker = class extends PermissionChecker {
         reason: "Background memory tasks only support scoped file operations"
       };
     }
-    const path2 = canonicalPath(resolve8(this.memoryWorkDir, requested));
-    const insideMemory = this.memoryRoots.some((root) => isPathWithin(canonicalPath(root), path2));
+    const path = canonicalPath(resolve8(this.memoryWorkDir, requested));
+    const insideMemory = this.memoryRoots.some((root) => isPathWithin(canonicalPath(root), path));
     if (category === "write") {
-      return insideMemory && extname2(path2) === ".md" ? { effect: "allow", reason: "Memory file update" } : {
+      return insideMemory && extname2(path) === ".md" ? { effect: "allow", reason: "Memory file update" } : {
         effect: "deny",
         reason: "Background memory writes must stay in the memory directories and use .md files"
       };
     }
-    return insideMemory || this.allowProjectReads && isPathWithin(canonicalPath(this.memoryWorkDir), path2) ? { effect: "allow", reason: "Memory task read" } : { effect: "deny", reason: "Read outside the memory task's scope" };
+    return insideMemory || this.allowProjectReads && isPathWithin(canonicalPath(this.memoryWorkDir), path) ? { effect: "allow", reason: "Memory task read" } : { effect: "deny", reason: "Read outside the memory task's scope" };
   }
 };
 
@@ -7421,7 +7662,7 @@ function extractWrittenPaths(messages) {
 
 // src/tools/file-state-cache.ts
 import { statSync as statSync7 } from "fs";
-var log22 = createChildLogger({ module: "file-state-cache" });
+var log23 = createChildLogger({ module: "file-state-cache" });
 var FileStateCache = class {
   cache = /* @__PURE__ */ new Map();
   // path -> mtimeMs
@@ -7447,7 +7688,7 @@ var FileStateCache = class {
     try {
       currentModifiedTime = statSync7(filePath).mtimeMs;
     } catch (err) {
-      log22.error({ err }, "file state cache operation failed");
+      log23.error({ err }, "file state cache operation failed");
       return {
         ok: false,
         error: "Error: file was deleted or is no longer accessible; read it again before editing."
@@ -7470,7 +7711,7 @@ var FileStateCache = class {
     try {
       lastModifiedTimeMs = statSync7(filePath).mtimeMs;
     } catch (err) {
-      log22.error({ err }, "file state cache operation failed");
+      log23.error({ err }, "file state cache operation failed");
       this.cache.delete(filePath);
       return;
     }
@@ -7479,7 +7720,7 @@ var FileStateCache = class {
 };
 
 // src/memory/consolidation.ts
-var log23 = createChildLogger({ module: "memory" });
+var log24 = createChildLogger({ module: "memory" });
 var DEFAULT_MIN_HOURS = 24;
 var DEFAULT_MIN_SESSIONS = 5;
 var SCAN_THROTTLE_MS = 10 * 60 * 1e3;
@@ -7571,30 +7812,30 @@ function lockPath(memDir) {
   return join16(memDir, LOCK_FILE);
 }
 function readLastConsolidatedAt(memDir) {
-  const path2 = lockPath(memDir);
-  if (!existsSync10(path2)) {
+  const path = lockPath(memDir);
+  if (!existsSync10(path)) {
     return 0;
   }
   try {
-    return statSync8(path2).mtimeMs;
+    return statSync8(path).mtimeMs;
   } catch {
     return 0;
   }
 }
 function tryAcquireLock(memDir) {
-  const path2 = lockPath(memDir);
+  const path = lockPath(memDir);
   let mtimeMs;
   let holderPid;
-  if (existsSync10(path2)) {
+  if (existsSync10(path)) {
     try {
-      mtimeMs = statSync8(path2).mtimeMs;
-      const raw = readFileSync12(path2, "utf-8").trim();
+      mtimeMs = statSync8(path).mtimeMs;
+      const raw = readFileSync11(path, "utf-8").trim();
       const parsed = parseInt(raw, 10);
       if (Number.isFinite(parsed)) {
         holderPid = parsed;
       }
     } catch (err) {
-      log23.error({ err }, "failed to read consolidation lock file");
+      log24.error({ err }, "failed to read consolidation lock file");
     }
   }
   if (mtimeMs !== void 0 && Date.now() - mtimeMs < HOLDER_STALE_MS) {
@@ -7603,9 +7844,9 @@ function tryAcquireLock(memDir) {
     }
   }
   mkdirSync7(memDir, { recursive: true });
-  writeFileSync7(path2, String(process.pid));
+  writeFileSync7(path, String(process.pid));
   try {
-    const verify = readFileSync12(path2, "utf-8").trim();
+    const verify = readFileSync11(path, "utf-8").trim();
     if (parseInt(verify, 10) !== process.pid) {
       return null;
     }
@@ -7615,17 +7856,17 @@ function tryAcquireLock(memDir) {
   return mtimeMs ?? 0;
 }
 function rollbackLock(memDir, priorMtime) {
-  const path2 = lockPath(memDir);
+  const path = lockPath(memDir);
   try {
     if (priorMtime === 0) {
-      unlinkSync3(path2);
+      unlinkSync3(path);
       return;
     }
-    writeFileSync7(path2, "");
+    writeFileSync7(path, "");
     const t = priorMtime / 1e3;
-    utimesSync(path2, t, t);
+    utimesSync(path, t, t);
   } catch (err) {
-    log23.error({ err }, "failed to rollback consolidation lock");
+    log24.error({ err }, "failed to rollback consolidation lock");
   }
 }
 function isProcessRunning(pid) {
@@ -7679,14 +7920,14 @@ function buildConsolidationPrompt(memDir, userMemDir, transcriptDir2, sessionIDs
 }
 
 // src/memory/extractor.ts
-import { readdirSync as readdirSync4, readFileSync as readFileSync14, existsSync as existsSync12, mkdirSync as mkdirSync9, writeFileSync as writeFileSync9 } from "fs";
+import { readdirSync as readdirSync4, readFileSync as readFileSync13, existsSync as existsSync12, mkdirSync as mkdirSync9, writeFileSync as writeFileSync9 } from "fs";
 import { homedir as homedir6 } from "os";
 import { join as join18, basename as basename5 } from "path";
 import yaml5 from "js-yaml";
 
 // src/memory/manager.ts
 import {
-  readFileSync as readFileSync13,
+  readFileSync as readFileSync12,
   readdirSync as readdirSync3,
   unlinkSync as unlinkSync4,
   existsSync as existsSync11,
@@ -7697,7 +7938,7 @@ import {
 import { homedir as homedir5 } from "os";
 import { join as join17, relative as relative2, basename as basename4 } from "path";
 import yaml4 from "js-yaml";
-import z11, { parse as parse4 } from "zod";
+import z10, { parse as parse4 } from "zod";
 
 // src/memory/memory-age.ts
 function memoryAgeDays(mtimeMs) {
@@ -7722,7 +7963,7 @@ function memoryFreshnessText(mtimeMs) {
 }
 
 // src/memory/manager.ts
-var log24 = createChildLogger({ module: "memory" });
+var log25 = createChildLogger({ module: "memory" });
 var MAX_ENTRYPOINT_LINES2 = 200;
 var MAX_ENTRYPOINT_BYTES = 25e3;
 var MEMORY_INDEX_NAME = "MEMORY.md";
@@ -7750,8 +7991,8 @@ function formatFileSize(bytes) {
   }
   return `${(bytes / 1024 / 1024).toFixed(1)}MB`;
 }
-var SelectedMemoriesSchema = z11.object({
-  selected_memories: z11.array(z11.string())
+var SelectedMemoriesSchema = z10.object({
+  selected_memories: z10.array(z10.string())
 });
 var SELECT_MEMORIES_SYSTEM_PROMPT = `# Task
 Select up to 5 listed memories clearly useful for the query, based on their paths and descriptions. Omit uncertain matches; return an empty list when none qualify.
@@ -7774,7 +8015,7 @@ var MemoryManager = class {
     try {
       const stat3 = statSync9(fullPath);
       fingerprint = `${String(stat3.mtimeMs)}:${String(stat3.size)}`;
-      const parsed = parseFrontmatter(readFileSync13(fullPath, "utf-8"));
+      const parsed = parseFrontmatter(readFileSync12(fullPath, "utf-8"));
       this.malformedFingerprints.delete(fullPath);
       return {
         memory: {
@@ -7789,7 +8030,7 @@ var MemoryManager = class {
     } catch (err) {
       if (this.malformedFingerprints.get(fullPath) !== fingerprint) {
         this.malformedFingerprints.set(fullPath, fingerprint);
-        log24.error({ err, path: fullPath }, "memory operation failed");
+        log25.error({ err, path: fullPath }, "memory operation failed");
       }
       return null;
     }
@@ -7806,7 +8047,7 @@ var MemoryManager = class {
           (file) => file.endsWith(".md") && file !== MEMORY_INDEX_NAME
         );
       } catch (err) {
-        log24.error({ err, path: dir }, "memory operation failed");
+        log25.error({ err, path: dir }, "memory operation failed");
         continue;
       }
       for (const file of files) {
@@ -7876,7 +8117,7 @@ ${body}
         try {
           unlinkSync4(join17(dir, file));
         } catch (err) {
-          log24.error({ err }, "memory operation failed");
+          log25.error({ err }, "memory operation failed");
           continue;
         }
       }
@@ -7906,7 +8147,7 @@ ${body}
     mkdirSync8(this.projectDir, { recursive: true });
     if (existsSync11(indexPath)) {
       try {
-        if (readFileSync13(indexPath, "utf-8") === content) {
+        if (readFileSync12(indexPath, "utf-8") === content) {
           return;
         }
       } catch {
@@ -7954,7 +8195,7 @@ ${manifest}${toolsSection}`;
         }
       }
     } catch (err) {
-      log24.error({ err }, "memory operation failed");
+      log25.error({ err }, "memory operation failed");
       return [];
     }
     const jsonStr = extractJSONObject(rawResponse);
@@ -7966,7 +8207,7 @@ ${manifest}${toolsSection}`;
       const raw = JSON.parse(jsonStr);
       parsed = parse4(SelectedMemoriesSchema, raw);
     } catch (err) {
-      log24.error({ err }, "memory operation failed");
+      log25.error({ err }, "memory operation failed");
       return [];
     }
     const byKey = /* @__PURE__ */ new Map();
@@ -7994,7 +8235,7 @@ ${manifest}${toolsSection}`;
     try {
       files = readdirSync3(dir).filter((file) => file.endsWith(".md") && file !== MEMORY_INDEX_NAME);
     } catch (err) {
-      log24.error({ err, path: dir }, "memory operation failed");
+      log25.error({ err, path: dir }, "memory operation failed");
       return [];
     }
     const headers = [];
@@ -8023,7 +8264,7 @@ ${manifest}${toolsSection}`;
     for (const mem of memories) {
       let content;
       try {
-        content = readFileSync13(mem.path, "utf-8");
+        content = readFileSync12(mem.path, "utf-8");
       } catch {
         continue;
       }
@@ -8048,11 +8289,11 @@ function formatMemoryManifest(memories) {
     const scope = m.scope ? `[${m.scope}-scope] ` : "";
     const tag = m.type ? `[${m.type}] ` : "";
     const ts = new Date(m.mtimeMs).toISOString();
-    const path2 = m.filePath || m.filename;
+    const path = m.filePath || m.filename;
     if (m.description) {
-      lines.push(`- ${scope}${tag}${path2} (${ts}): ${m.description}`);
+      lines.push(`- ${scope}${tag}${path} (${ts}): ${m.description}`);
     } else {
-      lines.push(`- ${scope}${tag}${path2} (${ts})`);
+      lines.push(`- ${scope}${tag}${path} (${ts})`);
     }
   }
   return lines.join("\n");
@@ -8072,12 +8313,12 @@ function extractJSONObject(raw) {
   }
   return trimmed.slice(start, end + 1);
 }
-var FrontmatterSchema = z11.looseObject({
-  name: z11.string().optional(),
-  description: z11.string().optional(),
-  type: z11.string().optional(),
-  metadata: z11.looseObject({
-    type: z11.string().optional()
+var FrontmatterSchema = z10.looseObject({
+  name: z10.string().optional(),
+  description: z10.string().optional(),
+  type: z10.string().optional(),
+  metadata: z10.looseObject({
+    type: z10.string().optional()
   }).optional()
 });
 function parseFrontmatter(content) {
@@ -8156,7 +8397,7 @@ var MemoryExtractor = class {
         const files = readdirSync4(dir).filter((f) => f.endsWith(".md") && f !== "MEMORY.md");
         for (const file of files) {
           try {
-            const content = readFileSync14(join18(dir, file), "utf-8");
+            const content = readFileSync13(join18(dir, file), "utf-8");
             const typeMatch = /type:\s*(.+)/.exec(content);
             const descMatch = /description:\s*(.+)/.exec(content);
             const type = typeMatch?.[1]?.trim() ?? "reference";
@@ -8351,10 +8592,10 @@ ${mem.body}
 };
 
 // src/memory/instructions.ts
-import { readFileSync as readFileSync15, existsSync as existsSync13 } from "fs";
+import { readFileSync as readFileSync14, existsSync as existsSync13 } from "fs";
 import { homedir as homedir7 } from "os";
 import { join as join19, dirname as dirname6, resolve as resolve9, isAbsolute as isAbsolute3, relative as relative3 } from "path";
-var log25 = createChildLogger({ module: "memory" });
+var log26 = createChildLogger({ module: "memory" });
 var MAX_INCLUDE_DEPTH = 5;
 function loadInstructions(workDir) {
   const sources = discoverInstructions(workDir);
@@ -8370,7 +8611,7 @@ function loadInstructions(workDir) {
         label = rel;
       }
     } catch (err) {
-      log25.error({ err }, "memory operation failed");
+      log26.error({ err }, "memory operation failed");
     }
     parts.push(`Contents of ${label}:
 
@@ -8385,7 +8626,7 @@ function discoverInstructions(workDir) {
     const home = homedir7();
     addSource(sources, seen, join19(home, ".swifty", "AGENTS.md"));
   } catch (err) {
-    log25.error({ err }, "memory operation failed");
+    log26.error({ err }, "memory operation failed");
   }
   const dirs = projectInstructionDirs(workDir);
   for (const dir of dirs) {
@@ -8399,7 +8640,7 @@ function addSource(out, seen, filePath) {
   try {
     abs = resolve9(filePath);
   } catch (err) {
-    log25.error({ err }, "memory operation failed");
+    log26.error({ err }, "memory operation failed");
     return;
   }
   if (seen.has(abs)) {
@@ -8410,9 +8651,9 @@ function addSource(out, seen, filePath) {
   }
   let data;
   try {
-    data = readFileSync15(abs, "utf-8");
+    data = readFileSync14(abs, "utf-8");
   } catch (err) {
-    log25.error({ err }, "memory operation failed");
+    log26.error({ err }, "memory operation failed");
     return;
   }
   seen.add(abs);
@@ -8442,19 +8683,19 @@ function expandIncludes(content, baseDir, seen, depth) {
           try {
             abs = resolve9(resolved);
           } catch (err) {
-            log25.error({ err }, "memory operation failed");
+            log26.error({ err }, "memory operation failed");
             out.push(line);
             continue;
           }
           if (!seen.has(abs)) {
             try {
-              const data = readFileSync15(abs, "utf-8");
+              const data = readFileSync14(abs, "utf-8");
               seen.add(abs);
               out.push(`<!-- included from ${includePath} -->`);
               out.push(expandIncludes(data, dirname6(abs), seen, depth + 1));
               continue;
             } catch (err) {
-              log25.error({ err }, "memory operation failed");
+              log26.error({ err }, "memory operation failed");
             }
           }
         }
@@ -8485,7 +8726,7 @@ function resolveInclude(p, baseDir) {
     try {
       return join19(homedir7(), p.slice(2));
     } catch (err) {
-      log25.error({ err }, "memory operation failed");
+      log26.error({ err }, "memory operation failed");
       return "";
     }
   }
@@ -8499,7 +8740,7 @@ function projectInstructionDirs(workDir) {
   try {
     abs = resolve9(workDir);
   } catch (err) {
-    log25.error({ err }, "memory operation failed");
+    log26.error({ err }, "memory operation failed");
     return [workDir];
   }
   const root = findGitRoot(abs);
@@ -8530,7 +8771,7 @@ function findGitRoot(start) {
         return cur;
       }
     } catch (err) {
-      log25.error({ err }, "memory operation failed");
+      log26.error({ err }, "memory operation failed");
     }
     const parent = dirname6(cur);
     if (parent === cur) {
@@ -8594,7 +8835,7 @@ function usingToolsSection() {
 - ReadFile offsets are 0-based; displayed lines are 1-based. Read before editing or overwriting existing files; stale file-state errors require a fresh read and revised edit. Exclude display line numbers from edits.
 - Narrow searches; follow truncation/readback instructions rather than treating partial output as exhaustive. Parallelize independent reads or disjoint tasks, not dependent operations or writes to shared files.
 - Use available task tools for complex work, not trivial requests. Delegate bounded work with Agent only when useful, supplying scope, paths, edit permissions, and expected evidence. Forks inherit a snapshot; other subagents need self-contained context.
-- One-shot Agent results return inline, even with run_in_background (a tool restriction, not async execution). Persistent async teammates require TeamCreate and Agent team_name, with SendMessage for follow-ups. Worktrees isolate changes but do not merge them.
+- One-shot Agent results return inline by default. With run_in_background=true, Agent returns a task ID immediately and reports completion through a task notification. Persistent teammates require TeamCreate and Agent team_name, with SendMessage for follow-ups. Worktrees isolate changes but do not merge them.
 - Load relevant skills before using their procedures; respect execution mode and resolve resources relative to the skill directory.
 - Discover deferred tools with ToolSearch (query "select:<exact-tool-name>"). Follow returned instructions: dispatch-mode MCP tools use McpCall with the target arguments; other modes expose callable tools directly.`
   };
@@ -8638,7 +8879,7 @@ function environmentSection(env) {
 }
 
 // src/prompt/builder.ts
-var log26 = createChildLogger({ module: "prompt" });
+var log27 = createChildLogger({ module: "prompt" });
 var PromptBuilder = class {
   sections = [];
   add(s) {
@@ -8677,7 +8918,7 @@ function detectEnvironment(workDir) {
       }).trim();
     }
   } catch (err) {
-    log26.error({ err }, "prompt operation failed");
+    log27.error({ err }, "prompt operation failed");
   }
   return env;
 }
@@ -8739,8 +8980,8 @@ function preview(text) {
   return `${text.slice(0, TEXT_PREVIEW_CHARS)}\u2026 (+${String(text.length - TEXT_PREVIEW_CHARS)} chars)`;
 }
 var AgentEventLogger = class {
-  constructor(log39) {
-    this.log = log39;
+  constructor(log40) {
+    this.log = log40;
   }
   log;
   /**
@@ -8783,24 +9024,19 @@ var AgentEventLogger = class {
 };
 
 // src/remote/server.ts
-import { readFileSync as readFileSync23, existsSync as existsSync20, statSync as statSync11 } from "fs";
+import { readFileSync as readFileSync22, existsSync as existsSync20, statSync as statSync11 } from "fs";
 import { createServer } from "http";
 import { join as join26, extname as extname3, normalize } from "path";
 import { cwd } from "process";
 import Koa from "koa";
 import { WebSocketServer, WebSocket } from "ws";
-import z20 from "zod";
+import z19 from "zod";
 
 // src/remote/session-state.ts
 function restoreRemoteSession(state, sessionId, saved) {
   const replay = rebuildFromSession(saved);
   state.conv.reset();
-  state.conv.appendMessages(
-    replay.map((message) => ({
-      ...message,
-      toolUses: message.toolUses?.map((tool) => ({ ...tool, arguments: tool.arguments ?? {} }))
-    }))
-  );
+  state.conv.appendMessages(replay);
   state.sessionId = sessionId;
   state.fileHistory = new FileHistory(state.workDir, sessionId);
   state.fileStateCache = new FileStateCache();
@@ -8873,11 +9109,11 @@ ${body}`,
 import { randomBytes as randomBytes2 } from "crypto";
 
 // src/subagent/loader.ts
-import { readdirSync as readdirSync5, readFileSync as readFileSync16, existsSync as existsSync14 } from "fs";
+import { readdirSync as readdirSync5, readFileSync as readFileSync15, existsSync as existsSync14 } from "fs";
 import { homedir as homedir8 } from "os";
 import { join as join20 } from "path";
 import yaml6 from "js-yaml";
-import z12, { parse as parse5 } from "zod";
+import z11, { parse as parse5 } from "zod";
 
 // src/subagent/definition.ts
 var BUILTIN_AGENTS = [
@@ -8901,7 +9137,7 @@ var BUILTIN_AGENTS = [
 ];
 
 // src/subagent/loader.ts
-var log27 = createChildLogger({ module: "subagent" });
+var log28 = createChildLogger({ module: "subagent" });
 function loadAgentDefinitions(workDir) {
   const definitions = [...BUILTIN_AGENTS];
   const home = homedir8();
@@ -8921,7 +9157,7 @@ function loadDir(dir, definitions) {
   const files = readdirSync5(dir).filter((f) => f.endsWith(".md"));
   for (const file of files) {
     try {
-      const content = readFileSync16(join20(dir, file), "utf-8");
+      const content = readFileSync15(join20(dir, file), "utf-8");
       const def = parseAgentDefinition(content);
       if (def) {
         const existing = definitions.findIndex((d) => d.name === def.name);
@@ -8932,21 +9168,21 @@ function loadDir(dir, definitions) {
         }
       }
     } catch (err) {
-      log27.error({ err }, "subagent operation failed");
+      log28.error({ err }, "subagent operation failed");
       continue;
     }
   }
 }
-var YamlFrontmatterSchema3 = z12.looseObject({
-  name: z12.string(),
-  description: z12.string().optional(),
-  tools: z12.array(z12.string()).optional(),
-  disallowed_tools: z12.array(z12.string()).optional(),
-  system_prompt: z12.string().optional(),
-  max_turns: z12.number().optional(),
-  model: z12.string().optional(),
-  background: z12.boolean().optional(),
-  isolation: z12.literal("worktree").optional()
+var YamlFrontmatterSchema3 = z11.looseObject({
+  name: z11.string(),
+  description: z11.string().optional(),
+  tools: z11.array(z11.string()).optional(),
+  disallowed_tools: z11.array(z11.string()).optional(),
+  system_prompt: z11.string().optional(),
+  max_turns: z11.number().optional(),
+  model: z11.string().optional(),
+  background: z11.boolean().optional(),
+  isolation: z11.literal("worktree").optional()
 });
 function parseAgentDefinition(content) {
   if (!content.startsWith("---")) {
@@ -8974,11 +9210,120 @@ function parseAgentDefinition(content) {
       initialPrompt: body
     };
   } catch (err) {
-    log27.error({ err }, "subagent operation failed");
+    log28.error({ err }, "subagent operation failed");
     return null;
   }
 }
 
+// src/subagent/task-manager.ts
+var TaskManager = class {
+  tasks = /* @__PURE__ */ new Map();
+  notifiedTaskIds = /* @__PURE__ */ new Set();
+  listeners = /* @__PURE__ */ new Set();
+  nextId = 1;
+  create(name, runner, cancel, options = {}) {
+    const id = `agent-${String(this.nextId++)}`;
+    const task = {
+      id,
+      name,
+      ...options.originToolCallId ? { originToolCallId: options.originToolCallId } : {},
+      status: "running",
+      output: "",
+      cancel,
+      done: Promise.resolve()
+    };
+    this.tasks.set(id, task);
+    this.emitChange();
+    task.done = Promise.resolve().then(() => runner(task)).then((output) => {
+      if (task.status === "running") {
+        task.status = "completed";
+        task.output = output;
+        this.emitChange();
+      }
+    }).catch((error) => {
+      if (task.status === "running") {
+        task.status = "failed";
+        task.output = `Error: ${asErrorString(error)}`;
+        this.emitChange();
+      }
+    });
+    return task;
+  }
+  get(id) {
+    return this.tasks.get(id);
+  }
+  list() {
+    return [...this.tasks.values()];
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    listener(this.list());
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  emitChange() {
+    const tasks = this.list();
+    for (const listener of this.listeners) {
+      listener(tasks);
+    }
+  }
+  hasRunning() {
+    return this.list().some((task) => task.status === "running");
+  }
+  stop(id) {
+    const task = this.tasks.get(id);
+    if (task?.status !== "running") {
+      return false;
+    }
+    task.status = "cancelled";
+    task.output = "Stopped by user";
+    task.cancel();
+    this.emitChange();
+    return true;
+  }
+  async stopAndWait(id) {
+    const task = this.tasks.get(id);
+    if (!task || !this.stop(id)) {
+      return false;
+    }
+    await task.done;
+    return true;
+  }
+  async stopAll() {
+    const running = this.list().filter((task) => task.status === "running");
+    for (const task of running) {
+      this.stop(task.id);
+    }
+    await Promise.allSettled(running.map((task) => task.done));
+  }
+  async waitAll() {
+    await Promise.allSettled(this.list().map((task) => task.done));
+  }
+  drainNotifications() {
+    const completed = this.list().filter(
+      (task) => task.status !== "running" && !this.notifiedTaskIds.has(task.id)
+    );
+    for (const task of completed) {
+      this.notifiedTaskIds.add(task.id);
+    }
+    return completed;
+  }
+  clear() {
+    this.tasks.clear();
+    this.notifiedTaskIds.clear();
+    this.emitChange();
+  }
+};
+function formatAgentTaskNotification(task) {
+  return [
+    `<task-notification task_id="${task.id}" status="${task.status}">`,
+    `name=${task.name}`,
+    task.output,
+    "</task-notification>"
+  ].join("\n");
+}
+
 // src/teams/task-tools.ts
 var VALID_STATUSES = /* @__PURE__ */ new Set(["pending", "in_progress", "completed", "blocked"]);
 var TeamTaskCreateTool = class {
@@ -9365,14 +9710,14 @@ function getNameRegistry() {
 }
 
 // src/teams/tools.ts
-var log28 = createChildLogger({ module: "teams" });
+var log29 = createChildLogger({ module: "teams" });
 var TeamCreateTool = class {
   constructor(mgr) {
     this.mgr = mgr;
   }
   mgr;
   name = "TeamCreate";
-  description = "Create a team for coordinating multiple agents.";
+  description = "Create a team for coordinating multiple agents. At most one team exists at a time: creating a team deletes any other team, stopping its members.";
   category = "read";
   schema() {
     return {
@@ -9399,12 +9744,9 @@ var TeamCreateTool = class {
         isError: true
       });
     }
-    let name = requested;
-    for (let i = 2; this.mgr.get(name); i++) {
-      name = `${requested}-${String(i)}`;
-    }
+    await this.mgr.deleteAll();
     const description = strArg(args, "description");
-    const team = this.mgr.create(name, void 0, {
+    const team = this.mgr.create(requested, void 0, {
       leadAgentId: "lead",
       description
     });
@@ -9460,7 +9802,11 @@ var SpawnTeammateTool = class {
         isError: true
       });
     }
-    const t = this.mgr.get(team) ?? this.mgr.create(team);
+    let t = this.mgr.get(team);
+    if (!t) {
+      await this.mgr.deleteAll();
+      t = this.mgr.create(team);
+    }
     t.spawnTeammate(name, task, this.runAgent, void 0, this.providerBaseUrl);
     return Promise.resolve({
       output: `Teammate '${name}' spawned in team '${team}'. Its result will arrive on the team channel; keep working and watch for it.`,
@@ -9592,7 +9938,7 @@ var SendMessageTool = class {
     try {
       await t.sendMessage(this.senderName, recipient, message);
     } catch (err) {
-      log28.error({ err }, "teams operation failed");
+      log29.error({ err }, "teams operation failed");
       return {
         output: `Error: ${asErrorString(err)}`,
         isError: true
@@ -9670,7 +10016,7 @@ var TeamDeleteTool = class {
 };
 
 // src/subagent/agent-tool.ts
-var log29 = createChildLogger({ module: "subagent" });
+var log30 = createChildLogger({ module: "subagent" });
 var GENERAL_PURPOSE_AGENT_TYPE = "general-purpose";
 function newAgentSlug() {
   return `agent-a${randomBytes2(4).toString("hex").slice(0, 7)}`;
@@ -9688,6 +10034,7 @@ var AgentTool = class {
   definitions;
   registry;
   conversation;
+  taskManager;
   // Identifies the derived context of the current AgentTool instance;
   // re-forking is prohibited when non-empty and equal to FORK_QUERY_SOURCE
   querySource = "";
@@ -9710,13 +10057,14 @@ var AgentTool = class {
   teamProviderBaseUrl;
   spawnHandler;
   forkHandler;
-  constructor(workDir, registry, spawnHandler, conversation, forkHandler) {
+  constructor(workDir, registry, spawnHandler, conversation, forkHandler, taskManager = new TaskManager()) {
     this.definitions = loadAgentDefinitions(workDir);
     this.workDir = workDir;
     this.registry = registry;
     this.spawnHandler = spawnHandler;
     this.conversation = conversation;
     this.forkHandler = forkHandler;
+    this.taskManager = taskManager;
   }
   /**
    * Sets the team manager and teammate run callback, enabling the team_name parameter.
@@ -9754,7 +10102,7 @@ var AgentTool = class {
           },
           run_in_background: {
             type: "boolean",
-            description: "Apply background-agent tool restrictions. One-shot calls currently wait and return their result inline; use team_name for persistent asynchronous teammates.",
+            description: "Run this one-shot subagent asynchronously. Returns a task ID immediately and delivers the final result through a task notification.",
             default: false
           },
           isolation: {
@@ -9785,7 +10133,7 @@ var AgentTool = class {
 Available roles (pass a role as subagent_type, not as a tool name):
 ${roles.join("\n")}
 
-One-shot calls return results inline, including run_in_background calls (that flag restricts tools). Use team_name for persistent asynchronous teammates and SendMessage for their follow-up assignments. Do not predict results before receiving them.
+Foreground calls return results inline. With run_in_background=true, the call returns a task ID immediately and the final result arrives through a task notification. Use team_name for persistent teammates and SendMessage for their follow-up assignments. Do not predict results before receiving them.
 
 Launch independent tasks together; avoid concurrent writes to the same files. Review returned evidence and integrate it before reporting completion. Worktree isolation separates edits but does not merge them.`;
   }
@@ -9809,10 +10157,26 @@ Launch independent tasks together; avoid concurrent writes to the same files. Re
         description,
         prompt,
         args.plan_mode_required === true,
-        isolation === "worktree"
+        isolation === "worktree",
+        ctx.toolCallId
       );
     }
     if (!subagentType) {
+      if (background && this.conversation && this.forkHandler) {
+        const snapshot = this.conversation.fork();
+        return this.startBackground(
+          description,
+          ctx,
+          (backgroundContext) => this.runFork(
+            prompt,
+            description,
+            modelOverride,
+            backgroundContext,
+            isolation === "worktree",
+            snapshot
+          )
+        );
+      }
       return this.runFork(prompt, description, modelOverride, ctx, isolation === "worktree");
     }
     const definition = this.definitions.find((d) => d.name === subagentType);
@@ -9838,44 +10202,76 @@ ${prompt}`;
         };
       }
     }
-    try {
-      const output = await this.spawnHandler(
-        definition,
-        effectivePrompt,
-        background || !!definition.background,
-        modelOverride,
-        workDirOverride,
-        ctx
-      );
-      return {
-        output: workDirOverride ? `${output}
+    const run2 = async (runContext) => {
+      try {
+        const output = await this.spawnHandler(
+          definition,
+          effectivePrompt,
+          background || !!definition.background,
+          modelOverride,
+          workDirOverride,
+          runContext
+        );
+        return {
+          output: workDirOverride ? `${output}
 
 Worktree retained at: ${workDirOverride}` : output,
-        isError: false
-      };
-    } catch (err) {
-      return {
-        output: `Agent error: ${asErrorString(err)}${workDirOverride ? `
+          isError: false
+        };
+      } catch (err) {
+        return {
+          output: `Agent error: ${asErrorString(err)}${workDirOverride ? `
 Worktree retained at: ${workDirOverride}` : ""}`,
-        isError: true
-      };
-    }
+          isError: true
+        };
+      }
+    };
+    return background ? this.startBackground(description, ctx, run2) : run2(ctx);
+  }
+  startBackground(description, ctx, runner) {
+    const controller = new AbortController();
+    const task = this.taskManager.create(
+      description,
+      async (backgroundTask) => {
+        const result = await runner({
+          ...ctx,
+          backgroundTaskId: backgroundTask.id,
+          abortSignal: controller.signal
+        });
+        if (result.isError) {
+          throw new Error(result.output);
+        }
+        return result.output;
+      },
+      () => {
+        controller.abort();
+      },
+      { originToolCallId: ctx.toolCallId }
+    );
+    return {
+      output: `Background agent '${description}' started (task_id: ${task.id}). Its result will arrive as a task notification.`,
+      isError: false
+    };
   }
   /**
    * Team-member mode: Spawns a persistent teammate in the specified team.
    * Delegates to Team.spawnTeammate() to start the idle-poll main loop.
    */
-  async runAsTeammate(teamName, description, prompt, planModeRequired, worktreeIsolation) {
+  async runAsTeammate(teamName, description, prompt, planModeRequired, worktreeIsolation, originToolCallId) {
     if (!this.teamManager) {
       return {
         output: `Error: team manager '${teamName}' not found.`,
         isError: true
       };
     }
-    const team = this.teamManager.get(teamName) ?? this.teamManager.create(teamName, void 0, {
-      leadAgentId: "lead",
-      description
-    });
+    let team = this.teamManager.get(teamName);
+    if (!team) {
+      await this.teamManager.deleteAll();
+      team = this.teamManager.create(teamName, void 0, {
+        leadAgentId: "lead",
+        description
+      });
+    }
     let memberName = description.replace(/\s+/g, "-").toLowerCase().slice(0, 30);
     let suffix = 2;
     const base = memberName;
@@ -9917,14 +10313,20 @@ ${prompt}`;
     const checker = planModeRequired ? new PermissionChecker(memberWorkDir, "plan") : void 0;
     const runAgent = this.teamRunAgentFactory?.(teammateRegistry, checker, memberWorkDir);
     if (runAgent) {
-      team.spawnTeammate(memberName, teammatePrompt, runAgent, checker, this.teamProviderBaseUrl);
+      team.spawnTeammate(
+        memberName,
+        teammatePrompt,
+        runAgent,
+        checker,
+        this.teamProviderBaseUrl,
+        originToolCallId
+      );
       if (worktreeIsolation) {
         team.setMemberMeta(memberName, { worktreePath: memberWorkDir });
       }
     }
     return {
-      output: `Teammate '${memberName}' spawned in team '${teamName}' (mode: ${team.mode})${planModeRequired ? ", starting in plan mode" : ""}.
-        The teammate is now working on the assigned task.`,
+      output: `Teammate '${memberName}' spawned in team '${teamName}' (mode: ${team.mode})${planModeRequired ? ", starting in plan mode" : ""}`,
       isError: false
     };
   }
@@ -9933,7 +10335,7 @@ ${prompt}`;
    * Unlike definition mode, the forked subagent can see the full history of the parent conversation,
    * achieving byte alignment for the prompt-cache prefix to improve cache hit rate.
    */
-  async runFork(prompt, description, modelOverride, ctx, isolate) {
+  async runFork(prompt, description, modelOverride, ctx, isolate, conversationSnapshot) {
     if (!this.conversation || !this.forkHandler) {
       return {
         output: "Error: fork requires parent conversation context",
@@ -9969,9 +10371,9 @@ ${prompt}`;
           permissionChecker: ctx.permissionChecker?.forWorkDir(worktree.path)
         };
       }
-      const { cloneRegistryForFork: cloneRegistryForFork2 } = await import("./tool-filter-IMIU7CW2.js");
+      const { cloneRegistryForFork: cloneRegistryForFork2 } = await import("./tool-filter-BFEINZIA.js");
       const forkedRegistry = cloneRegistryForFork2(this.registry);
-      const snapshot = this.conversation.fork();
+      const snapshot = conversationSnapshot ?? this.conversation.fork();
       const output = await this.forkHandler(
         `${FORK_BOILERPLATE}
 
@@ -9989,7 +10391,7 @@ Worktree retained at: ${worktreePath}` : ""}`,
         isError: false
       };
     } catch (err) {
-      log29.error({ err }, "subagent operation failed");
+      log30.error({ err }, "subagent operation failed");
       return {
         output: `Fork error: ${asErrorString(err)}${worktreePath ? `
 Worktree retained at: ${worktreePath}` : ""}`,
@@ -10000,6 +10402,7 @@ Worktree retained at: ${worktreePath}` : ""}`,
 };
 
 // src/subagent/spawn.ts
+var SUBAGENT_INTERRUPTED_MARKER = "[Interrupted]";
 async function spawnSubagent(definition, prompt, parentClient, parentRegistry, parentProvider, workDir, onProgress, onEvent, modelOverride, checkerOverride, options = {}) {
   options.abortSignal?.throwIfAborted();
   const effectiveModel = modelOverride ?? definition.model;
@@ -10049,10 +10452,17 @@ async function spawnSubagent(definition, prompt, parentClient, parentRegistry, p
         onProgress?.({ lastTool: event.toolName });
         onEvent?.({
           type: "tool_use",
+          toolId: event.toolId,
           toolName: event.toolName,
           args: event.args
         });
         break;
+      case "tool_result":
+        onEvent?.({
+          type: "tool_result",
+          toolId: event.toolId
+        });
+        break;
       case "usage":
         onEvent?.({
           type: "usage",
@@ -10064,16 +10474,15 @@ async function spawnSubagent(definition, prompt, parentClient, parentRegistry, p
         break;
       case "turn_complete":
         onProgress?.({ turn: ++turn });
+        onEvent?.({ type: "turn_complete" });
         break;
       case "loop_complete":
         if (event.stopReason === "interrupted") {
-          return `${output}${output ? "\n\n" : ""}[Interrupted]`;
+          return `${output}${output ? "\n\n" : ""}${SUBAGENT_INTERRUPTED_MARKER}`;
         }
         return output || "[No output]";
       case "error":
-        return output ? `${output}
-
-[Error: ${event.error.message}]` : `Error: ${event.error.message}`;
+        throw event.error;
     }
   }
   return output || "[No output]";
@@ -10102,12 +10511,14 @@ function coordinatorActive(enabled = false) {
 
 // src/teams/task-stop.ts
 var TaskStopTool = class {
-  constructor(teamManager) {
+  constructor(teamManager, taskManager) {
     this.teamManager = teamManager;
+    this.taskManager = taskManager;
   }
   teamManager;
+  taskManager;
   name = "TaskStop";
-  description = "Stop a running teammate. Pass the teammate name as it appears in the from= field of a team-notification. Use this when you sent a teammate in the wrong direction \u2014 for example when the user changes requirements after you launched it.";
+  description = "Stop a running teammate or background Agent task. Pass exactly one of teammate or task_id.";
   category = "command";
   schema() {
     return {
@@ -10119,16 +10530,34 @@ var TaskStopTool = class {
           teammate: {
             type: "string",
             description: "Name of the teammate to stop, exactly as it appears in the from= field of a team-notification"
+          },
+          task_id: {
+            type: "string",
+            description: "ID of a background Agent task"
           }
-        },
-        required: ["teammate"]
+        }
       }
     };
   }
   async execute(_ctx, args) {
     const name = strArg(args, "teammate", "");
-    if (!name) {
-      return { output: "Error: teammate is required", isError: true };
+    const taskId = strArg(args, "task_id", "");
+    if (!name && !taskId || name && taskId) {
+      return { output: "Error: pass exactly one of teammate or task_id", isError: true };
+    }
+    if (taskId) {
+      const task = this.taskManager?.get(taskId);
+      if (!task) {
+        return { output: `Error: background task '${taskId}' not found`, isError: true };
+      }
+      if (task.status !== "running") {
+        return {
+          output: `Background task '${taskId}' is ${task.status}, nothing to stop`,
+          isError: false
+        };
+      }
+      await this.taskManager?.stopAndWait(taskId);
+      return { output: `Background task '${taskId}' stopped.`, isError: false };
     }
     for (const team of this.teamManager.list()) {
       const member = team.members.get(name);
@@ -10165,12 +10594,12 @@ var TaskStopTool = class {
 };
 
 // src/teams/team.ts
-import { mkdirSync as mkdirSync14, readFileSync as readFileSync21, rmSync } from "fs";
+import { mkdirSync as mkdirSync14, readFileSync as readFileSync20, rmSync } from "fs";
 import { join as join24 } from "path";
 
 // src/teams/file-mailbox.ts
 import {
-  readFileSync as readFileSync17,
+  readFileSync as readFileSync16,
   writeFileSync as writeFileSync10,
   mkdirSync as mkdirSync10,
   existsSync as existsSync15,
@@ -10180,35 +10609,35 @@ import {
   closeSync
 } from "fs";
 import { join as join21 } from "path";
-import z13, { safeParse as safeParse3 } from "zod";
-var log30 = createChildLogger({ module: "teams" });
-var FileMailMessageSchema = z13.object({
-  from: z13.string(),
-  text: z13.string(),
-  timestamp: z13.string(),
+import z12, { safeParse as safeParse3 } from "zod";
+var log31 = createChildLogger({ module: "teams" });
+var FileMailMessageSchema = z12.object({
+  from: z12.string(),
+  text: z12.string(),
+  timestamp: z12.string(),
   // timestamp: z
   //   .union([z.string(), z.number()])
   //   .nullish()
   //   .transform((v) => (!v ? "" : String(v))),
   // Read marker: false on delivery, set to true once the message is read or explicitly marked.
-  read: z13.boolean().optional(),
+  read: z12.boolean().optional(),
   // Three fields for structured messages; left empty for plain-text messages.
   // See the constants in protocol.ts for type values; requestId correlates responses
   // to their originating requests; approve uses an optional field to distinguish
   // "no response yet" from "explicitly rejected".
-  type: z13.string().optional(),
-  requestId: z13.string().optional(),
-  approve: z13.boolean().optional()
+  type: z12.string().optional(),
+  requestId: z12.string().optional(),
+  approve: z12.boolean().optional()
 });
 var LOCK_ACQUIRE_TIMEOUT_MS = 5e3;
 var LOCK_STALE_MS = 1e4;
 var LOCK_MIN_BACKOFF_MS = 5;
 var LOCK_MAX_BACKOFF_MS = 80;
-var ErrnoExceptionSchema = z13.looseObject({
-  errno: z13.number().optional(),
-  code: z13.string().optional(),
-  path: z13.string().optional(),
-  syscall: z13.string().optional()
+var ErrnoExceptionSchema = z12.looseObject({
+  errno: z12.number().optional(),
+  code: z12.string().optional(),
+  path: z12.string().optional(),
+  syscall: z12.string().optional()
 });
 function sleepSync(ms) {
   Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
@@ -10222,7 +10651,7 @@ function acquireLock(lockFile) {
       closeSync(fd);
       return;
     } catch (err) {
-      log30.error({ err }, "teams operation failed");
+      log31.error({ err }, "teams operation failed");
       const { data, success } = safeParse3(ErrnoExceptionSchema, err);
       let code = "";
       if (success && data.code) {
@@ -10238,11 +10667,11 @@ function acquireLock(lockFile) {
             unlinkSync5(lockFile);
             continue;
           } catch (err2) {
-            log30.error({ err: err2 }, "teams operation failed");
+            log31.error({ err: err2 }, "teams operation failed");
           }
         }
       } catch (err2) {
-        log30.error({ err: err2 }, "teams operation failed");
+        log31.error({ err: err2 }, "teams operation failed");
       }
       if (Date.now() >= deadline) {
         throw new Error(
@@ -10258,7 +10687,7 @@ function releaseLock(lockFile) {
   try {
     unlinkSync5(lockFile);
   } catch (err) {
-    log30.error({ err }, "teams operation failed");
+    log31.error({ err }, "teams operation failed");
   }
 }
 function withLock(filePath, fn) {
@@ -10281,7 +10710,7 @@ var FileMailbox = class {
       return [];
     }
     try {
-      const raw = JSON.parse(readFileSync17(this.filePath, "utf-8"));
+      const raw = JSON.parse(readFileSync16(this.filePath, "utf-8"));
       const data = [];
       if (Array.isArray(raw)) {
         for (const item of raw) {
@@ -10293,7 +10722,7 @@ var FileMailbox = class {
       }
       return data;
     } catch (err) {
-      log30.error({ err }, "teams operation failed");
+      log31.error({ err }, "teams operation failed");
       return [];
     }
   }
@@ -10367,44 +10796,52 @@ var FileMailbox = class {
 };
 
 // src/teams/progress.ts
-import { z as z14 } from "zod";
-var ToolActivitySchema = z14.object({
-  toolName: z14.string(),
-  input: z14.record(z14.string(), z14.unknown()),
-  activityDescription: z14.string()
+import { z as z13 } from "zod";
+var ToolActivitySchema = z13.object({
+  toolName: z13.string(),
+  input: z13.record(z13.string(), z13.unknown()),
+  activityDescription: z13.string()
   // e.g. "Reading src/foo.ts"
 });
-var AgentProgressSchema = z14.object({
-  toolUseCount: z14.number(),
-  tokenCount: z14.number(),
+var ActiveToolSchema = z13.object({
+  toolId: z13.string(),
+  toolName: z13.string()
+});
+var AgentProgressSchema = z13.object({
+  toolUseCount: z13.number(),
+  turnCount: z13.number(),
+  tokenCount: z13.number(),
+  activeTools: z13.array(ActiveToolSchema),
   lastActivity: ToolActivitySchema.optional(),
-  recentActivities: z14.array(ToolActivitySchema)
+  recentActivities: z13.array(ToolActivitySchema)
   // circular buffer, max 5
 });
-var TeammateUIStateSchema = z14.object({
-  name: z14.string(),
-  teamName: z14.string(),
-  status: z14.enum(["running", "idle", "completed", "failed", "stopped"]),
+var TeammateUIStateSchema = z13.object({
+  name: z13.string(),
+  teamName: z13.string(),
+  status: z13.enum(["running", "idle", "completed", "failed", "stopped"]),
   progress: AgentProgressSchema,
-  startTime: z14.number(),
-  spinnerVerb: z14.string(),
-  lastMessage: z14.string().optional()
+  originToolCallId: z13.string().optional(),
+  startTime: z13.number(),
+  spinnerVerb: z13.string(),
+  lastMessage: z13.string().optional()
 });
 function createProgress() {
   return {
     toolUseCount: 0,
+    turnCount: 0,
     tokenCount: 0,
+    activeTools: [],
     lastActivity: void 0,
     recentActivities: []
   };
 }
 function recordToolUse(p, toolName, input) {
   p.toolUseCount++;
-  const desc = describeToolActivity(toolName, input);
   const activity = {
     toolName,
     input,
-    activityDescription: desc
+    activityDescription: describeToolActivity(toolName, input)
   };
   p.lastActivity = activity;
   p.recentActivities.push(activity);
@@ -10412,8 +10849,22 @@ function recordToolUse(p, toolName, input) {
     p.recentActivities.shift();
   }
 }
+function recordToolStart(p, toolId, toolName, input) {
+  recordToolUse(p, toolName, input);
+  p.activeTools = [...p.activeTools.filter((tool) => tool.toolId !== toolId), { toolId, toolName }];
+}
+function recordToolResult(p, toolId) {
+  p.activeTools = p.activeTools.filter((tool) => tool.toolId !== toolId);
+}
+function recordTurnComplete(p) {
+  p.turnCount++;
+  p.activeTools = [];
+}
+function clearActiveTools(p) {
+  p.activeTools = [];
+}
 function recordTokens(p, inputTokens, outputTokens) {
-  p.tokenCount = inputTokens + outputTokens;
+  p.tokenCount += inputTokens + outputTokens;
 }
 function describeToolActivity(toolName, input) {
   switch (toolName) {
@@ -10432,6 +10883,8 @@ function describeToolActivity(toolName, input) {
       return `Searching ${strArg(input, "pattern", "files")}`;
     case "Grep":
       return `Grepping ${strArg(input, "pattern", "pattern")}`;
+    case "WebFetch":
+      return `Fetching ${strArg(input, "url", "page")}`;
     default:
       return toolName;
   }
@@ -10453,29 +10906,29 @@ function formatTokens(n) {
 }
 
 // src/teams/shared-task.ts
-import { readFileSync as readFileSync18, writeFileSync as writeFileSync11, mkdirSync as mkdirSync11, existsSync as existsSync16 } from "fs";
+import { readFileSync as readFileSync17, writeFileSync as writeFileSync11, mkdirSync as mkdirSync11, existsSync as existsSync16 } from "fs";
 import { dirname as dirname7 } from "path";
-import z15, { parse as parse6 } from "zod";
-var SerializedTaskSchema = z15.object({
-  id: z15.string(),
-  title: z15.string(),
-  description: z15.string().default(""),
-  status: z15.string().default("pending"),
-  assignee: z15.string().default(""),
-  blocks: z15.array(z15.string()).default([]),
-  blocked_by: z15.array(z15.string()).default([]),
-  created_by: z15.string().default("")
+import z14, { parse as parse6 } from "zod";
+var SerializedTaskSchema = z14.object({
+  id: z14.string(),
+  title: z14.string(),
+  description: z14.string().default(""),
+  status: z14.string().default("pending"),
+  assignee: z14.string().default(""),
+  blocks: z14.array(z14.string()).default([]),
+  blocked_by: z14.array(z14.string()).default([]),
+  created_by: z14.string().default("")
 });
-var StoreDataSchema = z15.object({
-  next_id: z15.number().int().positive().default(1),
-  tasks: z15.array(SerializedTaskSchema).default([])
+var StoreDataSchema = z14.object({
+  next_id: z14.number().int().positive().default(1),
+  tasks: z14.array(SerializedTaskSchema).default([])
 });
 var SharedTaskStore = class {
   path;
   nextId = 1;
   tasks = [];
-  constructor(path2) {
-    this.path = path2;
+  constructor(path) {
+    this.path = path;
     this.load();
   }
   load() {
@@ -10483,7 +10936,7 @@ var SharedTaskStore = class {
       return;
     }
     try {
-      const raw = JSON.parse(readFileSync18(this.path, "utf-8"));
+      const raw = JSON.parse(readFileSync17(this.path, "utf-8"));
       const data = parse6(StoreDataSchema, raw);
       this.nextId = data.next_id;
       this.tasks = data.tasks.map((t) => ({
@@ -10591,26 +11044,26 @@ var SharedTaskStore = class {
 };
 
 // src/teams/team-file.ts
-import { existsSync as existsSync17, mkdirSync as mkdirSync12, readFileSync as readFileSync19, writeFileSync as writeFileSync12 } from "fs";
+import { existsSync as existsSync17, mkdirSync as mkdirSync12, readdirSync as readdirSync6, readFileSync as readFileSync18, writeFileSync as writeFileSync12 } from "fs";
 import { homedir as homedir9 } from "os";
 import { dirname as dirname8, join as join22 } from "path";
-import z16 from "zod";
-var TeamMemberEntrySchema = z16.object({
-  agentId: z16.string(),
-  name: z16.string(),
-  agentType: z16.string().optional(),
-  model: z16.string().optional(),
-  joinedAt: z16.number(),
-  worktreePath: z16.string().optional(),
-  backendType: z16.string().optional(),
-  isActive: z16.boolean().optional()
+import z15 from "zod";
+var TeamMemberEntrySchema = z15.object({
+  agentId: z15.string(),
+  name: z15.string(),
+  agentType: z15.string().optional(),
+  model: z15.string().optional(),
+  joinedAt: z15.number(),
+  worktreePath: z15.string().optional(),
+  backendType: z15.string().optional(),
+  isActive: z15.boolean().optional()
 });
-var TeamFileSchema = z16.object({
-  name: z16.string(),
-  description: z16.string().optional(),
-  createdAt: z16.number(),
-  leadAgentId: z16.string(),
-  members: z16.array(TeamMemberEntrySchema)
+var TeamFileSchema = z15.object({
+  name: z15.string(),
+  description: z15.string().optional(),
+  createdAt: z15.number(),
+  leadAgentId: z15.string(),
+  members: z15.array(TeamMemberEntrySchema)
 });
 function teamsBaseDir() {
   return join22(homedir9(), ".swifty", "teams");
@@ -10621,16 +11074,23 @@ function sanitizeTeamName(name) {
 function teamDir(name) {
   return join22(teamsBaseDir(), sanitizeTeamName(name));
 }
+function listTeamNames() {
+  try {
+    return readdirSync6(teamsBaseDir(), { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+  } catch {
+    return [];
+  }
+}
 function teamConfigPath(name) {
   return join22(teamDir(name), "config.json");
 }
 function readTeamFile(name) {
-  const path2 = teamConfigPath(name);
-  if (!existsSync17(path2)) {
+  const path = teamConfigPath(name);
+  if (!existsSync17(path)) {
     return null;
   }
   try {
-    const raw = JSON.parse(readFileSync19(path2, "utf-8"));
+    const raw = JSON.parse(readFileSync18(path, "utf-8"));
     return TeamFileSchema.parse(raw);
   } catch {
     return null;
@@ -10638,33 +11098,33 @@ function readTeamFile(name) {
 }
 function writeTeamFile(name, file) {
   try {
-    const path2 = teamConfigPath(name);
-    mkdirSync12(dirname8(path2), { recursive: true });
-    writeFileSync12(path2, JSON.stringify(file, null, 2), "utf-8");
+    const path = teamConfigPath(name);
+    mkdirSync12(dirname8(path), { recursive: true });
+    writeFileSync12(path, JSON.stringify(file, null, 2), "utf-8");
   } catch {
   }
 }
 
 // src/teams/transcript.ts
-import { mkdirSync as mkdirSync13, readFileSync as readFileSync20, writeFileSync as writeFileSync13, existsSync as existsSync18 } from "fs";
+import { mkdirSync as mkdirSync13, readFileSync as readFileSync19, writeFileSync as writeFileSync13, existsSync as existsSync18 } from "fs";
 import { join as join23 } from "path";
-import z17, { parse as parse7 } from "zod";
-var log31 = createChildLogger({ module: "teams" });
-var TranscriptToolUseSchema = z17.object({
-  tool_use_id: z17.string(),
-  tool_name: z17.string(),
-  arguments: z17.record(z17.string(), z17.unknown())
+import z16, { parse as parse7 } from "zod";
+var log32 = createChildLogger({ module: "teams" });
+var TranscriptToolUseSchema = z16.object({
+  tool_use_id: z16.string(),
+  tool_name: z16.string(),
+  arguments: z16.record(z16.string(), z16.unknown())
 });
-var TranscriptToolResultSchema = z17.object({
-  tool_use_id: z17.string(),
-  content: z17.string(),
-  is_error: z17.boolean().optional()
+var TranscriptToolResultSchema = z16.object({
+  tool_use_id: z16.string(),
+  content: z16.string(),
+  is_error: z16.boolean().optional()
 });
-var TranscriptEntrySchema = z17.object({
-  role: z17.string(),
-  content: z17.string().optional(),
-  tool_uses: z17.array(TranscriptToolUseSchema).optional(),
-  tool_results: z17.array(TranscriptToolResultSchema).optional()
+var TranscriptEntrySchema = z16.object({
+  role: z16.string(),
+  content: z16.string().optional(),
+  tool_uses: z16.array(TranscriptToolUseSchema).optional(),
+  tool_results: z16.array(TranscriptToolResultSchema).optional()
 });
 function serializeConversation(conversation) {
   const entries = [];
@@ -10697,22 +11157,22 @@ function transcriptDir(workDir, teamName) {
 function saveTranscript(workDir, teamName, agentId, conversation) {
   const dir = transcriptDir(workDir, teamName);
   mkdirSync13(dir, { recursive: true });
-  const path2 = join23(dir, `${agentId}.json`);
+  const path = join23(dir, `${agentId}.json`);
   const data = serializeConversation(conversation);
-  writeFileSync13(path2, JSON.stringify(data, null, 2), "utf-8");
-  return path2;
+  writeFileSync13(path, JSON.stringify(data, null, 2), "utf-8");
+  return path;
 }
 function loadTranscript(workDir, teamName, agentId) {
-  const path2 = join23(transcriptDir(workDir, teamName), `${agentId}.json`);
-  if (!existsSync18(path2)) {
+  const path = join23(transcriptDir(workDir, teamName), `${agentId}.json`);
+  if (!existsSync18(path)) {
     return null;
   }
   try {
-    const raw = JSON.parse(readFileSync20(path2, "utf-8"));
-    const parsed = parse7(z17.array(TranscriptEntrySchema), raw);
+    const raw = JSON.parse(readFileSync19(path, "utf-8"));
+    const parsed = parse7(z16.array(TranscriptEntrySchema), raw);
     return parsed;
   } catch (err) {
-    log31.error({ err }, "teams operation failed");
+    log32.error({ err }, "teams operation failed");
     return null;
   }
 }
@@ -10854,7 +11314,7 @@ function randomCompletionVerb() {
 }
 
 // src/teams/team.ts
-var log32 = createChildLogger({ module: "teams" });
+var log33 = createChildLogger({ module: "teams" });
 var Team = class _Team {
   name;
   mode;
@@ -10941,15 +11401,15 @@ var Team = class _Team {
    * Falls back to in-process when the external backend is unavailable (tmux not installed,
    * non-iTerm environment, etc.) to avoid crashes.
    */
-  spawnTeammate(name, task, runAgent, checker, providerBaseUrl) {
+  spawnTeammate(name, task, runAgent, checker, providerBaseUrl, originToolCallId) {
     if (this.mode === "in-process") {
-      this.spawnInProcess(name, task, runAgent, checker);
+      this.spawnInProcess(name, task, runAgent, checker, originToolCallId);
       return;
     }
     try {
-      this.spawnExternal(name, task, providerBaseUrl);
+      this.spawnExternal(name, task, providerBaseUrl, originToolCallId);
     } catch {
-      this.spawnInProcess(name, task, runAgent, checker);
+      this.spawnInProcess(name, task, runAgent, checker, originToolCallId);
     }
   }
   /**
@@ -10958,7 +11418,7 @@ var Team = class _Team {
    * by `--team-dir`; task assignments from the lead and idle/result notifications from the
    * worker all land in this directory, keeping both sides in sync.
    */
-  spawnExternal(name, task, providerBaseUrl) {
+  spawnExternal(name, task, providerBaseUrl, originToolCallId) {
     const member = this.addMember(name);
     member.active = true;
     getNameRegistry().register(name, name);
@@ -10967,6 +11427,7 @@ var Team = class _Team {
       teamName: this.name,
       status: "running",
       progress: createProgress(),
+      ...originToolCallId ? { originToolCallId } : {},
       startTime: Date.now(),
       spinnerVerb: randomVerb()
     };
@@ -11002,7 +11463,7 @@ var Team = class _Team {
    * Exits the loop upon receiving a shutdown message or being canceled.
    * Uses the idle-poll-continue pattern: after each turn completes, reports idle and waits for the next task.
    */
-  spawnInProcess(name, task, runAgent, checker) {
+  spawnInProcess(name, task, runAgent, checker, originToolCallId) {
     const member = this.addMember(name);
     member.active = true;
     member.checker = checker;
@@ -11016,6 +11477,7 @@ var Team = class _Team {
       teamName: this.name,
       status: "running",
       progress: createProgress(),
+      ...originToolCallId ? { originToolCallId } : {},
       startTime: Date.now(),
       spinnerVerb: randomVerb()
     };
@@ -11023,19 +11485,16 @@ var Team = class _Team {
     const onEvent = (event) => {
       switch (event.type) {
         case "tool_use":
-          if (event.toolName && event.args) {
-            recordToolUse(uiState.progress, event.toolName, event.args);
-          }
+          recordToolStart(uiState.progress, event.toolId, event.toolName, event.args);
+          break;
+        case "tool_result":
+          recordToolResult(uiState.progress, event.toolId);
           break;
         case "usage":
-          if (event.usage) {
-            recordTokens(uiState.progress, event.usage.inputTokens, event.usage.outputTokens);
-          }
+          recordTokens(uiState.progress, event.usage.inputTokens, event.usage.outputTokens);
           break;
-        case "stream_text":
-          if (event.text) {
-            uiState.lastMessage = event.text;
-          }
+        case "turn_complete":
+          recordTurnComplete(uiState.progress);
           break;
       }
     };
@@ -11050,7 +11509,13 @@ var Team = class _Team {
             onEvent,
             abortController.signal
           );
+          clearActiveTools(uiState.progress);
           uiState.lastMessage = result.length > 200 ? result.slice(0, 200) + "..." : result;
+          if (abortController.signal.aborted || !member.active) {
+            uiState.status = "stopped";
+            await this.leadMailbox.send(name, `[idle] ${name} (reason: stopped)`);
+            break;
+          }
           if (member.checker?.mode === "plan") {
             uiState.status = "idle";
             const next = await this.runPlanApproval(member, this.readPlanForReview());
@@ -11079,20 +11544,23 @@ var Team = class _Team {
           }
           nextPrompt = pollResult.prompt;
         }
-        uiState.status = "completed";
+        if (uiState.status !== "stopped") {
+          uiState.status = "completed";
+        }
       } catch (err) {
         if (abortController.signal.aborted || !member.active) {
           uiState.status = "stopped";
           uiState.lastMessage = "Stopped";
           await this.leadMailbox.send(name, `[idle] ${name} (reason: stopped)`);
         } else {
-          log32.error({ err }, "teams operation failed");
+          log33.error({ err }, "teams operation failed");
           uiState.status = "failed";
           uiState.lastMessage = asErrorString(err);
           await this.leadMailbox.send(name, `[idle] ${name} (reason: failed)`);
         }
       } finally {
         member.active = false;
+        clearActiveTools(uiState.progress);
         if (uiState.status === "running") {
           uiState.status = "idle";
         }
@@ -11100,7 +11568,7 @@ var Team = class _Team {
           try {
             saveTranscript(this.workDir, this.name, name, member.conversation);
           } catch (err) {
-            log32.error({ err }, "teams operation failed");
+            log33.error({ err }, "teams operation failed");
           }
         }
       }
@@ -11144,7 +11612,7 @@ ${prompt}` };
    */
   readPlanForReview() {
     try {
-      const text = readFileSync21(getOrCreatePlanPath(this.workDir), "utf-8");
+      const text = readFileSync20(getOrCreatePlanPath(this.workDir), "utf-8");
       if (text.trim()) {
         return text;
       }
@@ -11177,6 +11645,9 @@ Please revise the plan accordingly and resubmit.`;
     if (!member) {
       throw new Error(`Member '${to}' not found in team '${this.name}'`);
     }
+    if (member.active && member.uiState) {
+      member.uiState.status = "running";
+    }
     await member.mailbox.send(from, content);
   }
   async stopMember(name) {
@@ -11187,9 +11658,7 @@ Please revise the plan accordingly and resubmit.`;
     }
   }
   async stopAll() {
-    for (const member of this.members.values()) {
-      await this.stopOne(member);
-    }
+    await Promise.allSettled([...this.members.values()].map((member) => this.stopOne(member)));
   }
   /**
    * Stops a single teammate: marks it inactive and updates UI state.
@@ -11199,7 +11668,7 @@ Please revise the plan accordingly and resubmit.`;
    */
   async stopOne(member) {
     member.active = false;
-    if (member.uiState?.status === "running") {
+    if (member.uiState?.status === "running" || member.uiState?.status === "idle") {
       member.uiState.status = "stopped";
     }
     if (member.external) {
@@ -11286,6 +11755,9 @@ var TeamManager = class {
   list() {
     return [...this.teams.values()];
   }
+  async stopAll() {
+    await Promise.allSettled(this.list().map((team) => team.stopAll()));
+  }
   async delete(name) {
     const team = this.teams.get(name);
     if (team) {
@@ -11299,6 +11771,20 @@ var TeamManager = class {
     this.taskStores.delete(name);
     rmSync(teamDir(name), { recursive: true, force: true });
   }
+  /**
+   * Deletes every team: in-memory teams are stopped and unregistered, then any
+   * residual team directories on disk (e.g. leftovers from previous sessions,
+   * which never appear in list()) are removed too. Enforces the single-team
+   * invariant before a new team is created.
+   */
+  async deleteAll() {
+    for (const team of this.list()) {
+      await this.delete(team.name);
+    }
+    for (const name of listTeamNames()) {
+      await this.delete(name);
+    }
+  }
   getAllTeammateStates() {
     return this.list().flatMap((t) => t.getTeammateStates());
   }
@@ -11316,6 +11802,11 @@ var TeamManager = class {
       const lines = [];
       lines.push(`<task-notification team="${team.name}">`);
       for (const msg of msgs) {
+        const member = team.getMember(msg.from);
+        if (member?.active && member.uiState && msg.text.startsWith("[idle]")) {
+          member.uiState.status = "idle";
+          clearActiveTools(member.uiState.progress);
+        }
         lines.push(`from=${msg.from}: ${msg.text}`);
       }
       lines.push("</task-notification>");
@@ -11329,21 +11820,21 @@ function isTeamMode(mode) {
 }
 
 // src/todo/store.ts
-import { readFileSync as readFileSync22, writeFileSync as writeFileSync14, mkdirSync as mkdirSync15, existsSync as existsSync19 } from "fs";
+import { readFileSync as readFileSync21, writeFileSync as writeFileSync14, mkdirSync as mkdirSync15, existsSync as existsSync19 } from "fs";
 import { join as join25, dirname as dirname9 } from "path";
-import z18, { parse as parse8 } from "zod";
-var log33 = createChildLogger({ module: "todo" });
-var StoredTaskStatusSchema = z18.enum(["pending", "in_progress", "completed"]);
-var StoredTaskSchema = z18.object({
-  id: z18.string(),
-  subject: z18.string(),
-  description: z18.string(),
+import z17, { parse as parse8 } from "zod";
+var log34 = createChildLogger({ module: "todo" });
+var StoredTaskStatusSchema = z17.enum(["pending", "in_progress", "completed"]);
+var StoredTaskSchema = z17.object({
+  id: z17.string(),
+  subject: z17.string(),
+  description: z17.string(),
   status: StoredTaskStatusSchema,
-  owner: z18.string().optional(),
-  activeForm: z18.string().optional(),
-  blocks: z18.array(z18.string()),
-  blockedBy: z18.array(z18.string()),
-  metadata: z18.record(z18.string(), z18.unknown())
+  owner: z17.string().optional(),
+  activeForm: z17.string().optional(),
+  blocks: z17.array(z17.string()),
+  blockedBy: z17.array(z17.string()),
+  metadata: z17.record(z17.string(), z17.unknown())
 });
 var TaskStore = class {
   filePath;
@@ -11356,12 +11847,12 @@ var TaskStore = class {
       return [];
     }
     try {
-      const data = readFileSync22(this.filePath, "utf-8");
+      const data = readFileSync21(this.filePath, "utf-8");
       const raw = JSON.parse(data);
-      const parsed = parse8(z18.array(StoredTaskSchema), raw);
+      const parsed = parse8(z17.array(StoredTaskSchema), raw);
       return parsed;
     } catch (err) {
-      log33.error({ err }, "todo operation failed");
+      log34.error({ err }, "todo operation failed");
       return [];
     }
   }
@@ -11476,16 +11967,16 @@ var TaskList = class {
 };
 
 // src/tools/ask-user.ts
-import { safeParseAsync as safeParseAsync2, z as z19 } from "zod";
-var QuestionOptionSchema = z19.object({
-  label: z19.string(),
-  description: z19.string().optional()
+import { safeParseAsync as safeParseAsync2, z as z18 } from "zod";
+var QuestionOptionSchema = z18.object({
+  label: z18.string(),
+  description: z18.string().optional()
 });
-var QuestionSchema = z19.object({
-  question: z19.string(),
-  header: z19.string(),
-  options: z19.array(QuestionOptionSchema),
-  multiSelect: z19.boolean()
+var QuestionSchema = z18.object({
+  question: z18.string(),
+  header: z18.string(),
+  options: z18.array(QuestionOptionSchema),
+  multiSelect: z18.boolean()
 });
 var AskUserQuestionTool = class {
   constructor(ask) {
@@ -11567,7 +12058,7 @@ var AskUserQuestionTool = class {
       success,
       data: argsData,
       error
-    } = await safeParseAsync2(z19.object({ questions: z19.array(QuestionSchema) }), args);
+    } = await safeParseAsync2(z18.object({ questions: z18.array(QuestionSchema) }), args);
     if (!success) {
       return {
         output: error.message,
@@ -11679,21 +12170,21 @@ var SyntheticOutputTool = class {
 };
 
 // src/remote/server.ts
-var log34 = createChildLogger({ module: "remote" });
-var WsInboundSchema = z20.object({
-  type: z20.string(),
-  data: z20.unknown()
+var log35 = createChildLogger({ module: "remote" });
+var WsInboundSchema = z19.object({
+  type: z19.string(),
+  data: z19.unknown()
 });
-var UserMessageSchema = z20.object({
-  content: z20.string()
+var UserMessageSchema = z19.object({
+  content: z19.string()
 });
-var PermissionResponseSchema = z20.object({
-  id: z20.string(),
-  response: z20.enum(["allow", "deny", "allowAlways"])
+var PermissionResponseSchema = z19.object({
+  id: z19.string(),
+  response: z19.enum(["allow", "deny", "allowAlways"])
 });
-var AskUserResponseSchema = z20.object({
-  id: z20.string(),
-  answers: z20.record(z20.string(), z20.string())
+var AskUserResponseSchema = z19.object({
+  id: z19.string(),
+  answers: z19.record(z19.string(), z19.string())
 });
 var FE_DIST = join26(import.meta.dirname, "fe", "dist");
 var MIME_TYPES = {
@@ -11706,8 +12197,8 @@ var MIME_TYPES = {
   ".json": "application/json; charset=utf-8",
   ".woff2": "font/woff2"
 };
-function serveStatic(path2) {
-  const cleanPath = normalize(path2).replace(/^(\.\.[/\\])+/, "");
+function serveStatic(path) {
+  const cleanPath = normalize(path).replace(/^(\.\.[/\\])+/, "");
   const fullPath = join26(FE_DIST, cleanPath);
   if (!fullPath.startsWith(FE_DIST)) {
     return null;
@@ -11715,7 +12206,7 @@ function serveStatic(path2) {
   if (!existsSync20(fullPath) || !statSync11(fullPath).isFile()) {
     return null;
   }
-  const body = readFileSync23(fullPath);
+  const body = readFileSync22(fullPath);
   const mime = MIME_TYPES[extname3(fullPath)] ?? "application/octet-stream";
   return { body, mime };
 }
@@ -11734,6 +12225,7 @@ var AgentHandleImpl = class {
   hookEngine;
   recoveryState;
   teamManager;
+  backgroundTaskManager;
   enableCoordinatorMode;
   forkDisabled;
   memoryManager;
@@ -11763,6 +12255,7 @@ var AgentHandleImpl = class {
     this.hookEngine = agentHandleImpl.hookEngine;
     this.recoveryState = agentHandleImpl.recoveryState;
     this.teamManager = agentHandleImpl.teamManager;
+    this.backgroundTaskManager = agentHandleImpl.backgroundTaskManager;
     this.enableCoordinatorMode = agentHandleImpl.enableCoordinatorMode;
     this.forkDisabled = agentHandleImpl.forkDisabled;
     this.memoryManager = agentHandleImpl.memoryManager;
@@ -11810,7 +12303,10 @@ var AgentHandleImpl = class {
           const section = this.skillCatalog ? buildSkillSection(this.skillCatalog, this.workDir) : "";
           return section && !this.conv.hasReminderContaining(section) ? section : "";
         },
-        notificationFn: () => this.teamManager.drainLeads(),
+        notificationFn: () => [
+          ...this.teamManager.drainLeads(),
+          ...this.backgroundTaskManager.drainNotifications().map(formatAgentTaskNotification)
+        ],
         onPermissionRequest: callbacks.onPermissionRequest,
         onLoopComplete: (conv) => {
           const summary = conv.getMessages().slice(-40).map((m) => `[${m.role}]: ${contentToText(m.content)}`).filter((s) => s.length > 12).join("\n");
@@ -11831,6 +12327,8 @@ var AgentHandleImpl = class {
   }
   abort() {
     this.abortController?.abort();
+    void this.backgroundTaskManager.stopAll();
+    void this.teamManager.stopAll();
   }
 };
 async function createRemoteAgent(opts) {
@@ -11841,9 +12339,9 @@ async function createRemoteAgent(opts) {
     mcpServers: mcpConfigs,
     enableCoordinatorMode,
     forkDisabled,
-    askUser
+    askUser,
+    sessionId = newSessionId()
   } = opts;
-  const sessionId = newSessionId();
   const fileHistory = new FileHistory(workDir, sessionId);
   const fileStateCache = new FileStateCache();
   const registry = buildToolRegistry(workDir, sessionId);
@@ -11859,7 +12357,7 @@ async function createRemoteAgent(opts) {
   conv.injectLongTermMemory(instructions, memReminder);
   const hookErr = validate(hookConfigs ?? []);
   if (hookErr) {
-    log34.warn({ message: hookErr.message }, "hook validation warning");
+    log35.warn({ message: hookErr.message }, "hook validation warning");
   }
   const hookEngine = new HookEngine(hookConfigs ?? []);
   const catalog = new SkillCatalog();
@@ -11881,8 +12379,8 @@ async function createRemoteAgent(opts) {
       if (!client) {
         throw new Error("no llm client (provider not initialized)");
       }
-      const { PermissionChecker: PC } = await import("./checker-QNMXPZ7C.js");
-      const { Agent: AgentClass } = await import("./agent-3OEC4SOB.js");
+      const { PermissionChecker: PC } = await import("./checker-UPY4CXUL.js");
+      const { Agent: AgentClass } = await import("./agent-NNYCUIOF.js");
       const subConv = new ConversationManager();
       subConv.addUserMessage(prompt);
       const subAgent = new AgentClass({
@@ -11909,7 +12407,9 @@ async function createRemoteAgent(opts) {
     }
   };
   registry.register(new LoadSkillTool(catalog, skillHost, skillForkHost));
-  registry.register(new AskUserQuestionTool(askUser));
+  if (askUser) {
+    registry.register(new AskUserQuestionTool(askUser));
+  }
   const teamRunAgentFactory = (registry2, teamChecker, memberWorkDir = workDir) => (task, onEvent, abortSignal) => spawnSubagent(
     BUILTIN_AGENTS[0],
     task,
@@ -11924,10 +12424,11 @@ async function createRemoteAgent(opts) {
     { abortSignal }
   );
   const teamManager = new TeamManager(workDir);
+  const backgroundTaskManager = new TaskManager();
   registry.register(new TeamCreateTool(teamManager));
   registry.register(new SendMessageTool(teamManager));
   registry.register(new TeamDeleteTool(teamManager));
-  registry.register(new TaskStopTool(teamManager));
+  registry.register(new TaskStopTool(teamManager, backgroundTaskManager));
   registry.register(new SyntheticOutputTool());
   const agentTool = new AgentTool(
     workDir,
@@ -11990,7 +12491,8 @@ async function createRemoteAgent(opts) {
         }
       }
       return output || "[No output]";
-    }
+    },
+    backgroundTaskManager
   );
   agentTool.forkDisabled = forkDisabled ?? false;
   agentTool.setTeamManager(teamManager, teamRunAgentFactory, provider.base_url);
@@ -12015,7 +12517,7 @@ async function createRemoteAgent(opts) {
       }
     }
     for (const { serverName, error } of result.errors) {
-      log34.error({ serverName, error }, "MCP server connection error");
+      log35.error({ serverName, error }, "MCP server connection error");
     }
     if (result.tools.length > 0) {
       decideAndApply(registry, provider.base_url, getContextWindow(provider));
@@ -12036,6 +12538,7 @@ async function createRemoteAgent(opts) {
     hookEngine,
     recoveryState: new RecoveryState(),
     teamManager,
+    backgroundTaskManager,
     forkDisabled,
     enableCoordinatorMode,
     memoryManager,
@@ -12115,7 +12618,7 @@ var RemoteServer = class {
   streaming = false;
   compactController = null;
   turnCount = 0;
-  eventLogger = new AgentEventLogger(log34);
+  eventLogger = new AgentEventLogger(log35);
   // Pending permission/ask-user requests waiting for WS client responses
   pendingPermissions = /* @__PURE__ */ new Map();
   pendingAsks = /* @__PURE__ */ new Map();
@@ -12172,12 +12675,12 @@ var RemoteServer = class {
         try {
           raw = JSON.parse(data.toString("utf-8"));
         } catch {
-          log34.warn("received non-JSON WebSocket message");
+          log35.warn("received non-JSON WebSocket message");
           return;
         }
         const parsed = WsInboundSchema.safeParse(raw);
         if (!parsed.success) {
-          log34.warn("received malformed WS message");
+          log35.warn("received malformed WS message");
           return;
         }
         void this.handleWsMessage(parsed.data);
@@ -12231,7 +12734,7 @@ var RemoteServer = class {
         break;
       }
       default:
-        log34.warn({ type: msg.type }, "unknown WS message type");
+        log35.warn({ type: msg.type }, "unknown WS message type");
     }
   }
   /**
@@ -12258,7 +12761,7 @@ var RemoteServer = class {
       });
       return this.agentHandle;
     } catch (err) {
-      log34.error({ err }, "failed to initialize agent");
+      log35.error({ err }, "failed to initialize agent");
       this.broadcast({
         type: "error",
         data: {
@@ -12319,7 +12822,7 @@ var RemoteServer = class {
         });
       }
     } catch (err) {
-      log34.error({ err }, "agent stream error");
+      log35.error({ err }, "agent stream error");
       this.broadcast({
         type: "error",
         data: { message: err instanceof Error ? err.message : String(err) }
@@ -12476,7 +12979,7 @@ var RemoteServer = class {
             });
           }
         } catch (err) {
-          log34.error({ err }, "agent stream error in prompt command");
+          log35.error({ err }, "agent stream error in prompt command");
           this.broadcast({
             type: "error",
             data: { message: err instanceof Error ? err.message : String(err) }
@@ -12697,7 +13200,7 @@ Explore the codebase and design your approach.`
           });
         }
       } catch (err) {
-        log34.error({ err }, "agent stream error in plan command");
+        log35.error({ err }, "agent stream error in plan command");
         this.broadcast({
           type: "error",
           data: { message: err instanceof Error ? err.message : String(err) }
@@ -12865,7 +13368,7 @@ Explore the codebase and design your approach.`
         forkDisabled: this.opts.forkDisabled
       });
     } catch (err) {
-      log34.warn({ err }, "agent init deferred -- will retry on first message");
+      log35.warn({ err }, "agent init deferred -- will retry on first message");
       this.agentHandle = null;
     }
     return new Promise((resolve12, reject) => {
@@ -12919,7 +13422,7 @@ import { randomUUID as randomUUID2 } from "crypto";
 import {
   mkdirSync as mkdirSync16,
   writeFileSync as writeFileSync15,
-  readFileSync as readFileSync24,
+  readFileSync as readFileSync23,
   lstatSync,
   realpathSync,
   openSync as openSync2,
@@ -12929,7 +13432,7 @@ import {
 } from "fs";
 import { join as join27, resolve as resolve10 } from "path";
 import yaml7 from "js-yaml";
-var log35 = createChildLogger({ module: "skills" });
+var log36 = createChildLogger({ module: "skills" });
 var InstallSkillTool = class {
   constructor(workDir, catalog, onInstalled) {
     this.workDir = workDir;
@@ -12993,7 +13496,7 @@ var InstallSkillTool = class {
           clearTimeout(timer);
         }
       } else {
-        content = readFileSync24(resolve10(this.workDir, source), "utf-8");
+        content = readFileSync23(resolve10(this.workDir, source), "utf-8");
       }
       const parsed = parseSkillFile(content);
       if (!parsed) {
@@ -13053,7 +13556,7 @@ ${parsed.body}
         isError: false
       };
     } catch (err) {
-      log35.error({ err }, "skills operation failed");
+      log36.error({ err }, "skills operation failed");
       return {
         output: `Error installing skill: ${asErrorString(err)}`,
         isError: true
@@ -13062,57 +13565,6 @@ ${parsed.body}
   }
 };
 
-// src/subagent/task-manager.ts
-var TaskManager = class {
-  tasks = /* @__PURE__ */ new Map();
-  nextId = 1;
-  create(name, runner, cancel) {
-    const id = String(this.nextId++);
-    const task = {
-      id,
-      name,
-      status: "running",
-      output: "",
-      cancel
-    };
-    this.tasks.set(id, task);
-    runner().then((output) => {
-      task.status = "completed";
-      task.output = output;
-    }).catch((err) => {
-      task.status = "failed";
-      task.output = `Error: ${asErrorString(err)}`;
-    });
-    return task;
-  }
-  get(id) {
-    return this.tasks.get(id);
-  }
-  list() {
-    return [...this.tasks.values()];
-  }
-  /** Abort a running task; returns whether a task was actually stopped. Returns false for tasks that have already finished. */
-  stop(id) {
-    const task = this.tasks.get(id);
-    if (task?.status === "running") {
-      task.cancel();
-      task.status = "cancelled";
-      task.output = "Stopped by user";
-      return true;
-    }
-    return false;
-  }
-  drainNotifications() {
-    const completed = [];
-    for (const task of this.tasks.values()) {
-      if (task.status !== "running") {
-        completed.push(task);
-      }
-    }
-    return completed;
-  }
-};
-
 // src/tools/is-diff-tool.ts
 function isDiffTool(toolName) {
   return toolName === "EditFile";
@@ -13351,20 +13803,20 @@ import { useEffect as useEffect2, useRef as useRef2 } from "react";
 // src/vscode/ide-client.ts
 import { setTimeout as delay2 } from "timers/promises";
 import { Client as Client2 } from "@modelcontextprotocol/sdk/client/index.js";
-import { z as z22 } from "zod";
+import { z as z21 } from "zod";
 
 // src/vscode/lockfile.ts
 import { readdir as readdir2, readFile as readFile6 } from "fs/promises";
 import { homedir as homedir10 } from "os";
 import { join as join28, resolve as resolve11, sep as sep2 } from "path";
-import { z as z21 } from "zod";
-var log36 = createChildLogger({ module: "vscode" });
-var LockfileSchema = z21.object({
-  workspaceFolders: z21.array(z21.string()).optional(),
-  pid: z21.number().optional(),
-  ideName: z21.string().optional(),
-  transport: z21.enum(["ws", "sse"]).optional(),
-  authToken: z21.string().optional()
+import { z as z20 } from "zod";
+var log37 = createChildLogger({ module: "vscode" });
+var LockfileSchema = z20.object({
+  workspaceFolders: z20.array(z20.string()).optional(),
+  pid: z20.number().optional(),
+  ideName: z20.string().optional(),
+  transport: z20.enum(["ws", "sse"]).optional(),
+  authToken: z20.string().optional()
 });
 function ideLockDir() {
   const configDir = process.env.CLAUDE_CONFIG_DIR ?? join28(homedir10(), ".claude");
@@ -13400,7 +13852,7 @@ async function readLockfile(dir, filename) {
       pid: parsed.pid
     };
   } catch (err) {
-    log36.error({ err, filename }, "failed to read IDE lockfile");
+    log37.error({ err, filename }, "failed to read IDE lockfile");
     return null;
   }
 }
@@ -13516,13 +13968,13 @@ var WebSocketTransport = class {
 };
 
 // src/vscode/ide-client.ts
-var log37 = createChildLogger({ module: "vscode" });
-var AtMentionedSchema = z22.object({
-  method: z22.literal("at_mentioned"),
-  params: z22.object({
-    filePath: z22.string(),
-    lineStart: z22.number().optional(),
-    lineEnd: z22.number().optional()
+var log38 = createChildLogger({ module: "vscode" });
+var AtMentionedSchema = z21.object({
+  method: z21.literal("at_mentioned"),
+  params: z21.object({
+    filePath: z21.string(),
+    lineStart: z21.number().optional(),
+    lineEnd: z21.number().optional()
   })
 });
 function inIdeTerminal() {
@@ -13558,7 +14010,7 @@ async function connectToIde(opts) {
   } catch (err) {
     await client.close().catch(() => void 0);
     if (!opts.signal?.aborted) {
-      log37.error({ err, url: ide.url }, "failed to connect to IDE extension");
+      log38.error({ err, url: ide.url }, "failed to connect to IDE extension");
     }
     return null;
   }
@@ -13584,7 +14036,7 @@ async function connectToIde(opts) {
       params: { pid: process.pid }
     });
   } catch (err) {
-    log37.error({ err }, "failed to send ide_connected notification");
+    log38.error({ err }, "failed to send ide_connected notification");
   }
   return {
     ideName: ide.ideName,
@@ -13593,7 +14045,7 @@ async function connectToIde(opts) {
       try {
         await client.close();
       } catch (err) {
-        log37.error({ err }, "failed to close IDE client");
+        log38.error({ err }, "failed to close IDE client");
       }
     }
   };
@@ -13709,10 +14161,11 @@ async function runPrintMode(args) {
   registry.register(new EditFileTool());
   registry.register(new ToolSearchTool(registry));
   const teamManager = new TeamManager(workDir);
+  const backgroundTaskManager = new TaskManager();
   registry.register(new TeamCreateTool(teamManager));
   registry.register(new SendMessageTool(teamManager));
   registry.register(new TeamDeleteTool(teamManager));
-  registry.register(new TaskStopTool(teamManager));
+  registry.register(new TaskStopTool(teamManager, backgroundTaskManager));
   registry.register(new SyntheticOutputTool());
   registry.register(new McpCallTool(registry));
   const agentTool = new AgentTool(
@@ -13753,7 +14206,8 @@ async function runPrintMode(args) {
         abortSignal: context?.abortSignal,
         onPermissionRequest: context?.onPermissionRequest
       }
-    )
+    ),
+    backgroundTaskManager
   );
   agentTool.forkDisabled = !forkEnabled(cfg);
   agentTool.setTeamManager(
@@ -13801,8 +14255,11 @@ async function runPrintMode(args) {
       contextWindow: getContextWindow(provider),
       maxOutput: getMaxOutputTokens(provider),
       instructions: loadInstructions(workDir),
-      // Teammate completion reports land in the Lead's inbox; drained each turn as a system-reminder delivered to the Lead
-      notificationFn: () => teamManager.drainLeads(),
+      // Completion reports are drained each turn as system reminders delivered to the Lead.
+      notificationFn: () => [
+        ...teamManager.drainLeads(),
+        ...backgroundTaskManager.drainNotifications().map(formatAgentTaskNotification)
+      ],
       toolFilter: coordinatorToolFilter(cfg.enable_coordinator_mode ?? false),
       coordinatorActiveFn: () => coordinatorActive(cfg.enable_coordinator_mode ?? false)
     });
@@ -13854,10 +14311,21 @@ Error: ${event.error.message}`);
           break;
       }
     }
+    await backgroundTaskManager.waitAll();
+    const backgroundNotifications = backgroundTaskManager.drainNotifications();
     const durationMs = Date.now() - startTime;
     if (args.outputFormat === "text" && resultText && !resultText.endsWith("\n")) {
       process.stdout.write("\n");
     }
+    for (const task of backgroundNotifications) {
+      const notification = formatAgentTaskNotification(task);
+      if (args.outputFormat === "stream-json") {
+        console.log(JSON.stringify({ type: "task_notification", notification }));
+      } else {
+        process.stdout.write(`${notification}
+`);
+      }
+    }
     if (args.outputFormat === "stream-json") {
       const resultLine = {
         type: "result",
@@ -13870,7 +14338,8 @@ Error: ${event.error.message}`);
       console.log(JSON.stringify(resultLine));
     }
   } finally {
-    await Promise.allSettled(teamManager.list().map((team) => team.stopAll()));
+    await backgroundTaskManager.stopAll();
+    await teamManager.stopAll();
     if (mcpManager) {
       try {
         await mcpManager.disconnectAll();
@@ -13943,6 +14412,23 @@ function recordError(context, error) {
   const stack = error instanceof Error ? error.stack ?? error.message : String(error);
   record(`crash [${context}] ${stack}`);
 }
+var TERMINAL_GONE_CODES = /* @__PURE__ */ new Set(["EIO", "EPIPE", "ERR_STREAM_DESTROYED"]);
+function isTerminalGone(err) {
+  if (err === null || typeof err !== "object" && typeof err !== "function") {
+    return false;
+  }
+  const code = Reflect.get(err, "code");
+  return typeof code === "string" && TERMINAL_GONE_CODES.has(code);
+}
+var terminalGoneRecorded = false;
+function exitForTerminalGone(context, error) {
+  if (!terminalGoneRecorded) {
+    terminalGoneRecorded = true;
+    const detail = error instanceof Error ? error.message : String(error);
+    record(`terminal closed [${context}] ${detail}`);
+  }
+  process.exit(0);
+}
 var exitRecorded = false;
 function recordExit(code) {
   if (exitRecorded) {
@@ -13953,15 +14439,35 @@ function recordExit(code) {
 }
 function recover() {
   record(`start pid=${String(process.pid)}`);
+  const onStdioError = (err) => {
+    if (isTerminalGone(err)) {
+      exitForTerminalGone("stdio", err);
+    }
+    throw err;
+  };
+  process.stdout.on("error", onStdioError);
+  process.stderr.on("error", onStdioError);
   process.on("uncaughtException", (err) => {
+    if (isTerminalGone(err)) {
+      exitForTerminalGone("uncaught exception", err);
+    }
     recordError("uncaught exception", err);
     logger.fatal({ err }, "uncaught exception");
-    process.exit(1);
+    captureTelemetryError(err, "uncaught exception");
+    void shutdownTelemetry().finally(() => {
+      process.exit(1);
+    });
   });
   process.on("unhandledRejection", (reason) => {
+    if (isTerminalGone(reason)) {
+      exitForTerminalGone("unhandled rejection", reason);
+    }
     recordError("unhandled rejection", reason);
     logger.fatal({ err: reason }, "unhandled rejection");
-    process.exit(1);
+    captureTelemetryError(reason, "unhandled rejection");
+    void shutdownTelemetry().finally(() => {
+      process.exit(1);
+    });
   });
   process.on("exit", (code) => {
     closeLogger();
@@ -14005,7 +14511,7 @@ function parseTeammateFlags(args) {
 }
 var ShutdownPrefix = "[shutdown]";
 var LeadName = "lead";
-var log38 = createChildLogger({ module: "teammate" });
+var log39 = createChildLogger({ module: "teammate" });
 function isShutdownRequest2(msg) {
   return msg.text.trimStart().startsWith(ShutdownPrefix);
 }
@@ -14050,13 +14556,13 @@ async function buildTeammateRegistry(opts) {
         }
       }
       for (const { serverName, error } of result.errors) {
-        log38.error({ serverName, error }, "MCP connection error");
+        log39.error({ serverName, error }, "MCP connection error");
       }
       if (result.tools.length > 0 && opts.contextWindow) {
         decideAndApply(registry, opts.baseUrl ?? "", opts.contextWindow);
       }
     } catch (err) {
-      log38.error({ err }, "MCP setup failed");
+      log39.error({ err }, "MCP setup failed");
     }
   }
   return registry;
@@ -14135,7 +14641,7 @@ ${body}`);
           console.log("--- Task complete ---");
           break;
         case "error":
-          log38.error({ err: event.error }, "agent error");
+          log39.error({ err: event.error }, "agent error");
           throw event.error;
       }
     }
@@ -14153,7 +14659,7 @@ ${body}`);
         if (event.type === "stream_text") {
           process.stdout.write(event.text);
         } else if (event.type === "error") {
-          log38.error({ err: event.error }, "agent error");
+          log39.error({ err: event.error }, "agent error");
           throw event.error;
         }
       }
@@ -14164,7 +14670,7 @@ ${body}`);
       try {
         await mcpManager.disconnectAll();
       } catch (err) {
-        log38.error({ err }, "MCP cleanup failed");
+        log39.error({ err }, "MCP cleanup failed");
       }
     }
     process.off("exit", closeLogger);
@@ -14173,6 +14679,7 @@ ${body}`);
 }
 export {
   ASYNC_AGENT_ALLOWED_TOOLS,
+  ActiveToolSchema,
   Agent,
   AgentEventLogger,
   AgentProgressSchema,
@@ -14223,6 +14730,7 @@ export {
   LLMError,
   ListTeamsTool,
   LoadSkillTool,
+  MACOS_SNIPPET,
   MAIN_AGENT_ONLY_TOOLS,
   MAX_DIMENSION_PX,
   MAX_HISTORY_ENTRIES,
@@ -14270,6 +14778,7 @@ export {
   SHUTDOWN_PREFIX,
   SKIP_DIRS,
   SUBAGENT_DISALLOWED_TOOLS,
+  SUBAGENT_INTERRUPTED_MARKER,
   SUMMARY_INSTRUCTIONS,
   SeatbeltSandbox,
   SendMessageTool,
@@ -14304,6 +14813,10 @@ export {
   ToolActivitySchema,
   ToolRegistry,
   ToolSearchTool,
+  WEB_FETCH_DESCRIPTION,
+  WINDOWS_CSHARP_SNIPPET,
+  WINDOWS_PWSH_INCLUDES_CSHARP_SNIPPET,
+  WINDOWS_PWSH_SNIPPET,
   WRITE_FILE_DESCRIPTION,
   WebSocketTransport,
   WriteFileTool,
@@ -14340,10 +14853,12 @@ export {
   canonicalPath,
   clampThinkingLevel,
   cleanExpiredSessions,
+  clearActiveTools,
   clipboardImageFileName,
   cloneRegistryForFork,
   closeLogger,
   coerceBySchema,
+  compactPath,
   computeCompactThreshold,
   computeKeepStartIndex,
   connectToIde,
@@ -14390,6 +14905,7 @@ export {
   filterToolsForAgent,
   forceCompact,
   forkEnabled,
+  formatAgentTaskNotification,
   formatInteractionSummary,
   formatShellOutput,
   formatTokens,
@@ -14423,9 +14939,11 @@ export {
   isSafeCommand,
   isShutdownRequest,
   isSpillReadback,
+  isTerminalGone,
   isToolResultContentBlock,
   isValidThinkingLevel,
   listSessions,
+  listTeamNames,
   load,
   loadAgentDefinitions,
   loadConfig,
@@ -14474,7 +14992,10 @@ export {
   recordError,
   recordExit,
   recordTokens,
+  recordToolResult,
+  recordToolStart,
   recordToolUse,
+  recordTurnComplete,
   recover,
   removeAgentWorktree,
   removeMcpTools,