@swifty.js/swifty 0.0.30 → 0.0.31

package/dist/lib/index.js

@@ -38,7 +38,7 @@ import {
   toDisplayPreview,
   toolResultsToRecords,
   toolUsesToRecords
-} from "./chunk-OOSNCCI7.js";
+} from "./chunk-J6AV7SIF.js";
 import {
   AnthropicClient,
   CHARS_PER_TOKEN,
@@ -55,18 +55,18 @@ import {
   markToolsForCache,
   measureSchemaChars,
   needsToolSearchBeta
-} from "./chunk-IYPTOY3Y.js";
+} from "./chunk-4MDCRPVV.js";
 import {
   SKIP_DIRS,
   isToolResultContentBlock,
   normalizeToolResultContentBlock
-} from "./chunk-PIL7M52F.js";
+} from "./chunk-XT67KGWE.js";
 import {
   OpenAIClient,
   OpenAICompatClient,
   buildChatCompletionMessages,
   buildOpenAIInput
-} from "./chunk-I7OPU4K2.js";
+} from "./chunk-OEPCNATU.js";
 import {
   AuthenticationError,
   ConfigError,
@@ -110,7 +110,7 @@ import {
   extractContent,
   isPathWithin,
   isSafeCommand
-} from "./chunk-RMB3J46W.js";
+} from "./chunk-A4MXZA5Q.js";
 import {
   MCPToolWrapper,
   MCP_NAME_SEP,
@@ -122,7 +122,7 @@ import {
   mcpCallPermissionContent,
   mcpToolNamePrefix,
   sanitizeSegment
-} from "./chunk-KG4MJGKQ.js";
+} from "./chunk-FZ4Y6MBN.js";
 import {
   asError,
   asErrorString,
@@ -148,16 +148,13 @@ import {
   ASYNC_AGENT_ALLOWED_TOOLS,
   CUSTOM_AGENT_DISALLOWED_TOOLS,
   FORK_QUERY_SOURCE,
+  MAIN_AGENT_ONLY_TOOLS,
   SUBAGENT_DISALLOWED_TOOLS,
   TEAMMATE_DISALLOWED_TOOLS,
   ToolRegistry,
   cloneRegistryForFork,
   filterToolsForAgent
-} from "./chunk-7QPDFSQE.js";
-import {
-  MCP_CALL_TOOL_NAME,
-  TOOL_SEARCH_TOOL_NAME
-} from "./chunk-GHF2PSEW.js";
+} from "./chunk-EWE5IWZE.js";
 import {
   BwrapSandbox
 } from "./chunk-ORSYNBMM.js";
@@ -1265,7 +1262,7 @@ function createDefaultRegistry() {
         }
         return detail;
       }
