@swifty.js/swifty 0.0.35 → 0.0.36

package/dist/lib/index.d.ts

@@ -37,7 +37,7 @@ interface UsageInfo {
     cacheReadInputTokens: number;
     cacheCreationInputTokens: number;
 }
-/** Tool use delta: Input partial JSON */
+/** Events emitted by an LLM stream: text/thinking deltas, tool-call lifecycle, and stream end. */
 type StreamEvent = {
     type: "text_delta";
     text: string;
@@ -253,7 +253,7 @@ declare class PermissionChecker {
     allowAlways(toolName: string, args: Record<string, unknown>): void;
     /**
      * Generate a human-readable description of the tool action for display in HITL confirmation dialogs.
-     * Prioritizes extracting fields defined in contentFields (e.g., command, file_path);
+     * Prioritizes extracting fields defined in CONTENT_FIELDS (e.g., command, file_path);
      * falls back to a key:value summary of parameters if no match is found.
      */
     describeToolAction(toolName: string, args: Record<string, unknown>): string;
@@ -275,6 +275,100 @@ declare namespace index$v {
   export { type index$v_Decision as Decision, type index$v_DecisionEffect as DecisionEffect, index$v_PathSandbox as PathSandbox, index$v_PermissionChecker as PermissionChecker, type index$v_PermissionMode as PermissionMode, index$v_RuleEngine as RuleEngine, index$v_evaluateRules as evaluateRules, index$v_extractContent as extractContent, index$v_isSafeCommand as isSafeCommand };
 }
 
+/**
+ * Copyright (c) 2026 hangtiancheng
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+type AgentTaskStatus = "running" | "completed" | "failed" | "cancelled";
+/**
+ * What a task wraps. Hosts use this to wait selectively: print-mode blocks on
+ * agent tasks (their results feed the final answer) but must not block on
+ * shell/js tasks, which can run indefinitely (dev servers) and are killed at
+ * exit instead. Absent kind means "agent" (the original TaskManager use).
+ */
+type TaskKind = "agent" | "shell" | "js";
+interface AgentTask {
+    id: string;
+    name: string;
+    originToolCallId?: string;
+    kind?: TaskKind;
+    status: AgentTaskStatus;
+    output: string;
+    cancel: () => void;
+    done: Promise<void>;
+}
+interface CreateTaskOptions {
+    originToolCallId?: string;
+    /** ID prefix; defaults to "agent" (background subagents). Bash background tasks use "bash". */
+    idPrefix?: string;
+    /** Task category; defaults to "agent". */
+    kind?: TaskKind;
+}
+/**
+ * A runner failure that carries its own pre-formatted output. TaskManager
+ * stores `output` verbatim on the failed task instead of the generic
+ * `Error: <message>` wrapper, so tool-level results (e.g. a background Bash
+ * command's captured output and exit code) reach the notification intact.
+ */
+declare class TaskFailure extends Error {
+    readonly output: string;
+    constructor(output: string);
+}
+declare class TaskManager {
+    private tasks;
+    private notifiedTaskIds;
+    private listeners;
+    private nextId;
+    private pendingTaskIds;
+    create(name: string, runner: (task: AgentTask) => Promise<string>, cancel: () => void, options?: CreateTaskOptions): AgentTask;
+    get(id: string): AgentTask | undefined;
+    list(): AgentTask[];
+    subscribe(listener: (tasks: AgentTask[]) => void): () => void;
+    private emitChange;
+    hasRunning(): boolean;
+    stop(id: string): boolean;
+    stopAndWait(id: string): Promise<boolean>;
+    stopAll(): Promise<void>;
+    /**
+     * 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).
+     */
+    waitAll(filter?: (task: AgentTask) => boolean): Promise<void>;
+    drainNotifications(): AgentTask[];
+    clear(): void;
+}
+declare function formatAgentTaskNotification(task: AgentTask): string;
+
+type taskManager_AgentTask = AgentTask;
+type taskManager_AgentTaskStatus = AgentTaskStatus;
+type taskManager_TaskFailure = TaskFailure;
+declare const taskManager_TaskFailure: typeof TaskFailure;
+type taskManager_TaskKind = TaskKind;
+type taskManager_TaskManager = TaskManager;
+declare const taskManager_TaskManager: typeof TaskManager;
+declare const taskManager_formatAgentTaskNotification: typeof formatAgentTaskNotification;
+declare namespace taskManager {
+  export { type taskManager_AgentTask as AgentTask, type taskManager_AgentTaskStatus as AgentTaskStatus, taskManager_TaskFailure as TaskFailure, type taskManager_TaskKind as TaskKind, taskManager_TaskManager as TaskManager, taskManager_formatAgentTaskNotification as formatAgentTaskNotification };
+}
+
 /**
  * Copyright (c) 2026 hangtiancheng
  *
@@ -312,6 +406,22 @@ interface ToolContext {
     workDir: string;
     toolCallId?: string;
     backgroundTaskId?: string;
+    /**
+     * Owning session, when the call runs on the main thread. Lets tools persist
+     * auxiliary artifacts (e.g. a backgrounded Bash command's output) into the
+     * session's tool-results spill directory so the model can Read them back.
+     */
+    sessionId?: string;
+    /**
+     * Background task registry of the loop running this call. Subagent loops
+     * inject their own manager so backgrounded Bash commands notify that loop
+     * instead of the main thread; tools fall back to their host-wired default
+     * when absent. Explicit `null` disables backgrounding for this call even
+     * when the tool instance carries a host-wired manager (in-process teammate
+     * turns use this: their per-turn drain disappears at turn end, so commands
+     * backgrounded there could never deliver a notification).
+     */
+    taskManager?: TaskManager | null;
     abortSignal?: AbortSignal;
     fileHistory?: FileHistory | undefined;
     fileStateCache?: FileStateCache | undefined;
@@ -399,9 +509,10 @@ interface Tool {
      * judged by actual arguments rather than just the tool category.
      *
      * When not implemented, falls back to category: read-only tools may run
-     * concurrently, write and command tools may not. Currently only Bash
-     * implements this — whether a command is read-only depends on the command
-     * itself (ls vs rm are both Bash but have very different safety profiles).
+     * concurrently, write and command tools may not. Currently Bash
+     * (argument-dependent: ls vs rm are both Bash but have very different safety
+     * profiles) and ComputerUse (always false — it drives a single physical
+     * screen/mouse/keyboard) implement this.
      */
     isConcurrencySafe?(args: Record<string, unknown>): boolean;
     schema(): ToolSchema;
@@ -735,7 +846,8 @@ declare function rebuildFromSession(saved: SessionMessage[]): RestoredMessage[];
 declare function listSessions(workDir: string): SessionInfo[];
 /**
  * Cleans up expired sessions: deletes .jsonl files whose last modified time exceeds SESSION_EXPIRY_DAYS.
- * Called during listSessions or on startup to prevent the session directory from growing indefinitely.
+ * Not currently invoked anywhere; intended to run during listSessions or on
+ * startup to prevent the session directory from growing indefinitely.
  * Silently skips failures (best-effort).
  */
 declare function cleanExpiredSessions(workDir: string): number;
@@ -1771,7 +1883,6 @@ interface MemoryHeader {
     description: string;
     type: string;
 }
-/** One memory selected for surfacing into the main conversation. */
 /**
  * The output of a single recall: the rendered system-reminder body and the
  * selected memory file paths. Paths are only recorded as surfaced once the
@@ -1781,6 +1892,7 @@ interface RecallResult {
     reminder: string;
     paths: string[];
 }
+/** One memory selected for surfacing into the main conversation. */
 interface RelevantMemory {
     path: string;
     mtimeMs: number;
@@ -1795,7 +1907,9 @@ declare class MemoryManager {
     loadAll(): MemoryFile[];
     getMemories(): MemoryFile[];
     /**
-     * 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
@@ -1815,8 +1929,9 @@ declare class MemoryManager {
     private writeIndex;
     /**
      * 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.
      */
     findRelevantMemories(query: string, client: LLMClient, recentTools?: string[], alreadySurfaced?: Set<string>): Promise<RelevantMemory[]>;
     private scanMemoryHeaders;
@@ -2144,6 +2259,14 @@ interface AgentConfig {
     recoveryState?: RecoveryState;
     maxIterations?: number;
     notificationFn?: () => string[];
+    /**
+     * Background task registry owned by this loop. Injected into every tool
+     * context so backgrounded Bash commands register — and later notify — here
+     * instead of on the host-level default. Subagent runs pass their own;
+     * explicit `null` disables backgrounding for the whole loop (in-process
+     * teammate turns) even when tools carry a host-wired manager.
+     */
+    taskManager?: TaskManager | null;
     onLoopComplete?: (conversation: ConversationManager) => void;
     activeSkills?: Map<string, string>;
     toolFilter?: (name: string) => boolean;
@@ -2181,6 +2304,7 @@ declare class Agent {
     private recoveryState;
     private maxIterations;
     private notificationFn?;
+    private taskManager?;
     private onLoopComplete?;
     private compactTracking;
     private onPermissionRequest?;
@@ -3307,6 +3431,15 @@ interface SubagentRunOptions {
     onPermissionRequest?: AgentConfig["onPermissionRequest"];
     permissionMode?: PermissionChecker["mode"];
     conversation?: ConversationManager;
+    /**
+     * Whether this run gets a per-run background task manager (default true).
+     * In-process teammate turns pass false: a teammate loop is one run per task
+     * turn, so the turn-end stopAll() would immediately kill anything the
+     * teammate backgrounded, and the drain disappears before any notification
+     * could be delivered. Teammates stay purely foreground (matching the
+     * subprocess teammate path); subagents they spawn themselves are unaffected.
+     */
+    backgroundTasks?: boolean;
 }
 declare function spawnSubagent(definition: AgentDefinition, prompt: string, parentClient: LLMClient, parentRegistry: ToolRegistry, parentProvider: ProviderConfig, workDir: string, onProgress?: (p: {
     turn?: number;
@@ -3348,18 +3481,20 @@ declare namespace spawn {
  * Auto-detect the best backend for running teammates.
  *
  * Auto-detection logic:
- *   - Default to **in-process** so progress tracking works (agent events
- *     flow in the same process and can update the Spinner Tree in real time).
- *   - Only use tmux/iTerm panes when the user explicitly requests it via
- *     config `teammateMode: "tmux"`.
+ *   - Windows: always **in-process**.
+ *   - Otherwise: tmux/iTerm panes when the corresponding environment is
+ *     detected (TMUX / ITERM_SESSION_ID), else **in-process** so progress
+ *     tracking works (agent events flow in the same process and can update
+ *     the Spinner Tree in real time).
  *
  * In-process teammates share the Node.js event loop but are context-isolated.
  * They communicate via the same file-based mailbox as external teammates.
  */
 declare function detectBackend(): TeamMode;
 /**
- * Detect available pane backend (for explicit tmux mode).
- * Used when the user overrides teammateMode to "tmux".
+ * Detect available pane backend from the environment (TMUX /
+ * ITERM_SESSION_ID); falls back to in-process. Called unconditionally by
+ * detectBackend on non-Windows platforms.
  */
 declare function detectBackendFromEnv(): TeamMode;
 interface SpawnConfig {
@@ -3589,71 +3724,8 @@ declare namespace registry {
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  * SOFTWARE.
  */
-type AgentTaskStatus = "running" | "completed" | "failed" | "cancelled";
-interface AgentTask {
-    id: string;
-    name: string;
-    originToolCallId?: string;
-    status: AgentTaskStatus;
-    output: string;
-    cancel: () => void;
-    done: Promise<void>;
-}
-interface CreateTaskOptions {
-    originToolCallId?: string;
-}
-declare class TaskManager {
-    private tasks;
-    private notifiedTaskIds;
-    private listeners;
-    private nextId;
-    create(name: string, runner: (task: AgentTask) => Promise<string>, cancel: () => void, options?: CreateTaskOptions): AgentTask;
-    get(id: string): AgentTask | undefined;
-    list(): AgentTask[];
-    subscribe(listener: (tasks: AgentTask[]) => void): () => void;
-    private emitChange;
-    hasRunning(): boolean;
-    stop(id: string): boolean;
-    stopAndWait(id: string): Promise<boolean>;
-    stopAll(): Promise<void>;
-    waitAll(): Promise<void>;
-    drainNotifications(): AgentTask[];
-    clear(): void;
-}
-declare function formatAgentTaskNotification(task: AgentTask): string;
 
-type taskManager_AgentTask = AgentTask;
-type taskManager_AgentTaskStatus = AgentTaskStatus;
-type taskManager_TaskManager = TaskManager;
-declare const taskManager_TaskManager: typeof TaskManager;
-declare const taskManager_formatAgentTaskNotification: typeof formatAgentTaskNotification;
-declare namespace taskManager {
-  export { type taskManager_AgentTask as AgentTask, type taskManager_AgentTaskStatus as AgentTaskStatus, taskManager_TaskManager as TaskManager, taskManager_formatAgentTaskNotification as formatAgentTaskNotification };
-}
-
-/**
- * Copyright (c) 2026 hangtiancheng
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-/** Abort a running teammate or one-shot background Agent task. */
+/** Abort a running teammate or one-shot background Agent/Bash/PowerShell/JavaScript task. */
 declare class TaskStopTool implements Tool {
     private teamManager;
     private taskManager?;
@@ -3662,7 +3734,7 @@ declare class TaskStopTool implements Tool {
     category: ToolCategory;
     constructor(teamManager: TeamManager, taskManager?: TaskManager | undefined);
     schema(): ToolSchema;
-    execute(_ctx: ToolContext, args: Record<string, unknown>): Promise<ToolResult>;
+    execute(ctx: ToolContext, args: Record<string, unknown>): Promise<ToolResult>;
     /** List all current teammate names for the model, so it doesn't keep retrying with a misremembered name */
     private knownMembers;
 }
@@ -3997,6 +4069,8 @@ declare class Team {
      * Returns the concatenated prompt or a shutdown flag.
      */
     private waitForNextPromptOrShutdown;
+    /** Reads the teammate's plan file for review; returns a fallback note when empty or unreadable. */
+    private readPlanForReview;
     /**
      * 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.
@@ -4007,7 +4081,6 @@ declare class Team {
      * drive progress from the Lead side. Returns null when the teammate has been
      * deactivated; the caller should exit the main loop.
      */
-    private readPlanForReview;
     private runPlanApproval;
     getMember(name: string): Member | undefined;
     sendMessage(from: string, to: string, content: string): Promise<void>;
@@ -5074,7 +5147,7 @@ declare function closeLogger(): void;
 /**
  * Global logger export. Modules can import and use it at file top level:
  * ```ts
- * import { logger } from "@/logger/logger.js";
+ * import { logger } from "@/logger/index.js";
  * logger.warn({ module: "app" }, "something looks off");
  * ```
  * Before initLogger(), calls fall back to the silent target (pre-init logs
@@ -5676,7 +5749,7 @@ declare namespace instructions {
  */
 /**
  Memory freshness calculation and expiration reminders. Appends a prompt text
- to memories older than 1 day, instructing the model that the memory may be
+ to memories at least 2 days old, instructing the model that the memory may be
  stale and should be verified before use.
  */
 declare function memoryAgeDays(mtimeMs: number): number;
@@ -6251,7 +6324,6 @@ interface CreateRemoteAgentOptions {
 /**
  * Initializes the full agent stack: tools, LLM client, conversation, session,
  * skills, hooks, MCP servers, team management, and memory.
- * Replicates ALL logic from server-old.ts initAgent() + initMCPServers().
  */
 declare function createRemoteAgent(opts: CreateRemoteAgentOptions): Promise<RemoteAgentHandle>;
 interface RemoteServerOptions {
@@ -6691,8 +6763,9 @@ declare const CUSTOM_AGENT_DISALLOWED_TOOLS: Set<AllTools>;
 declare const ASYNC_AGENT_ALLOWED_TOOLS: Set<AllTools>;
 /**
  * Multi-layer tool filtering, applied in order:
- * 1. MCP tools (mcp__*) — Always allowed
- * 2. ALL_AGENT_DISALLOWED_TOOLS — Globally disallowed (prevents recursion)
+ * 1. MCP tools (mcp__*) — exempt from layers 2-4, but still subject to
+ *    definition-level disallowedTools/tools (layers 5-6)
+ * 2. SUBAGENT_DISALLOWED_TOOLS — Globally disallowed (prevents recursion)
  * 3. CUSTOM_AGENT_DISALLOWED_TOOLS — Additional restrictions for custom Agents
  * 4. ASYNC_AGENT_ALLOWED_TOOLS — Whitelist for background Agents
  * 5. Definition-level disallowedTools — Blacklist
@@ -6763,8 +6836,16 @@ declare namespace index$6 {
  */
 
 declare const TOOL_RESULT_PREVIEW_CHARS = 2000;
+declare function spillDir(workDir: string, sessionId: string): string;
 declare function toDisplayPreview(content: string): string;
 declare function replaceToolResultContent(result: ToolResultBlock, content: string): void;
+/**
+ * The `<persisted-output>` wrapper text. buildSpillPreview derives the inputs
+ * from an in-memory string; tool-level producers (e.g. a backgrounded Bash
+ * command's live output file) build the same wrapper from a stat + partial
+ * read without ever loading the full content into JS.
+ */
+declare function buildPersistedOutputPreview(totalChars: number, preview: string, spillPath: string): string;
 /**
  * Determine whether a tool call is reading back a file under the spill
  * directory. Such results are not spilled: writing the model's freshly-read
@@ -6790,19 +6871,22 @@ declare function isSpillReadback(toolName: string, args: Record<string, unknown>
 declare function applyBudget(toolResults: ToolResultBlock[], workDir: string, sessionId: string, exemptIds?: Set<string>): void;
 /**
  * Spill an oversized tool output to disk and return the preview text. On
- * write failure the content is returned unchanged. Called from agent.ts when
- * tool results enter the conversation history, in place of direct truncation.
+ * write failure the content is returned unchanged. Called from agent/index.ts
+ * (and tools/javascript.ts) when tool results enter the conversation history,
+ * in place of direct truncation.
  */
 declare function persistLargeResult(workDir: string, sessionId: string, toolUseId: string, content: string): string;
 
 declare const index$5_TOOL_RESULT_PREVIEW_CHARS: typeof TOOL_RESULT_PREVIEW_CHARS;
 declare const index$5_applyBudget: typeof applyBudget;
+declare const index$5_buildPersistedOutputPreview: typeof buildPersistedOutputPreview;
 declare const index$5_isSpillReadback: typeof isSpillReadback;
 declare const index$5_persistLargeResult: typeof persistLargeResult;
 declare const index$5_replaceToolResultContent: typeof replaceToolResultContent;
+declare const index$5_spillDir: typeof spillDir;
 declare const index$5_toDisplayPreview: typeof toDisplayPreview;
 declare namespace index$5 {
-  export { index$5_TOOL_RESULT_PREVIEW_CHARS as TOOL_RESULT_PREVIEW_CHARS, index$5_applyBudget as applyBudget, index$5_isSpillReadback as isSpillReadback, index$5_persistLargeResult as persistLargeResult, index$5_replaceToolResultContent as replaceToolResultContent, index$5_toDisplayPreview as toDisplayPreview };
+  export { index$5_TOOL_RESULT_PREVIEW_CHARS as TOOL_RESULT_PREVIEW_CHARS, index$5_applyBudget as applyBudget, index$5_buildPersistedOutputPreview as buildPersistedOutputPreview, index$5_isSpillReadback as isSpillReadback, index$5_persistLargeResult as persistLargeResult, index$5_replaceToolResultContent as replaceToolResultContent, index$5_spillDir as spillDir, index$5_toDisplayPreview as toDisplayPreview };
 }
 
 /**
@@ -6834,6 +6918,18 @@ declare class BashTool implements Tool {
     sandbox: Sandbox | null;
     sandboxRequired: boolean;
     sandboxConfig: SandboxConfig;
+    /**
+     * 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: TaskManager | null;
+    /** Running foreground executions eligible for manual backgrounding (Ctrl+B). */
+    private foreground;
+    private nextForegroundId;
     /**
      * Read-only commands can run concurrently with other read-only tools;
      * mutating commands must run exclusively.
@@ -6845,8 +6941,30 @@ declare class BashTool implements Tool {
      * pipes, command chaining, and command substitution are already excluded.
      */
     isConcurrencySafe(args: Record<string, unknown>): boolean;
+    /**
+     * 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(): boolean;
+    /** True while at least one foreground Bash command runs (gates the Ctrl+B handler). */
+    hasForegroundTasks(): boolean;
+    /**
+     * Move every running foreground Bash command to the background (Ctrl+B).
+     * Returns how many commands were actually backgrounded.
+     */
+    backgroundForegroundTasks(): number;
     schema(): ToolSchema;
     execute(ctx: ToolContext, args: Record<string, unknown>): Promise<ToolResult>;
+    /**
+     * 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.
+     */
+    private startCommand;
 }
 
 type bash_BashTool = BashTool;
@@ -6969,8 +7087,28 @@ declare namespace computerUse {
  * SOFTWARE.
  */
 declare const BASH_DESCRIPTION = "Execute command in Bash; return stdout and stderr. Prefer PowerShell on Windows.\n- timeout is in seconds: default 120, maximum 600. Each call starts a fresh, independent shell in the Agent's working directory; cd, variables, functions, and options do not persist.\n- Quote paths with spaces. To change directory, use cd \"path\" && command in the same call. Separate independent commands; chain dependent commands with &&, not ;.\n- 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.\nGit: 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>.";
+/**
+ * Appended to the Bash schema description only when background execution is
+ * available (a TaskManager is wired and not disabled via env), so the
+ * run_in_background parameter and its guidance never advertise a capability
+ * the current host cannot deliver.
+ */
+declare const 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.";
 declare const POWERSHELL_DESCRIPTION = "Execute command in PowerShell; return stdout and stderr. Recommended on Windows (powershell.exe); uses pwsh elsewhere.\n- 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.\n- 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.\n- 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.\nGit: 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>.";
+/**
+ * Appended to the PowerShell schema description only when background execution
+ * is available; mirrors BASH_BACKGROUND_DESCRIPTION with PS-flavored wording.
+ */
+declare const 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.";
 declare const JAVASCRIPT_DESCRIPTION = "Execute JavaScript in a fresh isolated V8 context for pure computation.\n- Provide a function body and use return to produce a JSON-compatible result. Optional input is available as globalThis.input.\n- No filesystem, network, process, require, imports, timers, or host callbacks are available. Use Bash for Node.js or system operations.\n- timeout_ms defaults to 1000 (max 10000); memory_limit_mb defaults to 64 (max 256). Requires Node.js 24 or newer.";
+/**
+ * Appended to the JavaScript schema description only when background execution
+ * is available. No timeout auto-background here: 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 there is nothing left to keep running.
+ */
+declare const 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.";
 declare const READ_FILE_DESCRIPTION = "Read text with 1-based display line numbers, or images (png, jpg, jpeg, gif, webp) as visual content; not directories.\n- 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.\n- Images ignore offset/limit. A successful read refreshes the file-state cache used by EditFile/WriteFile; re-read after an external-change error.";
 declare const EDIT_FILE_DESCRIPTION = "Replace exact text in an existing file and return a diff. Prefer this over whole-file rewrites.\n- file_path is absolute or relative to the Agent's working directory. ReadFile is required first; stale file-state errors require a fresh read and revised edit.\n- old_string must be non-empty and unique unless replace_all=true (default false). Use enough context to disambiguate; preserve whitespace and exclude display line numbers.\n- new_string must differ from old_string; an empty string deletes the match.";
 declare const WRITE_FILE_DESCRIPTION = "Write complete UTF-8 content to file_path, creating parent directories and overwriting existing content. Use for new files or complete rewrites; prefer EditFile for targeted changes.\n- file_path is absolute or relative to the Agent's working directory. Existing files require ReadFile first; re-read if the cached state is stale.\n- content includes any desired trailing newline; an empty string creates or truncates an empty file. Avoid unrelated files or unsolicited documentation.";
@@ -6978,17 +7116,20 @@ declare const GLOB_DESCRIPTION = "Find files by glob pattern (e.g. \"**/*.ts\",
 declare const GREP_DESCRIPTION = "Search file content with a case-insensitive, line-by-line JavaScript-style regex pattern; return file:line:content with 1-based lines and working-directory-relative paths.\n- path is a file or directory, absolute or relative to the Agent's working directory (default \".\"). Escape regex backslashes in JSON. No multiline matching or general PCRE support.\n- include is an optional glob: \"*.ts\" matches names at any depth; patterns with \"/\" match working-directory-relative paths. A direct file path is searched without this filter.\n- Traversal includes dotfiles but skips fixed directories such as .git, .agents, .swifty, node_modules, dist, and __pycache__, not .gitignore rules. Binary/unreadable files are skipped; directory symlinks are not traversed.\n- At most 500 matching lines. Narrow searches; never search the filesystem root. Use ReadFile for context and this tool instead of shell grep/rg.";
 declare const WEB_FETCH_DESCRIPTION = "Fetch a URL over HTTP(S) and return its content as Markdown. Use it to retrieve and analyze web pages.\n- url must be a fully-formed http or https URL; redirects are followed automatically and the final URL is reported when it differs.\n- HTML is converted to Markdown; other text formats (plain text, JSON, XML, Markdown) are returned as-is. Binary content (images, PDFs, archives) is rejected.\n- Responses over 10MB are rejected and results are truncated at 100K characters. Successful fetches are cached for 15 minutes.";
 
+declare const descriptions_BASH_BACKGROUND_DESCRIPTION: typeof BASH_BACKGROUND_DESCRIPTION;
 declare const descriptions_BASH_DESCRIPTION: typeof BASH_DESCRIPTION;
 declare const descriptions_EDIT_FILE_DESCRIPTION: typeof EDIT_FILE_DESCRIPTION;
 declare const descriptions_GLOB_DESCRIPTION: typeof GLOB_DESCRIPTION;
 declare const descriptions_GREP_DESCRIPTION: typeof GREP_DESCRIPTION;
+declare const descriptions_JAVASCRIPT_BACKGROUND_DESCRIPTION: typeof JAVASCRIPT_BACKGROUND_DESCRIPTION;
 declare const descriptions_JAVASCRIPT_DESCRIPTION: typeof JAVASCRIPT_DESCRIPTION;
+declare const descriptions_POWERSHELL_BACKGROUND_DESCRIPTION: typeof POWERSHELL_BACKGROUND_DESCRIPTION;
 declare const descriptions_POWERSHELL_DESCRIPTION: typeof POWERSHELL_DESCRIPTION;
 declare const descriptions_READ_FILE_DESCRIPTION: typeof READ_FILE_DESCRIPTION;
 declare const descriptions_WEB_FETCH_DESCRIPTION: typeof WEB_FETCH_DESCRIPTION;
 declare const descriptions_WRITE_FILE_DESCRIPTION: typeof WRITE_FILE_DESCRIPTION;
 declare namespace descriptions {
-  export { descriptions_BASH_DESCRIPTION as BASH_DESCRIPTION, descriptions_EDIT_FILE_DESCRIPTION as EDIT_FILE_DESCRIPTION, descriptions_GLOB_DESCRIPTION as GLOB_DESCRIPTION, descriptions_GREP_DESCRIPTION as GREP_DESCRIPTION, descriptions_JAVASCRIPT_DESCRIPTION as JAVASCRIPT_DESCRIPTION, descriptions_POWERSHELL_DESCRIPTION as POWERSHELL_DESCRIPTION, descriptions_READ_FILE_DESCRIPTION as READ_FILE_DESCRIPTION, descriptions_WEB_FETCH_DESCRIPTION as WEB_FETCH_DESCRIPTION, descriptions_WRITE_FILE_DESCRIPTION as WRITE_FILE_DESCRIPTION };
+  export { descriptions_BASH_BACKGROUND_DESCRIPTION as BASH_BACKGROUND_DESCRIPTION, descriptions_BASH_DESCRIPTION as BASH_DESCRIPTION, descriptions_EDIT_FILE_DESCRIPTION as EDIT_FILE_DESCRIPTION, descriptions_GLOB_DESCRIPTION as GLOB_DESCRIPTION, descriptions_GREP_DESCRIPTION as GREP_DESCRIPTION, descriptions_JAVASCRIPT_BACKGROUND_DESCRIPTION as JAVASCRIPT_BACKGROUND_DESCRIPTION, descriptions_JAVASCRIPT_DESCRIPTION as JAVASCRIPT_DESCRIPTION, descriptions_POWERSHELL_BACKGROUND_DESCRIPTION as POWERSHELL_BACKGROUND_DESCRIPTION, descriptions_POWERSHELL_DESCRIPTION as POWERSHELL_DESCRIPTION, descriptions_READ_FILE_DESCRIPTION as READ_FILE_DESCRIPTION, descriptions_WEB_FETCH_DESCRIPTION as WEB_FETCH_DESCRIPTION, descriptions_WRITE_FILE_DESCRIPTION as WRITE_FILE_DESCRIPTION };
 }
 
 /**
@@ -7107,6 +7248,47 @@ declare namespace enterWorktree {
   export { enterWorktree_EnterWorktreeTool as EnterWorktreeTool };
 }
 
+/**
+ * Copyright (c) 2026 hangtiancheng
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+/**
+ * Extract the base command name from a command string.
+ * For piped commands, take the last segment: bash and PowerShell both surface
+ * the exit code of the last command in a pipeline.
+ */
+declare function extractBaseCmd(command: string): string;
+/**
+ * Return a semantic hint for a non-zero exit code, helping the LLM understand
+ * what the code means. Command-specific hints win over generic ones; POSIX
+ * 128+n signal exits get a fallback description. Returns empty string when
+ * nothing is recognized.
+ */
+declare function exitCodeHint(command: string, exitCode: number): string;
+
+declare const exitCodeHints_exitCodeHint: typeof exitCodeHint;
+declare const exitCodeHints_extractBaseCmd: typeof extractBaseCmd;
+declare namespace exitCodeHints {
+  export { exitCodeHints_exitCodeHint as exitCodeHint, exitCodeHints_extractBaseCmd as extractBaseCmd };
+}
+
 /**
  * Copyright (c) 2026 hangtiancheng
  *
@@ -7331,8 +7513,35 @@ declare class JavaScriptTool implements Tool {
     name: string;
     description: string;
     category: ToolCategory;
+    /**
+     * 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: TaskManager | null;
+    /** Running foreground evaluations eligible for manual backgrounding (Ctrl+B). */
+    private foreground;
+    private nextForegroundId;
+    /** Instance-level background gate; see BashTool.backgroundEnabled. */
+    backgroundEnabled(): boolean;
+    /** True while at least one foreground evaluation runs. */
+    hasForegroundTasks(): boolean;
+    /** Move every running foreground evaluation to the background (Ctrl+B). */
+    backgroundForegroundTasks(): number;
     schema(): ToolSchema;
     execute(ctx: ToolContext, args: Record<string, unknown>): Promise<ToolResult>;
+    /**
+     * 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.
+     */
+    private startEvaluation;
 }
 
 type javascript_JavaScriptEvaluation = JavaScriptEvaluation;
@@ -7367,13 +7576,16 @@ declare namespace javascript {
  * SOFTWARE.
  */
 /**
- * Unified call entry point for MCP tools.
+ * Unified call entry point for MCP tools (dispatch mode only — see
+ * mcp/strategy.ts for the eager/native modes, where MCP tools ship in tools[]
+ * directly or stay there flagged with defer_loading).
  *
- * MCP tools never enter tools[]. The model first reads the schema via ToolSearch,
- * then passes the tool name and arguments through McpCall. This keeps the tools
- * array byte-identical throughout the whole session, so the prompt cache prefix is
- * never broken — tools render after system and before messages, so any change to
- * the array forces the entire trailing history to be recomputed.
+ * In dispatch mode MCP tools never enter tools[]. The model first reads the
+ * schema via ToolSearch, then passes the tool name and arguments through
+ * McpCall. This keeps the tools array byte-identical throughout the whole
+ * session, so the prompt cache prefix is never broken — tools render after
+ * system and before messages, so any change to the array forces the entire
+ * trailing history to be recomputed.
  *
  * The trade-off is that arguments are generated freely by the model with no schema
  * constraint at the interface level, so the JSON type is occasionally wrong.
@@ -7458,8 +7670,30 @@ declare class PowerShellTool implements Tool {
     name: string;
     description: string;
     category: ToolCategory;
+    /**
+     * 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: TaskManager | null;
+    /** Running foreground executions eligible for manual backgrounding (Ctrl+B). */
+    private foreground;
+    private nextForegroundId;
+    /** Instance-level background gate; see BashTool.backgroundEnabled. */
+    backgroundEnabled(): boolean;
+    /** True while at least one foreground PowerShell command runs. */
+    hasForegroundTasks(): boolean;
+    /** Move every running foreground command to the background (Ctrl+B). */
+    backgroundForegroundTasks(): number;
     schema(): ToolSchema;
     execute(ctx: ToolContext, args: Record<string, unknown>): Promise<ToolResult>;
+    /**
+     * 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.
+     */
+    private startCommand;
 }
 
 type powershell_PowerShellTool = PowerShellTool;
@@ -7505,6 +7739,138 @@ declare namespace readFile {
   export { readFile_ReadFileTool as ReadFileTool };
 }
 
+/** Notification body budget: larger outputs stay on disk and only a preview travels in the notification. */
+declare const BACKGROUND_NOTIFICATION_CHARS = 30000;
+/**
+ * ccb parity: a backgrounded command may fill up to 5GB before the size
+ * watchdog kills it (their incident: a stuck append loop wrote 768GB with no
+ * JS in the write path to notice). Foreground keeps the historical 10MB cap.
+ */
+declare const BACKGROUND_MAX_OUTPUT_BYTES: number;
+declare const SIZE_WATCHDOG_INTERVAL_MS = 500;
+/** Why a command moved to the background. */
+type BackgroundReason = "explicit" | "user" | "timeout";
+/** Terminal facts about the child process, consumed to build results and notifications. */
+interface ShellExit {
+    code: number | null;
+    signal: NodeJS.Signals | null;
+    aborted: boolean;
+    timedOut: boolean;
+    sizeKilled: boolean;
+    spawnError?: string;
+}
+interface CommandHandle {
+    /** Resolves the tool call: either the inline completion or an early "moved to background" message. */
+    result: Promise<ToolResult>;
+    /**
+     * Move the running command to the background. Returns the background task ID,
+     * or null when the command already finished or backgrounding is unavailable.
+     */
+    background: (reason: BackgroundReason) => string | null;
+}
+/**
+ * Whether a command may be *automatically* backgrounded on timeout. Bare
+ * sleeps are killed instead: backgrounding one would just hold a task slot
+ * until session end. Explicit run_in_background and manual Ctrl+B are always
+ * honored regardless of this gate. Only the first token is considered:
+ * `sleep 60` should die on timeout, but `npm run build && sleep 1` is a real
+ * workload worth keeping alive.
+ */
+declare function isAutobackgroundingAllowed(command: string, disallowed: ReadonlySet<string>): boolean;
+declare function backgroundTaskName(command: string): string;
+declare function backgroundMessage(reason: BackgroundReason, taskId: string, timeout: number): string;
+/** Slice buf to at most maxBytes, ending on a UTF-8 character boundary. */
+declare function sliceUtf8Safe(buf: Buffer, maxBytes: number): Buffer;
+/** Read at most maxBytes of the output file; missing files read as empty. */
+declare function readOutputFile(path: string, maxBytes: number): {
+    text: string;
+    size: number;
+    truncated: boolean;
+};
+declare function unlinkQuiet(path: string): void;
+declare function discardFd(fd: number): void;
+declare function openOutputFd(path: string): number;
+/**
+ * Create the file that receives a command's stdout+stderr. Lives in the
+ * session tool-results directory (the established spill location, readable by
+ * the model for backgrounded commands); falls back to the OS temp dir when
+ * that directory cannot be created.
+ */
+declare function createShellOutputFile(workDir: string, sessionId: string): {
+    path: string;
+    fd: number;
+};
+/**
+ * Build the foreground tool result from exit facts and the captured output.
+ * Shared verbatim by the inline foreground path and the background task
+ * notification body, so both report identically. `prompt` is the tool's shell
+ * marker ("$ " for Bash, "PS> " for PowerShell).
+ */
+declare function formatFinalResult(prompt: string, command: string, exit: ShellExit, merged: string, truncated: boolean, timeout: number): ToolResult;
+/**
+ * Build the notification body for a finished background command from the
+ * output file. Small outputs are inlined and the file is deleted; large
+ * outputs keep the file on disk and the notification carries its path with a
+ * 2000-char preview, so the full text stays readable via ReadFile without ever
+ * loading it into JS here. `annotate` is the sandbox's stderr annotator
+ * (sandbox-runtime violation notes); the foreground path applies it in
+ * settleExit, and background notifications must report identically.
+ */
+declare function buildBackgroundBody(prompt: string, command: string, exit: ShellExit, outputPath: string, timeout: number, annotate?: (text: string) => string): ToolResult;
+/** The subset of a tool instance the host wiring below needs. */
+interface BackgroundableTool {
+    taskManager: TaskManager | null;
+    backgroundEnabled(): boolean;
+    hasForegroundTasks(): boolean;
+    backgroundForegroundTasks(): number;
+}
+/** Tools that support background execution, in Ctrl+B priority order. */
+declare const BACKGROUNDABLE_TOOL_NAMES: readonly ["Bash", "PowerShell", "JavaScript"];
+/**
+ * Share one background task registry across every backgroundable tool in the
+ * registry, so run_in_background, Ctrl+B and timeout auto-background deliver
+ * results through the same task-notification drain as background agents.
+ */
+declare function attachBackgroundTaskManager(registry: ToolRegistry, manager: TaskManager): void;
+/**
+ * Whether any backgroundable tool has a running foreground task. Gates the
+ * Ctrl+B handler: the keypress must stay inert when nothing is running, so
+ * other components that also bind Ctrl+B (e.g. the provider-login form's
+ * cursor-back) don't double-fire.
+ */
+declare function hasAnyForegroundTasks(registry: ToolRegistry): boolean;
+/**
+ * Move every running foreground task of every backgroundable tool to the
+ * background (the Ctrl+B action). Returns how many were backgrounded.
+ */
+declare function backgroundAllForegroundTasks(registry: ToolRegistry): number;
+
+declare const shellBackground_BACKGROUNDABLE_TOOL_NAMES: typeof BACKGROUNDABLE_TOOL_NAMES;
+declare const shellBackground_BACKGROUND_MAX_OUTPUT_BYTES: typeof BACKGROUND_MAX_OUTPUT_BYTES;
+declare const shellBackground_BACKGROUND_NOTIFICATION_CHARS: typeof BACKGROUND_NOTIFICATION_CHARS;
+type shellBackground_BackgroundReason = BackgroundReason;
+type shellBackground_BackgroundableTool = BackgroundableTool;
+type shellBackground_CommandHandle = CommandHandle;
+declare const shellBackground_SIZE_WATCHDOG_INTERVAL_MS: typeof SIZE_WATCHDOG_INTERVAL_MS;
+type shellBackground_ShellExit = ShellExit;
+declare const shellBackground_attachBackgroundTaskManager: typeof attachBackgroundTaskManager;
+declare const shellBackground_backgroundAllForegroundTasks: typeof backgroundAllForegroundTasks;
+declare const shellBackground_backgroundMessage: typeof backgroundMessage;
+declare const shellBackground_backgroundTaskName: typeof backgroundTaskName;
+declare const shellBackground_buildBackgroundBody: typeof buildBackgroundBody;
+declare const shellBackground_createShellOutputFile: typeof createShellOutputFile;
+declare const shellBackground_discardFd: typeof discardFd;
+declare const shellBackground_formatFinalResult: typeof formatFinalResult;
+declare const shellBackground_hasAnyForegroundTasks: typeof hasAnyForegroundTasks;
+declare const shellBackground_isAutobackgroundingAllowed: typeof isAutobackgroundingAllowed;
+declare const shellBackground_openOutputFd: typeof openOutputFd;
+declare const shellBackground_readOutputFile: typeof readOutputFile;
+declare const shellBackground_sliceUtf8Safe: typeof sliceUtf8Safe;
+declare const shellBackground_unlinkQuiet: typeof unlinkQuiet;
+declare namespace shellBackground {
+  export { shellBackground_BACKGROUNDABLE_TOOL_NAMES as BACKGROUNDABLE_TOOL_NAMES, shellBackground_BACKGROUND_MAX_OUTPUT_BYTES as BACKGROUND_MAX_OUTPUT_BYTES, shellBackground_BACKGROUND_NOTIFICATION_CHARS as BACKGROUND_NOTIFICATION_CHARS, type shellBackground_BackgroundReason as BackgroundReason, type shellBackground_BackgroundableTool as BackgroundableTool, type shellBackground_CommandHandle as CommandHandle, shellBackground_SIZE_WATCHDOG_INTERVAL_MS as SIZE_WATCHDOG_INTERVAL_MS, type shellBackground_ShellExit as ShellExit, shellBackground_attachBackgroundTaskManager as attachBackgroundTaskManager, shellBackground_backgroundAllForegroundTasks as backgroundAllForegroundTasks, shellBackground_backgroundMessage as backgroundMessage, shellBackground_backgroundTaskName as backgroundTaskName, shellBackground_buildBackgroundBody as buildBackgroundBody, shellBackground_createShellOutputFile as createShellOutputFile, shellBackground_discardFd as discardFd, shellBackground_formatFinalResult as formatFinalResult, shellBackground_hasAnyForegroundTasks as hasAnyForegroundTasks, shellBackground_isAutobackgroundingAllowed as isAutobackgroundingAllowed, shellBackground_openOutputFd as openOutputFd, shellBackground_readOutputFile as readOutputFile, shellBackground_sliceUtf8Safe as sliceUtf8Safe, shellBackground_unlinkQuiet as unlinkQuiet };
+}
+
 /**
  * Copyright (c) 2026 hangtiancheng
  *
@@ -7662,6 +8028,42 @@ declare namespace toolSearch {
   export { toolSearch_ToolSearchTool as ToolSearchTool };
 }
 
+/**
+ * Copyright (c) 2026 hangtiancheng
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+declare class WebFetchTool implements Tool {
+    name: string;
+    description: string;
+    category: ToolCategory;
+    schema(): ToolSchema;
+    execute(ctx: ToolContext, args: Record<string, unknown>): Promise<ToolResult>;
+}
+
+type webFetch_WebFetchTool = WebFetchTool;
+declare const webFetch_WebFetchTool: typeof WebFetchTool;
+declare namespace webFetch {
+  export { webFetch_WebFetchTool as WebFetchTool };
+}
+
 /**
  * Copyright (c) 2026 hangtiancheng
  *
@@ -7721,7 +8123,7 @@ declare namespace writeFile {
  */
 
 declare namespace index$4 {
-  export { askUser as AskUser, bash as Bash, computerUse as ComputerUse, descriptions as Descriptions, diff as Diff, editFile as EditFile, enterWorktree as EnterWorktree, exitPlanMode as ExitPlanMode, exitWorktree as ExitWorktree, fileMutationQueue as FileMutationQueue, fileStateCache as FileStateCache, glob as Glob, grep as Grep, isDiffTool$1 as IsDiffTool, javascript as JavaScript, mcpCall as McpCall, powershell as PowerShell, readFile as ReadFile, registry$1 as Registry, shellOutput as ShellOutput, snippets as Snippets, syntheticOutput as SyntheticOutput, toolSearch as ToolSearch, types as Types, writeFile as WriteFile };
+  export { askUser as AskUser, bash as Bash, computerUse as ComputerUse, descriptions as Descriptions, diff as Diff, editFile as EditFile, enterWorktree as EnterWorktree, exitCodeHints as ExitCodeHints, exitPlanMode as ExitPlanMode, exitWorktree as ExitWorktree, fileMutationQueue as FileMutationQueue, fileStateCache as FileStateCache, glob as Glob, grep as Grep, isDiffTool$1 as IsDiffTool, javascript as JavaScript, mcpCall as McpCall, powershell as PowerShell, readFile as ReadFile, registry$1 as Registry, shellBackground as ShellBackground, shellOutput as ShellOutput, snippets as Snippets, syntheticOutput as SyntheticOutput, toolSearch as ToolSearch, types as Types, webFetch as WebFetchTool, writeFile as WriteFile };
 }
 
 /**