@swifty.js/swifty 0.0.35 → 0.0.37

package/dist/lib/index.d.ts

@@ -2,11 +2,9 @@ import * as acp from '@agentclientprotocol/sdk';
 import { InitializeRequest, InitializeResponse, NewSessionRequest, NewSessionResponse, LoadSessionRequest, ResumeSessionRequest, ListSessionsRequest, ListSessionsResponse, PromptRequest, AgentRequestContext, PromptResponse, CancelNotification, CloseSessionRequest, AgentApp, Usage, SessionUpdate, SessionNotification, ContentBlock, StopReason, ToolKind, ToolCallLocation } from '@agentclientprotocol/sdk';
 import z, { z as z$1 } from 'zod';
 import Anthropic from '@anthropic-ai/sdk';
-import { BetaToolComputerUse20251124 } from '@anthropic-ai/sdk/resources/beta/messages/messages';
 import OpenAI from 'openai';
 import { Logger } from 'pino';
 import { SandboxRuntimeConfig } from '@anthropic-ai/sandbox-runtime';
-import * as react from 'react';
 import { Transport } from '@modelcontextprotocol/sdk/shared/transport.js';
 import { JSONRPCMessage } from '@modelcontextprotocol/sdk/types.js';
 
@@ -37,7 +35,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;
@@ -169,13 +167,13 @@ declare class FileHistory {
     save(): void;
 }
 