-      const cmds = registry.listCommands();
+      const cmds = registry.listCommands().filter((c) => !c.isSkill);
       let output = "Available commands:\n\n";
       output += cmds.map((c) => {
         const aliases = c.aliases.length > 0 ? `, /${c.aliases.join(", /")}` : "";
@@ -2645,15 +2642,15 @@ async function saveClipboardImage(workDir, sessionId) {
 async function createClient(config, systemPrompt) {
   switch (config.protocol) {
     case "anthropic": {
-      const { AnthropicClient: AnthropicClient2 } = await import("./anthropic-CL5IK7KN.js");
+      const { AnthropicClient: AnthropicClient2 } = await import("./anthropic-R6DMXE7U.js");
       return new AnthropicClient2(config, systemPrompt);
     }
     case "openai": {
-      const { OpenAIClient: OpenAIClient2 } = await import("./openai-LH4E7ZQS.js");
+      const { OpenAIClient: OpenAIClient2 } = await import("./openai-5N42ZYIJ.js");
       return new OpenAIClient2(config, systemPrompt);
     }
     case "openai-compat": {
-      const { OpenAICompatClient: OpenAICompatClient2 } = await import("./openai-LH4E7ZQS.js");
+      const { OpenAICompatClient: OpenAICompatClient2 } = await import("./openai-5N42ZYIJ.js");
       return new OpenAICompatClient2(config, systemPrompt);
     }
     default:
@@ -2702,7 +2699,7 @@ var PackageJsonSchema = z5.object({
 });
 function resolveVersion() {
   if (true) {
-    return "0.0.30";
+    return "0.0.31";
   }
   const here = path.dirname(fileURLToPath(import.meta.url));
   for (const levels of ["..", "../.."]) {
@@ -2816,7 +2813,10 @@ var MCPClient = class {
       const opts = {
         requestInit: { headers }
       };
-      this.transport = this.config.transport === "sse" ? new SSEClientTransport(url, opts) : new StreamableHTTPClientTransport(url, opts);
+      this.transport = this.config.transport === "sse" ? (
+        // eslint-disable-next-line @typescript-eslint/no-deprecated
+        new SSEClientTransport(url, opts)
+      ) : new StreamableHTTPClientTransport(url, opts);
     } else {
       throw new Error(
         `MCP server '${this.name}': needs either 'command' (stdio) or 'url' (http/sse)`
@@ -2945,9 +2945,63 @@ import {
 import { homedir as homedir3 } from "os";
 import { join as join12, basename as basename3 } from "path";
 
+// src/memory/permissions.ts
+import { homedir as homedir2 } from "os";
+import { extname as extname2, join as join8, resolve as resolve2 } from "path";
+var MemoryPermissionChecker = class extends PermissionChecker {
+  constructor(memoryWorkDir, allowProjectReads = false) {
+    super(memoryWorkDir, "default");
+    this.memoryWorkDir = memoryWorkDir;
+    this.allowProjectReads = allowProjectReads;
+    this.memoryRoots = [
+      join8(memoryWorkDir, ".swifty", "memory"),
+      join8(homedir2(), ".swifty", "memory")
+    ];
+  }
+  memoryWorkDir;
+  allowProjectReads;
+  memoryRoots;
+  check(_name, category, args) {
+    const requested = args.file_path ?? args.path ?? this.memoryWorkDir;
+    if (category === "command" || typeof requested !== "string") {
+      return {
+        effect: "deny",
+        reason: "Background memory tasks only support scoped file operations"
+      };
+    }
+    const path2 = canonicalPath(resolve2(this.memoryWorkDir, requested));
+    const insideMemory = this.memoryRoots.some((root) => isPathWithin(canonicalPath(root), path2));
+    if (category === "write") {
+      return insideMemory && extname2(path2) === ".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" };
+  }
+};
+
+// src/memory/written-paths.ts
+function extractWrittenPaths(messages) {
+  const successful = new Set(
+    messages.flatMap(
+      (message) => (message.toolResults ?? []).filter((result) => !result.isError).map((result) => result.toolUseId)
+    )
+  );
+  const paths = /* @__PURE__ */ new Set();
+  for (const message of messages) {
+    for (const tool of message.toolUses ?? []) {
+      if ((tool.toolName === "WriteFile" || tool.toolName === "EditFile") && successful.has(tool.toolUseId) && typeof tool.arguments.file_path === "string") {
+        paths.add(tool.arguments.file_path);
+      }
+    }
+  }
+  return [...paths];
+}
+
 // src/tools/edit-file.ts
 import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
-import { resolve as resolve3 } from "path";
+import { resolve as resolve4 } from "path";
 
 // src/tools/descriptions.ts
 var GIT_GUIDANCE = `Git: commit or push only when requested. Destructive operations (push --force, reset --hard, checkout ., clean -f, branch -D), amending, or skipping hooks/signing require explicit authorization; never bypass permission/hook denials. Prefer new commits. When committing, include Co-Authored-By: Swifty <usr161043261@outlook.com>.`;
@@ -3044,15 +3098,15 @@ function buildDiff(oldContent, newContent) {
 
 // src/tools/file-mutation-queue.ts
 import { realpath } from "fs/promises";
-import { basename, dirname as dirname2, join as join8, resolve as resolve2 } from "path";
+import { basename, dirname as dirname2, join as join9, resolve as resolve3 } from "path";
 var queues = /* @__PURE__ */ new Map();
 async function canonicalPath2(filePath) {
-  const absolutePath = resolve2(filePath);
+  const absolutePath = resolve3(filePath);
   try {
     return await realpath(absolutePath);
   } catch {
     try {
-      return join8(await realpath(dirname2(absolutePath)), basename(absolutePath));
+      return join9(await realpath(dirname2(absolutePath)), basename(absolutePath));
     } catch {
       return absolutePath;
     }
@@ -3125,7 +3179,7 @@ var EditFileTool = class {
         isError: true
       };
     }
-    const filePath = resolve3(ctx.workDir, requestedPath);
+    const filePath = resolve4(ctx.workDir, requestedPath);
     if (!oldString) {
       return {
         output: "Error: old_string is required",
@@ -3259,7 +3313,7 @@ var FileStateCache = class {
 
 // src/tools/glob.ts
 import { statSync as statSync5 } from "fs";
-import { join as join9, resolve as resolve4 } from "path";
+import { join as join10, resolve as resolve5 } from "path";
 import { globIterate } from "glob";
 var log15 = createChildLogger({ module: "tools" });
 var IGNORE = [...SKIP_DIRS].map((dir) => `**/${dir}/**`);
@@ -3300,7 +3354,7 @@ var GlobTool = class {
         isError: true
       };
     }
-    const basePath = resolve4(ctx.workDir, strArg(args, "path", ctx.workDir));
+    const basePath = resolve5(ctx.workDir, strArg(args, "path", ctx.workDir));
     if (!statSync5(basePath, { throwIfNoEntry: false })?.isDirectory()) {
       return {
         output: `Error: not a directory, scan '${basePath}'`,
@@ -3334,7 +3388,7 @@ var GlobTool = class {
       for (const match of matches) {
         let mtime = 0;
         try {
-          mtime = statSync5(join9(basePath, match)).mtimeMs;
+          mtime = statSync5(join10(basePath, match)).mtimeMs;
         } catch {
         }
         mtimes.set(match, mtime);
@@ -3361,7 +3415,7 @@ var GlobTool = class {
 
 // src/tools/grep.ts
 import { lstat, readdir, readFile as readFile3, stat } from "fs/promises";
-import { join as join10, relative, resolve as resolve5, sep } from "path";
+import { join as join11, relative, resolve as resolve6, sep } from "path";
 import { Minimatch } from "minimatch";
 var log16 = createChildLogger({ module: "tools" });
 var MAX_RESULTS = 500;
@@ -3448,7 +3502,7 @@ var GrepTool = class {
         isError: true
       };
     }
-    const searchPath = resolve5(ctx.workDir, strArg(args, "path", ctx.workDir));
+    const searchPath = resolve6(ctx.workDir, strArg(args, "path", ctx.workDir));
     const include = strArg(args, "include");
     let regex;
     try {
@@ -3485,7 +3539,7 @@ var GrepTool = class {
         if (SKIP_DIRS.has(entry)) {
           continue;
         }
-        const fullPath = join10(dir, entry);
+        const fullPath = join11(dir, entry);
         let fileStat;
         try {
           fileStat = await lstat(fullPath);
@@ -3555,7 +3609,7 @@ var GrepTool = class {
 
 // src/tools/read-file.ts
 import { existsSync as existsSync6, readFileSync as readFileSync9, statSync as statSync6 } from "fs";
-import { basename as basename2, resolve as resolve6 } from "path";
+import { basename as basename2, resolve as resolve7 } from "path";
 
 // src/tools/shell-output.ts
 var MAX_SHELL_OUTPUT_BYTES = 10 * 1024 * 1024;
@@ -3644,7 +3698,7 @@ var ReadFileTool = class {
         isError: true
       });
     }
-    const filePath = resolve6(ctx.workDir, requestedPath);
+    const filePath = resolve7(ctx.workDir, requestedPath);
     if (!existsSync6(filePath)) {
       return Promise.resolve({
         output: `Error: file not found: ${filePath}`,
@@ -3767,7 +3821,7 @@ var ReadFileTool = class {
 
 // src/tools/write-file.ts
 import { existsSync as existsSync7, mkdirSync as mkdirSync5, writeFileSync as writeFileSync5 } from "fs";
-import { dirname as dirname3, resolve as resolve7 } from "path";
+import { dirname as dirname3, resolve as resolve8 } from "path";
 var log18 = createChildLogger({ module: "tools" });
 var WriteFileTool = class {
   // Use a hardcoded string instead of WriteFileTool.name.replace("Tool", "")
@@ -3812,10 +3866,13 @@ var WriteFileTool = class {
       });
     }
     const content = args.content;
-    const filePath = resolve7(ctx.workDir, requestedPath);
+    const filePath = resolve8(ctx.workDir, requestedPath);
     return withFileMutationQueue(filePath, () => {
       if (ctx.abortSignal?.aborted) {
-        return Promise.resolve({ output: "Error: operation interrupted", isError: true });
+        return Promise.resolve({
+          output: "Error: operation interrupted",
+          isError: true
+        });
       }
       if (ctx.fileStateCache && (existsSync7(filePath) || ctx.fileStateCache.has(filePath))) {
         const gate = ctx.fileStateCache.check(filePath);
@@ -3844,60 +3901,6 @@ var WriteFileTool = class {
   }
 };
 
-// src/memory/permissions.ts
-import { homedir as homedir2 } from "os";
-import { extname as extname2, join as join11, resolve as resolve8 } from "path";
-var MemoryPermissionChecker = class extends PermissionChecker {
-  constructor(memoryWorkDir, allowProjectReads = false) {
-    super(memoryWorkDir, "default");
-    this.memoryWorkDir = memoryWorkDir;
-    this.allowProjectReads = allowProjectReads;
-    this.memoryRoots = [
-      join11(memoryWorkDir, ".swifty", "memory"),
-      join11(homedir2(), ".swifty", "memory")
-    ];
-  }
-  memoryWorkDir;
-  allowProjectReads;
-  memoryRoots;
-  check(_name, category, args) {
-    const requested = args.file_path ?? args.path ?? this.memoryWorkDir;
-    if (category === "command" || typeof requested !== "string") {
-      return {
-        effect: "deny",
-        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));
-    if (category === "write") {
-      return insideMemory && extname2(path2) === ".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" };
-  }
-};
-
-// src/memory/written-paths.ts
-function extractWrittenPaths(messages) {
-  const successful = new Set(
-    messages.flatMap(
-      (message) => (message.toolResults ?? []).filter((result) => !result.isError).map((result) => result.toolUseId)
-    )
-  );
-  const paths = /* @__PURE__ */ new Set();
-  for (const message of messages) {
-    for (const tool of message.toolUses ?? []) {
-      if ((tool.toolName === "WriteFile" || tool.toolName === "EditFile") && successful.has(tool.toolUseId) && typeof tool.arguments.file_path === "string") {
-        paths.add(tool.arguments.file_path);
-      }
-    }
-  }
-  return [...paths];
-}
-
 // src/memory/consolidation.ts
 var log19 = createChildLogger({ module: "memory" });
 var DEFAULT_MIN_HOURS = 24;
@@ -5117,6 +5120,113 @@ function buildSystemPrompt(env) {
 // src/subagent/agent-tool.ts
 import { randomBytes as randomBytes2 } from "crypto";
 
+// src/subagent/loader.ts
+import { readdirSync as readdirSync4, readFileSync as readFileSync14, existsSync as existsSync12 } from "fs";
+import { homedir as homedir7 } from "os";
+import { join as join16 } from "path";
+import yaml4 from "js-yaml";
+import z7, { parse as parse5 } from "zod";
+
+// src/subagent/definition.ts
+var BUILTIN_AGENTS = [
+  {
+    name: "general-purpose",
+    description: "General-purpose agent for researching complex questions, exploring codebase, and executing multi-step tasks."
+  },
+  {
+    name: "plan",
+    description: "Investigate the existing architecture and propose a concrete implementation plan with relevant files, constraints, and verification steps. Read-only: do not create, edit, or delete files. Return unresolved questions to the parent agent.",
+    disallowedTools: ["EditFile", "WriteFile"],
+    permissionMode: "plan"
+  },
+  {
+    name: "explore",
+    description: "Find code, trace relevant call paths, and report evidence with file paths and line numbers. Use Glob, Grep, ReadFile, and read-only shell commands. Do not modify files; return missing context or blockers to the parent agent.",
+    disallowedTools: ["EditFile", "WriteFile"],
+    permissionMode: "plan",
+    model: "haiku"
+  }
+];
+
+// src/subagent/loader.ts
+var log23 = createChildLogger({ module: "subagent" });
+function loadAgentDefinitions(workDir) {
+  const definitions = [...BUILTIN_AGENTS];
+  const home = homedir7();
+  if (home) {
+    loadDir(join16(home, ".swifty", "agents"), definitions);
+  }
+  const dirs = [join16(workDir, ".swifty", "agents")];
+  for (const dir of dirs) {
+    loadDir(dir, definitions);
+  }
+  return definitions;
+}
+function loadDir(dir, definitions) {
+  if (!existsSync12(dir)) {
+    return;
+  }
+  const files = readdirSync4(dir).filter((f) => f.endsWith(".md"));
+  for (const file of files) {
+    try {
+      const content = readFileSync14(join16(dir, file), "utf-8");
+      const def = parseAgentDefinition(content);
+      if (def) {
+        const existing = definitions.findIndex((d) => d.name === def.name);
+        if (existing >= 0) {
+          definitions[existing] = def;
+        } else {
+          definitions.push(def);
+        }
+      }
+    } catch (err) {
+      log23.error({ err }, "subagent operation failed");
+      continue;
+    }
+  }
+}
+var YamlFrontmatterSchema2 = z7.looseObject({
+  name: z7.string(),
+  description: z7.string().optional(),
+  tools: z7.array(z7.string()).optional(),
+  disallowed_tools: z7.array(z7.string()).optional(),
+  system_prompt: z7.string().optional(),
+  max_turns: z7.number().optional(),
+  model: z7.string().optional(),
+  background: z7.boolean().optional(),
+  isolation: z7.literal("worktree").optional()
+});
+function parseAgentDefinition(content) {
+  if (!content.startsWith("---")) {
+    return null;
+  }
+  const endIdx = content.indexOf("---", 3);
+  if (endIdx === -1) {
+    return null;
+  }
+  const frontmatter = content.slice(3, endIdx).trim();
+  const body = content.slice(endIdx + 3).trim();
+  try {
+    const raw = yaml4.load(frontmatter);
+    const parsed = parse5(YamlFrontmatterSchema2, raw);
+    return {
+      name: parsed.name,
+      description: parsed.description ?? body.slice(0, 200),
+      tools: parsed.tools,
+      disallowedTools: parsed.disallowed_tools,
+      systemPromptOverride: parsed.system_prompt,
+      maxTurns: parsed.max_turns,
+      model: parsed.model,
+      background: parsed.background,
+      isolation: parsed.isolation,
+      initialPrompt: body
+    };
+  } catch (err) {
+    log23.error({ err }, "subagent operation failed");
+    return null;
+  }
+}
+
 // src/teams/task-tools.ts
 var VALID_STATUSES = /* @__PURE__ */ new Set(["pending", "in_progress", "completed", "blocked"]);
 var TaskCreateTool = class {
@@ -5503,7 +5613,7 @@ function getNameRegistry() {
 }
 
 // src/teams/tools.ts
-var log23 = createChildLogger({ module: "teams" });
+var log24 = createChildLogger({ module: "teams" });
 var TeamCreateTool = class {
   constructor(mgr) {
     this.mgr = mgr;
@@ -5728,7 +5838,7 @@ var SendMessageTool = class {
     try {
       await t.sendMessage(this.senderName, recipient, message);
     } catch (err) {
-      log23.error({ err }, "teams operation failed");
+      log24.error({ err }, "teams operation failed");
       return {
         output: `Error: ${asErrorString(err)}`,
         isError: true
@@ -5808,9 +5918,9 @@ var TeamDeleteTool = class {
 // src/worktree/worktree.ts
 import { execFile } from "child_process";
 import { access, cp, mkdir as mkdir2, readFile as readFile4, realpath as realpath2, stat as stat2, symlink } from "fs/promises";
-import { dirname as dirname5, isAbsolute as isAbsolute3, join as join16 } from "path";
+import { dirname as dirname5, isAbsolute as isAbsolute3, join as join17 } from "path";
 import { promisify } from "util";
-var log24 = createChildLogger({ module: "worktree" });
+var log25 = createChildLogger({ module: "worktree" });
 var execFileAsync = promisify(execFile);
 var SAFE_REF_RE = /^[a-zA-Z0-9/._+@-]+$/;
 var SHA_RE = /^[0-9a-f]{40}([0-9a-f]{24})?$/;
@@ -5834,12 +5944,12 @@ async function pathExists(path2) {
     await access(path2);
     return true;
   } catch (err) {
-    log24.error({ err }, "worktree operation failed");
+    log25.error({ err }, "worktree operation failed");
     return false;
   }
 }
 async function resolveGitDir(root) {
-  const gitPath = join16(root, ".git");
+  const gitPath = join17(root, ".git");
   if (!await pathExists(gitPath)) {
     return "";
   }
@@ -5852,24 +5962,24 @@ async function resolveGitDir(root) {
     return "";
   }
   const rel = raw.slice("gitdir:".length).trim();
-  return isAbsolute3(rel) ? rel : join16(root, rel);
+  return isAbsolute3(rel) ? rel : join17(root, rel);
 }
 async function getCommonDir(gitDir) {
   try {
-    const commonDir = join16(gitDir, "commondir");
+    const commonDir = join17(gitDir, "commondir");
     const raw = (await readFile4(commonDir, "utf-8")).trim();
-    return isAbsolute3(raw) ? raw : join16(gitDir, raw);
+    return isAbsolute3(raw) ? raw : join17(gitDir, raw);
   } catch (err) {
-    log24.error({ err }, "worktree operation failed");
+    log25.error({ err }, "worktree operation failed");
     return "";
   }
 }
 async function readGitHead(gitDir) {
   let raw;
   try {
-    raw = (await readFile4(join16(gitDir, "HEAD"), "utf-8")).trim();
+    raw = (await readFile4(join17(gitDir, "HEAD"), "utf-8")).trim();
   } catch (err) {
-    log24.error({ err }, "worktree operation failed");
+    log25.error({ err }, "worktree operation failed");
     return null;
   }
   if (raw.startsWith("ref:")) {
@@ -5894,7 +6004,7 @@ async function readGitHead(gitDir) {
 }
 async function resolveRefInDir(dir, ref) {
   try {
-    const content = (await readFile4(join16(dir, ref), "utf-8")).trim();
+    const content = (await readFile4(join17(dir, ref), "utf-8")).trim();
     if (content.startsWith("ref:")) {
       const target = content.slice("ref:".length).trim();
       if (!isSafeRefName(target)) {
@@ -5907,10 +6017,10 @@ async function resolveRefInDir(dir, ref) {
     }
     return "";
   } catch (err) {
-    log24.error({ err }, "worktree operation failed");
+    log25.error({ err }, "worktree operation failed");
   }
   try {
-    const packed = await readFile4(join16(dir, "packed-refs"), "utf-8");
+    const packed = await readFile4(join17(dir, "packed-refs"), "utf-8");
     for (const line of packed.split("\n")) {
       if (!line || line.startsWith("#") || line.startsWith("^")) {
         continue;
@@ -5928,7 +6038,7 @@ async function resolveRefInDir(dir, ref) {
       }
     }
   } catch (err) {
-    log24.error({ err }, "worktree operation failed");
+    log25.error({ err }, "worktree operation failed");
   }
   return "";
 }
@@ -5946,16 +6056,16 @@ async function resolveRef(gitDir, ref) {
 async function readWorktreeHeadSha(worktreePath) {
   let raw;
   try {
-    raw = (await readFile4(join16(worktreePath, ".git"), "utf-8")).trim();
+    raw = (await readFile4(join17(worktreePath, ".git"), "utf-8")).trim();
   } catch (err) {
-    log24.error({ err }, "worktree operation failed");
+    log25.error({ err }, "worktree operation failed");
     return "";
   }
   if (!raw.startsWith("gitdir:")) {
     return "";
   }
   const rel = raw.slice("gitdir:".length).trim();
-  const gitDir = isAbsolute3(rel) ? rel : join16(worktreePath, rel);
+  const gitDir = isAbsolute3(rel) ? rel : join17(worktreePath, rel);
   const head = await readGitHead(gitDir);
   if (!head) {
     return "";
@@ -5981,7 +6091,7 @@ async function createAgentWorktree(slug, gitRoot) {
     throw new Error("Invalid worktree slug: use only alphanumeric, hyphen, underscore");
   }
   const root = gitRoot ?? (await execFileAsync("git", ["rev-parse", "--show-toplevel"])).stdout.trim();
-  const worktreeDir = join16(root, ".swifty", "worktrees", slug);
+  const worktreeDir = join17(root, ".swifty", "worktrees", slug);
   const branch = `worktree-${slug}`;
   if (await pathExists(worktreeDir)) {
     const { stdout: topLevel } = await execFileAsync("git", ["rev-parse", "--show-toplevel"], {
@@ -6029,7 +6139,9 @@ async function createAgentWorktree(slug, gitRoot) {
   };
 }
 async function removeAgentWorktree(path2, branch, gitRoot) {
-  await execFileAsync("git", ["worktree", "remove", "--", path2], { cwd: gitRoot });
+  await execFileAsync("git", ["worktree", "remove", "--", path2], {
+    cwd: gitRoot
+  });
   await execFileAsync("git", ["branch", "-d", "--", branch], { cwd: gitRoot });
 }
 async function hasWorktreeChanges(path2, headCommit) {
@@ -6043,7 +6155,7 @@ async function hasWorktreeChanges(path2, headCommit) {
     const currentHead = await readWorktreeHeadSha(path2) || (await execFileAsync("git", ["rev-parse", "HEAD"], { cwd: path2 })).stdout.trim();
     return currentHead !== headCommit;
   } catch (err) {
-    log24.error({ err }, "worktree operation failed");
+    log25.error({ err }, "worktree operation failed");
     return true;
   }
 }
@@ -6062,56 +6174,56 @@ async function performPostCreationSetup(repoRoot, wtPath) {
 var SHARED_SWIFTY_ENTRIES = ["permissions.yaml", "agents", "memory"];
 var SHARED_AGENTS_ENTRIES = ["AGENTS.md", "skills"];
 async function copySwiftySettings(repoRoot, wtPath) {
-  const swiftyDir = join16(repoRoot, ".swifty");
+  const swiftyDir = join17(repoRoot, ".swifty");
   if (!await pathExists(swiftyDir)) {
     return;
   }
-  const dstRoot = join16(wtPath, ".swifty");
+  const dstRoot = join17(wtPath, ".swifty");
   try {
     await mkdir2(dstRoot, { recursive: true });
   } catch (err) {
-    log24.error({ err }, "failed to create .swifty/ in worktree");
+    log25.error({ err }, "failed to create .swifty/ in worktree");
     return;
   }
   for (const entry of SHARED_SWIFTY_ENTRIES) {
-    const src = join16(swiftyDir, entry);
+    const src = join17(swiftyDir, entry);
     if (!await pathExists(src)) {
       continue;
     }
     try {
-      await cp(src, join16(dstRoot, entry), { recursive: true });
+      await cp(src, join17(dstRoot, entry), { recursive: true });
     } catch (err) {
-      log24.error({ err, entry }, "failed to copy .swifty/ entry to worktree");
+      log25.error({ err, entry }, "failed to copy .swifty/ entry to worktree");
     }
   }
 }
 async function copyAgentsSettings(repoRoot, wtPath) {
-  const agentsDir = join16(repoRoot, ".agents");
+  const agentsDir = join17(repoRoot, ".agents");
   if (!await pathExists(agentsDir)) {
     return;
   }
-  const dstRoot = join16(wtPath, ".agents");
+  const dstRoot = join17(wtPath, ".agents");
   try {
     await mkdir2(dstRoot, { recursive: true });
   } catch (err) {
-    log24.error({ err }, "failed to create .agents in worktree");
+    log25.error({ err }, "failed to create .agents in worktree");
     return;
   }
   for (const entry of SHARED_AGENTS_ENTRIES) {
-    const src = join16(agentsDir, entry);
+    const src = join17(agentsDir, entry);
     if (!await pathExists(src)) {
       continue;
     }
     try {
-      await cp(src, join16(dstRoot, entry), { recursive: true });
+      await cp(src, join17(dstRoot, entry), { recursive: true });
     } catch (err) {
-      log24.error({ err, entry }, "failed to copy .agents/ entry to worktree");
+      log25.error({ err, entry }, "failed to copy .agents/ entry to worktree");
     }
   }
 }
 async function configureHooksPath(repoRoot, worktreePath) {
   try {
-    const candidates = [join16(repoRoot, ".husky"), join16(repoRoot, ".git", "hooks")];
+    const candidates = [join17(repoRoot, ".husky"), join17(repoRoot, ".git", "hooks")];
     let hooksPath;
     for (const c of candidates) {
       try {
@@ -6121,7 +6233,7 @@ async function configureHooksPath(repoRoot, worktreePath) {
           break;
         }
       } catch (err) {
-        log24.error({ err }, "worktree operation failed");
+        log25.error({ err }, "worktree operation failed");
       }
     }
     if (!hooksPath) {
@@ -6131,27 +6243,27 @@ async function configureHooksPath(repoRoot, worktreePath) {
       cwd: worktreePath
     });
   } catch (err) {
-    log24.error({ err }, "failed to configure hooks path in worktree");
+    log25.error({ err }, "failed to configure hooks path in worktree");
   }
 }
 async function symlinkNodeModules(repoRoot, worktreePath) {
   try {
-    const src = join16(repoRoot, "node_modules");
+    const src = join17(repoRoot, "node_modules");
     if (!await pathExists(src)) {
       return;
     }
-    const dst = join16(worktreePath, "node_modules");
+    const dst = join17(worktreePath, "node_modules");
     if (await pathExists(dst)) {
       return;
     }
     await symlink(src, dst);
   } catch (err) {
-    log24.warn({ err }, "failed to symlink node_modules in worktree");
+    log25.warn({ err }, "failed to symlink node_modules in worktree");
   }
 }
 async function copyWorktreeIncludeFiles(repoRoot, worktreePath) {
   try {
-    const includeFile = join16(repoRoot, ".worktreeinclude");
+    const includeFile = join17(repoRoot, ".worktreeinclude");
     if (!await pathExists(includeFile)) {
       return;
     }
@@ -6162,11 +6274,11 @@ async function copyWorktreeIncludeFiles(repoRoot, worktreePath) {
         continue;
       }
       try {
-        const src = join16(repoRoot, relPath);
+        const src = join17(repoRoot, relPath);
         if (!await pathExists(src)) {
           continue;
         }
-        const dst = join16(worktreePath, relPath);
+        const dst = join17(worktreePath, relPath);
         await mkdir2(dirname5(dst), { recursive: true });
         const info = await stat2(src);
         if (info.isDirectory()) {
@@ -6175,126 +6287,19 @@ async function copyWorktreeIncludeFiles(repoRoot, worktreePath) {
           await cp(src, dst);
         }
       } catch (err) {
-        log24.error({ err }, "worktree operation failed");
+        log25.error({ err }, "worktree operation failed");
       }
     }
   } catch (err) {
-    log24.error({ err }, "failed to process .worktreeinclude");
+    log25.error({ err }, "failed to process .worktreeinclude");
   }
 }
 
-// src/subagent/loader.ts
-import { readdirSync as readdirSync4, readFileSync as readFileSync14, existsSync as existsSync12 } from "fs";
-import { homedir as homedir7 } from "os";
-import { join as join17 } from "path";
-import yaml4 from "js-yaml";
-import z7, { parse as parse5 } from "zod";
-
-// src/subagent/definition.ts
-var BUILTIN_AGENTS = [
-  {
-    name: "general-purpose",
-    description: "General-purpose agent for researching complex questions, exploring codebase, and executing multi-step tasks."
-  },
-  {
-    name: "plan",
-    description: "Investigate the existing architecture and propose a concrete implementation plan with relevant files, constraints, and verification steps. Read-only: do not create, edit, or delete files. Return unresolved questions to the parent agent.",
-    disallowedTools: ["EditFile", "WriteFile"],
-    permissionMode: "plan"
-  },
-  {
-    name: "explore",
-    description: "Find code, trace relevant call paths, and report evidence with file paths and line numbers. Use Glob, Grep, ReadFile, and read-only shell commands. Do not modify files; return missing context or blockers to the parent agent.",
-    disallowedTools: ["EditFile", "WriteFile"],
-    permissionMode: "plan",
-    model: "haiku"
-  }
-];
-
-// src/subagent/loader.ts
-var log25 = createChildLogger({ module: "subagent" });
-function loadAgentDefinitions(workDir) {
-  const definitions = [...BUILTIN_AGENTS];
-  const home = homedir7();
-  if (home) {
-    loadDir(join17(home, ".swifty", "agents"), definitions);
-  }
-  const dirs = [join17(workDir, ".swifty", "agents")];
-  for (const dir of dirs) {
-    loadDir(dir, definitions);
-  }
-  return definitions;
-}
-function loadDir(dir, definitions) {
-  if (!existsSync12(dir)) {
-    return;
-  }
-  const files = readdirSync4(dir).filter((f) => f.endsWith(".md"));
-  for (const file of files) {
-    try {
-      const content = readFileSync14(join17(dir, file), "utf-8");
-      const def = parseAgentDefinition(content);
-      if (def) {
-        const existing = definitions.findIndex((d) => d.name === def.name);
-        if (existing >= 0) {
-          definitions[existing] = def;
-        } else {
-          definitions.push(def);
-        }
-      }
-    } catch (err) {
-      log25.error({ err }, "subagent operation failed");
-      continue;
-    }
-  }
-}
-var YamlFrontmatterSchema2 = z7.looseObject({
-  name: z7.string(),
-  description: z7.string().optional(),
-  tools: z7.array(z7.string()).optional(),
-  disallowed_tools: z7.array(z7.string()).optional(),
-  system_prompt: z7.string().optional(),
-  max_turns: z7.number().optional(),
-  model: z7.string().optional(),
-  background: z7.boolean().optional(),
-  isolation: z7.literal("worktree").optional()
-});
-function parseAgentDefinition(content) {
-  if (!content.startsWith("---")) {
-    return null;
-  }
-  const endIdx = content.indexOf("---", 3);
-  if (endIdx === -1) {
-    return null;
-  }
-  const frontmatter = content.slice(3, endIdx).trim();
-  const body = content.slice(endIdx + 3).trim();
-  try {
-    const raw = yaml4.load(frontmatter);
-    const parsed = parse5(YamlFrontmatterSchema2, raw);
-    return {
-      name: parsed.name,
-      description: parsed.description ?? body.slice(0, 200),
-      tools: parsed.tools,
-      disallowedTools: parsed.disallowed_tools,
-      systemPromptOverride: parsed.system_prompt,
-      maxTurns: parsed.max_turns,
-      model: parsed.model,
-      background: parsed.background,
-      isolation: parsed.isolation,
-      initialPrompt: body
-    };
-  } catch (err) {
-    log25.error({ err }, "subagent operation failed");
-    return null;
-  }
-}
-
-// src/subagent/agent-tool.ts
-var log26 = createChildLogger({ module: "subagent" });
-var GENERAL_PURPOSE_AGENT_TYPE = "general-purpose";
-function newAgentSlug() {
-  return `agent-a${randomBytes2(4).toString("hex").slice(0, 7)}`;
+// src/subagent/agent-tool.ts
+var log26 = createChildLogger({ module: "subagent" });
+var GENERAL_PURPOSE_AGENT_TYPE = "general-purpose";
+function newAgentSlug() {
+  return `agent-a${randomBytes2(4).toString("hex").slice(0, 7)}`;
 }
 var FORK_BOILERPLATE_TAG = "<fork_boilerplate>";
 var FORK_QUERY_SOURCE2 = "agent:builtin:fork";
@@ -6588,7 +6593,7 @@ ${prompt}`;
           permissionChecker: ctx.permissionChecker?.forWorkDir(worktree.path)
         };
       }
-      const { cloneRegistryForFork: cloneRegistryForFork2 } = await import("./tool-filter-CS6W2GMU.js");
+      const { cloneRegistryForFork: cloneRegistryForFork2 } = await import("./tool-filter-XG2GXFVN.js");
       const forkedRegistry = cloneRegistryForFork2(this.registry);
       const snapshot = this.conversation.fork();
       const output = await this.forkHandler(
@@ -6808,142 +6813,6 @@ var TaskStopTool = class {
 import { mkdirSync as mkdirSync13, readFileSync as readFileSync19, rmSync } from "fs";
 import { join as join21 } from "path";
 
-// src/utils/verbs.ts
-var spinnerVerbs = [
-  "Accomplishing",
-  "Architecting",
-  "Baking",
-  "Barking",
-  "Woofing",
-  "Howling",
-  "Be-bopping'",
-  "Befuddling",
-  "Boogieing",
-  "Boondoggling",
-  "Bootstrapping",
-  "Brewing",
-  "Calculating",
-  "Canoodling",
-  "Caramelizing",
-  "Cascading",
-  "Cerebrating",
-  "Choreographing",
-  "Churning",
-  "Coalescing",
-  "Cogitating",
-  "Combobulating",
-  "Composing",
-  "Computing",
-  "Concocting",
-  "Considering",
-  "Contemplating",
-  "Cooking",
-  "Crafting",
-  "Creating",
-  "Crunching",
-  "Crystallizing",
-  "Cultivating",
-  "Deciphering",
-  "Deliberating",
-  "Dilly-dallying",
-  "Discombobulating",
-  "Doodling",
-  "Elucidating",
-  "Enchanting",
-  "Envisioning",
-  "Fermenting",
-  "Finagling",
-  "Flamb\xE9ing",
-  "Flummoxing",
-  "Forging",
-  "Frolicking",
-  "Gallivanting",
-  "Garnishing",
-  "Generating",
-  "Germinating",
-  "Grooving",
-  "Harmonizing",
-  "Hatching",
-  "Honking",
-  "Ideating",
-  "Imagining",
-  "Improvising",
-  "Incubating",
-  "Inferring",
-  "Infusing",
-  "Kneading",
-  "Lollygagging",
-  "Manifesting",
-  "Marinating",
-  "Meandering",
-  "Metamorphosing",
-  "Mewing",
-  "Moonwalking",
-  "Moseying",
-  "Mulling",
-  "Musing",
-  "Noodling",
-  "Orbiting",
-  "Orchestrating",
-  "Percolating",
-  "Philosophizing",
-  "Pondering",
-  "Pontificating",
-  "Pouncing",
-  "Purring",
-  "Puzzling",
-  "Razzle-dazzling",
-  "Ruminating",
-  "Scampering",
-  "Simmering",
-  "Sketching",
-  "Spelunking",
-  "Spinning",
-  "Sprouting",
-  "Synthesizing",
-  "Thinking",
-  "Tinkering",
-  "Transfiguring",
-  "Transmuting",
-  "Undulating",
-  "Unfurling",
-  "Unravelling",
-  "Vibing",
-  "Wandering",
-  "Whisking",
-  "Working",
-  "Wrangling",
-  "Zigzagging"
-];
-function randomVerb() {
-  return spinnerVerbs[Math.floor(Math.random() * spinnerVerbs.length)];
-}
-var completionVerbs = [
-  "Accomplished",
-  "Baked",
-  "Brewed",
-  "Cooked",
-  "Crafted",
-  "Crunched",
-  "Forged",
-  "Hatched",
-  "Pondered",
-  "Synthesized",
-  "Tinkered",
-  "Worked",
-  "Wrangled",
-  "Computed",
-  "Created",
-  "Composed",
-  "Conjured",
-  "Concocted",
-  "Cultivated",
-  "Deciphered"
-];
-function randomCompletionVerb() {
-  return completionVerbs[Math.floor(Math.random() * completionVerbs.length)];
-}
-
 // src/teams/file-mailbox.ts
 import {
   readFileSync as readFileSync15,
@@ -7493,65 +7362,201 @@ function loadTranscript(workDir, teamName, agentId) {
   }
 }
 
-// src/teams/team.ts
-var log29 = createChildLogger({ module: "teams" });
-var Team = class _Team {
-  name;
-  mode;
-  members = /* @__PURE__ */ new Map();
-  leadMailbox;
-  mailboxDir;
-  workDir;
-  // Team-level metadata for persistence
-  leadAgentId = "";
-  description;
-  createdAt = Math.floor(Date.now() / 1e3);
-  constructor(name, mode, workDir) {
-    this.name = name;
-    this.mode = mode;
-    this.workDir = workDir;
-    this.mailboxDir = join21(teamDir(name), "inboxes");
-    mkdirSync13(this.mailboxDir, { recursive: true });
-    this.leadMailbox = new FileMailbox(this.mailboxDir, "lead");
-  }
-  addMember(name) {
-    const mailbox = new FileMailbox(this.mailboxDir, name);
-    const member = {
-      name,
-      active: false,
-      mailbox,
-      agentId: name,
-      joinedAt: Math.floor(Date.now() / 1e3)
-    };
-    this.members.set(name, member);
-    this.persist();
-    return member;
-  }
-  /**
-   * Backfills member metadata (agent type, model, worktree path) and persists.
-   * The spawn flow obtains this information later than addMember, hence the two-step write.
-   */
-  setMemberMeta(name, meta) {
-    const member = this.members.get(name);
-    if (!member) {
-      return;
-    }
-    member.agentType = meta.agentType;
-    member.model = meta.model;
-    member.worktreePath = meta.worktreePath;
-    this.persist();
-  }
-  /** Exports the current state into a persistable structure. */
-  snapshot() {
-    return {
-      name: this.name,
-      description: this.description,
-      createdAt: this.createdAt,
-      leadAgentId: this.leadAgentId,
-      members: [...this.members.values()].map((m) => ({
-        agentId: m.agentId ?? m.name,
-        name: m.name,
-        agentType: m.agentType,
+// src/utils/verbs.ts
+var spinnerVerbs = [
+  "Accomplishing",
+  "Architecting",
+  "Baking",
+  "Barking",
+  "Woofing",
+  "Howling",
+  "Be-bopping'",
+  "Befuddling",
+  "Boogieing",
+  "Boondoggling",
+  "Bootstrapping",
+  "Brewing",
+  "Calculating",
+  "Canoodling",
+  "Caramelizing",
+  "Cascading",
+  "Cerebrating",
+  "Choreographing",
+  "Churning",
+  "Coalescing",
+  "Cogitating",
+  "Combobulating",
+  "Composing",
+  "Computing",
+  "Concocting",
+  "Considering",
+  "Contemplating",
+  "Cooking",
+  "Crafting",
+  "Creating",
+  "Crunching",
+  "Crystallizing",
+  "Cultivating",
+  "Deciphering",
+  "Deliberating",
+  "Dilly-dallying",
+  "Discombobulating",
+  "Doodling",
+  "Elucidating",
+  "Enchanting",
+  "Envisioning",
+  "Fermenting",
+  "Finagling",
+  "Flamb\xE9ing",
+  "Flummoxing",
+  "Forging",
+  "Frolicking",
+  "Gallivanting",
+  "Garnishing",
+  "Generating",
+  "Germinating",
+  "Grooving",
+  "Harmonizing",
+  "Hatching",
+  "Honking",
+  "Ideating",
+  "Imagining",
+  "Improvising",
+  "Incubating",
+  "Inferring",
+  "Infusing",
+  "Kneading",
+  "Lollygagging",
+  "Manifesting",
+  "Marinating",
+  "Meandering",
+  "Metamorphosing",
+  "Mewing",
+  "Moonwalking",
+  "Moseying",
+  "Mulling",
+  "Musing",
+  "Noodling",
+  "Orbiting",
+  "Orchestrating",
+  "Percolating",
+  "Philosophizing",
+  "Pondering",
+  "Pontificating",
+  "Pouncing",
+  "Purring",
+  "Puzzling",
+  "Razzle-dazzling",
+  "Ruminating",
+  "Scampering",
+  "Simmering",
+  "Sketching",
+  "Spelunking",
+  "Spinning",
+  "Sprouting",
+  "Synthesizing",
+  "Thinking",
+  "Tinkering",
+  "Transfiguring",
+  "Transmuting",
+  "Undulating",
+  "Unfurling",
+  "Unravelling",
+  "Vibing",
+  "Wandering",
+  "Whisking",
+  "Working",
+  "Wrangling",
+  "Zigzagging"
+];
+function randomVerb() {
+  return spinnerVerbs[Math.floor(Math.random() * spinnerVerbs.length)];
+}
+var completionVerbs = [
+  "Accomplished",
+  "Baked",
+  "Brewed",
+  "Cooked",
+  "Crafted",
+  "Crunched",
+  "Forged",
+  "Hatched",
+  "Pondered",
+  "Synthesized",
+  "Tinkered",
+  "Worked",
+  "Wrangled",
+  "Computed",
+  "Created",
+  "Composed",
+  "Conjured",
+  "Concocted",
+  "Cultivated",
+  "Deciphered"
+];
+function randomCompletionVerb() {
+  return completionVerbs[Math.floor(Math.random() * completionVerbs.length)];
+}
+
+// src/teams/team.ts
+var log29 = createChildLogger({ module: "teams" });
+var Team = class _Team {
+  name;
+  mode;
+  members = /* @__PURE__ */ new Map();
+  leadMailbox;
+  mailboxDir;
+  workDir;
+  // Team-level metadata for persistence
+  leadAgentId = "";
+  description;
+  createdAt = Math.floor(Date.now() / 1e3);
+  constructor(name, mode, workDir) {
+    this.name = name;
+    this.mode = mode;
+    this.workDir = workDir;
+    this.mailboxDir = join21(teamDir(name), "inboxes");
+    mkdirSync13(this.mailboxDir, { recursive: true });
+    this.leadMailbox = new FileMailbox(this.mailboxDir, "lead");
+  }
+  addMember(name) {
+    const mailbox = new FileMailbox(this.mailboxDir, name);
+    const member = {
+      name,
+      active: false,
+      mailbox,
+      agentId: name,
+      joinedAt: Math.floor(Date.now() / 1e3)
+    };
+    this.members.set(name, member);
+    this.persist();
+    return member;
+  }
+  /**
+   * Backfills member metadata (agent type, model, worktree path) and persists.
+   * The spawn flow obtains this information later than addMember, hence the two-step write.
+   */
+  setMemberMeta(name, meta) {
+    const member = this.members.get(name);
+    if (!member) {
+      return;
+    }
+    member.agentType = meta.agentType;
+    member.model = meta.model;
+    member.worktreePath = meta.worktreePath;
+    this.persist();
+  }
+  /** Exports the current state into a persistable structure. */
+  snapshot() {
+    return {
+      name: this.name,
+      description: this.description,
+      createdAt: this.createdAt,
+      leadAgentId: this.leadAgentId,
+      members: [...this.members.values()].map((m) => ({
+        agentId: m.agentId ?? m.name,
+        name: m.name,
+        agentType: m.agentType,
         model: m.model,
         joinedAt: m.joinedAt ?? 0,
         worktreePath: m.worktreePath,
@@ -7645,7 +7650,9 @@ var Team = class _Team {
     member.active = true;
     member.checker = checker;
     const abortController = new AbortController();
-    member.cancel = () => abortController.abort();
+    member.cancel = () => {
+      abortController.abort();
+    };
     getNameRegistry().register(name, name);
     const uiState = {
       name,
@@ -7966,8 +7973,8 @@ function isTeamMode(mode) {
 
 // src/tools/bash.ts
 import { spawn as spawn3 } from "child_process";
-var MAX_TIMEOUT = 600;
-var KILL_GRACE_MS = 3e3;
+
+// src/tools/exit-code-hints.ts
 function extractBaseCmd(command) {
   const lastSegment = command.split("|").pop()?.trim() ?? command;
   const tokens = lastSegment.split(/\s+/);
@@ -7975,25 +7982,233 @@ function extractBaseCmd(command) {
     if (token.includes("=") && !token.startsWith("-")) {
       continue;
     }
-    return token.split("/").pop() ?? token;
+    const base = token.split(/[\\/]/).pop() ?? token;
+    return base.replace(/\.exe$/i, "").toLowerCase();
   }
   return "";
 }
-var exitCodeHints = /* @__PURE__ */ new Map([
-  ["grep", /* @__PURE__ */ new Map([[1, "no matches found"]])],
-  ["egrep", /* @__PURE__ */ new Map([[1, "no matches found"]])],
-  ["fgrep", /* @__PURE__ */ new Map([[1, "no matches found"]])],
-  ["rg", /* @__PURE__ */ new Map([[1, "no matches found"]])],
-  ["diff", /* @__PURE__ */ new Map([[1, "files differ"]])],
-  ["test", /* @__PURE__ */ new Map([[1, "condition is false"]])],
-  ["[", /* @__PURE__ */ new Map([[1, "condition is false"]])],
-  ["find", /* @__PURE__ */ new Map([[1, "partial success"]])]
+var EXIT_CODE_HINTS = /* @__PURE__ */ new Map([
+  // Search tools: exit 1 means "no match", not failure
+  [
+    "grep",
+    /* @__PURE__ */ new Map([
+      [1, "no matches found"],
+      [2, "error while searching"]
+    ])
+  ],
+  [
+    "egrep",
+    /* @__PURE__ */ new Map([
+      [1, "no matches found"],
+      [2, "error while searching"]
+    ])
+  ],
+  [
+    "fgrep",
+    /* @__PURE__ */ new Map([
+      [1, "no matches found"],
+      [2, "error while searching"]
+    ])
+  ],
+  [
+    "zgrep",
+    /* @__PURE__ */ new Map([
+      [1, "no matches found"],
+      [2, "error while searching"]
+    ])
+  ],
+  [
+    "rg",
+    /* @__PURE__ */ new Map([
+      [1, "no matches found"],
+      [2, "error while searching"]
+    ])
+  ],
+  ["ack", /* @__PURE__ */ new Map([[1, "no matches found"]])],
+  ["ag", /* @__PURE__ */ new Map([[1, "no matches found"]])],
+  [
+    "findstr",
+    /* @__PURE__ */ new Map([
+      [1, "no matches found"],
+      [2, "error while searching"]
+    ])
+  ],
+  ["where", /* @__PURE__ */ new Map([[1, "not found"]])],
+  // Comparison / condition tools: non-zero exit is informational
+  [
+    "diff",
+    /* @__PURE__ */ new Map([
+      [1, "files differ"],
+      [2, "trouble reading files"]
+    ])
+  ],
+  [
+    "diff3",
+    /* @__PURE__ */ new Map([
+      [1, "files differ"],
+      [2, "trouble reading files"]
+    ])
+  ],
+  [
+    "sdiff",
+    /* @__PURE__ */ new Map([
+      [1, "files differ"],
+      [2, "trouble reading files"]
+    ])
+  ],
+  [
+    "cmp",
+    /* @__PURE__ */ new Map([
+      [1, "files differ"],
+      [2, "trouble reading files"]
+    ])
+  ],
+  [
+    "test",
+    /* @__PURE__ */ new Map([
+      [1, "condition is false"],
+      [2, "expression error"]
+    ])
+  ],
+  [
+    "[",
+    /* @__PURE__ */ new Map([
+      [1, "condition is false"],
+      [2, "expression error"]
+    ])
+  ],
+  [
+    "expr",
+    /* @__PURE__ */ new Map([
+      [1, "expression is null or zero"],
+      [2, "syntax error"]
+    ])
+  ],
+  ["find", /* @__PURE__ */ new Map([[1, "partial success \u2014 some inputs could not be processed"]])],
+  // Process / batch helpers
+  [
+    "xargs",
+    /* @__PURE__ */ new Map([
+      [123, "some sub-command invocations exited with 1-125"],
+      [124, "a sub-command exited with 255"]
+    ])
+  ],
+  ["timeout", /* @__PURE__ */ new Map([[124, "command timed out"]])],
+  // File / build tools
+  [
+    "ls",
+    /* @__PURE__ */ new Map([
+      [1, "minor problem (e.g. unreadable subdirectory)"],
+      [2, "serious problem (e.g. inaccessible path)"]
+    ])
+  ],
+  [
+    "tar",
+    /* @__PURE__ */ new Map([
+      [1, "some files changed or differed while archiving"],
+      [2, "fatal error"]
+    ])
+  ],
+  [
+    "make",
+    /* @__PURE__ */ new Map([
+      [1, "targets not up to date (with -q)"],
+      [2, "build failed"]
+    ])
+  ],
+  ["gcc", /* @__PURE__ */ new Map([[1, "compilation failed"]])],
+  ["clang", /* @__PURE__ */ new Map([[1, "compilation failed"]])],
+  ["tsc", /* @__PURE__ */ new Map([[1, "type errors found"]])],
+  [
+    "eslint",
+    /* @__PURE__ */ new Map([
+      [1, "lint errors found"],
+      [2, "fatal lint problem (bad config or rule crash)"]
+    ])
+  ],
+  // Test runners
+  ["jest", /* @__PURE__ */ new Map([[1, "tests failed"]])],
+  ["vitest", /* @__PURE__ */ new Map([[1, "tests failed"]])],
+  ["go", /* @__PURE__ */ new Map([[1, "build/test/vet reported problems"]])],
+  // Interpreters
+  ["node", /* @__PURE__ */ new Map([[1, "uncaught exception"]])],
+  ["python", /* @__PURE__ */ new Map([[1, "unhandled exception"]])],
+  ["python3", /* @__PURE__ */ new Map([[1, "unhandled exception"]])],
+  // Network / remote tools
+  ["git", /* @__PURE__ */ new Map([[128, "fatal error (e.g. invalid ref or not a git repository)"]])],
+  ["ssh", /* @__PURE__ */ new Map([[255, "ssh error"]])],
+  [
+    "wget",
+    /* @__PURE__ */ new Map([
+      [1, "generic error"],
+      [4, "network failure"],
+      [5, "SSL verification failed"],
+      [6, "authentication failure"],
+      [7, "protocol error"],
+      [8, "server issued an error response"]
+    ])
+  ],
+  [
+    "curl",
+    /* @__PURE__ */ new Map([
+      [6, "couldn't resolve host"],
+      [7, "failed to connect to host"],
+      [22, "HTTP error >= 400 (with -f)"],
+      [28, "operation timed out"]
+    ])
+  ],
+  [
+    "jq",
+    /* @__PURE__ */ new Map([
+      [2, "usage or system error"],
+      [3, "jq program failed to compile"],
+      [5, "no valid result was produced"]
+    ])
+  ],
+  ["ping", /* @__PURE__ */ new Map([[1, "no response received"]])],
+  [
+    "rsync",
+    /* @__PURE__ */ new Map([
+      [23, "partial transfer due to error"],
+      [24, "source files vanished before transfer"]
+    ])
+  ],
+  // Windows
+  [
+    "robocopy",
+    /* @__PURE__ */ new Map([
+      [1, "success \u2014 files copied"],
+      [2, "success \u2014 extra files or directories detected"],
+      [4, "success \u2014 mismatched files detected"],
+      [8, "some files failed to copy"],
+      [16, "serious error \u2014 no files copied"]
+    ])
+  ]
+]);
+var GENERIC_HINTS = /* @__PURE__ */ new Map([
+  [126, "command found but not executable"],
+  [127, "command not found"],
+  [129, "terminated by SIGHUP"],
+  [130, "terminated by SIGINT (Ctrl+C)"],
+  [137, "killed by SIGKILL (often OOM)"],
+  [141, "downstream consumer exited early (SIGPIPE)"],
+  [143, "terminated by SIGTERM"]
 ]);
 function exitCodeHint(command, exitCode) {
   const baseCmd = extractBaseCmd(command);
-  const hints = exitCodeHints.get(baseCmd);
-  return hints?.get(exitCode) ?? "";
+  const hint = EXIT_CODE_HINTS.get(baseCmd)?.get(exitCode) ?? GENERIC_HINTS.get(exitCode);
+  if (hint) {
+    return hint;
+  }
+  if (exitCode >= 129 && exitCode <= 159) {
+    return `terminated by signal ${String(exitCode - 128)}`;
+  }
+  return "";
 }
+
+// src/tools/bash.ts
+var MAX_TIMEOUT = 600;
+var KILL_GRACE_MS = 3e3;
 var BashTool = class {
   // Use a hardcoded string instead of BashTool.name.replace("Tool", "")
   // because class names are not stable after minification — bundlers like
@@ -8067,7 +8282,10 @@ var BashTool = class {
       actualCommand = this.sandbox.wrap(command, this.sandboxConfig);
     }
     if (ctx.abortSignal?.aborted) {
-      return Promise.resolve({ output: "Error: command interrupted", isError: true });
+      return Promise.resolve({
+        output: "Error: command interrupted",
+        isError: true
+      });
     }
     return new Promise((resolve12) => {
       let timedOut = false;
@@ -8083,161 +8301,1450 @@ var BashTool = class {
       let stderr = "";
       let total = 0;
       let outputTruncated = false;
-      const alreadyExited = () => child.exitCode !== null || child.signalCode !== null;
       const killTree = (signal) => {
         if (typeof child.pid !== "number") {
           return;
         }
-        try {
-          process.kill(-child.pid, signal);
-        } catch {
+        try {
+          process.kill(-child.pid, signal);
+        } catch {
+          try {
+            child.kill(signal);
+          } catch {
+          }
+        }
+      };
+      const terminate = () => {
+        if (terminating) {
+          return;
+        }
+        terminating = true;
+        killTree("SIGTERM");
+        escalateTimer = setTimeout(() => {
+          killTree("SIGKILL");
+          child.stdout.destroy();
+          child.stderr.destroy();
+        }, KILL_GRACE_MS);
+        escalateTimer.unref();
+      };
+      const appendChunk = (chunk, target) => {
+        if (outputTruncated) {
+          return;
+        }
+        const remaining = MAX_SHELL_OUTPUT_BYTES - total;
+        const piece = takeUtf8Prefix(chunk, remaining);
+        total += utf8ByteLength(piece);
+        if (piece.length < chunk.length) {
+          outputTruncated = true;
+          terminate();
+        }
+        if (target === "stdout") {
+          stdout += piece;
+        } else {
+          stderr += piece;
+        }
+      };
+      child.stdout.setEncoding("utf-8");
+      child.stdout.on("data", (chunk) => {
+        appendChunk(chunk, "stdout");
+      });
+      child.stderr.setEncoding("utf-8");
+      child.stderr.on("data", (chunk) => {
+        appendChunk(chunk, "stderr");
+      });
+      const onAbort = () => {
+        aborted = true;
+        terminate();
+      };
+      const timeoutTimer = setTimeout(() => {
+        timedOut = true;
+        terminate();
+      }, timeout * 1e3);
+      timeoutTimer.unref();
+      ctx.abortSignal?.addEventListener("abort", onAbort, { once: true });
+      if (ctx.abortSignal?.aborted) {
+        onAbort();
+      }
+      const cleanup = () => {
+        clearTimeout(timeoutTimer);
+        if (escalateTimer) {
+          clearTimeout(escalateTimer);
+        }
+        ctx.abortSignal?.removeEventListener("abort", onAbort);
+      };
+      child.on("error", (err) => {
+        cleanup();
+        resolve12({
+          output: `Error executing command: ${err.message}`,
+          isError: true
+        });
+      });
+      child.on("close", (code, signal) => {
+        cleanup();
+        if (aborted) {
+          const captured = stdout || stderr || outputTruncated ? formatShellOutput("$ ", command, stdout, stderr, outputTruncated) : "";
+          resolve12({
+            output: captured ? `${captured}
+Error: command interrupted` : "Error: command interrupted",
+            isError: true
+          });
+          return;
+        }
+        if (timedOut) {
+          const captured = stdout || stderr || outputTruncated ? formatShellOutput("$ ", command, stdout, stderr, outputTruncated) : "";
+          resolve12({
+            output: captured ? `${captured}
+Error: command timed out after ${String(timeout)}s` : `Error: command timed out after ${String(timeout)}s`,
+            isError: true
+          });
+          return;
+        }
+        const exitCode = code ?? 0;
+        let output = formatShellOutput("$ ", command, stdout, stderr, outputTruncated);
+        if (outputTruncated) {
+          resolve12({ output, isError: true });
+          return;
+        }
+        if (exitCode !== 0) {
+          const hint = exitCodeHint(command, exitCode);
+          output += hint ? `
+Exit code ${String(exitCode)} (${hint})` : `
+Exit code ${String(exitCode)}`;
+        }
+        if (code === null) {
+          output += `
+Process terminated${signal ? ` by ${signal}` : " unexpectedly"}`;
+        }
+        resolve12({ output, isError: exitCode !== 0 || code === null });
+      });
+    });
+  }
+};
+
+// src/tools/computer-use.ts
+import { spawn as spawn4 } from "child_process";
+import { mkdtemp, readFile as readFile5, rm as rm2, writeFile as writeFile3 } from "fs/promises";
+import { tmpdir } from "os";
+import { join as join22 } from "path";
+import { setTimeout as delay } from "timers/promises";
+import sharp2 from "sharp";
+import { safeParse as safeParse3, z as z13 } from "zod";
+
+// raw-import:/Users/user/github/swifty-code/apps/swifty/src/tools/snippets/macos.swift
+var macos_default = `import AppKit
+import ApplicationServices
+import Foundation
+
+func fail(_ message: String) -> Never {
+  FileHandle.standardError.write(Data(message.utf8))
+  exit(2)
+}
+
+guard let encoded = ProcessInfo.processInfo.environment["SWIFTY_COMPUTER_INPUT"],
+  let data = Data(base64Encoded: encoded),
+  let object = try? JSONSerialization.jsonObject(with: data),
+  let input = object as? [String: Any],
+  let action = input["action"] as? String
+else {
+  fail("Invalid computer action payload.")
+}
+
+let keyCodes: [String: CGKeyCode] = [
+  "A": 0, "S": 1, "D": 2, "F": 3, "H": 4, "G": 5, "Z": 6, "X": 7,
+  "C": 8, "V": 9, "B": 11, "Q": 12, "W": 13, "E": 14, "R": 15,
+  "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,
+  ",": 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,
+  "ALT": 58, "OPTION": 58, "CTRL": 59, "CONTROL": 59, "LEFT": 123,
+  "RIGHT": 124, "DOWN": 125, "UP": 126, "HOME": 115, "END": 119,
+  "PAGEUP": 116, "PAGEDOWN": 121, "F1": 122, "F2": 120, "F3": 99,
+  "F4": 118, "F5": 96, "F6": 97, "F7": 98, "F8": 100, "F9": 101,
+  "F10": 109, "F11": 103, "F12": 111,
+]
+
+func number(_ name: String) -> CGFloat {
+  guard let value = input[name] as? NSNumber else { fail("Missing " + name + ".") }
+  return CGFloat(value.doubleValue)
+}
+
+func keys() -> [String] {
+  return (input["keys"] as? [String] ?? []).map { $0.uppercased() }
+}
+
+func keyCode(_ name: String) -> CGKeyCode {
+  guard let code = keyCodes[name.uppercased()] else { fail("Unsupported key: " + name) }
+  return code
+}
+
+func keyEvent(_ name: String, _ down: Bool) {
+  guard let event = CGEvent(keyboardEventSource: nil, virtualKey: keyCode(name), keyDown: down)
+  else {
+    fail("Unable to create keyboard event.")
+  }
+  event.post(tap: .cghidEventTap)
+}
+
+func withKeys(_ names: [String], _ body: () -> Void) {
+  for name in names { keyEvent(name, true) }
+  body()
+  for name in names.reversed() { keyEvent(name, false) }
+}
+
+func mouseEvent(_ type: CGEventType, _ point: CGPoint, _ button: CGMouseButton, clicks: Int64 = 1) {
+  guard
+    let event = CGEvent(
+      mouseEventSource: nil, mouseType: type, mouseCursorPosition: point, mouseButton: button)
+  else {
+    fail("Unable to create mouse event.")
+  }
+  event.setIntegerValueField(.mouseEventClickState, value: clicks)
+  event.post(tap: .cghidEventTap)
+}
+
+if action == "screen_size" {
+  let bounds = CGDisplayBounds(CGMainDisplayID())
+  print("\\(Int(bounds.width)),\\(Int(bounds.height))")
+  exit(0)
+}
+
+if action == "cursor_position" {
+  guard let event = CGEvent(source: nil) else { fail("Unable to read cursor position.") }
+  print("\\(Int(event.location.x)),\\(Int(event.location.y))")
+  exit(0)
+}
+
+if !AXIsProcessTrusted() {
+  fail(
+    "Accessibility permission is required. Enable it for the terminal running Swifty in System Settings > Privacy & Security > Accessibility."
+  )
+}
+
+let point = CGPoint(
+  x: (input["x"] as? NSNumber)?.doubleValue ?? 0,
+  y: (input["y"] as? NSNumber)?.doubleValue ?? 0
+)
+let heldKeys = keys()
+
+switch action {
+case "mouse_move":
+  withKeys(heldKeys) { mouseEvent(.mouseMoved, point, .left) }
+case "left_mouse_down":
+  mouseEvent(.leftMouseDown, CGEvent(source: nil)?.location ?? point, .left)
+case "left_mouse_up":
+  mouseEvent(.leftMouseUp, CGEvent(source: nil)?.location ?? point, .left)
+case "mouse_click":
+  let buttonName = input["button"] as? String ?? "left"
+  let button: CGMouseButton =
+    buttonName == "right" ? .right : buttonName == "middle" ? .center : .left
+  let downType: CGEventType =
+    button == .right ? .rightMouseDown : button == .center ? .otherMouseDown : .leftMouseDown
+  let upType: CGEventType =
+    button == .right ? .rightMouseUp : button == .center ? .otherMouseUp : .leftMouseUp
+  let count = (input["clicks"] as? NSNumber)?.int64Value ?? 1
+  withKeys(heldKeys) {
+    mouseEvent(.mouseMoved, point, button)
+    for click in 1...count {
+      mouseEvent(downType, point, button, clicks: click)
+      mouseEvent(upType, point, button, clicks: click)
+      Thread.sleep(forTimeInterval: 0.08)
+    }
+  }
+case "left_click_drag":
+  guard let path = input["path"] as? [[String: NSNumber]], let first = path.first else {
+    fail("Drag path is missing.")
+  }
+  let start = CGPoint(x: first["x"]?.doubleValue ?? 0, y: first["y"]?.doubleValue ?? 0)
+  withKeys(heldKeys) {
+    mouseEvent(.mouseMoved, start, .left)
+    mouseEvent(.leftMouseDown, start, .left)
+    for item in path.dropFirst() {
+      let next = CGPoint(x: item["x"]?.doubleValue ?? 0, y: item["y"]?.doubleValue ?? 0)
+      mouseEvent(.leftMouseDragged, next, .left)
+      Thread.sleep(forTimeInterval: 0.02)
+    }
+    let end = path.last ?? first
+    mouseEvent(
+      .leftMouseUp, CGPoint(x: end["x"]?.doubleValue ?? 0, y: end["y"]?.doubleValue ?? 0), .left)
+  }
+case "scroll":
+  if let x = input["x"] as? NSNumber, let y = input["y"] as? NSNumber {
+    mouseEvent(.mouseMoved, CGPoint(x: x.doubleValue, y: y.doubleValue), .left)
+  }
+  let horizontal = Int32((input["scrollX"] as? NSNumber)?.intValue ?? 0)
+  let vertical = Int32((input["scrollY"] as? NSNumber)?.intValue ?? 0)
+  withKeys(heldKeys) {
+    CGEvent(
+      scrollWheelEvent2Source: nil, units: .line, wheelCount: 2, wheel1: -vertical,
+      wheel2: -horizontal, wheel3: 0)?.post(tap: .cghidEventTap)
+  }
+case "key", "hold_key":
+  let names = keys()
+  if names.isEmpty { fail("No keys supplied.") }
+  for name in names { keyEvent(name, true) }
+  if action == "hold_key" {
+    Thread.sleep(forTimeInterval: (input["duration"] as? NSNumber)?.doubleValue ?? 0)
+  }
+  for name in names.reversed() { keyEvent(name, false) }
+case "type":
+  let text = input["text"] as? String ?? ""
+  let units = Array(text.utf16)
+  units.withUnsafeBufferPointer { buffer in
+    guard let down = CGEvent(keyboardEventSource: nil, virtualKey: 0, keyDown: true),
+      let up = CGEvent(keyboardEventSource: nil, virtualKey: 0, keyDown: false)
+    else {
+      fail("Unable to create text input events.")
+    }
+    down.keyboardSetUnicodeString(stringLength: units.count, unicodeString: buffer.baseAddress)
+    up.keyboardSetUnicodeString(stringLength: units.count, unicodeString: buffer.baseAddress)
+    down.post(tap: .cghidEventTap)
+    up.post(tap: .cghidEventTap)
+  }
+default:
+  fail("Unsupported action: " + action)
+}
+`;
+
+// raw-import:/Users/user/github/swifty-code/apps/swifty/src/tools/snippets/win32-script.ps1
+var win32_script_default = `$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)"
+`;
+
+// raw-import:/Users/user/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';
+
+// raw-import:/Users/user/github/swifty-code/apps/swifty/src/tools/snippets/windows.ps1
+var windows_default2 = `$ErrorActionPreference = 'Stop'
+Add-Type -AssemblyName System.Drawing
+Add-Type -AssemblyName System.Windows.Forms
+Add-Type -TypeDefinition @'
+\${WINDOWS.CS}
+'@
+
+$payload = [Text.Encoding]::UTF8.GetString([Convert]::FromBase64String($env:SWIFTY_COMPUTER_INPUT)) | ConvertFrom-Json
+function Resolve-Key([string]$name) {
+  switch ($name.ToUpperInvariant()) {
+    'CTRL' { return 0x11 }
+    'CONTROL' { return 0x11 }
+    'SHIFT' { return 0x10 }
+    'ALT' { return 0x12 }
+    'OPTION' { return 0x12 }
+    'CMD' { return 0x5B }
+    'COMMAND' { return 0x5B }
+    'META' { return 0x5B }
+    'WIN' { return 0x5B }
+    'WINDOWS' { return 0x5B }
+    'ENTER' { return 0x0D }
+    'RETURN' { return 0x0D }
+    'ESC' { return 0x1B }
+    'ESCAPE' { return 0x1B }
+    'BACKSPACE' { return 0x08 }
+    'DELETE' { return 0x2E }
+    'TAB' { return 0x09 }
+    'SPACE' { return 0x20 }
+    'LEFT' { return 0x25 }
+    'UP' { return 0x26 }
+    'RIGHT' { return 0x27 }
+    'DOWN' { return 0x28 }
+    'HOME' { return 0x24 }
+    'END' { return 0x23 }
+    'PAGEUP' { return 0x21 }
+    'PAGEDOWN' { return 0x22 }
+    default {
+      if ($name.Length -eq 1) { return [int][char]$name.ToUpperInvariant() }
+      try { return [int]([System.Enum]::Parse([System.Windows.Forms.Keys], $name, $true)) }
+      catch { throw "Unsupported key: $name" }
+    }
+  }
+}
+function Key-Down($keys) { foreach ($key in $keys) { [SwiftyComputer]::Key((Resolve-Key $key), $true) } }
+function Key-Up($keys) { for ($i = $keys.Count - 1; $i -ge 0; $i--) { [SwiftyComputer]::Key((Resolve-Key $keys[$i]), $false) } }
+function Move-To($value) {
+  $bounds = [System.Windows.Forms.Screen]::PrimaryScreen.Bounds
+  [SwiftyComputer]::Move($bounds.X + [int]$value.x, $bounds.Y + [int]$value.y)
+}
+
+$keys = @($payload.keys)
+switch ($payload.action) {
+  'cursor_position' {
+    $bounds = [System.Windows.Forms.Screen]::PrimaryScreen.Bounds
+    $point = [SwiftyComputer]::Position()
+    Write-Output "$(($point.X - $bounds.X)),$(($point.Y - $bounds.Y))"
+  }
+  'mouse_move' { Key-Down $keys; Move-To $payload; Key-Up $keys }
+  'left_mouse_down' { [SwiftyComputer]::Mouse(0x0002) }
+  'left_mouse_up' { [SwiftyComputer]::Mouse(0x0004) }
+  'mouse_click' {
+    Move-To $payload
+    Key-Down $keys
+    $down = switch ($payload.button) { 'right' { 0x0008 } 'middle' { 0x0020 } default { 0x0002 } }
+    $up = switch ($payload.button) { 'right' { 0x0010 } 'middle' { 0x0040 } default { 0x0004 } }
+    for ($i = 0; $i -lt [int]$payload.clicks; $i++) {
+      [SwiftyComputer]::Mouse($down); [SwiftyComputer]::Mouse($up); Start-Sleep -Milliseconds 80
+    }
+    Key-Up $keys
+  }
+  'left_click_drag' {
+    Key-Down $keys
+    Move-To $payload.path[0]
+    [SwiftyComputer]::Mouse(0x0002)
+    foreach ($point in $payload.path | Select-Object -Skip 1) { Move-To $point; Start-Sleep -Milliseconds 20 }
+    [SwiftyComputer]::Mouse(0x0004)
+    Key-Up $keys
+  }
+  'scroll' {
+    if ($null -ne $payload.x -and $null -ne $payload.y) { Move-To $payload }
+    Key-Down $keys
+    [SwiftyComputer]::Mouse(0x0800, - ([int]$payload.scrollY * 120))
+    [SwiftyComputer]::Mouse(0x01000, [int]$payload.scrollX * 120)
+    Key-Up $keys
+  }
+  'key' { Key-Down $keys; Key-Up $keys }
+  'hold_key' { Key-Down $keys; Start-Sleep -Milliseconds ([int]([double]$payload.duration * 1000)); Key-Up $keys }
+  'type' { [SwiftyComputer]::Text([string]$payload.text) }
+  default { throw "Unsupported action: $($payload.action)" }
+}
+`;
+
+// src/tools/computer-use.ts
+var ACTIONS = [
+  "key",
+  "hold_key",
+  "type",
+  "cursor_position",
+  "mouse_move",
+  "left_mouse_down",
+  "left_mouse_up",
+  "left_click",
+  "left_click_drag",
+  "right_click",
+  "middle_click",
+  "double_click",
+  "triple_click",
+  "scroll",
+  "wait",
+  "screenshot",
+  "zoom",
+  "click",
+  "drag",
+  "keypress",
+  "move"
+];
+var CoordinateSchema = z13.tuple([z13.number().int().nonnegative(), z13.number().int().nonnegative()]);
+var PathPointSchema = z13.object({
+  x: z13.number().int().nonnegative(),
+  y: z13.number().int().nonnegative()
+});
+var OPENAI_ACTION_TYPES = [
+  "click",
+  "double_click",
+  "drag",
+  "keypress",
+  "move",
+  "screenshot",
+  "scroll",
+  "type",
+  "wait"
+];
+var MAX_BATCH_ACTIONS = 100;
+var OpenAIActionSchema = z13.object({
+  type: z13.enum(OPENAI_ACTION_TYPES),
+  button: z13.enum(["left", "right", "wheel", "back", "forward"]).optional(),
+  x: z13.number().int().nonnegative().optional(),
+  y: z13.number().int().nonnegative().optional(),
+  keys: z13.array(z13.string().min(1)).max(8).optional(),
+  path: z13.array(PathPointSchema).min(2).max(200).optional(),
+  scrollX: z13.number().optional(),
+  scrollY: z13.number().optional(),
+  text: z13.string().max(1e4).optional()
+});
+var SafetyCheckSchema = z13.object({
+  id: z13.string().min(1),
+  code: z13.string().optional(),
+  message: z13.string().optional()
+});
+var ComputerUseInputSchema = z13.object({
+  action: z13.enum(ACTIONS).optional(),
+  actions: z13.array(OpenAIActionSchema).min(1).max(MAX_BATCH_ACTIONS).optional(),
+  pendingSafetyChecks: z13.array(SafetyCheckSchema).optional(),
+  status: z13.enum(["in_progress", "completed", "incomplete"]).optional(),
+  coordinate: CoordinateSchema.optional(),
+  duration: z13.number().nonnegative().max(60).optional(),
+  region: z13.tuple([
+    z13.number().int().nonnegative(),
+    z13.number().int().nonnegative(),
+    z13.number().int().nonnegative(),
+    z13.number().int().nonnegative()
+  ]).optional(),
+  scroll_amount: z13.number().optional(),
+  scroll_direction: z13.enum(["up", "down", "left", "right"]).optional(),
+  start_coordinate: CoordinateSchema.optional(),
+  text: z13.string().max(1e4).optional(),
+  x: z13.number().int().nonnegative().optional(),
+  y: z13.number().int().nonnegative().optional(),
+  button: z13.enum(["left", "right", "wheel", "middle", "back", "forward"]).optional(),
+  keys: z13.array(z13.string().min(1)).max(8).optional(),
+  path: z13.array(PathPointSchema).min(2).max(200).optional(),
+  scroll_x: z13.number().optional(),
+  scroll_y: z13.number().optional()
+});
+var COMMAND_TIMEOUT_MS = 15e3;
+var MAX_COMMAND_OUTPUT_BYTES = 32 * 1024 * 1024;
+var MAX_SCREENSHOT_WIDTH = 1366;
+var MAX_SCREENSHOT_HEIGHT = 900;
+function defaultEnvironment(platform2) {
+  if (platform2 === "darwin") {
+    return "mac";
+  }
+  if (platform2 === "win32") {
+    return "windows";
+  }
+  return "linux";
+}
+function runCommand(command, args, options = {}) {
+  const timeoutMs = options.timeoutMs ?? COMMAND_TIMEOUT_MS;
+  const maxOutputBytes = options.maxOutputBytes ?? MAX_COMMAND_OUTPUT_BYTES;
+  return new Promise((resolvePromise, rejectPromise) => {
+    const child = spawn4(command, [...args], {
+      env: options.env ?? process.env,
+      shell: false,
+      stdio: ["ignore", "pipe", "pipe"],
+      windowsHide: true
+    });
+    let settled = false;
+    let totalBytes = 0;
+    const stdout = [];
+    const stderr = [];
+    const finish = (callback) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      clearTimeout(timer);
+      options.signal?.removeEventListener("abort", onAbort);
+      callback();
+    };
+    const fail = (message) => {
+      child.kill();
+      finish(() => {
+        rejectPromise(new Error(message));
+      });
+    };
+    const onAbort = () => {
+      fail(`${command} was interrupted.`);
+    };
+    const append2 = (chunk, target) => {
+      totalBytes += chunk.length;
+      if (totalBytes > maxOutputBytes) {
+        fail(`${command} exceeded the ${String(maxOutputBytes)} byte output limit.`);
+        return;
+      }
+      target.push(chunk);
+    };
+    const timer = setTimeout(() => {
+      fail(`${command} timed out after ${String(timeoutMs)}ms.`);
+    }, timeoutMs);
+    timer.unref();
+    child.stdout.on("data", (chunk) => {
+      append2(chunk, stdout);
+    });
+    child.stderr.on("data", (chunk) => {
+      append2(chunk, stderr);
+    });
+    child.on("error", (err) => {
+      finish(() => {
+        rejectPromise(
+          err.code === "ENOENT" ? new Error(`${command} is not installed or not on PATH.`) : err
+        );
+      });
+    });
+    child.on("close", (code) => {
+      finish(() => {
+        resolvePromise({
+          code: code ?? 1,
+          stdout: Buffer.concat(stdout),
+          stderr: Buffer.concat(stderr).toString("utf8").trim()
+        });
+      });
+    });
+    options.signal?.addEventListener("abort", onAbort, { once: true });
+    if (options.signal?.aborted) {
+      onAbort();
+    }
+  });
+}
+function requiredPoint(input) {
+  if (input.coordinate) {
+    return { x: input.coordinate[0], y: input.coordinate[1] };
+  }
+  if (input.x !== void 0 && input.y !== void 0) {
+    return { x: input.x, y: input.y };
+  }
+  throw new Error(`action=${String(input.action)} requires coordinate or x and y.`);
+}
+function keysFor(input) {
+  if (input.keys?.length) {
+    return input.keys;
+  }
+  if (input.text) {
+    return input.text.split("+").map((key) => key.trim()).filter(Boolean);
+  }
+  return [];
+}
+function normalizeAction(input) {
+  switch (input.action) {
+    case "screenshot":
+      return "screenshot";
+    case "zoom": {
+      if (!input.region || input.region[2] <= input.region[0] || input.region[3] <= input.region[1]) {
+        throw new Error("action=zoom requires region [x1, y1, x2, y2] with positive area.");
+      }
+      return { region: input.region };
+    }
+    case "wait":
+      return { action: "wait", duration: input.duration ?? 1 };
+    case "cursor_position":
+      return { action: "cursor_position" };
+    case "type":
+      if (input.text === void 0) {
+        throw new Error("action=type requires text.");
+      }
+      return { action: "type", text: input.text };
+    case "key":
+    case "keypress": {
+      const keys = keysFor(input);
+      if (keys.length === 0) {
+        throw new Error(`action=${input.action} requires text or keys.`);
+      }
+      return { action: "key", keys };
+    }
+    case "hold_key": {
+      const keys = keysFor(input);
+      if (keys.length === 0 || input.duration === void 0) {
+        throw new Error("action=hold_key requires text or keys and duration.");
+      }
+      return { action: "hold_key", keys, duration: input.duration };
+    }
+    case "mouse_move":
+    case "move": {
+      const point = requiredPoint(input);
+      return { action: "mouse_move", ...point, keys: input.keys };
+    }
+    case "left_mouse_down":
+    case "left_mouse_up":
+      return { action: input.action, keys: input.keys };
+    case "left_click_drag": {
+      if (!input.start_coordinate) {
+        throw new Error("action=left_click_drag requires start_coordinate.");
+      }
+      const end = requiredPoint(input);
+      return {
+        action: "left_click_drag",
+        path: [{ x: input.start_coordinate[0], y: input.start_coordinate[1] }, end],
+        keys: input.keys
+      };
+    }
+    case "drag": {
+      if (!input.path) {
+        throw new Error("action=drag requires a path with at least two points.");
+      }
+      return { action: "left_click_drag", path: input.path, keys: input.keys };
+    }
+    case "left_click":
+    case "right_click":
+    case "middle_click":
+    case "double_click":
+    case "triple_click":
+    case "click": {
+      const point = requiredPoint(input);
+      const button = input.action === "right_click" ? "right" : input.action === "middle_click" ? "middle" : input.action === "click" ? input.button === "wheel" ? "middle" : input.button ?? "left" : "left";
+      const clicks = input.action === "double_click" ? 2 : input.action === "triple_click" ? 3 : 1;
+      return {
+        action: "mouse_click",
+        button,
+        clicks,
+        ...point,
+        keys: keysFor(input)
+      };
+    }
+    case "scroll": {
+      const point = input.coordinate ? { x: input.coordinate[0], y: input.coordinate[1] } : input.x !== void 0 && input.y !== void 0 ? { x: input.x, y: input.y } : {};
+      if (input.scroll_x !== void 0 || input.scroll_y !== void 0) {
+        const toWheelClicks = (value) => value === 0 ? 0 : Math.sign(value) * Math.max(1, Math.round(Math.abs(value) / 100));
+        return {
+          action: "scroll",
+          ...point,
+          scrollX: toWheelClicks(input.scroll_x ?? 0),
+          scrollY: toWheelClicks(input.scroll_y ?? 0),
+          keys: keysFor(input)
+        };
+      }
+      if (input.scroll_amount === void 0 || !input.scroll_direction) {
+        throw new Error(
+          "action=scroll requires scroll_amount and scroll_direction, or scroll_x and scroll_y."
+        );
+      }
+      const amount = Math.max(1, Math.round(Math.abs(input.scroll_amount)));
+      return {
+        action: "scroll",
+        ...point,
+        scrollX: input.scroll_direction === "left" ? -amount : input.scroll_direction === "right" ? amount : 0,
+        scrollY: input.scroll_direction === "up" ? -amount : input.scroll_direction === "down" ? amount : 0,
+        keys: keysFor(input)
+      };
+    }
+    default:
+      throw new Error("action is required.");
+  }
+}
+function openaiActionToFlat(item) {
+  const point = {
+    ...item.x !== void 0 ? { x: item.x } : {},
+    ...item.y !== void 0 ? { y: item.y } : {}
+  };
+  switch (item.type) {
+    case "click":
+      return {
+        action: "click",
+        ...item.button ? { button: item.button } : {},
+        ...point,
+        keys: item.keys
+      };
+    case "double_click":
+      return { action: "double_click", ...point, keys: item.keys };
+    case "drag":
+      return { action: "drag", path: item.path, keys: item.keys };
+    case "keypress":
+      return { action: "keypress", keys: item.keys };
+    case "move":
+      return { action: "move", ...point, keys: item.keys };
+    case "screenshot":
+      return { action: "screenshot" };
+    case "scroll":
+      return {
+        action: "scroll",
+        ...point,
+        scroll_x: item.scrollX ?? 0,
+        scroll_y: item.scrollY ?? 0,
+        keys: item.keys
+      };
+    case "type":
+      return { action: "type", text: item.text };
+    case "wait":
+      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)}`}`
+  );
+}
+var ComputerUseTool = class {
+  name = "ComputerUse";
+  description;
+  category = "command";
+  deferred = false;
+  displayHeightPx;
+  displayNumber;
+  displayWidthPx;
+  enableZoom;
+  environment;
+  platform;
+  run;
+  coordinateScaleX = 1;
+  coordinateScaleY = 1;
+  macHelperPromise;
+  constructor(options = {}) {
+    this.displayHeightPx = options.displayHeightPx ?? MAX_SCREENSHOT_HEIGHT;
+    this.displayNumber = options.displayNumber;
+    this.displayWidthPx = options.displayWidthPx ?? MAX_SCREENSHOT_WIDTH;
+    this.enableZoom = options.enableZoom ?? true;
+    this.platform = options.platform ?? process.platform;
+    this.environment = options.environment ?? defaultEnvironment(this.platform);
+    this.run = options.runCommand ?? runCommand;
+    this.description = `Control the current ${this.environment} computer with screenshots, mouse, keyboard, scrolling, waiting, and zoom. Use screenshot before choosing coordinates and verify consequential actions with another screenshot. Two call styles are supported: Anthropic-style single actions (action + coordinate/scroll_amount/scroll_direction/start_coordinate/region/text), and OpenAI-style batches (actions[] of typed actions with x/y/button/keys/path/scrollX/scrollY/text, plus pendingSafetyChecks and status; a screenshot is returned after the batch). Flat OpenAI aliases (action=click/drag/keypress/move) are also accepted.`;
+  }
+  isConcurrencySafe(_args) {
+    return false;
+  }
+  providerSchema(protocol) {
+    if (protocol === "anthropic") {
+      return {
+        type: "computer_20251124",
+        name: "computer",
+        display_width_px: this.displayWidthPx,
+        display_height_px: this.displayHeightPx,
+        ...this.displayNumber !== void 0 ? { display_number: this.displayNumber } : {},
+        ...this.enableZoom ? { enable_zoom: true } : {}
+      };
+    }
+    if (protocol === "openai") {
+      return { type: "computer" };
+    }
+    return void 0;
+  }
+  schema() {
+    return {
+      name: this.name,
+      description: this.description,
+      input_schema: {
+        type: "object",
+        properties: {
+          action: {
+            type: "string",
+            enum: ACTIONS,
+            description: "Anthropic-style single computer action. Send either action or actions, not both."
+          },
+          actions: {
+            type: "array",
+            items: {
+              type: "object",
+              properties: {
+                type: {
+                  type: "string",
+                  enum: OPENAI_ACTION_TYPES,
+                  description: "OpenAI-style action type: click (button, x, y, keys), double_click (x, y, keys), drag (path, keys), keypress (keys), move (x, y, keys), screenshot, scroll (x, y, scrollX, scrollY, keys), type (text), wait."
+                },
+                button: {
+                  type: "string",
+                  enum: ["left", "right", "wheel", "back", "forward"],
+                  description: "Button for type=click."
+                },
+                x: { type: "integer", minimum: 0 },
+                y: { type: "integer", minimum: 0 },
+                keys: {
+                  type: "array",
+                  items: { type: "string" },
+                  maxItems: 8,
+                  description: "Keys held during the action, or pressed by keypress."
+                },
+                path: {
+                  type: "array",
+                  items: {
+                    type: "object",
+                    properties: {
+                      x: { type: "integer", minimum: 0 },
+                      y: { type: "integer", minimum: 0 }
+                    },
+                    required: ["x", "y"],
+                    additionalProperties: false
+                  },
+                  minItems: 2,
+                  maxItems: 200,
+                  description: "Drag path for type=drag."
+                },
+                scrollX: {
+                  type: "number",
+                  description: "Horizontal scroll delta for type=scroll."
+                },
+                scrollY: {
+                  type: "number",
+                  description: "Vertical scroll delta for type=scroll."
+                },
+                text: {
+                  type: "string",
+                  description: "Text to type for type=type."
+                }
+              },
+              required: ["type"],
+              additionalProperties: false
+            },
+            minItems: 1,
+            maxItems: MAX_BATCH_ACTIONS,
+            description: "OpenAI-style ordered batch of computer actions, executed in sequence; a screenshot is returned after the batch."
+          },
+          pendingSafetyChecks: {
+            type: "array",
+            items: {
+              type: "object",
+              properties: {
+                id: { type: "string" },
+                code: { type: "string" },
+                message: { type: "string" }
+              },
+              required: ["id"],
+              additionalProperties: false
+            },
+            description: "OpenAI-style safety checks raised with the batch; acknowledged in the tool result."
+          },
+          status: {
+            type: "string",
+            enum: ["in_progress", "completed", "incomplete"],
+            description: "OpenAI-style status of the computer call; echoed in the tool result."
+          },
+          coordinate: {
+            type: "array",
+            items: { type: "integer", minimum: 0 },
+            minItems: 2,
+            maxItems: 2,
+            description: "Anthropic-style [x, y] coordinate in the latest screenshot space."
+          },
+          duration: {
+            type: "number",
+            minimum: 0,
+            maximum: 60,
+            description: "Seconds for hold_key or wait."
+          },
+          region: {
+            type: "array",
+            items: { type: "integer", minimum: 0 },
+            minItems: 4,
+            maxItems: 4,
+            description: "Zoom region [x1, y1, x2, y2] in the latest screenshot space."
+          },
+          scroll_amount: {
+            type: "number",
+            description: "Anthropic-style number of wheel clicks to scroll."
+          },
+          scroll_direction: {
+            type: "string",
+            enum: ["up", "down", "left", "right"]
+          },
+          start_coordinate: {
+            type: "array",
+            items: { type: "integer", minimum: 0 },
+            minItems: 2,
+            maxItems: 2,
+            description: "Anthropic-style drag start coordinate."
+          },
+          text: {
+            type: "string",
+            description: "Text to type, or a '+'-separated key combination."
+          },
+          x: {
+            type: "integer",
+            minimum: 0,
+            description: "OpenAI-style x coordinate."
+          },
+          y: {
+            type: "integer",
+            minimum: 0,
+            description: "OpenAI-style y coordinate."
+          },
+          button: {
+            type: "string",
+            enum: ["left", "right", "wheel", "middle", "back", "forward"],
+            description: "Button for action=click."
+          },
+          keys: {
+            type: "array",
+            items: { type: "string" },
+            maxItems: 8,
+            description: "OpenAI-style keys held during an action or pressed by keypress."
+          },
+          path: {
+            type: "array",
+            items: {
+              type: "object",
+              properties: {
+                x: { type: "integer", minimum: 0 },
+                y: { type: "integer", minimum: 0 }
+              },
+              required: ["x", "y"],
+              additionalProperties: false
+            },
+            minItems: 2,
+            maxItems: 200,
+            description: "OpenAI-style drag path."
+          },
+          scroll_x: {
+            type: "number",
+            description: "OpenAI-style horizontal scroll delta."
+          },
+          scroll_y: {
+            type: "number",
+            description: "OpenAI-style vertical scroll delta."
+          }
+        },
+        // Either action (Anthropic-style) or actions (OpenAI-style) is required;
+        // execute() enforces the mutual exclusivity JSON Schema cannot express.
+        required: [],
+        additionalProperties: false
+      }
+    };
+  }
+  async execute(ctx, args) {
+    const parsed = safeParse3(ComputerUseInputSchema, args);
+    if (!parsed.success) {
+      return {
+        output: `Error: ${z13.prettifyError(parsed.error)}`,
+        isError: true
+      };
+    }
+    const input = parsed.data;
+    const batch = input.actions ?? [];
+    if (batch.length > 0 && input.action !== void 0) {
+      return {
+        output: "Error: send either action (Anthropic-style, one action per call) or actions (OpenAI-style batch), not both.",
+        isError: true
+      };
+    }
+    if (batch.length === 0 && input.action === void 0) {
+      return {
+        output: "Error: action (Anthropic-style) or actions (OpenAI-style batch) is required.",
+        isError: true
+      };
+    }
+    try {
+      ctx.abortSignal?.throwIfAborted();
+      if (batch.length > 0) {
+        return await this.executeBatch(ctx, input);
+      }
+      return await this.runSingle(ctx, input);
+    } catch (err) {
+      return { output: `Error: ${asErrorString(err)}`, isError: true };
+    }
+  }
+  /** Execute one Anthropic-style action (also the per-item path for batches). */
+  async runSingle(ctx, input) {
+    const action = normalizeAction(input);
+    if (action === "screenshot") {
+      return await this.screenshot(ctx.abortSignal);
+    }
+    if ("region" in action) {
+      return await this.screenshot(ctx.abortSignal, action.region);
+    }
+    if (action.action === "wait") {
+      await delay((action.duration ?? 1) * 1e3, void 0, {
+        signal: ctx.abortSignal
+      });
+      return { output: "Wait completed.", isError: false };
+    }
+    const native = this.toNativeCoordinates(action);
+    let output = await this.executeNative(native, ctx.abortSignal);
+    if (native.action === "cursor_position" && output) {
+      const [x, y] = output.split(",").map(Number);
+      if (Number.isFinite(x) && Number.isFinite(y)) {
+        output = `${String(Math.round(x / this.coordinateScaleX))},${String(Math.round(y / this.coordinateScaleY))}`;
+      }
+    }
+    return {
+      output: output || `Computer action ${input.action ?? "batch"} completed.`,
+      isError: false
+    };
+  }
+  /**
+   * Execute an OpenAI-style ordered action batch. Per the OpenAI computer
+   * output contract, the result always carries the screenshot taken after the
+   * batch ran, and status / safety checks are echoed so the model can continue.
+   */
+  async executeBatch(ctx, input) {
+    const actions = input.actions ?? [];
+    const executed = [];
+    let screenshotResult;
+    for (const [index, item] of actions.entries()) {
+      ctx.abortSignal?.throwIfAborted();
+      let result;
+      try {
+        result = await this.runSingle(ctx, openaiActionToFlat(item));
+      } catch (err) {
+        return {
+          output: `Error at actions[${String(index)}] (${item.type}): ${asErrorString(err)}`,
+          isError: true
+        };
+      }
+      if (result.isError) {
+        return {
+          output: `Error at actions[${String(index)}] (${item.type}): ${result.output}`,
+          contentBlocks: result.contentBlocks,
+          isError: true
+        };
+      }
+      executed.push(item.type);
+      if (item.type === "screenshot") {
+        screenshotResult = result;
+      }
+    }
+    screenshotResult ??= await this.screenshot(ctx.abortSignal).catch(
+      (err) => ({
+        output: `Actions completed, but the follow-up screenshot failed: ${asErrorString(err)}`,
+        isError: false
+      })
+    );
+    const notes = [
+      input.status ? `Status: ${input.status}.` : "",
+      input.pendingSafetyChecks?.length ? `Acknowledged safety checks: ${input.pendingSafetyChecks.map((check) => check.id).join(", ")}.` : ""
+    ].filter(Boolean).join(" ");
+    return {
+      output: `${screenshotResult.output} Executed ${String(executed.length)} action(s): ${executed.join(", ")}.${notes ? ` ${notes}` : ""}`,
+      contentBlocks: screenshotResult.contentBlocks,
+      isError: false
+    };
+  }
+  toNativeCoordinates(action) {
+    const scalePoint = (point) => ({
+      x: Math.round(point.x * this.coordinateScaleX),
+      y: Math.round(point.y * this.coordinateScaleY)
+    });
+    return {
+      ...action,
+      ...action.x !== void 0 && action.y !== void 0 ? scalePoint({ x: action.x, y: action.y }) : {},
+      ...action.path ? { path: action.path.map(scalePoint) } : {}
+    };
+  }
+  async executeNative(action, signal) {
+    switch (this.platform) {
+      case "darwin":
+        return this.executeMac(action, signal);
+      case "win32":
+        return this.executeWindows(action, signal);
+      case "linux":
+        return this.executeLinux(action, signal);
+      default:
+        throw new Error(`ComputerUse is not supported on ${this.platform}.`);
+    }
+  }
+  async executeMac(action, signal) {
+    return this.runMacPayload(
+      action,
+      signal,
+      action.action === "hold_key" ? Math.max(COMMAND_TIMEOUT_MS, (action.duration ?? 0) * 1e3 + 5e3) : COMMAND_TIMEOUT_MS
+    );
+  }
+  async runMacPayload(payload, signal, timeoutMs = COMMAND_TIMEOUT_MS) {
+    const helper = await this.getMacHelper(signal);
+    const result = await this.run(helper, [], {
+      env: {
+        ...process.env,
+        SWIFTY_COMPUTER_INPUT: Buffer.from(JSON.stringify(payload)).toString("base64")
+      },
+      signal,
+      timeoutMs
+    });
+    if (result.code !== 0) {
+      throw commandError("macOS computer helper", result);
+    }
+    return result.stdout.toString("utf8").trim();
+  }
+  async getMacHelper(signal) {
+    this.macHelperPromise ??= this.compileMacHelper(signal);
+    try {
+      return await this.macHelperPromise;
+    } catch (err) {
+      this.macHelperPromise = void 0;
+      throw err;
+    }
+  }
+  async compileMacHelper(signal) {
+    const directory = await mkdtemp(join22(tmpdir(), "swifty-computer-helper-"));
+    const sourcePath = join22(directory, "main.swift");
+    const executablePath = join22(directory, "computer-helper");
+    try {
+      await writeFile3(sourcePath, macos_default, "utf8");
+      const result = await this.run(
+        "/usr/bin/xcrun",
+        ["swiftc", "-O", sourcePath, "-o", executablePath],
+        { signal, timeoutMs: 12e4 }
+      );
+      if (result.code !== 0) {
+        throw commandError("swiftc", result);
+      }
+      return executablePath;
+    } catch (err) {
+      await rm2(directory, { recursive: true, force: true });
+      throw err;
+    }
+  }
+  async executeWindows(action, signal) {
+    const result = await this.run(
+      "powershell.exe",
+      ["-NoProfile", "-NonInteractive", "-Sta", "-Command", WINDOWS_POWERSHELL],
+      {
+        env: {
+          ...process.env,
+          SWIFTY_COMPUTER_INPUT: Buffer.from(JSON.stringify(action)).toString("base64")
+        },
+        signal,
+        timeoutMs: action.action === "hold_key" ? Math.max(COMMAND_TIMEOUT_MS, (action.duration ?? 0) * 1e3 + 5e3) : COMMAND_TIMEOUT_MS
+      }
+    );
+    if (result.code !== 0) {
+      throw commandError("powershell.exe", result);
+    }
+    return result.stdout.toString("utf8").trim();
+  }
+  async executeLinux(action, signal) {
+    const runXdotool = async (args) => {
+      const result = await this.run("xdotool", args, { signal });
+      if (result.code !== 0) {
+        throw commandError("xdotool", result);
+      }
+      return result.stdout.toString("utf8").trim();
+    };
+    const keys = action.keys ?? [];
+    const keyDown = async () => {
+      for (const key of keys) {
+        await runXdotool(["keydown", key]);
+      }
+    };
+    const keyUp = async () => {
+      for (const key of [...keys].reverse()) {
+        await runXdotool(["keyup", key]);
+      }
+    };
+    const withKeys = async (operation) => {
+      await keyDown();
+      try {
+        await operation();
+      } finally {
+        await keyUp();
+      }
+    };
+    const move = async () => {
+      if (action.x !== void 0 && action.y !== void 0) {
+        await runXdotool(["mousemove", "--sync", String(action.x), String(action.y)]);
+      }
+    };
+    switch (action.action) {
+      case "cursor_position": {
+        const output = await runXdotool(["getmouselocation", "--shell"]);
+        const x = /(?:^|\n)X=(\d+)/.exec(output)?.[1];
+        const y = /(?:^|\n)Y=(\d+)/.exec(output)?.[1];
+        if (!x || !y) {
+          throw new Error(`Unable to parse cursor position: ${output}`);
+        }
+        return `${x},${y}`;
+      }
+      case "mouse_move":
+        await withKeys(move);
+        return "";
+      case "left_mouse_down":
+        await runXdotool(["mousedown", "1"]);
+        return "";
+      case "left_mouse_up":
+        await runXdotool(["mouseup", "1"]);
+        return "";
+      case "mouse_click": {
+        await move();
+        const button = action.button === "right" ? 3 : action.button === "middle" ? 2 : action.button === "back" ? 8 : action.button === "forward" ? 9 : 1;
+        await withKeys(async () => {
+          await runXdotool([
+            "click",
+            "--repeat",
+            String(action.clicks ?? 1),
+            "--delay",
+            "80",
+            String(button)
+          ]);
+        });
+        return "";
+      }
+      case "left_click_drag": {
+        const path2 = action.path ?? [];
+        if (path2.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(["mousedown", "1"]);
           try {
-            child.kill(signal);
-          } catch {
+            for (const point of path2.slice(1)) {
+              await runXdotool(["mousemove", "--sync", String(point.x), String(point.y)]);
+            }
+          } finally {
+            await runXdotool(["mouseup", "1"]);
           }
-        }
-      };
-      const terminate = () => {
-        if (terminating) {
-          return;
-        }
-        terminating = true;
-        killTree("SIGTERM");
-        escalateTimer = setTimeout(() => {
-          killTree("SIGKILL");
-          child.stdout.destroy();
-          child.stderr.destroy();
-        }, KILL_GRACE_MS);
-        escalateTimer.unref();
-      };
-      const appendChunk = (chunk, target) => {
-        if (outputTruncated) {
-          return;
-        }
-        const remaining = MAX_SHELL_OUTPUT_BYTES - total;
-        const piece = takeUtf8Prefix(chunk, remaining);
-        total += utf8ByteLength(piece);
-        if (piece.length < chunk.length) {
-          outputTruncated = true;
-          terminate();
-        }
-        if (target === "stdout") {
-          stdout += piece;
-        } else {
-          stderr += piece;
-        }
-      };
-      child.stdout.setEncoding("utf-8");
-      child.stdout.on("data", (chunk) => {
-        appendChunk(chunk, "stdout");
-      });
-      child.stderr.setEncoding("utf-8");
-      child.stderr.on("data", (chunk) => {
-        appendChunk(chunk, "stderr");
-      });
-      const onAbort = () => {
-        if (alreadyExited()) {
-          return;
-        }
-        aborted = true;
-        terminate();
-      };
-      const timeoutTimer = setTimeout(() => {
-        if (alreadyExited()) {
-          return;
-        }
-        timedOut = true;
-        terminate();
-      }, timeout * 1e3);
-      timeoutTimer.unref();
-      ctx.abortSignal?.addEventListener("abort", onAbort, { once: true });
-      if (ctx.abortSignal?.aborted) {
-        onAbort();
+        });
+        return "";
       }
-      const cleanup = () => {
-        clearTimeout(timeoutTimer);
-        if (escalateTimer) {
-          clearTimeout(escalateTimer);
-        }
-        ctx.abortSignal?.removeEventListener("abort", onAbort);
-      };
-      child.on("error", (err) => {
-        cleanup();
-        resolve12({
-          output: `Error executing command: ${err.message}`,
-          isError: true
+      case "scroll": {
+        await move();
+        await withKeys(async () => {
+          const clicks = [
+            [action.scrollY ?? 0, (action.scrollY ?? 0) < 0 ? 4 : 5],
+            [action.scrollX ?? 0, (action.scrollX ?? 0) < 0 ? 6 : 7]
+          ];
+          for (const [amount, button] of clicks) {
+            if (amount !== 0) {
+              await runXdotool(["click", "--repeat", String(Math.abs(amount)), String(button)]);
+            }
+          }
         });
-      });
-      child.on("close", (code, signal) => {
-        cleanup();
-        if (aborted) {
-          const captured = stdout || stderr || outputTruncated ? formatShellOutput("$ ", command, stdout, stderr, outputTruncated) : "";
-          resolve12({
-            output: captured ? `${captured}
-Error: command interrupted` : "Error: command interrupted",
-            isError: true
-          });
-          return;
-        }
-        if (timedOut) {
-          const captured = stdout || stderr || outputTruncated ? formatShellOutput("$ ", command, stdout, stderr, outputTruncated) : "";
-          resolve12({
-            output: captured ? `${captured}
-Error: command timed out after ${String(timeout)}s` : `Error: command timed out after ${String(timeout)}s`,
-            isError: true
-          });
-          return;
-        }
-        const exitCode = code ?? 0;
-        let output = formatShellOutput("$ ", command, stdout, stderr, outputTruncated);
-        if (outputTruncated) {
-          resolve12({ output, isError: true });
-          return;
+        return "";
+      }
+      case "key":
+        await runXdotool(["key", keys.join("+")]);
+        return "";
+      case "hold_key":
+        await keyDown();
+        try {
+          await delay((action.duration ?? 0) * 1e3, void 0, { signal });
+        } finally {
+          await keyUp();
         }
-        if (exitCode !== 0) {
-          const hint = exitCodeHint(command, exitCode);
-          output += hint ? `
-Exit code ${String(exitCode)} (${hint})` : `
-Exit code ${String(exitCode)}`;
+        return "";
+      case "type":
+        await runXdotool(["type", "--delay", "1", "--", action.text ?? ""]);
+        return "";
+    }
+  }
+  async screenshot(signal, region) {
+    const capture = await this.captureScreenshot(signal);
+    const metadata = await sharp2(capture.bytes).metadata();
+    if (!metadata.width || !metadata.height) {
+      throw new Error("Unable to determine screenshot dimensions.");
+    }
+    if (region) {
+      const left = Math.round(region[0] * this.coordinateScaleX);
+      const top = Math.round(region[1] * this.coordinateScaleY);
+      const right = Math.round(region[2] * this.coordinateScaleX);
+      const bottom = Math.round(region[3] * this.coordinateScaleY);
+      const rawScaleX = metadata.width / capture.width;
+      const rawScaleY = metadata.height / capture.height;
+      const rawLeft = Math.max(0, Math.min(metadata.width - 1, Math.round(left * rawScaleX)));
+      const rawTop = Math.max(0, Math.min(metadata.height - 1, Math.round(top * rawScaleY)));
+      const rawRight = Math.max(
+        rawLeft + 1,
+        Math.min(metadata.width, Math.round(right * rawScaleX))
+      );
+      const rawBottom = Math.max(
+        rawTop + 1,
+        Math.min(metadata.height, Math.round(bottom * rawScaleY))
+      );
+      const cropped = await sharp2(capture.bytes).extract({
+        left: rawLeft,
+        top: rawTop,
+        width: rawRight - rawLeft,
+        height: rawBottom - rawTop
+      }).png({ compressionLevel: 8 }).toBuffer();
+      return this.imageResult(cropped, `Zoomed screenshot of [${region.join(", ")}].`);
+    }
+    const targetScale = Math.min(
+      1,
+      MAX_SCREENSHOT_WIDTH / capture.width,
+      MAX_SCREENSHOT_HEIGHT / capture.height
+    );
+    const targetWidth = Math.max(1, Math.round(capture.width * targetScale));
+    const targetHeight = Math.max(1, Math.round(capture.height * targetScale));
+    const normalized = await sharp2(capture.bytes).resize(targetWidth, targetHeight, { fit: "fill" }).png({ compressionLevel: 8 }).toBuffer();
+    const result = await this.imageResult(
+      normalized,
+      `Screenshot ${String(targetWidth)}x${String(targetHeight)}. Use this coordinate space for subsequent actions.`
+    );
+    const outputBlock = result.contentBlocks?.[0];
+    if (outputBlock?.type === "image" && outputBlock.source.type === "base64") {
+      const finalMetadata = await sharp2(Buffer.from(outputBlock.source.data, "base64")).metadata();
+      if (finalMetadata.width && finalMetadata.height) {
+        this.coordinateScaleX = capture.width / finalMetadata.width;
+        this.coordinateScaleY = capture.height / finalMetadata.height;
+        result.output = `Screenshot ${String(finalMetadata.width)}x${String(finalMetadata.height)}. Use this coordinate space for subsequent actions.`;
+      }
+    }
+    return result;
+  }
+  async imageResult(bytes, output) {
+    const image = await maybeResizeAndDownsampleImage(bytes, "image/png");
+    const imageBlock = {
+      type: "image",
+      source: {
+        type: "base64",
+        media_type: image.mediaType,
+        data: image.data
+      }
+    };
+    return { output, contentBlocks: [imageBlock], isError: false };
+  }
+  async captureScreenshot(signal) {
+    const directory = await mkdtemp(join22(tmpdir(), "swifty-computer-"));
+    const screenshotPath = join22(directory, "screenshot.png");
+    try {
+      switch (this.platform) {
+        case "darwin": {
+          const capture = await this.run(
+            "/usr/sbin/screencapture",
+            ["-x", "-m", "-t", "png", screenshotPath],
+            { signal }
+          );
+          if (capture.code !== 0) {
+            throw commandError("screencapture", capture);
+          }
+          const size = await this.runMacPayload({ action: "screen_size" }, signal).catch(() => "");
+          const [width, height] = size.split(",").map(Number);
+          const bytes = await readFile5(screenshotPath);
+          const metadata = await sharp2(bytes).metadata();
+          return {
+            bytes,
+            width: Number.isFinite(width) && width > 0 ? width : metadata.width ?? 1,
+            height: Number.isFinite(height) && height > 0 ? height : metadata.height ?? 1
+          };
         }
-        if (code === null) {
-          output += `
-Process terminated${signal ? ` by ${signal}` : " unexpectedly"}`;
+        case "win32": {
+          const capture = await this.run(
+            "powershell.exe",
+            ["-NoProfile", "-NonInteractive", "-Sta", "-Command", win32_script_default],
+            {
+              env: { ...process.env, SWIFTY_SCREENSHOT_PATH: screenshotPath },
+              signal
+            }
+          );
+          if (capture.code !== 0) {
+            throw commandError("powershell.exe", capture);
+          }
+          const [width, height] = capture.stdout.toString("utf8").trim().split(",").map(Number);
+          return { bytes: await readFile5(screenshotPath), width, height };
+        }
+        case "linux": {
+          const backends = [
+            ["gnome-screenshot", ["-f", screenshotPath]],
+            ["scrot", [screenshotPath]],
+            ["import", ["-window", "root", screenshotPath]]
+          ];
+          let lastError = "No screenshot backend succeeded.";
+          for (const [command, args] of backends) {
+            try {
+              const capture = await this.run(command, args, { signal });
+              if (capture.code === 0) {
+                const bytes = await readFile5(screenshotPath);
+                const metadata = await sharp2(bytes).metadata();
+                return {
+                  bytes,
+                  width: metadata.width ?? 1,
+                  height: metadata.height ?? 1
+                };
+              }
+              lastError = commandError(command, capture).message;
+            } catch (err) {
+              lastError = asErrorString(err);
+            }
+          }
+          throw new Error(
+            `${lastError} Install gnome-screenshot, scrot, or ImageMagick; xdotool is required for input control.`
+          );
         }
-        resolve12({ output, isError: exitCode !== 0 || code === null });
-      });
-    });
+        default:
+          throw new Error(`ComputerUse is not supported on ${this.platform}.`);
+      }
+    } finally {
+      await rm2(directory, { recursive: true, force: true });
+    }
   }
 };
 
 // src/tools/powershell.ts
-import { execFile as execFile2, spawn as spawn4 } from "child_process";
+import { execFile as execFile2, spawn as spawn5 } from "child_process";
 var MAX_TIMEOUT2 = 600;
 var KILL_GRACE_MS2 = 3e3;
-function extractBaseCmd2(command) {
-  const lastSegment = command.split("|").pop()?.trim() ?? command;
-  const tokens = lastSegment.split(/\s+/);
-  for (const token of tokens) {
-    if (token.includes("=") && !token.startsWith("-")) {
-      continue;
-    }
-    const base = token.split(/[\\/]/).pop() ?? token;
-    return base.replace(/\.exe$/i, "").toLowerCase();
-  }
-  return "";
-}
-var exitCodeHints2 = /* @__PURE__ */ new Map([
-  ["findstr", /* @__PURE__ */ new Map([[1, "no matches found"]])],
-  ["where", /* @__PURE__ */ new Map([[1, "not found"]])],
-  ["grep", /* @__PURE__ */ new Map([[1, "no matches found"]])],
-  ["rg", /* @__PURE__ */ new Map([[1, "no matches found"]])],
-  ["diff", /* @__PURE__ */ new Map([[1, "files differ"]])]
-]);
-function exitCodeHint2(command, exitCode) {
-  const baseCmd = extractBaseCmd2(command);
-  const hints = exitCodeHints2.get(baseCmd);
-  return hints?.get(exitCode) ?? "";
-}
 var PowerShellTool = class {
   // Use a hardcoded string instead of PowerShellTool.name.replace("Tool", "")
   // because class names are not stable after minification — bundlers like
@@ -8287,7 +9794,10 @@ var PowerShellTool = class {
     }
     const shell = process.platform === "win32" ? "powershell.exe" : "pwsh";
     if (ctx.abortSignal?.aborted) {
-      return Promise.resolve({ output: "Error: command interrupted", isError: true });
+      return Promise.resolve({
+        output: "Error: command interrupted",
+        isError: true
+      });
     }
     return new Promise((resolve12) => {
       let timedOut = false;
@@ -8303,7 +9813,7 @@ var PowerShellTool = class {
         "-Command",
         shellCommand
       ] : ["-NoProfile", "-NonInteractive", "-Command", shellCommand];
-      const child = spawn4(shell, shellArgs, {
+      const child = spawn5(shell, shellArgs, {
         cwd: ctx.workDir,
         // Only POSIX needs its own process group for kill(-pid); the Windows
         // tree kill goes through taskkill and needs no new group.
@@ -8382,16 +9892,10 @@ var PowerShellTool = class {
         appendChunk(chunk, "stderr");
       });
       const onAbort = () => {
-        if (alreadyExited()) {
-          return;
-        }
         aborted = true;
         terminate();
       };
       const timeoutTimer = setTimeout(() => {
-        if (alreadyExited()) {
-          return;
-        }
         timedOut = true;
         terminate();
       }, timeout * 1e3);
@@ -8442,7 +9946,7 @@ Error: command timed out after ${String(timeout)}s` : `Error: command timed out
           return;
         }
         if (exitCode !== 0) {
-          const hint = exitCodeHint2(command, exitCode);
+          const hint = exitCodeHint(command, exitCode);
           output += hint ? `
 Exit code ${String(exitCode)} (${hint})` : `
 Exit code ${String(exitCode)}`;
@@ -8542,7 +10046,7 @@ var SyntheticOutputTool = class {
 
 // src/tools/tool-search.ts
 var ToolSearchTool = class {
-  name = TOOL_SEARCH_TOOL_NAME;
+  name = "ToolSearch";
   description = "Search for and load deferred tools by name or keyword.";
   category = "read";
   registry;
@@ -8585,7 +10089,10 @@ var ToolSearchTool = class {
       query.slice("select:".length).split(",").map((name) => name.trim()).filter(Boolean)
     ) : this.registry.searchDeferred(query, Math.max(1, Math.min(maxResults, 50)));
     if (tools.length === 0) {
-      return Promise.resolve({ output: "No deferred tools matched the query.", isError: false });
+      return Promise.resolve({
+        output: "No deferred tools matched the query.",
+        isError: false
+      });
     }
     const mcp = tools.filter((tool) => tool.name.startsWith(MCP_TOOL_PREFIX));
     const local = tools.filter((tool) => !tool.name.startsWith(MCP_TOOL_PREFIX));
@@ -8657,6 +10164,7 @@ async function runPrintMode(args) {
   registry.register(new ReadFileTool());
   registry.register(new BashTool());
   registry.register(new PowerShellTool());
+  registry.register(new ComputerUseTool());
   registry.register(new GlobTool());
   registry.register(new GrepTool());
   registry.register(new WriteFileTool());
@@ -8881,9 +10389,9 @@ function emitStreamJson(event) {
 
 // src/recover.ts
 import { appendFileSync, mkdirSync as mkdirSync14 } from "fs";
-import { join as join22 } from "path";
+import { join as join23 } from "path";
 var LOG_DIR = ".swifty";
-var LOG_PATH = join22(LOG_DIR, "crash.log");
+var LOG_PATH = join23(LOG_DIR, "crash.log");
 function record(text) {
   try {
     mkdirSync14(LOG_DIR, { recursive: true });
@@ -8977,11 +10485,45 @@ var AgentEventLogger = class {
 // src/remote/server.ts
 import { readFileSync as readFileSync23, existsSync as existsSync20, statSync as statSync11 } from "fs";
 import { createServer } from "http";
-import { join as join26, extname as extname3, normalize } from "path";
+import { join as join27, extname as extname3, normalize } from "path";
 import { cwd } from "process";
 import Koa from "koa";
 import { WebSocketServer, WebSocket } from "ws";
-import z18 from "zod";
+import z19 from "zod";
+
+// src/remote/address.ts
+function parseRemoteAddress(address) {
+  const value = address.trim();
+  const match = /^(?:\[([^\]]+)\]|([^:]*))(?::(\d+))?$/.exec(value);
+  if (!match) {
+    throw new Error("Invalid remote address; use host:port or [IPv6]:port");
+  }
+  const host = match[1] || match[2] || "127.0.0.1";
+  const port = Number(match[3] ?? "18888");
+  if (!Number.isInteger(port) || port < 1 || port > 65535) {
+    throw new Error("Remote port must be an integer between 1 and 65535");
+  }
+  return { host, port };
+}
+
+// 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.sessionId = sessionId;
+  state.fileHistory = new FileHistory(state.workDir, sessionId);
+  state.fileStateCache = new FileStateCache();
+  state.recoveryState = new RecoveryState();
+  state.activeSkills.clear();
+  state.toolFilter = null;
+  return replay;
+}
 
 // src/config/provider-login.ts
 import { randomUUID } from "crypto";
@@ -8993,22 +10535,22 @@ import {
   unlinkSync as unlinkSync5,
   writeFileSync as writeFileSync13
 } from "fs";
-import { dirname as dirname8, join as join23 } from "path";
+import { dirname as dirname8, join as join24 } from "path";
 import yaml5 from "js-yaml";
-import { z as z13 } from "zod";
-var tokenLimit = (fallback, min, max) => z13.preprocess(
+import { z as z14 } from "zod";
+var tokenLimit = (fallback, min, max) => z14.preprocess(
   (value) => value === void 0 || typeof value === "string" && !value.trim() ? fallback : value,
-  z13.union([
-    z13.number(),
-    z13.string().trim().regex(/^\d+$/, "Enter a whole number").transform(Number)
-  ]).pipe(z13.number().int().min(min).max(max))
+  z14.union([
+    z14.number(),
+    z14.string().trim().regex(/^\d+$/, "Enter a whole number").transform(Number)
+  ]).pipe(z14.number().int().min(min).max(max))
 );
 var ProviderLoginSchema = ProviderConfigSchema.extend({
-  name: z13.string().trim().min(1, "Name is required"),
-  base_url: z13.string().trim().url("Enter a valid HTTP(S) URL").refine((url) => /^https?:\/\//i.test(url), "Use an HTTP(S) URL"),
-  api_key: z13.string().trim().min(1, "API key is required"),
-  model: z13.string().trim().min(1, "Model is required"),
-  thinking: z13.enum(THINKING_LEVELS).optional(),
+  name: z14.string().trim().min(1, "Name is required"),
+  base_url: z14.url("Enter a valid HTTP(S) URL").refine((url) => /^https?:\/\//i.test(url), "Use an HTTP(S) URL"),
+  api_key: z14.string().trim().min(1, "API key is required"),
+  model: z14.string().trim().min(1, "Model is required"),
+  thinking: z14.enum(THINKING_LEVELS).optional(),
   context_window: tokenLimit(DEFAULT_CONTEXT_WINDOW, 1e3, 1e7),
   max_output_tokens: tokenLimit(DEFAULT_MAX_OUTPUT_TOKENS, 1, 1e6)
 }).refine((provider) => provider.max_output_tokens <= provider.context_window, {
@@ -9028,12 +10570,12 @@ function readConfigRaw(path2) {
   } catch {
     throw new Error(`Unable to read existing ${path2}; it has not been changed.`);
   }
-  return z13.record(z13.string(), z13.unknown()).parse(raw ?? {});
+  return z14.record(z14.string(), z14.unknown()).parse(raw ?? {});
 }
 function writeConfigAtomic(path2, raw) {
   const directory = dirname8(path2);
   mkdirSync15(directory, { recursive: true });
-  const temporary = join23(directory, `.config-${randomUUID()}.tmp`);
+  const temporary = join24(directory, `.config-${randomUUID()}.tmp`);
   try {
     writeFileSync13(temporary, yaml5.dump(raw, { lineWidth: -1, noRefs: true }), {
       encoding: "utf-8",
@@ -9050,7 +10592,7 @@ function writeConfigAtomic(path2, raw) {
 function persistThinkingLevel(providerName, level) {
   const path2 = globalConfigPath();
   const config = readConfigRaw(path2);
-  const providers = z13.array(z13.record(z13.string(), z13.unknown())).parse(config.providers ?? []);
+  const providers = z14.array(z14.record(z14.string(), z14.unknown())).parse(config.providers ?? []);
   const target = providers.find((entry) => entry.name === providerName);
   if (!target) {
     throw new Error(`Provider "${providerName}" not found in ${path2}.`);
@@ -9065,9 +10607,9 @@ function persistThinkingLevel(providerName, level) {
 // src/skills/catalog.ts
 import { readdirSync as readdirSync5, readFileSync as readFileSync21, existsSync as existsSync18, statSync as statSync10 } from "fs";
 import { homedir as homedir9 } from "os";
-import { join as join24 } from "path";
+import { join as join25 } from "path";
 import yaml6 from "js-yaml";
-import { z as z14 } from "zod";
+import { z as z15 } from "zod";
 var log30 = createChildLogger({ module: "skills" });
 var SkillCatalog = class {
   entries = /* @__PURE__ */ new Map();
@@ -9118,7 +10660,7 @@ var SkillCatalog = class {
   }
   skillDirPaths() {
     return [homedir9(), ...this.workDir ? [this.workDir] : []].flatMap(
-      (root) => [".agents"].map((ecosystem) => join24(root, ecosystem, "skills"))
+      (root) => [".agents"].map((ecosystem) => join25(root, ecosystem, "skills"))
     );
   }
   scanDirectory(dir) {
@@ -9130,12 +10672,12 @@ var SkillCatalog = class {
       return;
     }
     for (const entry of dirEntries) {
-      const fullPath = join24(dir, entry);
+      const fullPath = join25(dir, entry);
       try {
         const stat3 = statSync10(fullPath);
         if (stat3.isDirectory()) {
           this.dirModTimes.set(fullPath, stat3.mtimeMs);
-          const skillFile = join24(fullPath, "SKILL.md");
+          const skillFile = join25(fullPath, "SKILL.md");
           if (existsSync18(skillFile)) {
             this.loadSkill(skillFile, fullPath, true);
           }
@@ -9223,12 +10765,12 @@ function resolveMode(raw) {
   }
   return strArg(asRecord(raw), "context") === "fork" ? "fork" : "inline";
 }
-var YamlFrontmatterSchema3 = z14.looseObject({
-  name: z14.string().trim().min(1),
-  description: z14.string().optional(),
-  mode: z14.enum(["inline", "fork"]).optional(),
-  model: z14.string().optional(),
-  fork_context: z14.enum(["full", "none", "recent"]).optional()
+var YamlFrontmatterSchema3 = z15.looseObject({
+  name: z15.string().trim().min(1),
+  description: z15.string().optional(),
+  mode: z15.enum(["inline", "fork"]).optional(),
+  model: z15.string().optional(),
+  fork_context: z15.enum(["full", "none", "recent"]).optional()
 });
 function parseSkillFile(content) {
   const normalized = content.replace(/^\uFEFF/, "");
@@ -9264,7 +10806,7 @@ function buildSkillSection(catalog, workDir) {
   if (metas.length === 0) {
     return "";
   }
-  const skillsDir = join24(workDir, ".agents", "skills");
+  const skillsDir = join25(workDir, ".agents", "skills");
   const lines = [
     "## Skills",
     'Load relevant instructions with LoadSkill {name: "<skill-name>"}, or user command /<skill-name>. Mode inline activates in this conversation; fork runs in a subagent when available, otherwise inline. Load resources only as needed, relative to the skill directory. Tool access remains host-controlled.',
@@ -9398,26 +10940,26 @@ ${body}`,
 
 // src/todo/store.ts
 import { readFileSync as readFileSync22, writeFileSync as writeFileSync14, mkdirSync as mkdirSync16, existsSync as existsSync19 } from "fs";
-import { join as join25, dirname as dirname9 } from "path";
-import z15, { parse as parse8 } from "zod";
+import { join as join26, dirname as dirname9 } from "path";
+import z16, { parse as parse8 } from "zod";
 var log31 = createChildLogger({ module: "todo" });
-var TaskStatusSchema = z15.enum(["pending", "in_progress", "completed"]);
-var TaskSchema = z15.object({
-  id: z15.string(),
-  subject: z15.string(),
-  description: z15.string(),
+var TaskStatusSchema = z16.enum(["pending", "in_progress", "completed"]);
+var TaskSchema = z16.object({
+  id: z16.string(),
+  subject: z16.string(),
+  description: z16.string(),
   status: TaskStatusSchema,
-  owner: z15.string().optional(),
-  activeForm: z15.string().optional(),
-  blocks: z15.array(z15.string()),
-  blockedBy: z15.array(z15.string()),
-  metadata: z15.record(z15.string(), z15.unknown())
+  owner: z16.string().optional(),
+  activeForm: z16.string().optional(),
+  blocks: z16.array(z16.string()),
+  blockedBy: z16.array(z16.string()),
+  metadata: z16.record(z16.string(), z16.unknown())
 });
 var TaskStore = class {
   filePath;
   // Session-scoped store: .swifty/tasks/<listId>.json.
   constructor(workDir, listId) {
-    this.filePath = join25(workDir, ".swifty", "tasks", `${listId}.json`);
+    this.filePath = join26(workDir, ".swifty", "tasks", `${listId}.json`);
   }
   load() {
     if (!existsSync19(this.filePath)) {
@@ -9426,7 +10968,7 @@ var TaskStore = class {
     try {
       const data = readFileSync22(this.filePath, "utf-8");
       const raw = JSON.parse(data);
-      const parsed = parse8(z15.array(TaskSchema), raw);
+      const parsed = parse8(z16.array(TaskSchema), raw);
       return parsed;
     } catch (err) {
       log31.error({ err }, "todo operation failed");
@@ -9545,7 +11087,7 @@ var TaskList = class {
 
 // src/todo/tools.ts
 import { safeParseAsync } from "@modelcontextprotocol/sdk/server/zod-compat.js";
-import z16 from "zod";
+import z17 from "zod";
 var TaskCreateTool2 = class {
   name = "TaskCreate";
   description = "Create a new task to track work.";
@@ -9732,27 +11274,27 @@ var TaskUpdateTool2 = class {
     return { output: `Updated task #${taskId} status`, isError: false };
   }
 };
-var TaskUpdateArgsSchema = z16.object({
-  taskId: z16.string(),
-  subject: z16.string().optional(),
-  description: z16.string().optional(),
-  status: z16.enum(["pending", "in_progress", "completed", "deleted"]).optional(),
-  owner: z16.string().optional(),
-  addBlocks: z16.array(z16.string()).optional(),
-  addBlockedBy: z16.array(z16.string()).optional()
+var TaskUpdateArgsSchema = z17.object({
+  taskId: z17.string(),
+  subject: z17.string().optional(),
+  description: z17.string().optional(),
+  status: z17.enum(["pending", "in_progress", "completed", "deleted"]).optional(),
+  owner: z17.string().optional(),
+  addBlocks: z17.array(z17.string()).optional(),
+  addBlockedBy: z17.array(z17.string()).optional()
 });
 
 // src/tools/ask-user.ts
-import { safeParseAsync as safeParseAsync2, z as z17 } from "zod";
-var QuestionOptionSchema = z17.object({
-  label: z17.string(),
-  description: z17.string().optional()
+import { safeParseAsync as safeParseAsync2, z as z18 } from "zod";
+var QuestionOptionSchema = z18.object({
+  label: z18.string(),
+  description: z18.string().optional()
 });
-var QuestionSchema = z17.object({
-  question: z17.string(),
-  header: z17.string(),
-  options: z17.array(QuestionOptionSchema),
-  multiSelect: z17.boolean()
+var QuestionSchema = z18.object({
+  question: z18.string(),
+  header: z18.string(),
+  options: z18.array(QuestionOptionSchema),
+  multiSelect: z18.boolean()
 });
 var AskUserQuestionTool = class {
   constructor(ask) {
@@ -9834,7 +11376,7 @@ var AskUserQuestionTool = class {
       success,
       data: argsData,
       error
-    } = await safeParseAsync2(z17.object({ questions: z17.array(QuestionSchema) }), args);
+    } = await safeParseAsync2(z18.object({ questions: z18.array(QuestionSchema) }), args);
     if (!success) {
       return {
         output: error.message,
@@ -10047,58 +11589,24 @@ Branch: ${branch}`,
   }
 };
 
-// src/remote/address.ts
-function parseRemoteAddress(address) {
-  const value = address.trim();
-  const match = /^(?:\[([^\]]+)\]|([^:]*))(?::(\d+))?$/.exec(value);
-  if (!match) {
-    throw new Error("Invalid remote address; use host:port or [IPv6]:port");
-  }
-  const host = match[1] || match[2] || "127.0.0.1";
-  const port = Number(match[3] ?? "18888");
-  if (!Number.isInteger(port) || port < 1 || port > 65535) {
-    throw new Error("Remote port must be an integer between 1 and 65535");
-  }
-  return { host, port };
-}
-
-// 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.sessionId = sessionId;
-  state.fileHistory = new FileHistory(state.workDir, sessionId);
-  state.fileStateCache = new FileStateCache();
-  state.recoveryState = new RecoveryState();
-  state.activeSkills.clear();
-  state.toolFilter = null;
-  return replay;
-}
-
 // src/remote/server.ts
 var log34 = createChildLogger({ module: "remote" });
-var WsInboundSchema = z18.object({
-  type: z18.string(),
-  data: z18.unknown()
+var WsInboundSchema = z19.object({
+  type: z19.string(),
+  data: z19.unknown()
 });
-var UserMessageSchema = z18.object({
-  content: z18.string()
+var UserMessageSchema = z19.object({
+  content: z19.string()
 });
-var PermissionResponseSchema = z18.object({
-  id: z18.string(),
-  response: z18.enum(["allow", "deny", "allowAlways"])
+var PermissionResponseSchema = z19.object({
+  id: z19.string(),
+  response: z19.enum(["allow", "deny", "allowAlways"])
 });
-var AskUserResponseSchema = z18.object({
-  id: z18.string(),
-  answers: z18.record(z18.string(), z18.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 FE_DIST = join27(import.meta.dirname, "fe", "dist");
 var MIME_TYPES = {
   ".html": "text/html; charset=utf-8",
   ".js": "application/javascript; charset=utf-8",
@@ -10111,7 +11619,7 @@ var MIME_TYPES = {
 };
 function serveStatic(path2) {
   const cleanPath = normalize(path2).replace(/^(\.\.[/\\])+/, "");
-  const fullPath = join26(FE_DIST, cleanPath);
+  const fullPath = join27(FE_DIST, cleanPath);
   if (!fullPath.startsWith(FE_DIST)) {
     return null;
   }
@@ -10282,13 +11790,13 @@ async function createRemoteAgent(opts) {
       if (!client) {
         throw new Error("no llm client (provider not initialized)");
       }
-      const { PermissionChecker: PC } = await import("./checker-BS4MK3O6.js");
-      const { Agent: AgentClass } = await import("./agent-IRY7KR5D.js");
+      const { PermissionChecker: PC } = await import("./checker-M7RKMKJQ.js");
+      const { Agent: AgentClass } = await import("./agent-YRTROHXU.js");
       const subConv = new ConversationManager();
       subConv.addUserMessage(prompt);
       const subAgent = new AgentClass({
         client,
-        registry,
+        registry: filterToolsForAgent(registry, void 0, void 0, false),
         checker: new PC(workDir, "acceptEdits"),
         conversation: subConv,
         workDir,
@@ -10461,6 +11969,7 @@ function buildToolRegistry(workDir, sessionId) {
   registry.register(new ReadFileTool());
   registry.register(new BashTool());
   registry.register(new PowerShellTool());
+  registry.register(new ComputerUseTool());
   registry.register(new GlobTool());
   registry.register(new GrepTool());
   registry.register(new WriteFileTool());
@@ -10492,6 +12001,7 @@ function wireSkillsToCommands(catalog, skillHost, cmdRegistry) {
         aliases: [],
         type: isFork ? "skill_fork" : "prompt",
         description: `${meta.description} [skill]`,
+        isSkill: true,
         handler: isFork ? () => "" : (ctx) => runInline(skill, ctx.args, skillHost)
       });
     } catch {
@@ -11014,7 +12524,9 @@ ${lines.join("\n")}`
         handle.client.setThinkingLevel?.(level);
         handle.provider.thinking = handle.client.getThinkingLevel?.() ?? level;
       } : void 0,
-      persistThinkingLevel: (level) => persistThinkingLevel(handle.provider.name, level)
+      persistThinkingLevel: (level) => {
+        persistThinkingLevel(handle.provider.name, level);
+      }
     };
   }
   /** Handles /compact command: force context compaction. */
@@ -11304,7 +12816,7 @@ Explore the codebase and design your approach.`
 };
 
 // src/teammate.ts
-import { basename as basename6, dirname as dirname10, join as join28 } from "path";
+import { basename as basename6, dirname as dirname10, join as join29 } from "path";
 
 // src/skills/install-tool.ts
 import { randomUUID as randomUUID2 } from "crypto";
@@ -11319,7 +12831,7 @@ import {
   renameSync as renameSync2,
   rmSync as rmSync2
 } from "fs";
-import { join as join27, resolve as resolve10 } from "path";
+import { join as join28, resolve as resolve10 } from "path";
 import yaml7 from "js-yaml";
 var log35 = createChildLogger({ module: "skills" });
 var InstallSkillTool = class {
@@ -11411,7 +12923,7 @@ ${parsed.body}
       ctx.abortSignal?.throwIfAborted();
       let dir = realpathSync(this.workDir);
       for (const segment of [".agents", "skills", name]) {
-        dir = join27(dir, segment);
+        dir = join28(dir, segment);
         const stat4 = lstatSync(dir, { throwIfNoEntry: false });
         if (stat4) {
           if (stat4.isSymbolicLink() || !stat4.isDirectory()) {
@@ -11421,12 +12933,12 @@ ${parsed.body}
           mkdirSync17(dir);
         }
       }
-      const destination = join27(dir, "SKILL.md");
+      const destination = join28(dir, "SKILL.md");
       const stat3 = lstatSync(destination, { throwIfNoEntry: false });
       if (stat3 && (stat3.isSymbolicLink() || !stat3.isFile())) {
         throw new Error(`Installation target must be a regular file: ${destination}`);
       }
-      const temporary = join27(dir, `.SKILL-${randomUUID2()}.tmp`);
+      const temporary = join28(dir, `.SKILL-${randomUUID2()}.tmp`);
       const fd = openSync2(temporary, "wx", stat3?.mode ?? 438);
       try {
         try {
@@ -11550,7 +13062,7 @@ async function runTeammate(args) {
   initLogger({
     sessionId: `teammate-${safeMemberName}-${Date.now().toString(36)}`,
     mode: "teammate",
-    logDir: join28(dirname10(args.teamDir), "logs"),
+    logDir: join29(dirname10(args.teamDir), "logs"),
     skipCleanup: true
   });
   process.on("exit", closeLogger);
@@ -11725,26 +13237,26 @@ function isDiffTool(toolName) {
 }
 
 // src/vscode/ide-client.ts
-import { setTimeout as delay } from "timers/promises";
+import { setTimeout as delay2 } from "timers/promises";
 import { Client as Client2 } from "@modelcontextprotocol/sdk/client/index.js";
-import { z as z20 } from "zod";
+import { z as z21 } from "zod";
 
 // src/vscode/lockfile.ts
-import { readdir as readdir2, readFile as readFile5 } from "fs/promises";
+import { readdir as readdir2, readFile as readFile6 } from "fs/promises";
 import { homedir as homedir10 } from "os";
-import { join as join29, resolve as resolve11, sep as sep2 } from "path";
-import { z as z19 } from "zod";
+import { join as join30, resolve as resolve11, sep as sep2 } from "path";
+import { z as z20 } from "zod";
 var log37 = createChildLogger({ module: "vscode" });
-var LockfileSchema = z19.object({
-  workspaceFolders: z19.array(z19.string()).optional(),
-  pid: z19.number().optional(),
-  ideName: z19.string().optional(),
-  transport: z19.enum(["ws", "sse"]).optional(),
-  authToken: z19.string().optional()
+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 ?? join29(homedir10(), ".claude");
-  return join29(configDir, "ide");
+  const configDir = process.env.CLAUDE_CONFIG_DIR ?? join30(homedir10(), ".claude");
+  return join30(configDir, "ide");
 }
 function cwdInWorkspace(cwd2, workspaceFolders) {
   const normalizedCwd = cwd2.normalize("NFC");
@@ -11762,7 +13274,7 @@ async function readLockfile(dir, filename) {
     return null;
   }
   try {
-    const content = await readFile5(join29(dir, filename), "utf-8");
+    const content = await readFile6(join30(dir, filename), "utf-8");
     const parsed = LockfileSchema.parse(JSON.parse(content));
     if (parsed.transport !== "ws") {
       return null;
@@ -11893,12 +13405,12 @@ var WebSocketTransport = class {
 
 // src/vscode/ide-client.ts
 var log38 = createChildLogger({ module: "vscode" });
-var AtMentionedSchema = z20.object({
-  method: z20.literal("at_mentioned"),
-  params: z20.object({
-    filePath: z20.string(),
-    lineStart: z20.number().optional(),
-    lineEnd: z20.number().optional()
+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() {
@@ -11912,7 +13424,7 @@ async function connectToIde(opts) {
   let ide = await detectIde(opts.cwd);
   while (!ide && Date.now() < deadline) {
     try {
-      await delay(1e3, void 0, { signal: opts.signal });
+      await delay2(1e3, void 0, { signal: opts.signal });
     } catch {
       return null;
     }
@@ -11994,6 +13506,7 @@ export {
   CodeReviewManager,
   CommandRegistry,
   CommandUsageTracker,
+  ComputerUseTool,
   ConfigError,
   ContextTooLongError,
   ConversationManager,
@@ -12022,6 +13535,7 @@ export {
   LLMError,
   ListTeamsTool,
   LoadSkillTool,
+  MAIN_AGENT_ONLY_TOOLS,
   MAX_DIMENSION_PX,
   MAX_HISTORY_ENTRIES,
   MAX_IMAGES_PER_MESSAGE,
@@ -12029,7 +13543,6 @@ export {
   MCPClient,
   MCPManager,
   MCPToolWrapper,
-  MCP_CALL_TOOL_NAME,
   MCP_NAME_SEP,
   MCP_TOOL_PREFIX,
   MIN_THINKING_ANSWER_TOKENS,
@@ -12076,7 +13589,6 @@ export {
   THINKING_BUDGETS,
   THINKING_LEVELS,
   TOOL_RESULT_PREVIEW_CHARS,
-  TOOL_SEARCH_TOOL_NAME,
   TaskCreateTool2 as TaskCreateTool,
   TaskGetTool2 as TaskGetTool,
   TaskList,