@swifty.js/swifty 0.0.35 → 0.0.36

package/dist/lib/index.js

@@ -10,8 +10,10 @@ import {
   ConversationManager,
   FileHistory,
   RecoveryState,
+  TOOL_RESULT_PREVIEW_CHARS,
   agent_exports,
   asImageMediaType,
+  buildPersistedOutputPreview,
   captureTelemetryError,
   compact_exports,
   conversation_exports,
@@ -27,6 +29,7 @@ import {
   loadSession,
   maybeResizeAndDownsampleImage,
   newSessionId,
+  persistLargeResult,
   plan_file_exports,
   plan_mode_exports,
   prompts_exports,
@@ -37,13 +40,14 @@ import {
   saveMessage,
   session_exports,
   shutdownTelemetry,
+  spillDir,
   telemetry_exports,
   tool_result_exports
-} from "./chunk-S5VWPTME.js";
+} from "./chunk-YUDCYSKO.js";
 import {
   version,
   version_exports
-} from "./chunk-OJTISIYU.js";
+} from "./chunk-PJ7354ZG.js";
 import {
   anthropic_exports,
   decideAndApply,
@@ -78,7 +82,7 @@ import {
   PermissionChecker,
   isSafeCommand,
   permissions_exports
-} from "./chunk-RUDYC7OS.js";
+} from "./chunk-BHSNJT6Z.js";
 import {
   MCPToolWrapper,
   MCP_TOOL_PREFIX,
@@ -347,9 +351,9 @@ __export(server_exports, {
   RemoteServer: () => RemoteServer,
   createRemoteAgent: () => createRemoteAgent
 });
-import { readFileSync as readFileSync16, existsSync as existsSync16, statSync as statSync9 } from "fs";
+import { readFileSync as readFileSync16, existsSync as existsSync16, statSync as statSync12 } from "fs";
 import { createServer } from "http";
-import { join as join20, extname as extname2, normalize } from "path";
+import { join as join21, extname as extname2, normalize } from "path";
 import { cwd } from "process";
 import Koa from "koa";
 import { WebSocketServer, WebSocket } from "ws";
@@ -1927,11 +1931,14 @@ import { resolve as resolve4 } from "path";
 // src/tools/descriptions.ts
 var descriptions_exports = {};
 __export(descriptions_exports, {
+  BASH_BACKGROUND_DESCRIPTION: () => BASH_BACKGROUND_DESCRIPTION,
   BASH_DESCRIPTION: () => BASH_DESCRIPTION,
   EDIT_FILE_DESCRIPTION: () => EDIT_FILE_DESCRIPTION,
   GLOB_DESCRIPTION: () => GLOB_DESCRIPTION,
   GREP_DESCRIPTION: () => GREP_DESCRIPTION,
+  JAVASCRIPT_BACKGROUND_DESCRIPTION: () => JAVASCRIPT_BACKGROUND_DESCRIPTION,
   JAVASCRIPT_DESCRIPTION: () => JAVASCRIPT_DESCRIPTION,
+  POWERSHELL_BACKGROUND_DESCRIPTION: () => POWERSHELL_BACKGROUND_DESCRIPTION,
   POWERSHELL_DESCRIPTION: () => POWERSHELL_DESCRIPTION,
   READ_FILE_DESCRIPTION: () => READ_FILE_DESCRIPTION,
   WEB_FETCH_DESCRIPTION: () => WEB_FETCH_DESCRIPTION,
@@ -1943,15 +1950,18 @@ var BASH_DESCRIPTION = `Execute command in Bash; return stdout and stderr. Prefe
 - Quote paths with spaces. To change directory, use cd "path" && command in the same call. Separate independent commands; chain dependent commands with &&, not ;.
 - Prefer dedicated file/search tools over cat, head, tail, sed, awk, echo, or find. Scope searches to a directory, never the filesystem root. Diagnose failures rather than retrying in sleep loops.
 ${GIT_GUIDANCE}`;
+var BASH_BACKGROUND_DESCRIPTION = `- Set run_in_background to true to run the command in the background. The call returns a task ID immediately and the result arrives later as a task notification; do not poll or sleep waiting for it. Use this for long-running commands you do not need the result of right away. Use TaskStop with the task_id to kill a background command early. A foreground command that exceeds its timeout is moved to the background automatically instead of being killed, unless it is a bare sleep.`;
 var POWERSHELL_DESCRIPTION = `Execute command in PowerShell; return stdout and stderr. Recommended on Windows (powershell.exe); uses pwsh elsewhere.
 - timeout is in seconds: default 120, maximum 600. Each call starts a fresh, independent shell in the Agent's working directory; location, variables, and options do not persist.
 - Quote paths with spaces; use Set-Location -LiteralPath "path" in the same call. Separate independent commands. For dependencies, check $LASTEXITCODE for native commands and use -ErrorAction Stop for cmdlets; ; does not stop on failure. Do not assume PowerShell 7 syntax.
 - Prefer dedicated file/search tools over Get-Content, Select-String, or Write-Output. Scope recursion to a directory, not a drive root. Diagnose failures rather than retrying in Start-Sleep loops.
 ${GIT_GUIDANCE}`;
+var POWERSHELL_BACKGROUND_DESCRIPTION = `- Set run_in_background to true to run the command in the background. The call returns a task ID immediately and the result arrives later as a task notification; do not poll or Start-Sleep waiting for it. Use this for long-running commands you do not need the result of right away. Use TaskStop with the task_id to kill a background command early. A foreground command that exceeds its timeout is moved to the background automatically instead of being killed, unless it is a bare Start-Sleep.`;
 var JAVASCRIPT_DESCRIPTION = `Execute JavaScript in a fresh isolated V8 context for pure computation.
 - Provide a function body and use return to produce a JSON-compatible result. Optional input is available as globalThis.input.
 - No filesystem, network, process, require, imports, timers, or host callbacks are available. Use Bash for Node.js or system operations.
 - timeout_ms defaults to 1000 (max 10000); memory_limit_mb defaults to 64 (max 256). Requires Node.js 24 or newer.`;
+var JAVASCRIPT_BACKGROUND_DESCRIPTION = `- Set run_in_background to true to evaluate in the background. The call returns a task ID immediately and the result arrives later as a task notification; do not poll. timeout_ms still caps the evaluation (max 10000). Use TaskStop with the task_id to abort it early.`;
 var READ_FILE_DESCRIPTION = `Read text with 1-based display line numbers, or images (png, jpg, jpeg, gif, webp) as visual content; not directories.
 - file_path is absolute or relative to the Agent's working directory. offset skips lines (0-based, default 0); limit defaults to 2000 lines, with a 50KB text output cap. Displayed line 101 starts at offset=100. Follow continuation/readback instructions for partial output.
 - Images ignore offset/limit. A successful read refreshes the file-state cache used by EditFile/WriteFile; re-read after an external-change error.`;
@@ -3178,7 +3188,9 @@ var MemoryManager = class {
     return this.loadAll();
   }
   /**
-   * Builds the memory index injected into the system prompt.
+   * Builds the memory index injected into the conversation as a
+   * system-reminder message (not the system prompt, which stays
+   * project-independent to preserve prompt caching).
    *
    * This content is re-sent to the model on every conversation turn, so each additional index line
    * is a recurring cost. We therefore enforce both a line-count and a byte-size cap at the output
@@ -3268,8 +3280,9 @@ ${body}
   // ── Feature 2: findRelevantMemories ────────────────────────────────
   /**
    * Scans all memory headers from both dirs, asks the LLM to select the
-   * top 5 most relevant ones for the query, and returns the full content
-   * of those files. Best-effort: selector failures return an empty array.
+   * top 5 most relevant ones for the query, and returns their paths (with
+   * mtimes); the file contents are read later by renderReminder.
+   * Best-effort: selector failures return an empty array.
    */
   async findRelevantMemories(query, client, recentTools = [], alreadySurfaced = /* @__PURE__ */ new Set()) {
     const allHeaders = [];
@@ -4543,27 +4556,37 @@ function parseAgentDefinition(content) {
 // src/subagent/task-manager.ts
 var task_manager_exports = {};
 __export(task_manager_exports, {
+  TaskFailure: () => TaskFailure,
   TaskManager: () => TaskManager,
   formatAgentTaskNotification: () => formatAgentTaskNotification
 });
+var TaskFailure = class extends Error {
+  constructor(output) {
+    super("task failed");
+    this.output = output;
+  }
+  output;
+};
 var TaskManager = class {
   tasks = /* @__PURE__ */ new Map();
   notifiedTaskIds = /* @__PURE__ */ new Set();
   listeners = /* @__PURE__ */ new Set();
   nextId = 1;
+  pendingTaskIds = /* @__PURE__ */ new Set();
   create(name, runner, cancel, options = {}) {
-    const id = `agent-${String(this.nextId++)}`;
+    const id = `${options.idPrefix ?? "agent"}-${String(this.nextId++)}`;
     const task = {
       id,
       name,
       ...options.originToolCallId ? { originToolCallId: options.originToolCallId } : {},
+      ...options.kind ? { kind: options.kind } : {},
       status: "running",
       output: "",
       cancel,
       done: Promise.resolve()
     };
     this.tasks.set(id, task);
-    this.emitChange();
+    this.pendingTaskIds.add(id);
     task.done = Promise.resolve().then(() => runner(task)).then((output) => {
       if (task.status === "running") {
         task.status = "completed";
@@ -4573,10 +4596,17 @@ var TaskManager = class {
     }).catch((error) => {
       if (task.status === "running") {
         task.status = "failed";
-        task.output = `Error: ${asErrorString(error)}`;
+        task.output = error instanceof TaskFailure ? error.output : `Error: ${asErrorString(error)}`;
+        this.emitChange();
+      } else if (task.status === "cancelled" && error instanceof TaskFailure) {
+        task.output = error.output;
         this.emitChange();
       }
+    }).finally(() => {
+      this.pendingTaskIds.delete(id);
+      this.emitChange();
     });
+    this.emitChange();
     return task;
   }
   get(id) {
@@ -4614,25 +4644,32 @@ var TaskManager = class {
   }
   async stopAndWait(id) {
     const task = this.tasks.get(id);
-    if (!task || !this.stop(id)) {
+    if (!task) {
       return false;
     }
+    const stopped = this.stop(id);
     await task.done;
-    return true;
+    return stopped;
   }
   async stopAll() {
-    const running = this.list().filter((task) => task.status === "running");
+    const running = this.list().filter((task) => this.pendingTaskIds.has(task.id));
     for (const task of running) {
       this.stop(task.id);
     }
     await Promise.allSettled(running.map((task) => task.done));
   }
-  async waitAll() {
-    await Promise.allSettled(this.list().map((task) => task.done));
+  /**
+   * Wait for tasks to settle. An optional filter selects which tasks to wait
+   * for (e.g. print-mode waits only for agent-kind tasks: shell/js tasks may
+   * run indefinitely and are stopped, not awaited, at exit).
+   */
+  async waitAll(filter) {
+    const tasks = filter ? this.list().filter(filter) : this.list();
+    await Promise.allSettled(tasks.map((task) => task.done));
   }
   drainNotifications() {
     const completed = this.list().filter(
-      (task) => task.status !== "running" && !this.notifiedTaskIds.has(task.id)
+      (task) => task.status !== "running" && !this.pendingTaskIds.has(task.id) && !this.notifiedTaskIds.has(task.id)
     );
     for (const task of completed) {
       this.notifiedTaskIds.add(task.id);
@@ -6218,6 +6255,7 @@ async function spawnSubagent(definition, prompt, parentClient, parentRegistry, p
   const conversation = options.conversation ?? new ConversationManager();
   conversation.addSystemReminder(buildSubagentInstructions(definition));
   conversation.addUserMessage(prompt);
+  const taskManager = options.backgroundTasks === false ? null : new TaskManager();
   const agent2 = new Agent({
     client,
     registry,
@@ -6230,53 +6268,59 @@ async function spawnSubagent(definition, prompt, parentClient, parentRegistry, p
     fileStateCache: new FileStateCache(),
     instructions: loadInstructions(workDir),
     contextWindow: getContextWindow(provider),
-    maxOutput: getMaxOutputTokens(provider)
+    maxOutput: getMaxOutputTokens(provider),
+    taskManager,
+    notificationFn: taskManager ? () => taskManager.drainNotifications().map(formatAgentTaskNotification) : void 0
   });
   let output = "";
   let turn = 0;
-  for await (const event of agent2.run()) {
-    switch (event.type) {
-      case "stream_text":
-        output += event.text;
-        break;
-      case "tool_use":
-        onProgress?.({ lastTool: event.toolName });
-        onEvent?.({
-          type: "tool_use",
-          toolId: event.toolId,
-          toolName: event.toolName,
-          args: event.args
-        });
-        break;
-      case "tool_result":
-        onEvent?.({
-          type: "tool_result",
-          toolId: event.toolId
-        });
-        break;
-      case "usage":
-        onEvent?.({
-          type: "usage",
-          usage: {
-            inputTokens: event.usage.inputTokens,
-            outputTokens: event.usage.outputTokens
+  try {
+    for await (const event of agent2.run()) {
+      switch (event.type) {
+        case "stream_text":
+          output += event.text;
+          break;
+        case "tool_use":
+          onProgress?.({ lastTool: event.toolName });
+          onEvent?.({
+            type: "tool_use",
+            toolId: event.toolId,
+            toolName: event.toolName,
+            args: event.args
+          });
+          break;
+        case "tool_result":
+          onEvent?.({
+            type: "tool_result",
+            toolId: event.toolId
+          });
+          break;
+        case "usage":
+          onEvent?.({
+            type: "usage",
+            usage: {
+              inputTokens: event.usage.inputTokens,
+              outputTokens: event.usage.outputTokens
+            }
+          });
+          break;
+        case "turn_complete":
+          onProgress?.({ turn: ++turn });
+          onEvent?.({ type: "turn_complete" });
+          break;
+        case "loop_complete":
+          if (event.stopReason === "interrupted") {
+            return `${output}${output ? "\n\n" : ""}${SUBAGENT_INTERRUPTED_MARKER}`;
           }
-        });
-        break;
-      case "turn_complete":
-        onProgress?.({ turn: ++turn });
-        onEvent?.({ type: "turn_complete" });
-        break;
-      case "loop_complete":
-        if (event.stopReason === "interrupted") {
-          return `${output}${output ? "\n\n" : ""}${SUBAGENT_INTERRUPTED_MARKER}`;
-        }
-        return output || "[No output]";
-      case "error":
-        throw event.error;
+          return output || "[No output]";
+        case "error":
+          throw event.error;
+      }
     }
+    return output || "[No output]";
+  } finally {
+    await taskManager?.stopAll();
   }
-  return output || "[No output]";
 }
 
 // src/teams/coordinator.ts
@@ -7063,7 +7107,7 @@ var TaskStopTool = class {
   teamManager;
   taskManager;
   name = "TaskStop";
-  description = "Stop a running teammate or background Agent task. Pass exactly one of teammate or task_id.";
+  description = "Stop a running teammate or background task (Agent, Bash, PowerShell or JavaScript). Pass exactly one of teammate or task_id.";
   category = "command";
   schema() {
     return {
@@ -7078,20 +7122,21 @@ var TaskStopTool = class {
           },
           task_id: {
             type: "string",
-            description: "ID of a background Agent task"
+            description: "ID of a background task (Agent, Bash, PowerShell or JavaScript)"
           }
         }
       }
     };
   }
-  async execute(_ctx, args) {
+  async execute(ctx, args) {
     const name = strArg(args, "teammate", "");
     const taskId = strArg(args, "task_id", "");
     if (!name && !taskId || name && taskId) {
       return { output: "Error: pass exactly one of teammate or task_id", isError: true };
     }
     if (taskId) {
-      const task = this.taskManager?.get(taskId);
+      const manager = ctx.taskManager?.get(taskId) ? ctx.taskManager : this.taskManager;
+      const task = manager?.get(taskId);
       if (!task) {
         return { output: `Error: background task '${taskId}' not found`, isError: true };
       }
@@ -7101,7 +7146,7 @@ var TaskStopTool = class {
           isError: false
         };
       }
-      await this.taskManager?.stopAndWait(taskId);
+      await manager?.stopAndWait(taskId);
       return { output: `Background task '${taskId}' stopped.`, isError: false };
     }
     for (const team of this.teamManager.list()) {
@@ -7425,16 +7470,7 @@ ${prompt}` };
       shutdown: shutdownRequest("lead", "member deactivated")
     };
   }
-  /**
-   * Sends the teammate's completed plan to the Lead, blocks until approval is received,
-   * and returns the prompt to feed the model on the next turn.
-   *
-   * The teammate holds read-only permissions at this point, so no matter how long the
-   * wait, no damage can occur — hence no timeout is set here. Rather than timing out and
-   * autonomously modifying files, it is better to wait indefinitely and let the user
-   * drive progress from the Lead side. Returns null when the teammate has been
-   * deactivated; the caller should exit the main loop.
-   */
+  /** Reads the teammate's plan file for review; returns a fallback note when empty or unreadable. */
   readPlanForReview() {
     try {
       const text = readFileSync14(getOrCreatePlanPath(this.workDir), "utf-8");
@@ -7445,6 +7481,16 @@ ${prompt}` };
     }
     return "(Plan file is empty \u2014 the teammate may not have written the plan as expected)";
   }
+  /**
+   * Sends the teammate's completed plan to the Lead, blocks until approval is received,
+   * and returns the prompt to feed the model on the next turn.
+   *
+   * The teammate holds read-only permissions at this point, so no matter how long the
+   * wait, no damage can occur — hence no timeout is set here. Rather than timing out and
+   * autonomously modifying files, it is better to wait indefinitely and let the user
+   * drive progress from the Lead side. Returns null when the teammate has been
+   * deactivated; the caller should exit the main loop.
+   */
   async runPlanApproval(member, plan) {
     const req = planApprovalRequest(member.name, plan);
     await this.leadMailbox.send(member.name, req.text, req);
@@ -8139,8 +8185,50 @@ __export(bash_exports, {
   BashTool: () => BashTool
 });
 import { spawn as spawn2 } from "child_process";
+import { statSync as statSync10 } from "fs";
+
+// src/tools/shell-background.ts
+var shell_background_exports = {};
+__export(shell_background_exports, {
+  BACKGROUNDABLE_TOOL_NAMES: () => BACKGROUNDABLE_TOOL_NAMES,
+  BACKGROUND_MAX_OUTPUT_BYTES: () => BACKGROUND_MAX_OUTPUT_BYTES,
+  BACKGROUND_NOTIFICATION_CHARS: () => BACKGROUND_NOTIFICATION_CHARS,
+  SIZE_WATCHDOG_INTERVAL_MS: () => SIZE_WATCHDOG_INTERVAL_MS,
+  attachBackgroundTaskManager: () => attachBackgroundTaskManager,
+  backgroundAllForegroundTasks: () => backgroundAllForegroundTasks,
+  backgroundMessage: () => backgroundMessage,
+  backgroundTaskName: () => backgroundTaskName,
+  buildBackgroundBody: () => buildBackgroundBody,
+  createShellOutputFile: () => createShellOutputFile,
+  discardFd: () => discardFd,
+  formatFinalResult: () => formatFinalResult,
+  hasAnyForegroundTasks: () => hasAnyForegroundTasks,
+  isAutobackgroundingAllowed: () => isAutobackgroundingAllowed,
+  openOutputFd: () => openOutputFd,
+  readOutputFile: () => readOutputFile,
+  sliceUtf8Safe: () => sliceUtf8Safe,
+  unlinkQuiet: () => unlinkQuiet
+});
+import { randomBytes as randomBytes3 } from "crypto";
+import {
+  closeSync as closeSync2,
+  constants as fsConstants,
+  fstatSync,
+  mkdirSync as mkdirSync12,
+  openSync as openSync2,
+  readSync,
+  statSync as statSync9,
+  unlinkSync as unlinkSync5
+} from "fs";
+import { tmpdir } from "os";
+import { join as join19 } from "path";
 
 // src/tools/exit-code-hints.ts
+var exit_code_hints_exports = {};
+__export(exit_code_hints_exports, {
+  exitCodeHint: () => exitCodeHint,
+  extractBaseCmd: () => extractBaseCmd
+});
 function extractBaseCmd(command) {
   const lastSegment = command.split("|").pop()?.trim() ?? command;
   const tokens = lastSegment.split(/\s+/);
@@ -8372,9 +8460,201 @@ function exitCodeHint(command, exitCode) {
   return "";
 }
 
+// src/tools/shell-background.ts
+var BACKGROUND_NOTIFICATION_CHARS = 3e4;
+var BACKGROUND_MAX_OUTPUT_BYTES = 5 * 1024 * 1024 * 1024;
+var SIZE_WATCHDOG_INTERVAL_MS = 500;
+function isAutobackgroundingAllowed(command, disallowed) {
+  const first = /^\S+/.exec(command.trimStart())?.[0] ?? "";
+  const base = first.replace(/^.*\//, "").replace(/^["']|["']$/g, "").toLowerCase();
+  return !disallowed.has(base);
+}
+function backgroundTaskName(command) {
+  const flat = command.replace(/\s+/g, " ").trim();
+  return flat.length > 80 ? `${flat.slice(0, 77)}...` : flat;
+}
+function backgroundMessage(reason, taskId, timeout) {
+  switch (reason) {
+    case "explicit":
+      return `Command running in background (task_id: ${taskId}). You will be notified when it completes; do not poll. Use TaskStop with task_id to kill it early.`;
+    case "timeout":
+      return `Command exceeded its ${String(timeout)}s timeout and was moved to the background (task_id: ${taskId}). It is still running \u2014 you will be notified when it completes.`;
+    case "user":
+      return `Command was manually backgrounded by the user (task_id: ${taskId}). It is still running \u2014 you will be notified when it completes.`;
+  }
+}
+function sliceUtf8Safe(buf, maxBytes) {
+  if (buf.length <= maxBytes) {
+    return buf;
+  }
+  let end = maxBytes;
+  while (end > 0 && (buf[end] & 192) === 128) {
+    end--;
+  }
+  return buf.subarray(0, end);
+}
+function readOutputFile(path, maxBytes) {
+  let fd;
+  try {
+    fd = openSync2(path, "r");
+  } catch {
+    return { text: "", size: 0, truncated: false };
+  }
+  try {
+    const size = fstatSync(fd).size;
+    const readLen = Math.min(size, maxBytes + 1);
+    const buf = Buffer.alloc(readLen);
+    let bytesRead = 0;
+    while (bytesRead < readLen) {
+      const count = readSync(fd, buf, bytesRead, readLen - bytesRead, bytesRead);
+      if (count === 0) {
+        break;
+      }
+      bytesRead += count;
+    }
+    return {
+      text: sliceUtf8Safe(buf.subarray(0, bytesRead), maxBytes).toString("utf-8"),
+      size,
+      truncated: size > maxBytes
+    };
+  } finally {
+    closeSync2(fd);
+  }
+}
+function unlinkQuiet(path) {
+  try {
+    unlinkSync5(path);
+  } catch {
+  }
+}
+function discardFd(fd) {
+  try {
+    closeSync2(fd);
+  } catch {
+  }
+}
+function openOutputFd(path) {
+  const flags = process.platform === "win32" ? "w" : fsConstants.O_WRONLY | fsConstants.O_CREAT | fsConstants.O_APPEND | fsConstants.O_NOFOLLOW;
+  return openSync2(path, flags, 384);
+}
+function createShellOutputFile(workDir, sessionId) {
+  const fileName = `shell-${randomBytes3(8).toString("hex")}.output`;
+  const candidates = [];
+  try {
+    const dir = spillDir(workDir, sessionId);
+    mkdirSync12(dir, { recursive: true });
+    candidates.push(join19(dir, fileName));
+  } catch {
+  }
+  candidates.push(join19(tmpdir(), fileName));
+  let lastError = new Error("no candidate output directory");
+  for (const path of candidates) {
+    try {
+      return { path, fd: openOutputFd(path) };
+    } catch (error) {
+      lastError = error;
+    }
+  }
+  throw lastError instanceof Error ? lastError : new Error(String(lastError));
+}
+function formatFinalResult(prompt, command, exit, merged, truncated, timeout) {
+  if (exit.spawnError) {
+    return {
+      output: `Error executing command: ${exit.spawnError}`,
+      isError: true
+    };
+  }
+  if (exit.aborted || exit.timedOut) {
+    const captured = merged || truncated ? formatShellOutput(prompt, command, merged, "", truncated) : "";
+    const error = exit.aborted ? "Error: command interrupted" : `Error: command timed out after ${String(timeout)}s`;
+    return {
+      output: captured ? `${captured}
+${error}` : error,
+      isError: true
+    };
+  }
+  const exitCode = exit.code ?? 0;
+  let output = formatShellOutput(prompt, command, merged, "", truncated);
+  if (!truncated) {
+    if (exitCode !== 0) {
+      const hint = exitCodeHint(command, exitCode);
+      output += hint ? `
+Exit code ${String(exitCode)} (${hint})` : `
+Exit code ${String(exitCode)}`;
+    }
+    if (exit.code === null) {
+      output += `
+Process terminated${exit.signal ? ` by ${exit.signal}` : " unexpectedly"}`;
+    }
+  }
+  return { output, isError: truncated || exitCode !== 0 || exit.code === null };
+}
+function buildBackgroundBody(prompt, command, exit, outputPath, timeout, annotate) {
+  let size = 0;
+  try {
+    size = statSync9(outputPath).size;
+  } catch {
+  }
+  let result;
+  if (size <= BACKGROUND_NOTIFICATION_CHARS) {
+    const read = readOutputFile(outputPath, MAX_SHELL_OUTPUT_BYTES);
+    const merged = annotate ? annotate(read.text) : read.text;
+    result = formatFinalResult(prompt, command, exit, merged, read.truncated, timeout);
+    unlinkQuiet(outputPath);
+  } else {
+    const header = formatFinalResult(prompt, command, exit, "", false, timeout);
+    const preview2 = readOutputFile(outputPath, TOOL_RESULT_PREVIEW_CHARS).text;
+    result = {
+      output: `${header.output}
+${buildPersistedOutputPreview(size, annotate ? annotate(preview2) : preview2, outputPath)}`,
+      isError: header.isError
+    };
+  }
+  if (exit.sizeKilled) {
+    result.output += "\nBackground command killed: output file exceeded 5GB";
+    result.isError = true;
+  }
+  return result;
+}
+var BACKGROUNDABLE_TOOL_NAMES = ["Bash", "PowerShell", "JavaScript"];
+function asBackgroundable(tool) {
+  if (typeof tool === "object" && tool !== null && "taskManager" in tool && "backgroundForegroundTasks" in tool) {
+    return tool;
+  }
+  return null;
+}
+function attachBackgroundTaskManager(registry, manager) {
+  for (const name of BACKGROUNDABLE_TOOL_NAMES) {
+    const tool = asBackgroundable(registry.get(name));
+    if (tool) {
+      tool.taskManager = manager;
+    }
+  }
+}
+function hasAnyForegroundTasks(registry) {
+  for (const name of BACKGROUNDABLE_TOOL_NAMES) {
+    const tool = asBackgroundable(registry.get(name));
+    if (tool?.hasForegroundTasks()) {
+      return true;
+    }
+  }
+  return false;
+}
+function backgroundAllForegroundTasks(registry) {
+  let count = 0;
+  for (const name of BACKGROUNDABLE_TOOL_NAMES) {
+    const tool = asBackgroundable(registry.get(name));
+    if (tool) {
+      count += tool.backgroundForegroundTasks();
+    }
+  }
+  return count;
+}
+
 // src/tools/bash.ts
 var MAX_TIMEOUT = 600;
 var KILL_GRACE_MS = 3e3;
+var DISALLOWED_AUTO_BACKGROUND_COMMANDS = /* @__PURE__ */ new Set(["sleep"]);
 var BashTool = class {
   // Use a hardcoded string instead of BashTool.name.replace("Tool", "")
   // because class names are not stable after minification — bundlers like
@@ -8390,6 +8670,18 @@ var BashTool = class {
     denyWrite: [],
     networkEnabled: true
   };
+  /**
+   * Background task registry, injected by the host (TUI / print mode / remote
+   * server) — the same instance the Agent tool uses, so completion
+   * notifications share one drain and TaskStop covers both. When null, Bash is
+   * foreground-only: run_in_background disappears from the schema, timeouts
+   * kill, and Ctrl+B is a no-op. Calls running inside a subagent loop carry
+   * that loop's own manager in ctx.taskManager, which takes precedence.
+   */
+  taskManager = null;
+  /** Running foreground executions eligible for manual backgrounding (Ctrl+B). */
+  foreground = /* @__PURE__ */ new Map();
+  nextForegroundId = 1;
   /**
    * Read-only commands can run concurrently with other read-only tools;
    * mutating commands must run exclusively.
@@ -8404,26 +8696,62 @@ var BashTool = class {
     const command = args.command;
     return typeof command === "string" && isSafeCommand(command);
   }
+  /**
+   * The background subsystem needs a task manager and can be disabled
+   * wholesale with SWIFTY_DISABLE_BACKGROUND_TASKS=1 (schema parameter
+   * removed, timeouts kill, Ctrl+B becomes a no-op). Instance-level gate used
+   * by the schema; execute() re-checks with the ctx-resolved manager.
+   */
+  backgroundEnabled() {
+    return this.taskManager !== null && process.env.SWIFTY_DISABLE_BACKGROUND_TASKS !== "1";
+  }
+  /** True while at least one foreground Bash command runs (gates the Ctrl+B handler). */
+  hasForegroundTasks() {
+    return this.foreground.size > 0;
+  }
+  /**
+   * Move every running foreground Bash command to the background (Ctrl+B).
+   * Returns how many commands were actually backgrounded.
+   */
+  backgroundForegroundTasks() {
+    let count = 0;
+    for (const entry of [...this.foreground.values()]) {
+      if (entry.background()) {
+        count++;
+      }
+    }
+    return count;
+  }
   schema() {
-    const inputSchema = {
-      type: "object",
-      properties: {
-        command: {
-          type: "string",
-          description: "Shell command to execute"
-        },
-        timeout: {
-          type: "integer",
-          description: "Timeout in seconds (max 600)",
-          default: 120
-        }
+    const properties = {
+      command: {
+        type: "string",
+        description: "Shell command to execute"
       },
-      required: ["command"]
+      timeout: {
+        type: "integer",
+        description: "Timeout in seconds (max 600)",
+        default: 120
+      }
     };
+    let description = this.description;
+    if (this.backgroundEnabled()) {
+      properties.run_in_background = {
+        type: "boolean",
+        description: "Run the command in the background. Returns a task ID immediately; the result arrives later as a task notification.",
+        default: false
+      };
+      description = `${this.description}
+${BASH_BACKGROUND_DESCRIPTION}`;
+    }
     return {
       name: this.name,
-      description: this.description,
-      input_schema: inputSchema
+      description,
+      input_schema: {
+        type: "object",
+        properties,
+        required: ["command"]
+      }
     };
   }
   async execute(ctx, args) {
@@ -8444,12 +8772,29 @@ var BashTool = class {
     if (timeout > MAX_TIMEOUT) {
       timeout = MAX_TIMEOUT;
     }
+    const manager = ctx.taskManager !== void 0 ? ctx.taskManager : this.taskManager;
+    const backgroundAvailable = manager !== null && process.env.SWIFTY_DISABLE_BACKGROUND_TASKS !== "1";
+    const runInBackground = boolArg(args, "run_in_background") && backgroundAvailable;
+    let outputFile;
+    try {
+      outputFile = createShellOutputFile(ctx.workDir, ctx.sessionId ?? "");
+    } catch (error) {
+      return {
+        output: `Error creating output file: ${asErrorString(error)}`,
+        isError: true
+      };
+    }
+    const discardOutputFile = () => {
+      discardFd(outputFile.fd);
+      unlinkQuiet(outputFile.path);
+    };
     let prepared = {
       executable: "bash",
       args: ["-c", command]
     };
     if (this.sandboxRequired || this.sandbox) {
       if (!this.sandbox) {
+        discardOutputFile();
         return {
           output: "Error: sandbox is enabled but unavailable; command was not executed",
           isError: true
@@ -8457,17 +8802,28 @@ var BashTool = class {
       }
       try {
         if (!await this.sandbox.available()) {
+          discardOutputFile();
           return {
             output: `Error: ${this.sandbox.implementation} sandbox is unavailable; command was not executed`,
             isError: true
           };
         }
-        prepared = await this.sandbox.prepare(command, this.sandboxConfig, {
-          cwd: ctx.workDir,
-          abortSignal: ctx.abortSignal,
-          commandId: ctx.toolCallId
-        });
+        prepared = await this.sandbox.prepare(
+          command,
+          {
+            ...this.sandboxConfig,
+            // The child writes its output file directly; grant write access to
+            // that path even under a strict allowWrite config.
+            allowWrite: [...this.sandboxConfig.allowWrite, outputFile.path]
+          },
+          {
+            cwd: ctx.workDir,
+            abortSignal: ctx.abortSignal,
+            commandId: ctx.toolCallId
+          }
+        );
       } catch (error) {
+        discardOutputFile();
         return {
           output: `Error preparing sandbox: ${asErrorString(error)}`,
           isError: true
@@ -8475,6 +8831,7 @@ var BashTool = class {
       }
     }
     if (ctx.abortSignal?.aborted) {
+      discardOutputFile();
       try {
         await prepared.cleanup?.();
       } catch {
@@ -8484,22 +8841,58 @@ var BashTool = class {
         isError: true
       };
     }
-    return new Promise((resolve12) => {
-      let timedOut = false;
+    const handle = this.startCommand(ctx, prepared, command, timeout, outputFile, manager);
+    if (runInBackground) {
+      const taskId = handle.background("explicit");
+      if (taskId !== null) {
+        return {
+          output: backgroundMessage("explicit", taskId, timeout),
+          isError: false
+        };
+      }
+    }
+    return handle.result;
+  }
+  /**
+   * Spawn the command with stdout+stderr writing directly into the output
+   * file (ccb's file-descriptor mode): output never flows through JS, so
+   * backgrounding is a bookkeeping switch — no re-spawn, no buffer handover.
+   * The returned handle exposes the tool-call promise plus a background()
+   * trigger that transitions the running command into a TaskManager task.
+   */
+  startCommand(ctx, prepared, command, timeout, outputFile, manager) {
+    let backgroundFn;
+    const result = new Promise((resolve12) => {
       let aborted = false;
       let terminating = false;
       let settled = false;
+      let backgrounded = false;
+      let sizeKilled = false;
       let escalateTimer = null;
-      const child = spawn2(prepared.executable, prepared.args, {
-        cwd: ctx.workDir,
-        detached: true,
-        env: prepared.env,
-        stdio: ["ignore", "pipe", "pipe"]
+      let child;
+      try {
+        child = spawn2(prepared.executable, prepared.args, {
+          cwd: ctx.workDir,
+          detached: true,
+          env: prepared.env,
+          // stdout and stderr share one O_APPEND fd: each write lands on disk
+          // atomically and the streams interleave chronologically.
+          stdio: ["ignore", outputFile.fd, outputFile.fd]
+        });
+      } catch (error) {
+        discardFd(outputFile.fd);
+        unlinkQuiet(outputFile.path);
+        resolve12({
+          output: `Error executing command: ${asErrorString(error)}`,
+          isError: true
+        });
+        return;
+      }
+      discardFd(outputFile.fd);
+      let doneResolve;
+      const done = new Promise((resolveDone) => {
+        doneResolve = resolveDone;
       });
-      let stdout = "";
-      let stderr = "";
-      let total = 0;
-      let outputTruncated = false;
       const killTree = (signal) => {
         if (typeof child.pid !== "number") {
           return;
@@ -8521,41 +8914,35 @@ var BashTool = class {
         killTree("SIGTERM");
         escalateTimer = setTimeout(() => {
           killTree("SIGKILL");
-          child.stdout.destroy();
-          child.stderr.destroy();
         }, KILL_GRACE_MS);
         escalateTimer.unref();
       };
-      const appendChunk = (chunk, target) => {
-        if (outputTruncated) {
+      const watchdog = setInterval(() => {
+        let size = 0;
+        try {
+          size = statSync10(outputFile.path).size;
+        } catch {
           return;
         }
-        const remaining = MAX_SHELL_OUTPUT_BYTES - total;
-        const piece = takeUtf8Prefix(chunk, remaining);
-        total += utf8ByteLength(piece);
-        if (piece.length < chunk.length) {
-          outputTruncated = true;
+        const cap = backgrounded ? BACKGROUND_MAX_OUTPUT_BYTES : MAX_SHELL_OUTPUT_BYTES;
+        if (size > cap) {
+          sizeKilled = backgrounded;
+          clearInterval(watchdog);
           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");
-      });
+      }, SIZE_WATCHDOG_INTERVAL_MS);
+      watchdog.unref();
       const onAbort = () => {
         aborted = true;
         terminate();
       };
+      const backgroundAvailableHere = manager !== null && process.env.SWIFTY_DISABLE_BACKGROUND_TASKS !== "1";
+      const autoBackgroundAllowed = backgroundAvailableHere && isAutobackgroundingAllowed(command, DISALLOWED_AUTO_BACKGROUND_COMMANDS);
+      let timedOut = false;
       const timeoutTimer = setTimeout(() => {
+        if (autoBackgroundAllowed && backgroundExecution("timeout") !== null) {
+          return;
+        }
         timedOut = true;
         terminate();
       }, timeout * 1e3);
@@ -8564,14 +8951,17 @@ var BashTool = class {
       if (ctx.abortSignal?.aborted) {
         onAbort();
       }
+      const foregroundKey = `bash-${String(this.nextForegroundId++)}`;
       const cleanup = () => {
         clearTimeout(timeoutTimer);
+        clearInterval(watchdog);
         if (escalateTimer) {
           clearTimeout(escalateTimer);
         }
         ctx.abortSignal?.removeEventListener("abort", onAbort);
+        this.foreground.delete(foregroundKey);
       };
-      const settle = (result) => {
+      const settle = (finalResult) => {
         if (settled) {
           return;
         }
@@ -8582,54 +8972,105 @@ var BashTool = class {
         };
         void finalize().then(
           () => {
-            resolve12(result);
+            resolve12(finalResult);
           },
           (error) => {
             resolve12({
-              output: `${result.output}
+              output: `${finalResult.output}
 Error cleaning up sandbox: ${asErrorString(error)}`,
               isError: true
             });
           }
         );
       };
-      child.on("error", (error) => {
-        settle({
-          output: `Error executing command: ${error.message}`,
-          isError: true
-        });
-      });
-      child.on("close", (code, signal) => {
-        stderr = prepared.annotateStderr?.(stderr) ?? stderr;
-        if (aborted || timedOut) {
-          const captured = stdout || stderr || outputTruncated ? formatShellOutput("$ ", command, stdout, stderr, outputTruncated) : "";
-          const error = aborted ? "Error: command interrupted" : `Error: command timed out after ${String(timeout)}s`;
-          settle({
-            output: captured ? `${captured}
-${error}` : error,
-            isError: true
-          });
-          return;
-        }
-        const exitCode = code ?? 0;
-        let output = formatShellOutput("$ ", command, stdout, stderr, outputTruncated);
-        if (outputTruncated) {
-          settle({ output, isError: true });
+      const settleExit = (exit) => {
+        if (backgrounded) {
           return;
         }
-        if (exitCode !== 0) {
-          const hint = exitCodeHint(command, exitCode);
-          output += hint ? `
-Exit code ${String(exitCode)} (${hint})` : `
-Exit code ${String(exitCode)}`;
+        const read = readOutputFile(outputFile.path, MAX_SHELL_OUTPUT_BYTES);
+        const merged = prepared.annotateStderr?.(read.text) ?? read.text;
+        const finalResult = formatFinalResult("$ ", command, exit, merged, read.truncated, timeout);
+        unlinkQuiet(outputFile.path);
+        settle(finalResult);
+      };
+      const backgroundExecution = (reason) => {
+        if (backgrounded || settled || terminating || !manager || !backgroundAvailableHere) {
+          return null;
         }
-        if (code === null) {
-          output += `
-Process terminated${signal ? ` by ${signal}` : " unexpectedly"}`;
+        backgrounded = true;
+        settled = true;
+        clearTimeout(timeoutTimer);
+        ctx.abortSignal?.removeEventListener("abort", onAbort);
+        this.foreground.delete(foregroundKey);
+        const task = manager.create(
+          backgroundTaskName(command),
+          async () => {
+            const exit = await done;
+            try {
+              await prepared.cleanup?.();
+            } catch {
+            }
+            const annotate = prepared.annotateStderr ? (text) => prepared.annotateStderr?.(text) ?? text : void 0;
+            const body = buildBackgroundBody(
+              "$ ",
+              command,
+              exit,
+              outputFile.path,
+              timeout,
+              annotate
+            );
+            if (body.isError) {
+              throw new TaskFailure(body.output);
+            }
+            return body.output;
+          },
+          () => {
+            killTree("SIGKILL");
+          },
+          { originToolCallId: ctx.toolCallId, idPrefix: "bash", kind: "shell" }
+        );
+        resolve12({
+          output: backgroundMessage(reason, task.id, timeout),
+          isError: false
+        });
+        return task.id;
+      };
+      if (backgroundAvailableHere) {
+        this.foreground.set(foregroundKey, {
+          background: () => backgroundExecution("user") !== null
+        });
+      }
+      const stopTimers = () => {
+        clearInterval(watchdog);
+        if (escalateTimer) {
+          clearTimeout(escalateTimer);
         }
-        settle({ output, isError: exitCode !== 0 || code === null });
+      };
+      child.on("error", (error) => {
+        stopTimers();
+        const exit = {
+          code: null,
+          signal: null,
+          aborted,
+          timedOut,
+          sizeKilled,
+          spawnError: error.message
+        };
+        doneResolve?.(exit);
+        settleExit(exit);
+      });
+      child.on("close", (code, signal) => {
+        stopTimers();
+        const exit = { code, signal, aborted, timedOut, sizeKilled };
+        doneResolve?.(exit);
+        settleExit(exit);
       });
+      backgroundFn = backgroundExecution;
     });
+    return {
+      result,
+      background: (reason) => backgroundFn?.(reason) ?? null
+    };
   }
 };
 
@@ -8640,8 +9081,8 @@ __export(computer_use_exports, {
 });
 import { spawn as spawn3 } from "child_process";
 import { mkdtemp, readFile as readFile4, rm, writeFile as writeFile2 } from "fs/promises";
-import { tmpdir } from "os";
-import { join as join19 } from "path";
+import { tmpdir as tmpdir2 } from "os";
+import { join as join20 } from "path";
 import { setTimeout as delay } from "timers/promises";
 import sharp from "sharp";
 import { safeParse as safeParse2, z as z14 } from "zod";
@@ -9718,9 +10159,9 @@ var ComputerUseTool = class {
     }
   }
   async compileMacHelper(signal) {
-    const directory = await mkdtemp(join19(tmpdir(), "swifty-computer-helper-"));
-    const sourcePath = join19(directory, "main.swift");
-    const executablePath = join19(directory, "computer-helper");
+    const directory = await mkdtemp(join20(tmpdir2(), "swifty-computer-helper-"));
+    const sourcePath = join20(directory, "main.swift");
+    const executablePath = join20(directory, "computer-helper");
     try {
       await writeFile2(sourcePath, MACOS_SNIPPET, "utf8");
       const result = await this.run(
@@ -9937,8 +10378,8 @@ var ComputerUseTool = class {
     return { output, contentBlocks: [imageBlock], isError: false };
   }
   async captureScreenshot(signal) {
-    const directory = await mkdtemp(join19(tmpdir(), "swifty-computer-"));
-    const screenshotPath = join19(directory, "screenshot.png");
+    const directory = await mkdtemp(join20(tmpdir2(), "swifty-computer-"));
+    const screenshotPath = join20(directory, "screenshot.png");
     try {
       switch (this.platform) {
         case "darwin": {
@@ -10215,8 +10656,10 @@ __export(powershell_exports, {
   PowerShellTool: () => PowerShellTool
 });
 import { execFile as execFile2, spawn as spawn4 } from "child_process";
+import { statSync as statSync11 } from "fs";
 var MAX_TIMEOUT2 = 600;
 var KILL_GRACE_MS2 = 3e3;
+var DISALLOWED_AUTO_BACKGROUND_COMMANDS2 = /* @__PURE__ */ new Set(["start-sleep", "sleep"]);
 var PowerShellTool = class {
   // Use a hardcoded string instead of PowerShellTool.name.replace("Tool", "")
   // because class names are not stable after minification — bundlers like
@@ -10224,57 +10667,130 @@ var PowerShellTool = class {
   name = "PowerShell";
   description = POWERSHELL_DESCRIPTION;
   category = "command";
+  /**
+   * Background task registry, injected by the host — same contract as
+   * BashTool.taskManager (schema gating, timeout auto-background, Ctrl+B).
+   * Calls running inside a subagent loop carry that loop's own manager in
+   * ctx.taskManager, which takes precedence.
+   */
+  taskManager = null;
+  /** Running foreground executions eligible for manual backgrounding (Ctrl+B). */
+  foreground = /* @__PURE__ */ new Map();
+  nextForegroundId = 1;
+  /** Instance-level background gate; see BashTool.backgroundEnabled. */
+  backgroundEnabled() {
+    return this.taskManager !== null && process.env.SWIFTY_DISABLE_BACKGROUND_TASKS !== "1";
+  }
+  /** True while at least one foreground PowerShell command runs. */
+  hasForegroundTasks() {
+    return this.foreground.size > 0;
+  }
+  /** Move every running foreground command to the background (Ctrl+B). */
+  backgroundForegroundTasks() {
+    let count = 0;
+    for (const entry of [...this.foreground.values()]) {
+      if (entry.background()) {
+        count++;
+      }
+    }
+    return count;
+  }
   schema() {
-    const inputSchema = {
-      type: "object",
-      properties: {
-        command: {
-          type: "string",
-          description: "PowerShell command to execute"
-        },
-        timeout: {
-          type: "integer",
-          description: "Timeout in seconds (max 600)",
-          default: 120
-        }
+    const properties = {
+      command: {
+        type: "string",
+        description: "PowerShell command to execute"
       },
-      required: ["command"]
+      timeout: {
+        type: "integer",
+        description: "Timeout in seconds (max 600)",
+        default: 120
+      }
     };
+    let description = this.description;
+    if (this.backgroundEnabled()) {
+      properties.run_in_background = {
+        type: "boolean",
+        description: "Run the command in the background. Returns a task ID immediately; the result arrives later as a task notification.",
+        default: false
+      };
+      description = `${this.description}
+${POWERSHELL_BACKGROUND_DESCRIPTION}`;
+    }
     return {
       name: this.name,
-      description: this.description,
-      input_schema: inputSchema
+      description,
+      input_schema: {
+        type: "object",
+        properties,
+        required: ["command"]
+      }
     };
   }
-  execute(ctx, args) {
+  async execute(ctx, args) {
     const command = strArg(args, "command");
     if (!command) {
-      return Promise.resolve({
+      return {
         output: "Error: command is required",
         isError: true
-      });
+      };
     }
     let timeout = intArg(args, "timeout", 120);
     if (!Number.isFinite(timeout) || timeout <= 0) {
-      return Promise.resolve({
+      return {
         output: "Error: timeout must be a finite number greater than 0 seconds",
         isError: true
-      });
+      };
     }
     if (timeout > MAX_TIMEOUT2) {
       timeout = MAX_TIMEOUT2;
     }
+    const manager = ctx.taskManager !== void 0 ? ctx.taskManager : this.taskManager;
+    const backgroundAvailable = manager !== null && process.env.SWIFTY_DISABLE_BACKGROUND_TASKS !== "1";
+    const runInBackground = boolArg(args, "run_in_background") && backgroundAvailable;
     const shell = process.platform === "win32" ? "powershell.exe" : "pwsh";
+    let outputFile;
+    try {
+      outputFile = createShellOutputFile(ctx.workDir, ctx.sessionId ?? "");
+    } catch (error) {
+      return {
+        output: `Error creating output file: ${asErrorString(error)}`,
+        isError: true
+      };
+    }
     if (ctx.abortSignal?.aborted) {
-      return Promise.resolve({
+      discardFd(outputFile.fd);
+      unlinkQuiet(outputFile.path);
+      return {
         output: "Error: command interrupted",
         isError: true
-      });
+      };
     }
-    return new Promise((resolve12) => {
-      let timedOut = false;
+    const handle = this.startCommand(ctx, shell, command, timeout, outputFile, manager);
+    if (runInBackground) {
+      const taskId = handle.background("explicit");
+      if (taskId !== null) {
+        return {
+          output: backgroundMessage("explicit", taskId, timeout),
+          isError: false
+        };
+      }
+    }
+    return handle.result;
+  }
+  /**
+   * Spawn PowerShell with stdout+stderr writing directly into the output file
+   * (fd mode, shared with BashTool): output never flows through JS, so
+   * backgrounding is a bookkeeping switch — no re-spawn, no buffer handover.
+   */
+  startCommand(ctx, shell, command, timeout, outputFile, manager) {
+    let backgroundFn;
+    const result = new Promise((resolve12) => {
       let aborted = false;
       let terminating = false;
+      let settled = false;
+      let backgrounded = false;
+      let sizeKilled = false;
       let escalateTimer = null;
       const shellCommand = process.platform === "win32" ? "try { [Console]::OutputEncoding=[System.Text.Encoding]::UTF8 } catch {}\n" + command : command;
       const shellArgs = process.platform === "win32" ? [
@@ -10285,17 +10801,31 @@ var PowerShellTool = class {
         "-Command",
         shellCommand
       ] : ["-NoProfile", "-NonInteractive", "-Command", shellCommand];
-      const child = spawn4(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.
-        detached: process.platform !== "win32",
-        stdio: ["ignore", "pipe", "pipe"]
+      let child;
+      try {
+        child = spawn4(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.
+          detached: process.platform !== "win32",
+          // stdout and stderr share one O_APPEND fd: each write lands on disk
+          // atomically and the streams interleave chronologically.
+          stdio: ["ignore", outputFile.fd, outputFile.fd]
+        });
+      } catch (error) {
+        discardFd(outputFile.fd);
+        unlinkQuiet(outputFile.path);
+        resolve12({
+          output: `Error executing command: ${asErrorString(error)}`,
+          isError: true
+        });
+        return;
+      }
+      discardFd(outputFile.fd);
+      let doneResolve;
+      const done = new Promise((resolveDone) => {
+        doneResolve = resolveDone;
       });
-      let stdout = "";
-      let stderr = "";
-      let total = 0;
-      let outputTruncated = false;
       const alreadyExited = () => child.exitCode !== null || child.signalCode !== null;
       const killTree = (signal) => {
         if (typeof child.pid !== "number") {
@@ -10333,41 +10863,35 @@ var PowerShellTool = class {
         killTree("SIGTERM");
         escalateTimer = setTimeout(() => {
           killTree("SIGKILL");
-          child.stdout.destroy();
-          child.stderr.destroy();
         }, KILL_GRACE_MS2);
         escalateTimer.unref();
       };
-      const appendChunk = (chunk, target) => {
-        if (outputTruncated) {
+      const watchdog = setInterval(() => {
+        let size = 0;
+        try {
+          size = statSync11(outputFile.path).size;
+        } catch {
           return;
         }
-        const remaining = MAX_SHELL_OUTPUT_BYTES - total;
-        const piece = takeUtf8Prefix(chunk, remaining);
-        total += utf8ByteLength(piece);
-        if (piece.length < chunk.length) {
-          outputTruncated = true;
+        const cap = backgrounded ? BACKGROUND_MAX_OUTPUT_BYTES : MAX_SHELL_OUTPUT_BYTES;
+        if (size > cap) {
+          sizeKilled = backgrounded;
+          clearInterval(watchdog);
           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");
-      });
+      }, SIZE_WATCHDOG_INTERVAL_MS);
+      watchdog.unref();
       const onAbort = () => {
         aborted = true;
         terminate();
       };
+      const backgroundAvailableHere = manager !== null && process.env.SWIFTY_DISABLE_BACKGROUND_TASKS !== "1";
+      const autoBackgroundAllowed = backgroundAvailableHere && isAutobackgroundingAllowed(command, DISALLOWED_AUTO_BACKGROUND_COMMANDS2);
+      let timedOut = false;
       const timeoutTimer = setTimeout(() => {
+        if (autoBackgroundAllowed && backgroundExecution("timeout") !== null) {
+          return;
+        }
         timedOut = true;
         terminate();
       }, timeout * 1e3);
@@ -10376,60 +10900,107 @@ var PowerShellTool = class {
       if (ctx.abortSignal?.aborted) {
         onAbort();
       }
+      const foregroundKey = `ps-${String(this.nextForegroundId++)}`;
       const cleanup = () => {
         clearTimeout(timeoutTimer);
+        clearInterval(watchdog);
         if (escalateTimer) {
           clearTimeout(escalateTimer);
         }
         ctx.abortSignal?.removeEventListener("abort", onAbort);
+        this.foreground.delete(foregroundKey);
       };
-      child.on("error", (err) => {
-        cleanup();
-        const hint = strArg(asRecord(err), "code") === "ENOENT" && process.platform !== "win32" ? " (pwsh is required on macOS/Linux \u2014 install PowerShell Core)" : "";
-        resolve12({
-          output: `Error executing command: ${err.message}${hint}`,
-          isError: true
-        });
-      });
-      child.on("close", (code, signal) => {
-        cleanup();
-        if (aborted) {
-          const captured = stdout || stderr || outputTruncated ? formatShellOutput("PS> ", 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("PS> ", 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
-          });
+      const settle = (finalResult) => {
+        if (settled) {
           return;
         }
-        const exitCode = code ?? 0;
-        let output = formatShellOutput("PS> ", command, stdout, stderr, outputTruncated);
-        if (outputTruncated) {
-          resolve12({ output, isError: true });
+        settled = true;
+        cleanup();
+        resolve12(finalResult);
+      };
+      const settleExit = (exit) => {
+        if (backgrounded) {
           return;
         }
-        if (exitCode !== 0) {
-          const hint = exitCodeHint(command, exitCode);
-          output += hint ? `
-Exit code ${String(exitCode)} (${hint})` : `
-Exit code ${String(exitCode)}`;
+        const read = readOutputFile(outputFile.path, MAX_SHELL_OUTPUT_BYTES);
+        const finalResult = formatFinalResult(
+          "PS> ",
+          command,
+          exit,
+          read.text,
+          read.truncated,
+          timeout
+        );
+        unlinkQuiet(outputFile.path);
+        settle(finalResult);
+      };
+      const backgroundExecution = (reason) => {
+        if (backgrounded || settled || terminating || !manager || !backgroundAvailableHere) {
+          return null;
         }
-        if (code === null) {
-          output += `
-Process terminated${signal ? ` by ${signal}` : " unexpectedly"}`;
+        backgrounded = true;
+        settled = true;
+        clearTimeout(timeoutTimer);
+        ctx.abortSignal?.removeEventListener("abort", onAbort);
+        this.foreground.delete(foregroundKey);
+        const task = manager.create(
+          backgroundTaskName(command),
+          async () => {
+            const exit = await done;
+            const body = buildBackgroundBody("PS> ", command, exit, outputFile.path, timeout);
+            if (body.isError) {
+              throw new TaskFailure(body.output);
+            }
+            return body.output;
+          },
+          () => {
+            killTree("SIGKILL");
+          },
+          { originToolCallId: ctx.toolCallId, idPrefix: "ps", kind: "shell" }
+        );
+        resolve12({
+          output: backgroundMessage(reason, task.id, timeout),
+          isError: false
+        });
+        return task.id;
+      };
+      if (backgroundAvailableHere) {
+        this.foreground.set(foregroundKey, {
+          background: () => backgroundExecution("user") !== null
+        });
+      }
+      const stopTimers = () => {
+        clearInterval(watchdog);
+        if (escalateTimer) {
+          clearTimeout(escalateTimer);
         }
-        resolve12({ output, isError: exitCode !== 0 || code === null });
+      };
+      child.on("error", (err) => {
+        stopTimers();
+        const hint = strArg(asRecord(err), "code") === "ENOENT" && process.platform !== "win32" ? " (pwsh is required on macOS/Linux \u2014 install PowerShell Core)" : "";
+        const exit = {
+          code: null,
+          signal: null,
+          aborted,
+          timedOut,
+          sizeKilled,
+          spawnError: `${err.message}${hint}`
+        };
+        doneResolve?.(exit);
+        settleExit(exit);
+      });
+      child.on("close", (code, signal) => {
+        stopTimers();
+        const exit = { code, signal, aborted, timedOut, sizeKilled };
+        doneResolve?.(exit);
+        settleExit(exit);
       });
+      backgroundFn = backgroundExecution;
     });
+    return {
+      result,
+      background: (reason) => backgroundFn?.(reason) ?? null
+    };
   }
 };
 
@@ -10621,7 +11192,7 @@ var AskUserResponseSchema = z15.object({
   id: z15.string(),
   answers: z15.record(z15.string(), z15.string())
 });
-var FE_DIST = join20(import.meta.dirname, "fe", "dist");
+var FE_DIST = join21(import.meta.dirname, "fe", "dist");
 var MIME_TYPES = {
   ".html": "text/html; charset=utf-8",
   ".js": "application/javascript; charset=utf-8",
@@ -10634,11 +11205,11 @@ var MIME_TYPES = {
 };
 function serveStatic(path) {
   const cleanPath = normalize(path).replace(/^(\.\.[/\\])+/, "");
-  const fullPath = join20(FE_DIST, cleanPath);
+  const fullPath = join21(FE_DIST, cleanPath);
   if (!fullPath.startsWith(FE_DIST)) {
     return null;
   }
-  if (!existsSync16(fullPath) || !statSync9(fullPath).isFile()) {
+  if (!existsSync16(fullPath) || !statSync12(fullPath).isFile()) {
     return null;
   }
   const body = readFileSync16(fullPath);
@@ -10814,31 +11385,38 @@ async function createRemoteAgent(opts) {
       if (!client) {
         throw new Error("no llm client (provider not initialized)");
       }
-      const { PermissionChecker: PC } = await import("./permissions-BW4QPZXV.js");
-      const { Agent: AgentClass } = await import("./agent-TC4HSVMS.js");
+      const { PermissionChecker: PC } = await import("./permissions-77UJQITR.js");
+      const { Agent: AgentClass } = await import("./agent-ZMIS6IH6.js");
       const subConv = new ConversationManager();
       subConv.addUserMessage(prompt);
+      const taskManager = new TaskManager();
       const subAgent = new AgentClass({
         client,
         registry: filterToolsForAgent(registry, void 0, void 0, false),
         checker: new PC(workDir, "acceptEdits"),
         conversation: subConv,
         workDir,
-        maxIterations: 200
+        maxIterations: 200,
+        taskManager,
+        notificationFn: () => taskManager.drainNotifications().map(formatAgentTaskNotification)
       });
       let output = "";
-      for await (const event of subAgent.run()) {
-        switch (event.type) {
-          case "stream_text":
-            output += event.text;
-            break;
-          case "loop_complete":
-            return output || "[No output]";
-          case "error":
-            throw event.error;
+      try {
+        for await (const event of subAgent.run()) {
+          switch (event.type) {
+            case "stream_text":
+              output += event.text;
+              break;
+            case "loop_complete":
+              return output || "[No output]";
+            case "error":
+              throw event.error;
+          }
         }
+        return output || "[No output]";
+      } finally {
+        await taskManager.stopAll();
       }
-      return output || "[No output]";
     }
   };
   registry.register(new LoadSkillTool(catalog, skillHost, skillForkHost));
@@ -10856,10 +11434,12 @@ async function createRemoteAgent(opts) {
     onEvent,
     void 0,
     teamChecker,
-    { abortSignal }
+    // Teammates stay purely foreground: see SubagentRunOptions.backgroundTasks.
+    { abortSignal, backgroundTasks: false }
   );
   const teamManager = new TeamManager(workDir);
   const backgroundTaskManager = new TaskManager();
+  attachBackgroundTaskManager(registry, backgroundTaskManager);
   registry.register(new TeamCreateTool(teamManager));
   registry.register(new SendMessageTool(teamManager));
   registry.register(new TeamDeleteTool(teamManager));
@@ -10898,6 +11478,7 @@ async function createRemoteAgent(opts) {
       const forkClient = modelOverride ? await createClient({ ...provider, model: resolvedModel }, forkSystemPrompt) : client;
       const checker = context?.permissionChecker ?? new PermissionChecker(forkWorkDir, "acceptEdits");
       forkConv.addUserMessage(prompt);
+      const forkTaskManager = new TaskManager();
       const agent2 = new Agent({
         client: forkClient,
         registry: forkRegistry,
@@ -10909,23 +11490,29 @@ async function createRemoteAgent(opts) {
         onPermissionRequest: context?.onPermissionRequest,
         fileStateCache: new FileStateCache(),
         instructions,
-        memoryContent: memReminder
+        memoryContent: memReminder,
+        taskManager: forkTaskManager,
+        notificationFn: () => forkTaskManager.drainNotifications().map(formatAgentTaskNotification)
       });
       let output = "";
-      for await (const event of agent2.run()) {
-        switch (event.type) {
-          case "stream_text":
-            output += event.text;
-            break;
-          case "loop_complete":
-            return output || "[No output]";
-          case "error":
-            return output ? `${output}
+      try {
+        for await (const event of agent2.run()) {
+          switch (event.type) {
+            case "stream_text":
+              output += event.text;
+              break;
+            case "loop_complete":
+              return output || "[No output]";
+            case "error":
+              return output ? `${output}
 
 [Error: ${event.error.message}]` : `Error: ${event.error.message}`;
+          }
         }
+        return output || "[No output]";
+      } finally {
+        await forkTaskManager.stopAll();
       }
-      return output || "[No output]";
     },
     backgroundTaskManager
   );
@@ -12423,6 +13010,7 @@ __export(javascript_exports, {
   evaluateJavaScript: () => evaluateJavaScript,
   isolatedVmSupported: () => isolatedVmSupported
 });
+import { randomBytes as randomBytes4 } from "crypto";
 import { z as z16 } from "zod";
 var DEFAULT_TIMEOUT_MS = 1e3;
 var MAX_TIMEOUT_MS = 1e4;
@@ -12435,7 +13023,10 @@ var JavaScriptArgumentsSchema = z16.object({
   code: z16.string().min(1),
   input: z16.json().optional(),
   timeout_ms: z16.number().int().min(1).max(MAX_TIMEOUT_MS).default(DEFAULT_TIMEOUT_MS),
-  memory_limit_mb: z16.number().int().min(8).max(MAX_MEMORY_LIMIT_MB).default(DEFAULT_MEMORY_LIMIT_MB)
+  memory_limit_mb: z16.number().int().min(8).max(MAX_MEMORY_LIMIT_MB).default(DEFAULT_MEMORY_LIMIT_MB),
+  // Accepted even when backgrounding is unavailable (then simply ignored):
+  // the JSON schema gates what the model sees per host.
+  run_in_background: z16.boolean().optional()
 });
 var JavaScriptEvaluationOptionsSchema = z16.object({
   input: z16.json().optional(),
@@ -12471,14 +13062,22 @@ async function runJavaScript(code, input, timeoutMs, memoryLimitMb, abortSignal)
   }
   abortSignal?.throwIfAborted();
   const module = await import("isolated-vm");
+  abortSignal?.throwIfAborted();
   const ivm = module.default;
   const isolate = new ivm.Isolate({ memoryLimit: memoryLimitMb });
   const context = await isolate.createContext();
   const onAbort = () => {
-    isolate.dispose();
+    if (!isolate.isDisposed) {
+      isolate.dispose();
+    }
   };
   abortSignal?.addEventListener("abort", onAbort, { once: true });
+  let wallTimer;
   try {
+    if (abortSignal?.aborted) {
+      onAbort();
+      abortSignal.throwIfAborted();
+    }
     await context.global.set("input", input ?? null, { copy: true });
     const source = `
 (async () => {
@@ -12523,12 +13122,19 @@ ${code}
   return __payload;
 })()
 `;
-    const raw = await context.eval(source, {
+    const evaluation = context.eval(source, {
       timeout: timeoutMs,
       promise: true,
       copy: true,
       filename: "swifty-sandbox.js"
     });
+    const deadline = new Promise((_, reject) => {
+      wallTimer = setTimeout(() => {
+        reject(new Error(`JavaScript evaluation timed out after ${String(timeoutMs)}ms`));
+        onAbort();
+      }, timeoutMs);
+    });
+    const raw = await Promise.race([evaluation, deadline]);
     if (typeof raw !== "string") {
       throw new Error("JavaScript sandbox returned an invalid result");
     }
@@ -12538,6 +13144,7 @@ ${code}
     const decoded = JSON.parse(raw);
     return JavaScriptEvaluationSchema.parse(decoded);
   } finally {
+    clearTimeout(wallTimer);
     abortSignal?.removeEventListener("abort", onAbort);
     try {
       context.release();
@@ -12548,37 +13155,94 @@ ${code}
     }
   }
 }
+function formatEvaluation(result) {
+  const sections = [];
+  if (result.logs.length > 0) {
+    sections.push(`Console:
+${result.logs.join("\n")}`);
+  }
+  if (result.logsTruncated) {
+    sections.push("Console output truncated");
+  }
+  sections.push(`Result:
+${JSON.stringify(result.value, null, 2)}`);
+  return sections.join("\n\n");
+}
+function jsBackgroundMessage(reason, taskId) {
+  return reason === "user" ? `JavaScript evaluation was manually backgrounded by the user (task_id: ${taskId}). It is still running \u2014 you will be notified when it completes.` : `JavaScript running in background (task_id: ${taskId}). You will be notified when it completes; do not poll. Use TaskStop with task_id to abort it early.`;
+}
 var JavaScriptTool = class {
   name = "JavaScript";
   description = JAVASCRIPT_DESCRIPTION;
   category = "command";
+  /**
+   * Background task registry, injected by the host — same contract as
+   * BashTool.taskManager. Unlike the shell tools there is no timeout
+   * auto-background: timeout_ms is the isolate's hard safety cap — V8 kills a
+   * synchronous script at the cap, and a wall-clock deadline disposes the
+   * isolate when an evaluation is suspended on a promise — so nothing is left
+   * to keep running.
+   */
+  taskManager = null;
+  /** Running foreground evaluations eligible for manual backgrounding (Ctrl+B). */
+  foreground = /* @__PURE__ */ new Map();
+  nextForegroundId = 1;
+  /** Instance-level background gate; see BashTool.backgroundEnabled. */
+  backgroundEnabled() {
+    return this.taskManager !== null && process.env.SWIFTY_DISABLE_BACKGROUND_TASKS !== "1";
+  }
+  /** True while at least one foreground evaluation runs. */
+  hasForegroundTasks() {
+    return this.foreground.size > 0;
+  }
+  /** Move every running foreground evaluation to the background (Ctrl+B). */
+  backgroundForegroundTasks() {
+    let count = 0;
+    for (const entry of [...this.foreground.values()]) {
+      if (entry.background()) {
+        count++;
+      }
+    }
+    return count;
+  }
   schema() {
+    const properties = {
+      code: {
+        type: "string",
+        description: "JavaScript function body to execute; use return to produce a result"
+      },
+      input: {
+        description: "Optional JSON-compatible value exposed as globalThis.input"
+      },
+      timeout_ms: {
+        type: "integer",
+        minimum: 1,
+        maximum: MAX_TIMEOUT_MS,
+        default: DEFAULT_TIMEOUT_MS
+      },
+      memory_limit_mb: {
+        type: "integer",
+        minimum: 8,
+        maximum: MAX_MEMORY_LIMIT_MB,
+        default: DEFAULT_MEMORY_LIMIT_MB
+      }
+    };
+    let description = this.description;
+    if (this.backgroundEnabled()) {
+      properties.run_in_background = {
+        type: "boolean",
+        description: "Run the evaluation in the background. Returns a task ID immediately; the result arrives later as a task notification.",
+        default: false
+      };
+      description = `${this.description}
+${JAVASCRIPT_BACKGROUND_DESCRIPTION}`;
+    }
     return {
       name: this.name,
-      description: this.description,
+      description,
       input_schema: {
         type: "object",
-        properties: {
-          code: {
-            type: "string",
-            description: "JavaScript function body to execute; use return to produce a result"
-          },
-          input: {
-            description: "Optional JSON-compatible value exposed as globalThis.input"
-          },
-          timeout_ms: {
-            type: "integer",
-            minimum: 1,
-            maximum: MAX_TIMEOUT_MS,
-            default: DEFAULT_TIMEOUT_MS
-          },
-          memory_limit_mb: {
-            type: "integer",
-            minimum: 8,
-            maximum: MAX_MEMORY_LIMIT_MB,
-            default: DEFAULT_MEMORY_LIMIT_MB
-          }
-        },
+        properties,
         required: ["code"],
         additionalProperties: false
       }
@@ -12589,32 +13253,128 @@ var JavaScriptTool = class {
     if (!parsed.success) {
       return { output: `Error: ${parsed.error.message}`, isError: true };
     }
-    try {
-      const result = await runJavaScript(
-        parsed.data.code,
-        parsed.data.input,
-        parsed.data.timeout_ms,
-        parsed.data.memory_limit_mb,
-        ctx.abortSignal
-      );
-      const sections = [];
-      if (result.logs.length > 0) {
-        sections.push(`Console:
-${result.logs.join("\n")}`);
-      }
-      if (result.logsTruncated) {
-        sections.push("Console output truncated");
+    const manager = ctx.taskManager !== void 0 ? ctx.taskManager : this.taskManager;
+    const backgroundAvailable = manager !== null && process.env.SWIFTY_DISABLE_BACKGROUND_TASKS !== "1";
+    const runInBackground = parsed.data.run_in_background === true && backgroundAvailable;
+    const handle = this.startEvaluation(ctx, parsed.data, manager, backgroundAvailable);
+    if (runInBackground) {
+      const taskId = handle.background("explicit");
+      if (taskId !== null) {
+        return {
+          output: jsBackgroundMessage("explicit", taskId),
+          isError: false
+        };
       }
-      sections.push(`Result:
-${JSON.stringify(result.value, null, 2)}`);
-      return { output: sections.join("\n\n"), isError: false };
-    } catch (error) {
-      return { output: `Error executing JavaScript: ${asErrorString(error)}`, isError: true };
     }
+    return handle.result;
+  }
+  /**
+   * Start the isolated evaluation. The returned handle mirrors the shell
+   * tools: background() transitions the pending evaluation into a TaskManager
+   * task — the isolate keeps running on its own thread, the tool call
+   * resolves immediately, and completion arrives as a task notification.
+   * While foreground, the caller's abort signal (Esc) disposes the isolate;
+   * once backgrounded, only TaskStop or session shutdown can abort it.
+   */
+  startEvaluation(ctx, data, manager, backgroundAvailable) {
+    let backgroundFn;
+    const result = new Promise((resolve12) => {
+      let settled = false;
+      let backgrounded = false;
+      const controller = new AbortController();
+      const onCallerAbort = () => {
+        controller.abort();
+      };
+      if (ctx.abortSignal?.aborted) {
+        resolve12({ output: "Error: command interrupted", isError: true });
+        return;
+      }
+      ctx.abortSignal?.addEventListener("abort", onCallerAbort, { once: true });
+      const evalPromise = runJavaScript(
+        data.code,
+        data.input,
+        data.timeout_ms,
+        data.memory_limit_mb,
+        controller.signal
+      );
+      const foregroundKey = `js-${String(this.nextForegroundId++)}`;
+      const settle = (finalResult) => {
+        if (settled) {
+          return;
+        }
+        settled = true;
+        ctx.abortSignal?.removeEventListener("abort", onCallerAbort);
+        this.foreground.delete(foregroundKey);
+        resolve12(finalResult);
+      };
+      const backgroundExecution = (reason) => {
+        if (backgrounded || settled || controller.signal.aborted || !manager || !backgroundAvailable) {
+          return null;
+        }
+        backgrounded = true;
+        settled = true;
+        ctx.abortSignal?.removeEventListener("abort", onCallerAbort);
+        this.foreground.delete(foregroundKey);
+        const task = manager.create(
+          backgroundTaskName(data.code),
+          async (backgroundTask) => {
+            const cap = (text) => text.length > BACKGROUND_NOTIFICATION_CHARS ? persistLargeResult(
+              ctx.workDir,
+              ctx.sessionId ?? "",
+              `${backgroundTask.id}-${randomBytes4(4).toString("hex")}`,
+              text
+            ) : text;
+            try {
+              const evaluation = await evalPromise;
+              return cap(formatEvaluation(evaluation));
+            } catch (error) {
+              if (backgroundTask.status === "cancelled") {
+                throw error;
+              }
+              throw new TaskFailure(cap(`Error executing JavaScript: ${asErrorString(error)}`));
+            }
+          },
+          () => {
+            controller.abort();
+          },
+          { originToolCallId: ctx.toolCallId, idPrefix: "js", kind: "js" }
+        );
+        resolve12({
+          output: jsBackgroundMessage(reason, task.id),
+          isError: false
+        });
+        return task.id;
+      };
+      if (backgroundAvailable) {
+        this.foreground.set(foregroundKey, {
+          background: () => backgroundExecution("user") !== null
+        });
+      }
+      evalPromise.then(
+        (evaluation) => {
+          settle({ output: formatEvaluation(evaluation), isError: false });
+        },
+        (error) => {
+          settle({
+            output: `Error executing JavaScript: ${asErrorString(error)}`,
+            isError: true
+          });
+        }
+      );
+      backgroundFn = backgroundExecution;
+    });
+    return {
+      result,
+      background: (reason) => backgroundFn?.(reason) ?? null
+    };
   }
 };
 
 // src/tools/web-fetch.ts
+var web_fetch_exports = {};
+__export(web_fetch_exports, {
+  WebFetchTool: () => WebFetchTool
+});
 var log27 = createChildLogger({ module: "tools" });
 var MAX_CONTENT_BYTES = 10 * 1024 * 1024;
 var FETCH_TIMEOUT_MS = 6e4;
@@ -13615,8 +14375,8 @@ __export(manager_exports3, {
   CodeReviewManager: () => CodeReviewManager,
   createDefaultCodeReviewTeam: () => createDefaultCodeReviewTeam
 });
-import { readFileSync as readFileSync17, writeFileSync as writeFileSync11, existsSync as existsSync18, mkdirSync as mkdirSync12 } from "fs";
-import { join as join21 } from "path";
+import { readFileSync as readFileSync17, writeFileSync as writeFileSync11, existsSync as existsSync18, mkdirSync as mkdirSync13 } from "fs";
+import { join as join22 } from "path";
 import z17 from "zod";
 var log30 = createChildLogger({ module: "code-review" });
 var CodeReviewMemberSchema = z17.object({
@@ -13639,7 +14399,7 @@ var CodeReviewManager = class {
   workDir;
   constructor(workDir, teamManager) {
     this.workDir = workDir;
-    this.configPath = join21(workDir, ".swifty", "code-review-teams.json");
+    this.configPath = join22(workDir, ".swifty", "code-review-teams.json");
     this.teamManager = teamManager;
     this.loadTeams();
   }
@@ -13658,9 +14418,9 @@ var CodeReviewManager = class {
     }
   }
   saveTeams() {
-    const dir = join21(this.workDir, ".swifty");
+    const dir = join22(this.workDir, ".swifty");
     if (!existsSync18(dir)) {
-      mkdirSync12(dir, { recursive: true });
+      mkdirSync13(dir, { recursive: true });
     }
     const teams = [...this.teams.values()];
     writeFileSync11(this.configPath, JSON.stringify(teams, null, 2));
@@ -13806,8 +14566,8 @@ var usage_tracker_exports = {};
 __export(usage_tracker_exports, {
   CommandUsageTracker: () => CommandUsageTracker
 });
-import { readFileSync as readFileSync18, writeFileSync as writeFileSync12, mkdirSync as mkdirSync13, existsSync as existsSync19 } from "fs";
-import { join as join22, dirname as dirname9 } from "path";
+import { readFileSync as readFileSync18, writeFileSync as writeFileSync12, mkdirSync as mkdirSync14, existsSync as existsSync19 } from "fs";
+import { join as join23, dirname as dirname9 } from "path";
 import { safeParse as safeParse3, z as z18 } from "zod";
 var log31 = createChildLogger({ module: "commands" });
 var UsageEntrySchema = z18.object({
@@ -13818,10 +14578,10 @@ var CommandUsageTracker = class {
   usage = /* @__PURE__ */ new Map();
   filePath;
   constructor(workDir) {
-    const dir = join22(workDir, ".swifty");
-    this.filePath = join22(dir, "command_usage.json");
+    const dir = join23(workDir, ".swifty");
+    this.filePath = join23(dir, "command_usage.json");
     if (!existsSync19(dir)) {
-      mkdirSync13(dir, { recursive: true });
+      mkdirSync14(dir, { recursive: true });
     }
     this.load();
   }
@@ -13862,7 +14622,7 @@ var CommandUsageTracker = class {
   }
   save() {
     try {
-      mkdirSync13(dirname9(this.filePath), { recursive: true });
+      mkdirSync14(dirname9(this.filePath), { recursive: true });
       writeFileSync12(this.filePath, JSON.stringify(Object.fromEntries(this.usage), null, 2));
     } catch (err) {
       log31.error({ err }, "commands operation failed");
@@ -13885,15 +14645,15 @@ __export(history_exports, {
   append: () => append,
   load: () => load
 });
-import { readFileSync as readFileSync19, writeFileSync as writeFileSync13, mkdirSync as mkdirSync14, existsSync as existsSync20 } from "fs";
-import { join as join23 } from "path";
+import { readFileSync as readFileSync19, writeFileSync as writeFileSync13, mkdirSync as mkdirSync15, existsSync as existsSync20 } from "fs";
+import { join as join24 } from "path";
 import { parse as parse8, z as z19 } from "zod";
 var log32 = createChildLogger({ module: "history" });
 var MAX_HISTORY_ENTRIES = 200;
 var FILENAME = "prompt_history.jsonl";
 var JSONLSchema = z19.looseObject({ text: z19.string() });
 function load(dir) {
-  const filePath = join23(dir, FILENAME);
+  const filePath = join24(dir, FILENAME);
   if (!existsSync20(filePath)) {
     return [];
   }
@@ -13915,8 +14675,8 @@ function load(dir) {
   }
 }
 function append(dir, text) {
-  const filePath = join23(dir, FILENAME);
-  mkdirSync14(dir, { recursive: true });
+  const filePath = join24(dir, FILENAME);
+  mkdirSync15(dir, { recursive: true });
   const entries = load(dir);
   if (entries.length === 0 || entries[entries.length - 1] !== text) {
     entries.push(text);
@@ -14132,17 +14892,17 @@ __export(install_tool_exports, {
 });
 import { randomUUID as randomUUID2 } from "crypto";
 import {
-  mkdirSync as mkdirSync15,
+  mkdirSync as mkdirSync16,
   writeFileSync as writeFileSync14,
   readFileSync as readFileSync20,
   lstatSync,
   realpathSync,
-  openSync as openSync2,
-  closeSync as closeSync2,
+  openSync as openSync3,
+  closeSync as closeSync3,
   renameSync as renameSync2,
   rmSync as rmSync2
 } from "fs";
-import { join as join24, resolve as resolve10 } from "path";
+import { join as join25, resolve as resolve10 } from "path";
 import yaml7 from "js-yaml";
 var log33 = createChildLogger({ module: "skills" });
 var InstallSkillTool = class {
@@ -14234,28 +14994,28 @@ ${parsed.body}
       ctx.abortSignal?.throwIfAborted();
       let dir = realpathSync(this.workDir);
       for (const segment of [".agents", "skills", name]) {
-        dir = join24(dir, segment);
+        dir = join25(dir, segment);
         const stat4 = lstatSync(dir, { throwIfNoEntry: false });
         if (stat4) {
           if (stat4.isSymbolicLink() || !stat4.isDirectory()) {
             throw new Error(`Installation directory must be a real directory: ${dir}`);
           }
         } else {
-          mkdirSync15(dir);
+          mkdirSync16(dir);
         }
       }
-      const destination = join24(dir, "SKILL.md");
+      const destination = join25(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 = join24(dir, `.SKILL-${randomUUID2()}.tmp`);
-      const fd = openSync2(temporary, "wx", stat3?.mode ?? 438);
+      const temporary = join25(dir, `.SKILL-${randomUUID2()}.tmp`);
+      const fd = openSync3(temporary, "wx", stat3?.mode ?? 438);
       try {
         try {
           writeFileSync14(fd, content, "utf-8");
         } finally {
-          closeSync2(fd);
+          closeSync3(fd);
         }
         renameSync2(temporary, destination);
       } finally {
@@ -14298,6 +15058,7 @@ __export(tools_exports3, {
   Diff: () => diff_exports,
   EditFile: () => edit_file_exports,
   EnterWorktree: () => enter_worktree_exports,
+  ExitCodeHints: () => exit_code_hints_exports,
   ExitPlanMode: () => exit_plan_mode_exports,
   ExitWorktree: () => exit_worktree_exports,
   FileMutationQueue: () => file_mutation_queue_exports,
@@ -14310,11 +15071,13 @@ __export(tools_exports3, {
   PowerShell: () => powershell_exports,
   ReadFile: () => read_file_exports,
   Registry: () => registry_exports,
+  ShellBackground: () => shell_background_exports,
   ShellOutput: () => shell_output_exports,
   Snippets: () => snippets_exports,
   SyntheticOutput: () => synthetic_output_exports,
   ToolSearch: () => tool_search_exports,
   Types: () => types_exports,
+  WebFetchTool: () => web_fetch_exports,
   WriteFile: () => write_file_exports
 });
 
@@ -14600,7 +15363,7 @@ __export(lockfile_exports, {
 });
 import { readdir as readdir2, readFile as readFile5 } from "fs/promises";
 import { homedir as homedir10 } from "os";
-import { join as join25, resolve as resolve11, sep as sep2 } from "path";
+import { join as join26, resolve as resolve11, sep as sep2 } from "path";
 import { z as z21 } from "zod";
 var log34 = createChildLogger({ module: "vscode" });
 var LockfileSchema = z21.object({
@@ -14611,8 +15374,8 @@ var LockfileSchema = z21.object({
   authToken: z21.string().optional()
 });
 function ideLockDir() {
-  const configDir = process.env.CLAUDE_CONFIG_DIR ?? join25(homedir10(), ".claude");
-  return join25(configDir, "ide");
+  const configDir = process.env.CLAUDE_CONFIG_DIR ?? join26(homedir10(), ".claude");
+  return join26(configDir, "ide");
 }
 function cwdInWorkspace(cwd2, workspaceFolders) {
   const normalizedCwd = cwd2.normalize("NFC");
@@ -14630,7 +15393,7 @@ async function readLockfile(dir, filename) {
     return null;
   }
   try {
-    const content = await readFile5(join25(dir, filename), "utf-8");
+    const content = await readFile5(join26(dir, filename), "utf-8");
     const parsed = LockfileSchema.parse(JSON.parse(content));
     if (parsed.transport !== "ws") {
       return null;
@@ -14975,6 +15738,7 @@ async function runPrintMode(args) {
   registry.register(new ToolSearchTool(registry));
   const teamManager = new TeamManager(workDir);
   const backgroundTaskManager = new TaskManager();
+  attachBackgroundTaskManager(registry, backgroundTaskManager);
   registry.register(new TeamCreateTool(teamManager));
   registry.register(new SendMessageTool(teamManager));
   registry.register(new TeamDeleteTool(teamManager));
@@ -15036,7 +15800,8 @@ async function runPrintMode(args) {
       onEvent,
       void 0,
       teamChecker,
-      { abortSignal }
+      // Teammates stay purely foreground: see SubagentRunOptions.backgroundTasks.
+      { abortSignal, backgroundTasks: false }
     ),
     provider.base_url
   );
@@ -15124,7 +15889,7 @@ Error: ${event.error.message}`);
           break;
       }
     }
-    await backgroundTaskManager.waitAll();
+    await backgroundTaskManager.waitAll((task) => (task.kind ?? "agent") === "agent");
     const backgroundNotifications = backgroundTaskManager.drainNotifications();
     const durationMs = Date.now() - startTime;
     if (args.outputFormat === "text" && resultText && !resultText.endsWith("\n")) {
@@ -15217,13 +15982,13 @@ __export(recover_exports, {
   recordExit: () => recordExit,
   recover: () => recover
 });
-import { appendFileSync, mkdirSync as mkdirSync16 } from "fs";
-import { join as join26 } from "path";
+import { appendFileSync, mkdirSync as mkdirSync17 } from "fs";
+import { join as join27 } from "path";
 var LOG_DIR = ".swifty";
-var LOG_PATH = join26(LOG_DIR, "crash.log");
+var LOG_PATH = join27(LOG_DIR, "crash.log");
 function record(text) {
   try {
-    mkdirSync16(LOG_DIR, { recursive: true });
+    mkdirSync17(LOG_DIR, { recursive: true });
     appendFileSync(LOG_PATH, `[${(/* @__PURE__ */ new Date()).toISOString()}] ${text}
 `, "utf8");
   } catch {
@@ -15303,7 +16068,7 @@ __export(teammate_exports, {
   parseTeammateFlags: () => parseTeammateFlags,
   runTeammate: () => runTeammate
 });
-import { basename as basename6, dirname as dirname10, join as join27 } from "path";
+import { basename as basename6, dirname as dirname10, join as join28 } from "path";
 function parseTeammateFlags(args) {
   if (!args.includes("--teammate")) {
     return null;
@@ -15399,7 +16164,7 @@ async function runTeammate(args) {
   initLogger({
     sessionId: `teammate-${safeMemberName}-${Date.now().toString(36)}`,
     mode: "teammate",
-    logDir: join27(dirname10(args.teamDir), "logs"),
+    logDir: join28(dirname10(args.teamDir), "logs"),
     skipCleanup: true
   });
   process.on("exit", closeLogger);