-type index$w_Backup = Backup;
-type index$w_FileHistory = FileHistory;
-declare const index$w_FileHistory: typeof FileHistory;
-type index$w_Snapshot = Snapshot;
-declare const index$w_fileHistoryDir: typeof fileHistoryDir;
-declare namespace index$w {
-  export { type index$w_Backup as Backup, index$w_FileHistory as FileHistory, type index$w_Snapshot as Snapshot, index$w_fileHistoryDir as fileHistoryDir };
+type index$v_Backup = Backup;
+type index$v_FileHistory = FileHistory;
+declare const index$v_FileHistory: typeof FileHistory;
+type index$v_Snapshot = Snapshot;
+declare const index$v_fileHistoryDir: typeof fileHistoryDir;
+declare namespace index$v {
+  export { type index$v_Backup as Backup, index$v_FileHistory as FileHistory, type index$v_Snapshot as Snapshot, index$v_fileHistoryDir as fileHistoryDir };
 }
 
 /**
@@ -253,26 +251,120 @@ 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;
 }
 
-type index$v_Decision = Decision;
-type index$v_DecisionEffect = DecisionEffect;
-type index$v_PathSandbox = PathSandbox;
-declare const index$v_PathSandbox: typeof PathSandbox;
-type index$v_PermissionChecker = PermissionChecker;
-declare const index$v_PermissionChecker: typeof PermissionChecker;
-type index$v_PermissionMode = PermissionMode;
-type index$v_RuleEngine = RuleEngine;
-declare const index$v_RuleEngine: typeof RuleEngine;
-declare const index$v_evaluateRules: typeof evaluateRules;
-declare const index$v_extractContent: typeof extractContent;
-declare const index$v_isSafeCommand: typeof isSafeCommand;
-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 };
+type index$u_Decision = Decision;
+type index$u_DecisionEffect = DecisionEffect;
+type index$u_PathSandbox = PathSandbox;
+declare const index$u_PathSandbox: typeof PathSandbox;
+type index$u_PermissionChecker = PermissionChecker;
+declare const index$u_PermissionChecker: typeof PermissionChecker;
+type index$u_PermissionMode = PermissionMode;
+type index$u_RuleEngine = RuleEngine;
+declare const index$u_RuleEngine: typeof RuleEngine;
+declare const index$u_evaluateRules: typeof evaluateRules;
+declare const index$u_extractContent: typeof extractContent;
+declare const index$u_isSafeCommand: typeof isSafeCommand;
+declare namespace index$u {
+  export { type index$u_Decision as Decision, type index$u_DecisionEffect as DecisionEffect, index$u_PathSandbox as PathSandbox, index$u_PermissionChecker as PermissionChecker, type index$u_PermissionMode as PermissionMode, index$u_RuleEngine as RuleEngine, index$u_evaluateRules as evaluateRules, index$u_extractContent as extractContent, index$u_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 };
 }
 
 /**
@@ -312,6 +404,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;
@@ -357,7 +465,6 @@ interface ToolSchema {
         required?: string[];
         [keyword: string]: unknown;
     };
-    allowed_callers?: ("direct" | "code_execution_20250825" | "code_execution_20260120")[];
     cache_control?: {
         type: "ephemeral";
         ttl?: "5m" | "1h";
@@ -365,11 +472,10 @@ interface ToolSchema {
     eager_input_streaming?: boolean;
 }
 type ToolProtocol = "anthropic" | "openai" | "openai-compat";
-type AnthropicToolSchema = ToolSchema | Anthropic.Tool | BetaToolComputerUse20251124;
-type OpenAIResponsesToolSchema = OpenAI.Responses.FunctionTool | OpenAI.Responses.ComputerTool;
+type AnthropicToolSchema = ToolSchema | Anthropic.Tool;
+type OpenAIResponsesToolSchema = OpenAI.Responses.FunctionTool;
 type OpenAICompatToolSchema = OpenAI.ChatCompletionFunctionTool;
 type ProviderToolSchema = ToolSchema | AnthropicToolSchema | OpenAIResponsesToolSchema | OpenAICompatToolSchema;
-type ProviderNativeToolSchema = BetaToolComputerUse20251124 | OpenAI.Responses.ComputerTool;
 interface Tool {
     name: string;
     description: string;
@@ -388,20 +494,15 @@ interface Tool {
      * trip, so they are never deferred and always ship their full schema.
      */
     deferred?: boolean;
-    /**
-     * Return a provider-native declaration when the protocol supports this tool
-     * natively. Returning undefined lets the registry serialize schema() as a
-     * regular custom/function tool.
-     */
-    providerSchema?(protocol: ToolProtocol): ProviderNativeToolSchema | undefined;
     /**
      * Whether this particular invocation can run concurrently with others,
      * 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;
@@ -415,7 +516,6 @@ type types_McpLoadingMode = McpLoadingMode;
 type types_OpenAICompatToolSchema = OpenAICompatToolSchema;
 type types_OpenAIResponsesToolSchema = OpenAIResponsesToolSchema;
 type types_PermissionRequestHandler = PermissionRequestHandler;
-type types_ProviderNativeToolSchema = ProviderNativeToolSchema;
 type types_ProviderToolSchema = ProviderToolSchema;
 declare const types_SKIP_DIRS: typeof SKIP_DIRS;
 type types_Tool = Tool;
@@ -428,7 +528,7 @@ type types_ToolSchema = ToolSchema;
 declare const types_isToolResultContentBlock: typeof isToolResultContentBlock;
 declare const types_normalizeToolResultContentBlock: typeof normalizeToolResultContentBlock;
 declare namespace types {
-  export { type types_AnthropicToolSchema as AnthropicToolSchema, type types_MCPToolLike as MCPToolLike, type types_McpLoadingMode as McpLoadingMode, type types_OpenAICompatToolSchema as OpenAICompatToolSchema, type types_OpenAIResponsesToolSchema as OpenAIResponsesToolSchema, type types_PermissionRequestHandler as PermissionRequestHandler, type types_ProviderNativeToolSchema as ProviderNativeToolSchema, type types_ProviderToolSchema as ProviderToolSchema, types_SKIP_DIRS as SKIP_DIRS, type types_Tool as Tool, type types_ToolCategory as ToolCategory, type types_ToolContext as ToolContext, type types_ToolProtocol as ToolProtocol, type types_ToolResult as ToolResult, type types_ToolResultContentBlock as ToolResultContentBlock, type types_ToolSchema as ToolSchema, types_isToolResultContentBlock as isToolResultContentBlock, types_normalizeToolResultContentBlock as normalizeToolResultContentBlock };
+  export { type types_AnthropicToolSchema as AnthropicToolSchema, type types_MCPToolLike as MCPToolLike, type types_McpLoadingMode as McpLoadingMode, type types_OpenAICompatToolSchema as OpenAICompatToolSchema, type types_OpenAIResponsesToolSchema as OpenAIResponsesToolSchema, type types_PermissionRequestHandler as PermissionRequestHandler, type types_ProviderToolSchema as ProviderToolSchema, types_SKIP_DIRS as SKIP_DIRS, type types_Tool as Tool, type types_ToolCategory as ToolCategory, type types_ToolContext as ToolContext, type types_ToolProtocol as ToolProtocol, type types_ToolResult as ToolResult, type types_ToolResultContentBlock as ToolResultContentBlock, type types_ToolSchema as ToolSchema, types_isToolResultContentBlock as isToolResultContentBlock, types_normalizeToolResultContentBlock as normalizeToolResultContentBlock };
 }
 
 /**
@@ -594,14 +694,14 @@ declare class ConversationManager {
     } | null;
 }
 
-type index$u_ConversationManager = ConversationManager;
-declare const index$u_ConversationManager: typeof ConversationManager;
-type index$u_Message = Message;
-type index$u_ThinkingBlock = ThinkingBlock;
-type index$u_ToolResultBlock = ToolResultBlock;
-type index$u_ToolUseBlock = ToolUseBlock;
-declare namespace index$u {
-  export { atExpand as AtExpand, index$u_ConversationManager as ConversationManager, type index$u_Message as Message, pairing as Pairing, type index$u_ThinkingBlock as ThinkingBlock, type index$u_ToolResultBlock as ToolResultBlock, type index$u_ToolUseBlock as ToolUseBlock };
+type index$t_ConversationManager = ConversationManager;
+declare const index$t_ConversationManager: typeof ConversationManager;
+type index$t_Message = Message;
+type index$t_ThinkingBlock = ThinkingBlock;
+type index$t_ToolResultBlock = ToolResultBlock;
+type index$t_ToolUseBlock = ToolUseBlock;
+declare namespace index$t {
+  export { atExpand as AtExpand, index$t_ConversationManager as ConversationManager, type index$t_Message as Message, pairing as Pairing, type index$t_ThinkingBlock as ThinkingBlock, type index$t_ToolResultBlock as ToolResultBlock, type index$t_ToolUseBlock as ToolUseBlock };
 }
 
 /**
@@ -735,31 +835,32 @@ 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;
 
-declare const index$t_COMPACT_BOUNDARY: typeof COMPACT_BOUNDARY;
-type index$t_CompactBoundaryPayload = CompactBoundaryPayload;
-type index$t_KeptMessage = KeptMessage;
-type index$t_RestoredMessage = RestoredMessage;
-type index$t_SessionInfo = SessionInfo;
-type index$t_SessionMessage = SessionMessage;
-type index$t_ToolResultRecord = ToolResultRecord;
-type index$t_ToolUseRecord = ToolUseRecord;
-declare const index$t_cleanExpiredSessions: typeof cleanExpiredSessions;
-declare const index$t_getSessionFilePath: typeof getSessionFilePath;
-declare const index$t_listSessions: typeof listSessions;
-declare const index$t_loadSession: typeof loadSession;
-declare const index$t_newSessionId: typeof newSessionId;
-declare const index$t_rebuildFromSession: typeof rebuildFromSession;
-declare const index$t_saveCompactBoundary: typeof saveCompactBoundary;
-declare const index$t_saveMessage: typeof saveMessage;
-declare const index$t_toolResultsToRecords: typeof toolResultsToRecords;
-declare const index$t_toolUsesToRecords: typeof toolUsesToRecords;
-declare namespace index$t {
-  export { index$t_COMPACT_BOUNDARY as COMPACT_BOUNDARY, type index$t_CompactBoundaryPayload as CompactBoundaryPayload, type index$t_KeptMessage as KeptMessage, type index$t_RestoredMessage as RestoredMessage, type index$t_SessionInfo as SessionInfo, type index$t_SessionMessage as SessionMessage, type index$t_ToolResultRecord as ToolResultRecord, type index$t_ToolUseRecord as ToolUseRecord, index$t_cleanExpiredSessions as cleanExpiredSessions, index$t_getSessionFilePath as getSessionFilePath, index$t_listSessions as listSessions, index$t_loadSession as loadSession, index$t_newSessionId as newSessionId, index$t_rebuildFromSession as rebuildFromSession, index$t_saveCompactBoundary as saveCompactBoundary, index$t_saveMessage as saveMessage, index$t_toolResultsToRecords as toolResultsToRecords, index$t_toolUsesToRecords as toolUsesToRecords };
+declare const index$s_COMPACT_BOUNDARY: typeof COMPACT_BOUNDARY;
+type index$s_CompactBoundaryPayload = CompactBoundaryPayload;
+type index$s_KeptMessage = KeptMessage;
+type index$s_RestoredMessage = RestoredMessage;
+type index$s_SessionInfo = SessionInfo;
+type index$s_SessionMessage = SessionMessage;
+type index$s_ToolResultRecord = ToolResultRecord;
+type index$s_ToolUseRecord = ToolUseRecord;
+declare const index$s_cleanExpiredSessions: typeof cleanExpiredSessions;
+declare const index$s_getSessionFilePath: typeof getSessionFilePath;
+declare const index$s_listSessions: typeof listSessions;
+declare const index$s_loadSession: typeof loadSession;
+declare const index$s_newSessionId: typeof newSessionId;
+declare const index$s_rebuildFromSession: typeof rebuildFromSession;
+declare const index$s_saveCompactBoundary: typeof saveCompactBoundary;
+declare const index$s_saveMessage: typeof saveMessage;
+declare const index$s_toolResultsToRecords: typeof toolResultsToRecords;
+declare const index$s_toolUsesToRecords: typeof toolUsesToRecords;
+declare namespace index$s {
+  export { index$s_COMPACT_BOUNDARY as COMPACT_BOUNDARY, type index$s_CompactBoundaryPayload as CompactBoundaryPayload, type index$s_KeptMessage as KeptMessage, type index$s_RestoredMessage as RestoredMessage, type index$s_SessionInfo as SessionInfo, type index$s_SessionMessage as SessionMessage, type index$s_ToolResultRecord as ToolResultRecord, type index$s_ToolUseRecord as ToolUseRecord, index$s_cleanExpiredSessions as cleanExpiredSessions, index$s_getSessionFilePath as getSessionFilePath, index$s_listSessions as listSessions, index$s_loadSession as loadSession, index$s_newSessionId as newSessionId, index$s_rebuildFromSession as rebuildFromSession, index$s_saveCompactBoundary as saveCompactBoundary, index$s_saveMessage as saveMessage, index$s_toolResultsToRecords as toolResultsToRecords, index$s_toolUsesToRecords as toolUsesToRecords };
 }
 
 /**
@@ -1048,11 +1149,11 @@ type AcpMode = {
 declare function parseAcpMode(args: string[]): AcpMode | null;
 declare function runAcp(args: string[]): Promise<void>;
 
-type index$s_AcpMode = AcpMode;
-declare const index$s_parseAcpMode: typeof parseAcpMode;
-declare const index$s_runAcp: typeof runAcp;
-declare namespace index$s {
-  export { type index$s_AcpMode as AcpMode, agent as Agent, conversion as Conversion, stdio as Stdio, websocket as Websocket, index$s_parseAcpMode as parseAcpMode, index$s_runAcp as runAcp };
+type index$r_AcpMode = AcpMode;
+declare const index$r_parseAcpMode: typeof parseAcpMode;
+declare const index$r_runAcp: typeof runAcp;
+declare namespace index$r {
+  export { type index$r_AcpMode as AcpMode, agent as Agent, conversion as Conversion, stdio as Stdio, websocket as Websocket, index$r_parseAcpMode as parseAcpMode, index$r_runAcp as runAcp };
 }
 
 /**
@@ -1456,41 +1557,41 @@ declare function loadConfig(path?: string, options?: {
     allowEmptyProviders?: boolean;
 }): AppConfig;
 
-type index$r_AppConfig = AppConfig;
-type index$r_ConfigError = ConfigError;
-declare const index$r_ConfigError: typeof ConfigError;
-declare const index$r_DEFAULT_CONTEXT_WINDOW: typeof DEFAULT_CONTEXT_WINDOW;
-declare const index$r_DEFAULT_MAX_OUTPUT_TOKENS: typeof DEFAULT_MAX_OUTPUT_TOKENS;
-declare const index$r_DEFAULT_THINKING_LEVEL: typeof DEFAULT_THINKING_LEVEL;
-type index$r_HookConfig = HookConfig;
-declare const index$r_HookConfigSchema: typeof HookConfigSchema;
-type index$r_MCPServerConfig = MCPServerConfig;
-declare const index$r_MIN_THINKING_ANSWER_TOKENS: typeof MIN_THINKING_ANSWER_TOKENS;
-declare const index$r_MIN_THINKING_BUDGET_TOKENS: typeof MIN_THINKING_BUDGET_TOKENS;
-type index$r_ProviderConfig = ProviderConfig;
-declare const index$r_ProviderConfigSchema: typeof ProviderConfigSchema;
-type index$r_SandboxYamlConfig = SandboxYamlConfig;
-declare const index$r_THINKING_BUDGETS: typeof THINKING_BUDGETS;
-declare const index$r_THINKING_LEVELS: typeof THINKING_LEVELS;
-type index$r_ThinkingLevel = ThinkingLevel;
-declare const index$r_clampThinkingLevel: typeof clampThinkingLevel;
-declare const index$r_forkEnabled: typeof forkEnabled;
-declare const index$r_getContextWindow: typeof getContextWindow;
-declare const index$r_getMaxOutputTokens: typeof getMaxOutputTokens;
-declare const index$r_getSupportedThinkingLevels: typeof getSupportedThinkingLevels;
-declare const index$r_getThinkingLevel: typeof getThinkingLevel;
-declare const index$r_globalConfigPath: typeof globalConfigPath;
-declare const index$r_isValidThinkingLevel: typeof isValidThinkingLevel;
-declare const index$r_loadConfig: typeof loadConfig;
-declare const index$r_loadProjectMcpServers: typeof loadProjectMcpServers;
-declare const index$r_resolveAPIKey: typeof resolveAPIKey;
-declare const index$r_thinkingBudgetForLevel: typeof thinkingBudgetForLevel;
-declare const index$r_toAnthropicThinkingEffort: typeof toAnthropicThinkingEffort;
-declare const index$r_toReasoningEffort: typeof toReasoningEffort;
-declare const index$r_withProjectMcpServers: typeof withProjectMcpServers;
-declare const index$r_withProviderDefaults: typeof withProviderDefaults;
-declare namespace index$r {
-  export { type index$r_AppConfig as AppConfig, index$r_ConfigError as ConfigError, index$r_DEFAULT_CONTEXT_WINDOW as DEFAULT_CONTEXT_WINDOW, index$r_DEFAULT_MAX_OUTPUT_TOKENS as DEFAULT_MAX_OUTPUT_TOKENS, index$r_DEFAULT_THINKING_LEVEL as DEFAULT_THINKING_LEVEL, type index$r_HookConfig as HookConfig, index$r_HookConfigSchema as HookConfigSchema, type index$r_MCPServerConfig as MCPServerConfig, index$r_MIN_THINKING_ANSWER_TOKENS as MIN_THINKING_ANSWER_TOKENS, index$r_MIN_THINKING_BUDGET_TOKENS as MIN_THINKING_BUDGET_TOKENS, type index$r_ProviderConfig as ProviderConfig, index$r_ProviderConfigSchema as ProviderConfigSchema, type index$r_SandboxYamlConfig as SandboxYamlConfig, index$r_THINKING_BUDGETS as THINKING_BUDGETS, index$r_THINKING_LEVELS as THINKING_LEVELS, type index$r_ThinkingLevel as ThinkingLevel, index$r_clampThinkingLevel as clampThinkingLevel, index$r_forkEnabled as forkEnabled, index$r_getContextWindow as getContextWindow, index$r_getMaxOutputTokens as getMaxOutputTokens, index$r_getSupportedThinkingLevels as getSupportedThinkingLevels, index$r_getThinkingLevel as getThinkingLevel, index$r_globalConfigPath as globalConfigPath, index$r_isValidThinkingLevel as isValidThinkingLevel, index$r_loadConfig as loadConfig, index$r_loadProjectMcpServers as loadProjectMcpServers, index$r_resolveAPIKey as resolveAPIKey, index$r_thinkingBudgetForLevel as thinkingBudgetForLevel, index$r_toAnthropicThinkingEffort as toAnthropicThinkingEffort, index$r_toReasoningEffort as toReasoningEffort, index$r_withProjectMcpServers as withProjectMcpServers, index$r_withProviderDefaults as withProviderDefaults };
+type index$q_AppConfig = AppConfig;
+type index$q_ConfigError = ConfigError;
+declare const index$q_ConfigError: typeof ConfigError;
+declare const index$q_DEFAULT_CONTEXT_WINDOW: typeof DEFAULT_CONTEXT_WINDOW;
+declare const index$q_DEFAULT_MAX_OUTPUT_TOKENS: typeof DEFAULT_MAX_OUTPUT_TOKENS;
+declare const index$q_DEFAULT_THINKING_LEVEL: typeof DEFAULT_THINKING_LEVEL;
+type index$q_HookConfig = HookConfig;
+declare const index$q_HookConfigSchema: typeof HookConfigSchema;
+type index$q_MCPServerConfig = MCPServerConfig;
+declare const index$q_MIN_THINKING_ANSWER_TOKENS: typeof MIN_THINKING_ANSWER_TOKENS;
+declare const index$q_MIN_THINKING_BUDGET_TOKENS: typeof MIN_THINKING_BUDGET_TOKENS;
+type index$q_ProviderConfig = ProviderConfig;
+declare const index$q_ProviderConfigSchema: typeof ProviderConfigSchema;
+type index$q_SandboxYamlConfig = SandboxYamlConfig;
+declare const index$q_THINKING_BUDGETS: typeof THINKING_BUDGETS;
+declare const index$q_THINKING_LEVELS: typeof THINKING_LEVELS;
+type index$q_ThinkingLevel = ThinkingLevel;
+declare const index$q_clampThinkingLevel: typeof clampThinkingLevel;
+declare const index$q_forkEnabled: typeof forkEnabled;
+declare const index$q_getContextWindow: typeof getContextWindow;
+declare const index$q_getMaxOutputTokens: typeof getMaxOutputTokens;
+declare const index$q_getSupportedThinkingLevels: typeof getSupportedThinkingLevels;
+declare const index$q_getThinkingLevel: typeof getThinkingLevel;
+declare const index$q_globalConfigPath: typeof globalConfigPath;
+declare const index$q_isValidThinkingLevel: typeof isValidThinkingLevel;
+declare const index$q_loadConfig: typeof loadConfig;
+declare const index$q_loadProjectMcpServers: typeof loadProjectMcpServers;
+declare const index$q_resolveAPIKey: typeof resolveAPIKey;
+declare const index$q_thinkingBudgetForLevel: typeof thinkingBudgetForLevel;
+declare const index$q_toAnthropicThinkingEffort: typeof toAnthropicThinkingEffort;
+declare const index$q_toReasoningEffort: typeof toReasoningEffort;
+declare const index$q_withProjectMcpServers: typeof withProjectMcpServers;
+declare const index$q_withProviderDefaults: typeof withProviderDefaults;
+declare namespace index$q {
+  export { type index$q_AppConfig as AppConfig, index$q_ConfigError as ConfigError, index$q_DEFAULT_CONTEXT_WINDOW as DEFAULT_CONTEXT_WINDOW, index$q_DEFAULT_MAX_OUTPUT_TOKENS as DEFAULT_MAX_OUTPUT_TOKENS, index$q_DEFAULT_THINKING_LEVEL as DEFAULT_THINKING_LEVEL, type index$q_HookConfig as HookConfig, index$q_HookConfigSchema as HookConfigSchema, type index$q_MCPServerConfig as MCPServerConfig, index$q_MIN_THINKING_ANSWER_TOKENS as MIN_THINKING_ANSWER_TOKENS, index$q_MIN_THINKING_BUDGET_TOKENS as MIN_THINKING_BUDGET_TOKENS, type index$q_ProviderConfig as ProviderConfig, index$q_ProviderConfigSchema as ProviderConfigSchema, type index$q_SandboxYamlConfig as SandboxYamlConfig, index$q_THINKING_BUDGETS as THINKING_BUDGETS, index$q_THINKING_LEVELS as THINKING_LEVELS, type index$q_ThinkingLevel as ThinkingLevel, index$q_clampThinkingLevel as clampThinkingLevel, index$q_forkEnabled as forkEnabled, index$q_getContextWindow as getContextWindow, index$q_getMaxOutputTokens as getMaxOutputTokens, index$q_getSupportedThinkingLevels as getSupportedThinkingLevels, index$q_getThinkingLevel as getThinkingLevel, index$q_globalConfigPath as globalConfigPath, index$q_isValidThinkingLevel as isValidThinkingLevel, index$q_loadConfig as loadConfig, index$q_loadProjectMcpServers as loadProjectMcpServers, index$q_resolveAPIKey as resolveAPIKey, index$q_thinkingBudgetForLevel as thinkingBudgetForLevel, index$q_toAnthropicThinkingEffort as toAnthropicThinkingEffort, index$q_toReasoningEffort as toReasoningEffort, index$q_withProjectMcpServers as withProjectMcpServers, index$q_withProviderDefaults as withProviderDefaults };
 }
 
 /**
@@ -1549,15 +1650,15 @@ declare class HookEngine {
 }
 declare function validate(hooks: HookConfig[]): Error | null;
 
-type index$q_EventName = EventName;
-type index$q_HookContext = HookContext;
-type index$q_HookEngine = HookEngine;
-declare const index$q_HookEngine: typeof HookEngine;
-type index$q_HookResult = HookResult;
-type index$q_HookRuntimeOptions = HookRuntimeOptions;
-declare const index$q_validate: typeof validate;
-declare namespace index$q {
-  export { type index$q_EventName as EventName, type index$q_HookContext as HookContext, index$q_HookEngine as HookEngine, type index$q_HookResult as HookResult, type index$q_HookRuntimeOptions as HookRuntimeOptions, index$q_validate as validate };
+type index$p_EventName = EventName;
+type index$p_HookContext = HookContext;
+type index$p_HookEngine = HookEngine;
+declare const index$p_HookEngine: typeof HookEngine;
+type index$p_HookResult = HookResult;
+type index$p_HookRuntimeOptions = HookRuntimeOptions;
+declare const index$p_validate: typeof validate;
+declare namespace index$p {
+  export { type index$p_EventName as EventName, type index$p_HookContext as HookContext, index$p_HookEngine as HookEngine, type index$p_HookResult as HookResult, type index$p_HookRuntimeOptions as HookRuntimeOptions, index$p_validate as validate };
 }
 
 /**
@@ -1684,6 +1785,7 @@ declare class AnthropicClient implements LLMClient {
     private systemPrompt;
     private maxOutputTokens;
     private config;
+    private useExplicitCustomToolType;
     constructor(config: ProviderConfig, systemPrompt: string);
     setSystemPrompt(prompt: string): void;
     setMaxOutputTokens(maxTokens: number): void;
@@ -1771,7 +1873,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 +1882,7 @@ interface RecallResult {
     reminder: string;
     paths: string[];
 }
+/** One memory selected for surfacing into the main conversation. */
 interface RelevantMemory {
     path: string;
     mtimeMs: number;
@@ -1795,7 +1897,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 +1919,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;
@@ -1961,7 +2066,7 @@ declare namespace providers {
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  * SOFTWARE.
  */
-type TelemetryMode = "print" | "remote" | "teammate" | "tui" | "unknown";
+type TelemetryMode = "print" | "remote" | "teammate" | "terminal" | "unknown";
 type TelemetryObservationKind = "agent" | "generation" | "tool";
 type TelemetryMetricKind = "counter" | "histogram";
 type TelemetryAttributes = Record<string, string | number | boolean>;
@@ -1996,22 +2101,22 @@ declare function flushTelemetry(): Promise<void>;
 declare function shutdownTelemetry(): Promise<void>;
 declare function installRemoteTelemetrySignalHandlers(): void;
 
-type index$p_TelemetryAttributes = TelemetryAttributes;
-type index$p_TelemetryMetricKind = TelemetryMetricKind;
-type index$p_TelemetryMode = TelemetryMode;
-type index$p_TelemetryObservation = TelemetryObservation;
-type index$p_TelemetryObservationKind = TelemetryObservationKind;
-type index$p_TelemetryObservationUpdate = TelemetryObservationUpdate;
-type index$p_TelemetryRuntime = TelemetryRuntime;
-declare const index$p_captureTelemetryError: typeof captureTelemetryError;
-declare const index$p_flushTelemetry: typeof flushTelemetry;
-declare const index$p_getTelemetryRuntime: typeof getTelemetryRuntime;
-declare const index$p_initializeTelemetry: typeof initializeTelemetry;
-declare const index$p_installRemoteTelemetrySignalHandlers: typeof installRemoteTelemetrySignalHandlers;
-declare const index$p_setTelemetryMode: typeof setTelemetryMode;
-declare const index$p_shutdownTelemetry: typeof shutdownTelemetry;
-declare namespace index$p {
-  export { instrumentation as Instrumentation, providers as Providers, type index$p_TelemetryAttributes as TelemetryAttributes, type index$p_TelemetryMetricKind as TelemetryMetricKind, type index$p_TelemetryMode as TelemetryMode, type index$p_TelemetryObservation as TelemetryObservation, type index$p_TelemetryObservationKind as TelemetryObservationKind, type index$p_TelemetryObservationUpdate as TelemetryObservationUpdate, type index$p_TelemetryRuntime as TelemetryRuntime, index$p_captureTelemetryError as captureTelemetryError, index$p_flushTelemetry as flushTelemetry, index$p_getTelemetryRuntime as getTelemetryRuntime, index$p_initializeTelemetry as initializeTelemetry, index$p_installRemoteTelemetrySignalHandlers as installRemoteTelemetrySignalHandlers, index$p_setTelemetryMode as setTelemetryMode, index$p_shutdownTelemetry as shutdownTelemetry };
+type index$o_TelemetryAttributes = TelemetryAttributes;
+type index$o_TelemetryMetricKind = TelemetryMetricKind;
+type index$o_TelemetryMode = TelemetryMode;
+type index$o_TelemetryObservation = TelemetryObservation;
+type index$o_TelemetryObservationKind = TelemetryObservationKind;
+type index$o_TelemetryObservationUpdate = TelemetryObservationUpdate;
+type index$o_TelemetryRuntime = TelemetryRuntime;
+declare const index$o_captureTelemetryError: typeof captureTelemetryError;
+declare const index$o_flushTelemetry: typeof flushTelemetry;
+declare const index$o_getTelemetryRuntime: typeof getTelemetryRuntime;
+declare const index$o_initializeTelemetry: typeof initializeTelemetry;
+declare const index$o_installRemoteTelemetrySignalHandlers: typeof installRemoteTelemetrySignalHandlers;
+declare const index$o_setTelemetryMode: typeof setTelemetryMode;
+declare const index$o_shutdownTelemetry: typeof shutdownTelemetry;
+declare namespace index$o {
+  export { instrumentation as Instrumentation, providers as Providers, type index$o_TelemetryAttributes as TelemetryAttributes, type index$o_TelemetryMetricKind as TelemetryMetricKind, type index$o_TelemetryMode as TelemetryMode, type index$o_TelemetryObservation as TelemetryObservation, type index$o_TelemetryObservationKind as TelemetryObservationKind, type index$o_TelemetryObservationUpdate as TelemetryObservationUpdate, type index$o_TelemetryRuntime as TelemetryRuntime, index$o_captureTelemetryError as captureTelemetryError, index$o_flushTelemetry as flushTelemetry, index$o_getTelemetryRuntime as getTelemetryRuntime, index$o_initializeTelemetry as initializeTelemetry, index$o_installRemoteTelemetrySignalHandlers as installRemoteTelemetrySignalHandlers, index$o_setTelemetryMode as setTelemetryMode, index$o_shutdownTelemetry as shutdownTelemetry };
 }
 
 /**
@@ -2144,6 +2249,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 +2294,7 @@ declare class Agent {
     private recoveryState;
     private maxIterations;
     private notificationFn?;
+    private taskManager?;
     private onLoopComplete?;
     private compactTracking;
     private onPermissionRequest?;
@@ -2210,18 +2324,18 @@ declare class Agent {
      * Persist the most recently appended conversation message to the session log.
      *
      * Persistence lives in the main loop rather than in individual frontends: both
-     * the TUI and Web share the same recording path, ensuring intermediate assistant
+     * the UI and Web share the same recording path, ensuring intermediate assistant
      * text and complete tool-call chains are captured for session restoration.
      * Skipped when sessionId is empty (one-shot invocations, sub-agents).
      */
     private persistLastMessage;
 }
 
-type index$o_Agent = Agent;
-declare const index$o_Agent: typeof Agent;
-type index$o_AgentConfig = AgentConfig;
-declare namespace index$o {
-  export { index$o_Agent as Agent, type index$o_AgentConfig as AgentConfig, events as Events, streamingExecutor as StreamingExecutor };
+type index$n_Agent = Agent;
+declare const index$n_Agent: typeof Agent;
+type index$n_AgentConfig = AgentConfig;
+declare namespace index$n {
+  export { index$n_Agent as Agent, type index$n_AgentConfig as AgentConfig, events as Events, streamingExecutor as StreamingExecutor };
 }
 
 /**
@@ -2520,12 +2634,12 @@ interface SkillForkHost extends SkillHost {
     snapshotParentMessages(count: number): string;
 }
 
-type index$n_Skill = Skill;
-type index$n_SkillForkHost = SkillForkHost;
-type index$n_SkillHost = SkillHost;
-type index$n_SkillMeta = SkillMeta;
-declare namespace index$n {
-  export { catalog as Catalog, executor as Executor, installTool as InstallTool, loadSkillTool as LoadSkillTool, type index$n_Skill as Skill, type index$n_SkillForkHost as SkillForkHost, type index$n_SkillHost as SkillHost, type index$n_SkillMeta as SkillMeta };
+type index$m_Skill = Skill;
+type index$m_SkillForkHost = SkillForkHost;
+type index$m_SkillHost = SkillHost;
+type index$m_SkillMeta = SkillMeta;
+declare namespace index$m {
+  export { catalog as Catalog, executor as Executor, installTool as InstallTool, loadSkillTool as LoadSkillTool, type index$m_Skill as Skill, type index$m_SkillForkHost as SkillForkHost, type index$m_SkillHost as SkillHost, type index$m_SkillMeta as SkillMeta };
 }
 
 /**
@@ -2771,11 +2885,11 @@ declare class TaskList {
     addBlockedBy(taskId: string, blockerIds: string[]): void;
 }
 
-type index$m_Task = Task;
-type index$m_TaskList = TaskList;
-declare const index$m_TaskList: typeof TaskList;
-declare namespace index$m {
-  export { store as Store, type index$m_Task as Task, index$m_TaskList as TaskList, tools$1 as Tools };
+type index$l_Task = Task;
+type index$l_TaskList = TaskList;
+declare const index$l_TaskList: typeof TaskList;
+declare namespace index$l {
+  export { store as Store, type index$l_Task as Task, index$l_TaskList as TaskList, tools$1 as Tools };
 }
 
 /**
@@ -2842,7 +2956,7 @@ declare namespace toolRegistry {
  * SOFTWARE.
  */
 
-declare namespace index$l {
+declare namespace index$k {
   export { interactionSummary as InteractionSummary, toolRegistry as ToolRegistry };
 }
 
@@ -3279,7 +3393,7 @@ declare namespace definition {
 
 /**
  * Marker appended to a subagent's output when its run was interrupted. Shared
- * with the TUI so restored transcripts can render interrupted Agent cards with
+ * with the UI so restored transcripts can render interrupted Agent cards with
  * the same "stopped" styling as live ones.
  */
 declare const SUBAGENT_INTERRUPTED_MARKER = "[Interrupted]";
@@ -3307,6 +3421,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 +3471,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 +3714,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 +3724,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 +4059,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 +4071,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>;
@@ -4061,16 +4124,16 @@ declare class TeamManager {
     drainLeads(): string[];
 }
 
-type index$k_AgentEventCallback = AgentEventCallback;
-type index$k_Member = Member;
-type index$k_RunAgent = RunAgent;
-type index$k_Team = Team;
-declare const index$k_Team: typeof Team;
-type index$k_TeamManager = TeamManager;
-declare const index$k_TeamManager: typeof TeamManager;
-type index$k_TeamMode = TeamMode;
-declare namespace index$k {
-  export { type index$k_AgentEventCallback as AgentEventCallback, backend as Backend, coordinator$1 as Coordinator, fileMailbox as FileMailbox, type index$k_Member as Member, progress as Progress, protocol as Protocol, registry as Registry, type index$k_RunAgent as RunAgent, sharedTask as SharedTask, taskStop as TaskStop, taskTools as TaskTools, index$k_Team as Team, teamFile as TeamFile, index$k_TeamManager as TeamManager, type index$k_TeamMode as TeamMode, tools as Tools, transcript as Transcript };
+type index$j_AgentEventCallback = AgentEventCallback;
+type index$j_Member = Member;
+type index$j_RunAgent = RunAgent;
+type index$j_Team = Team;
+declare const index$j_Team: typeof Team;
+type index$j_TeamManager = TeamManager;
+declare const index$j_TeamManager: typeof TeamManager;
+type index$j_TeamMode = TeamMode;
+declare namespace index$j {
+  export { type index$j_AgentEventCallback as AgentEventCallback, backend as Backend, coordinator$1 as Coordinator, fileMailbox as FileMailbox, type index$j_Member as Member, progress as Progress, protocol as Protocol, registry as Registry, type index$j_RunAgent as RunAgent, sharedTask as SharedTask, taskStop as TaskStop, taskTools as TaskTools, index$j_Team as Team, teamFile as TeamFile, index$j_TeamManager as TeamManager, type index$j_TeamMode as TeamMode, tools as Tools, transcript as Transcript };
 }
 
 /**
@@ -4337,7 +4400,7 @@ declare namespace handler {
  * SOFTWARE.
  */
 
-declare namespace index$j {
+declare namespace index$i {
   export { handler as Handler, manager$1 as Manager, session as Session };
 }
 
@@ -4432,7 +4495,7 @@ declare namespace usageTracker {
  * SOFTWARE.
  */
 
-declare namespace index$i {
+declare namespace index$h {
   export { commands as Commands, loader$1 as Loader, usageTracker as UsageTracker };
 }
 
@@ -4549,7 +4612,7 @@ declare namespace prompts {
  * SOFTWARE.
  */
 
-declare namespace index$h {
+declare namespace index$g {
   export { compact as Compact, prompts as Prompts, recovery as Recovery };
 }
 
@@ -4752,11 +4815,11 @@ declare const MAX_HISTORY_ENTRIES = 200;
 declare function load(dir: string): string[];
 declare function append(dir: string, text: string): string[];
 
-declare const index$g_MAX_HISTORY_ENTRIES: typeof MAX_HISTORY_ENTRIES;
-declare const index$g_append: typeof append;
-declare const index$g_load: typeof load;
-declare namespace index$g {
-  export { index$g_MAX_HISTORY_ENTRIES as MAX_HISTORY_ENTRIES, index$g_append as append, index$g_load as load };
+declare const index$f_MAX_HISTORY_ENTRIES: typeof MAX_HISTORY_ENTRIES;
+declare const index$f_append: typeof append;
+declare const index$f_load: typeof load;
+declare namespace index$f {
+  export { index$f_MAX_HISTORY_ENTRIES as MAX_HISTORY_ENTRIES, index$f_append as append, index$f_load as load };
 }
 
 /**
@@ -4852,19 +4915,19 @@ declare function loadImageAttachment(absPath: string): Promise<ImageAttachment>;
 type ResizedImage = Omit<ImageAttachment, "sourcePath">;
 declare function maybeResizeAndDownsampleImage(buf: Buffer, mediaType: ImageMediaType): Promise<ResizedImage>;
 
-type index$f_ImageTooLargeError = ImageTooLargeError;
-declare const index$f_ImageTooLargeError: typeof ImageTooLargeError;
-declare const index$f_MAX_DIMENSION_PX: typeof MAX_DIMENSION_PX;
-declare const index$f_MAX_IMAGES_PER_MESSAGE: typeof MAX_IMAGES_PER_MESSAGE;
-declare const index$f_MAX_IMAGE_BYTES_PASSTHROUGH: typeof MAX_IMAGE_BYTES_PASSTHROUGH;
-declare const index$f_asImageMediaType: typeof asImageMediaType;
-declare const index$f_getMediaType: typeof getMediaType;
-declare const index$f_isImagePath: typeof isImagePath;
-declare const index$f_loadImageAttachment: typeof loadImageAttachment;
-declare const index$f_maybeResizeAndDownsampleImage: typeof maybeResizeAndDownsampleImage;
-declare const index$f_sniffMediaType: typeof sniffMediaType;
-declare namespace index$f {
-  export { clipboard as Clipboard, index$f_ImageTooLargeError as ImageTooLargeError, index$f_MAX_DIMENSION_PX as MAX_DIMENSION_PX, index$f_MAX_IMAGES_PER_MESSAGE as MAX_IMAGES_PER_MESSAGE, index$f_MAX_IMAGE_BYTES_PASSTHROUGH as MAX_IMAGE_BYTES_PASSTHROUGH, index$f_asImageMediaType as asImageMediaType, index$f_getMediaType as getMediaType, index$f_isImagePath as isImagePath, index$f_loadImageAttachment as loadImageAttachment, index$f_maybeResizeAndDownsampleImage as maybeResizeAndDownsampleImage, index$f_sniffMediaType as sniffMediaType };
+type index$e_ImageTooLargeError = ImageTooLargeError;
+declare const index$e_ImageTooLargeError: typeof ImageTooLargeError;
+declare const index$e_MAX_DIMENSION_PX: typeof MAX_DIMENSION_PX;
+declare const index$e_MAX_IMAGES_PER_MESSAGE: typeof MAX_IMAGES_PER_MESSAGE;
+declare const index$e_MAX_IMAGE_BYTES_PASSTHROUGH: typeof MAX_IMAGE_BYTES_PASSTHROUGH;
+declare const index$e_asImageMediaType: typeof asImageMediaType;
+declare const index$e_getMediaType: typeof getMediaType;
+declare const index$e_isImagePath: typeof isImagePath;
+declare const index$e_loadImageAttachment: typeof loadImageAttachment;
+declare const index$e_maybeResizeAndDownsampleImage: typeof maybeResizeAndDownsampleImage;
+declare const index$e_sniffMediaType: typeof sniffMediaType;
+declare namespace index$e {
+  export { clipboard as Clipboard, index$e_ImageTooLargeError as ImageTooLargeError, index$e_MAX_DIMENSION_PX as MAX_DIMENSION_PX, index$e_MAX_IMAGES_PER_MESSAGE as MAX_IMAGES_PER_MESSAGE, index$e_MAX_IMAGE_BYTES_PASSTHROUGH as MAX_IMAGE_BYTES_PASSTHROUGH, index$e_asImageMediaType as asImageMediaType, index$e_getMediaType as getMediaType, index$e_isImagePath as isImagePath, index$e_loadImageAttachment as loadImageAttachment, index$e_maybeResizeAndDownsampleImage as maybeResizeAndDownsampleImage, index$e_sniffMediaType as sniffMediaType };
 }
 
 /**
@@ -5011,7 +5074,7 @@ declare namespace modelResolver {
  * SOFTWARE.
  */
 
-declare namespace index$e {
+declare namespace index$d {
   export { anthropic as Anthropic, client$1 as Client, errors as Errors, events$1 as Events, modelDiscovery as ModelDiscovery, modelResolver as ModelResolver, openai as OpenAI };
 }
 
@@ -5038,7 +5101,7 @@ declare namespace index$e {
  */
 
 /** Execution mode, written into the base field of every log entry. */
-type LoggerMode = "tui" | "remote" | "teammate";
+type LoggerMode = "terminal" | "remote" | "teammate";
 /** Options for initLogger. Named to avoid clashing with pino's LoggerOptions. */
 interface InitLoggerOptions {
     /** Session ID, used as the log filename and a base field. */
@@ -5053,7 +5116,7 @@ interface InitLoggerOptions {
     skipCleanup?: boolean;
     /**
      * Mirror JSONL to stdout in addition to the log file. Only safe in remote
-     * mode (TUI owns stdout; teammates use it for IPC). Lets users watch logs
+     * mode (UI owns stdout; teammates use it for IPC). Lets users watch logs
      * live or pipe them through pino-pretty.
      */
     stdout?: boolean;
@@ -5074,7 +5137,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
@@ -5094,13 +5157,13 @@ declare function createChildLogger(bindings: {
     module: string;
 }): Logger;
 
-declare const index$d_closeLogger: typeof closeLogger;
-declare const index$d_createChildLogger: typeof createChildLogger;
-declare const index$d_initLogger: typeof initLogger;
-declare const index$d_logger: typeof logger;
-declare const index$d_sanitizeNameSegment: typeof sanitizeNameSegment;
-declare namespace index$d {
-  export { index$d_closeLogger as closeLogger, index$d_createChildLogger as createChildLogger, index$d_initLogger as initLogger, index$d_logger as logger, index$d_sanitizeNameSegment as sanitizeNameSegment };
+declare const index$c_closeLogger: typeof closeLogger;
+declare const index$c_createChildLogger: typeof createChildLogger;
+declare const index$c_initLogger: typeof initLogger;
+declare const index$c_logger: typeof logger;
+declare const index$c_sanitizeNameSegment: typeof sanitizeNameSegment;
+declare namespace index$c {
+  export { index$c_closeLogger as closeLogger, index$c_createChildLogger as createChildLogger, index$c_initLogger as initLogger, index$c_logger as logger, index$c_sanitizeNameSegment as sanitizeNameSegment };
 }
 
 /**
@@ -5470,7 +5533,7 @@ declare namespace toolWrapper {
  * SOFTWARE.
  */
 
-declare namespace index$c {
+declare namespace index$b {
   export { client as Client, instructions$1 as Instructions, manager as Manager, strategy as Strategy, toolWrapper as ToolWrapper };
 }
 
@@ -5676,7 +5739,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;
@@ -5778,7 +5841,7 @@ declare namespace writtenPaths {
  * SOFTWARE.
  */
 
-declare namespace index$b {
+declare namespace index$a {
   export { consolidation as Consolidation, extractor as Extractor, instructions as Instructions, manager$2 as Manager, memoryAge$1 as MemoryAge, permissions as Permissions, writtenPaths as WrittenPaths };
 }
 
@@ -5810,14 +5873,14 @@ declare function planExists(workDir: string): boolean;
 declare function resetPlanPath(): void;
 declare function getCurrentPlanPath(): string | null;
 
-declare const index$a_getCurrentPlanPath: typeof getCurrentPlanPath;
-declare const index$a_getOrCreatePlanPath: typeof getOrCreatePlanPath;
-declare const index$a_loadPlan: typeof loadPlan;
-declare const index$a_planExists: typeof planExists;
-declare const index$a_resetPlanPath: typeof resetPlanPath;
-declare const index$a_savePlan: typeof savePlan;
-declare namespace index$a {
-  export { index$a_getCurrentPlanPath as getCurrentPlanPath, index$a_getOrCreatePlanPath as getOrCreatePlanPath, index$a_loadPlan as loadPlan, index$a_planExists as planExists, index$a_resetPlanPath as resetPlanPath, index$a_savePlan as savePlan };
+declare const index$9_getCurrentPlanPath: typeof getCurrentPlanPath;
+declare const index$9_getOrCreatePlanPath: typeof getOrCreatePlanPath;
+declare const index$9_loadPlan: typeof loadPlan;
+declare const index$9_planExists: typeof planExists;
+declare const index$9_resetPlanPath: typeof resetPlanPath;
+declare const index$9_savePlan: typeof savePlan;
+declare namespace index$9 {
+  export { index$9_getCurrentPlanPath as getCurrentPlanPath, index$9_getOrCreatePlanPath as getOrCreatePlanPath, index$9_loadPlan as loadPlan, index$9_planExists as planExists, index$9_resetPlanPath as resetPlanPath, index$9_savePlan as savePlan };
 }
 
 /**
@@ -6044,7 +6107,7 @@ declare namespace planMode {
  * SOFTWARE.
  */
 
-declare namespace index$9 {
+declare namespace index$8 {
   export { builder as Builder, coordinator as Coordinator, delegation as Delegation, planMode as PlanMode, sections as Sections };
 }
 
@@ -6251,7 +6314,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 {
@@ -6363,7 +6425,7 @@ declare namespace sessionState {
  * SOFTWARE.
  */
 
-declare namespace index$8 {
+declare namespace index$7 {
   export { address as Address, log as Log, server as Server, sessionState as SessionState };
 }
 
@@ -6538,15 +6600,15 @@ interface Sandbox {
  */
 declare function createSandbox(backend?: SandboxBackend): Promise<Sandbox | null>;
 
-type index$7_PreparedSandboxCommand = PreparedSandboxCommand;
-type index$7_Sandbox = Sandbox;
-type index$7_SandboxBackend = SandboxBackend;
-type index$7_SandboxConfig = SandboxConfig;
-type index$7_SandboxExecutionContext = SandboxExecutionContext;
-type index$7_SandboxImplementation = SandboxImplementation;
-declare const index$7_createSandbox: typeof createSandbox;
-declare namespace index$7 {
-  export { bwrap as Bwrap, type index$7_PreparedSandboxCommand as PreparedSandboxCommand, type index$7_Sandbox as Sandbox, type index$7_SandboxBackend as SandboxBackend, type index$7_SandboxConfig as SandboxConfig, type index$7_SandboxExecutionContext as SandboxExecutionContext, type index$7_SandboxImplementation as SandboxImplementation, sandboxRuntime as SandboxRuntime, seatbelt as Seatbelt, index$7_createSandbox as createSandbox };
+type index$6_PreparedSandboxCommand = PreparedSandboxCommand;
+type index$6_Sandbox = Sandbox;
+type index$6_SandboxBackend = SandboxBackend;
+type index$6_SandboxConfig = SandboxConfig;
+type index$6_SandboxExecutionContext = SandboxExecutionContext;
+type index$6_SandboxImplementation = SandboxImplementation;
+declare const index$6_createSandbox: typeof createSandbox;
+declare namespace index$6 {
+  export { bwrap as Bwrap, type index$6_PreparedSandboxCommand as PreparedSandboxCommand, type index$6_Sandbox as Sandbox, type index$6_SandboxBackend as SandboxBackend, type index$6_SandboxConfig as SandboxConfig, type index$6_SandboxExecutionContext as SandboxExecutionContext, type index$6_SandboxImplementation as SandboxImplementation, sandboxRuntime as SandboxRuntime, seatbelt as Seatbelt, index$6_createSandbox as createSandbox };
 }
 
 /**
@@ -6691,8 +6753,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
@@ -6736,7 +6799,7 @@ declare namespace toolFilter {
  * SOFTWARE.
  */
 
-declare namespace index$6 {
+declare namespace index$5 {
   export { agentTool as AgentTool, definition as Definition, loader as Loader, spawn as Spawn, taskManager as TaskManager, toolFilter as ToolFilter };
 }
 
@@ -6763,8 +6826,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 +6861,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_isSpillReadback: typeof isSpillReadback;
-declare const index$5_persistLargeResult: typeof persistLargeResult;
-declare const index$5_replaceToolResultContent: typeof replaceToolResultContent;
-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 };
+declare const index$4_TOOL_RESULT_PREVIEW_CHARS: typeof TOOL_RESULT_PREVIEW_CHARS;
+declare const index$4_applyBudget: typeof applyBudget;
+declare const index$4_buildPersistedOutputPreview: typeof buildPersistedOutputPreview;
+declare const index$4_isSpillReadback: typeof isSpillReadback;
+declare const index$4_persistLargeResult: typeof persistLargeResult;
+declare const index$4_replaceToolResultContent: typeof replaceToolResultContent;
+declare const index$4_spillDir: typeof spillDir;
+declare const index$4_toDisplayPreview: typeof toDisplayPreview;
+declare namespace index$4 {
+  export { index$4_TOOL_RESULT_PREVIEW_CHARS as TOOL_RESULT_PREVIEW_CHARS, index$4_applyBudget as applyBudget, index$4_buildPersistedOutputPreview as buildPersistedOutputPreview, index$4_isSpillReadback as isSpillReadback, index$4_persistLargeResult as persistLargeResult, index$4_replaceToolResultContent as replaceToolResultContent, index$4_spillDir as spillDir, index$4_toDisplayPreview as toDisplayPreview };
 }
 
 /**
@@ -6834,6 +6908,18 @@ declare class BashTool implements Tool {
     sandbox: Sandbox | null;
     sandboxRequired: boolean;
     sandboxConfig: SandboxConfig;
+    /**
+     * Background task registry, injected by the host (UI / 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 +6931,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;
@@ -6916,7 +7024,6 @@ declare class ComputerUseTool implements Tool {
     private macHelperPromise?;
     constructor(options?: ComputerUseToolOptions);
     isConcurrencySafe(_args: Record<string, unknown>): boolean;
-    providerSchema(protocol: ToolProtocol): ProviderNativeToolSchema | undefined;
     schema(): ToolSchema;
     execute(ctx: ToolContext, args: Record<string, unknown>): Promise<ToolResult>;
     /** Execute one Anthropic-style action (also the per-item path for batches). */
@@ -6969,8 +7076,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 +7105,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 +7237,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 +7502,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 +7565,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 +7659,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 +7728,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
  *
@@ -7684,7 +8039,7 @@ declare namespace toolSearch {
  * SOFTWARE.
  */
 
-declare class WriteFileTool implements Tool {
+declare class WebFetchTool implements Tool {
     name: string;
     description: string;
     category: ToolCategory;
@@ -7692,10 +8047,10 @@ declare class WriteFileTool implements Tool {
     execute(ctx: ToolContext, args: Record<string, unknown>): Promise<ToolResult>;
 }
 
-type writeFile_WriteFileTool = WriteFileTool;
-declare const writeFile_WriteFileTool: typeof WriteFileTool;
-declare namespace writeFile {
-  export { writeFile_WriteFileTool as WriteFileTool };
+type webFetch_WebFetchTool = WebFetchTool;
+declare const webFetch_WebFetchTool: typeof WebFetchTool;
+declare namespace webFetch {
+  export { webFetch_WebFetchTool as WebFetchTool };
 }
 
 /**
@@ -7720,247 +8075,18 @@ declare namespace writeFile {
  * SOFTWARE.
  */
 
-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 };
-}
-
-/**
- * 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.
- */
-
-interface ThemePalette {
-    accent: string;
-    bashMode: string;
-    border: string;
-    borderAccent: string;
-    borderMuted: string;
-    customMessageBg: string;
-    customMessageLabel: string;
-    dim: string;
-    error: string;
-    mdCode: string;
-    mdCodeBlock: string;
-    mdCodeBlockBorder: string;
-    mdHeading: string;
-    mdHr: string;
-    mdLink: string;
-    mdLinkUrl: string;
-    mdListBullet: string;
-    mdQuote: string;
-    mdQuoteBorder: string;
-    muted: string;
-    searchMatchBg: string;
-    searchMatchText: string;
-    selectedBg: string;
-    success: string;
-    syntaxComment: string;
-    syntaxFunction: string;
-    syntaxKeyword: string;
-    syntaxNumber: string;
-    syntaxOperator: string;
-    syntaxPunctuation: string;
-    syntaxString: string;
-    syntaxType: string;
-    syntaxVariable: string;
-    text: string;
-    thinking: string;
-    thinkingText: string;
-    thinkingHigh: string;
-    thinkingLow: string;
-    thinkingMax: string;
-    thinkingMedium: string;
-    thinkingMinimal: string;
-    thinkingOff: string;
-    thinkingXHigh: string;
-    toolDiffAdded: string;
-    toolDiffContext: string;
-    toolDiffRemoved: string;
-    toolErrorBg: string;
-    toolOutput: string;
-    toolPendingBg: string;
-    toolSuccessBg: string;
-    toolTitle: string;
-    customMessageText: string;
-    userMessageText: string;
-    userMessageBg: string;
-    warning: string;
-}
-declare const DARK_THEME: ThemePalette;
-declare const LIGHT_THEME: ThemePalette;
-declare const THEME: ThemePalette;
-declare function setThemeMode(mode: "dark" | "light"): void;
-declare function thinkingLevelColor(level: ThinkingLevel): string;
-type ActivityStatus = "idle" | "working" | "retry" | "compacting" | "error";
-/** Map an agent lifecycle state to the color used by the composer status border. */
-declare function activityStatusColor(status: ActivityStatus): string;
-declare const ICONS: {
-    readonly active: "◉";
-    readonly arrow: "→";
-    readonly branch: "├─";
-    readonly collapsed: "⊞";
-    readonly expanded: "⊟";
-    readonly inactive: "○";
-    readonly lastBranch: "└─";
-    readonly prompt: ">";
-    readonly success: "✓";
-    readonly tree: "│";
-};
-
-type styles_ActivityStatus = ActivityStatus;
-declare const styles_DARK_THEME: typeof DARK_THEME;
-declare const styles_ICONS: typeof ICONS;
-declare const styles_LIGHT_THEME: typeof LIGHT_THEME;
-declare const styles_THEME: typeof THEME;
-type styles_ThemePalette = ThemePalette;
-declare const styles_activityStatusColor: typeof activityStatusColor;
-declare const styles_setThemeMode: typeof setThemeMode;
-declare const styles_thinkingLevelColor: typeof thinkingLevelColor;
-declare namespace styles {
-  export { type styles_ActivityStatus as ActivityStatus, styles_DARK_THEME as DARK_THEME, styles_ICONS as ICONS, styles_LIGHT_THEME as LIGHT_THEME, styles_THEME as THEME, type styles_ThemePalette as ThemePalette, styles_activityStatusColor as activityStatusColor, styles_setThemeMode as setThemeMode, styles_thinkingLevelColor as thinkingLevelColor };
-}
-
-/**
- * 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.
- */
-interface Options {
-    blocked: boolean;
-    send: (message: string) => Promise<void>;
-    onError: (error: unknown) => void;
-}
-declare function useFollowUpQueue({ blocked, send, onError }: Options): {
-    messages: string[];
-    enqueue: (message: string) => void;
-    takeLast: () => string | undefined;
-    processing: boolean;
-    paused: boolean;
-};
-
-declare const useFollowUpQueue$1_useFollowUpQueue: typeof useFollowUpQueue;
-declare namespace useFollowUpQueue$1 {
-  export { useFollowUpQueue$1_useFollowUpQueue as useFollowUpQueue };
-}
-
-/**
- * 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 function useIdeInput(workDir: string): {
-    insertInputTextRef: react.RefObject<((text: string) => void) | null>;
-    clearInputRef: react.RefObject<(() => void) | null>;
-};
-
-declare const useIdeInput$1_useIdeInput: typeof useIdeInput;
-declare namespace useIdeInput$1 {
-  export { useIdeInput$1_useIdeInput as useIdeInput };
-}
-
-/**
- * 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 function useTeammateStates(manager: TeamManager): {
+declare class WriteFileTool implements Tool {
     name: string;
-    teamName: string;
-    status: "completed" | "failed" | "running" | "idle" | "stopped";
-    progress: {
-        toolUseCount: number;
-        turnCount: number;
-        tokenCount: number;
-        activeTools: {
-            toolId: string;
-            toolName: string;
-        }[];
-        recentActivities: {
-            toolName: string;
-            input: Record<string, unknown>;
-            activityDescription: string;
-        }[];
-        lastActivity?: {
-            toolName: string;
-            input: Record<string, unknown>;
-            activityDescription: string;
-        } | undefined;
-    };
-    startTime: number;
-    spinnerVerb: string;
-    originToolCallId?: string | undefined;
-    lastMessage?: string | undefined;
-}[];
+    description: string;
+    category: ToolCategory;
+    schema(): ToolSchema;
+    execute(ctx: ToolContext, args: Record<string, unknown>): Promise<ToolResult>;
+}
 
-declare const useTeammateStates$1_useTeammateStates: typeof useTeammateStates;
-declare namespace useTeammateStates$1 {
-  export { useTeammateStates$1_useTeammateStates as useTeammateStates };
+type writeFile_WriteFileTool = WriteFileTool;
+declare const writeFile_WriteFileTool: typeof WriteFileTool;
+declare namespace writeFile {
+  export { writeFile_WriteFileTool as WriteFileTool };
 }
 
 /**
@@ -7986,7 +8112,7 @@ declare namespace useTeammateStates$1 {
  */
 
 declare namespace index$3 {
-  export { styles as Styles, useFollowUpQueue$1 as UseFollowUpQueue, useIdeInput$1 as UseIdeInput, useTeammateStates$1 as UseTeammateStates };
+  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 };
 }
 
 /**
@@ -8403,7 +8529,7 @@ declare function isTerminalGone(err: unknown): boolean;
 /**
  * Writes the exit marker; subsequent calls are no-ops.
  *
- * The TUI runs in raw mode where the `exit` event may not fire on teardown,
+ * The UI runs in raw mode where the `exit` event may not fire on teardown,
  * so the main flow also calls this explicitly. Whichever path arrives first wins.
  */
 declare function recordExit(code: number | string): void;
@@ -8524,4 +8650,4 @@ declare namespace version$1 {
   export { version$1_version as version };
 }
 
-export { index$s as Acp, index$o as Agent, index$l as Bootstrap, index$j as CodeReview, index$i as Commands, index$h as Compact, index$r as Config, index$u as Conversation, index$w as FileHistory, index$g as History, index$q as Hooks, index$f as Images, index$e as LLM, index$d as Logger, index$c as MCP, index$b as Memory, index$v as Permissions, index$a as PlanFile, printMode as PrintMode, index$9 as Prompt, providerLogin as ProviderLogin, recover$1 as Recover, index$8 as Remote, index$7 as Sandbox, index$t as Session, index$n as Skills, index$6 as Subagent, teammate as Teammate, index$k as Teams, index$p as Telemetry, index$m as Todo, index$5 as ToolResult, index$4 as Tools, index$3 as UI, index$2 as Utils, index$1 as VSCode, version$1 as Version, index as Worktree };
+export { index$r as Acp, index$n as Agent, index$k as Bootstrap, index$i as CodeReview, index$h as Commands, index$g as Compact, index$q as Config, index$t as Conversation, index$v as FileHistory, index$f as History, index$p as Hooks, index$e as Images, index$d as LLM, index$c as Logger, index$b as MCP, index$a as Memory, index$u as Permissions, index$9 as PlanFile, printMode as PrintMode, index$8 as Prompt, providerLogin as ProviderLogin, recover$1 as Recover, index$7 as Remote, index$6 as Sandbox, index$s as Session, index$m as Skills, index$5 as Subagent, teammate as Teammate, index$j as Teams, index$o as Telemetry, index$l as Todo, index$4 as ToolResult, index$3 as Tools, index$2 as Utils, index$1 as VSCode, version$1 as Version, index as Worktree };