wave-code 1.0.6 → 1.0.8

package/dist/components/AgentsManager.d.ts

@@ -0,0 +1,7 @@
+import React from "react";
+import type { SubagentConfiguration } from "wave-agent-sdk";
+export interface AgentsManagerProps {
+    onCancel: () => void;
+    agentDefinitions: SubagentConfiguration[];
+}
+export declare const AgentsManager: React.FC<AgentsManagerProps>;

package/dist/components/AgentsManager.js

@@ -0,0 +1,109 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { useEffect, useMemo, useReducer } from "react";
+import { Box, Text, useInput, useStdout } from "ink";
+import { Markdown } from "./Markdown.js";
+import { agentsManagerReducer, } from "../reducers/agentsManagerReducer.js";
+const SCOPE_LABELS = {
+    builtin: "Built-in agents",
+    user: "User agents",
+    project: "Project agents",
+    plugin: "Plugin agents",
+};
+const SCOPE_ORDER = [
+    "builtin",
+    "user",
+    "project",
+    "plugin",
+];
+const initialState = {
+    selectedIndex: 0,
+    viewMode: "list",
+    pendingEffect: null,
+};
+export const AgentsManager = ({ onCancel, agentDefinitions, }) => {
+    const [state, dispatch] = useReducer(agentsManagerReducer, initialState);
+    const { stdout } = useStdout();
+    // Handle pending effects
+    useEffect(() => {
+        if (!state.pendingEffect)
+            return;
+        const effect = state.pendingEffect;
+        dispatch({ type: "CLEAR_PENDING_EFFECT" });
+        if (effect.type === "CANCEL") {
+            onCancel();
+        }
+    }, [state.pendingEffect, onCancel]);
+    // Flatten definitions (grouped by scope) into one navigable list. Headers
+    // and the empty-state line are non-selectable.
+    const entries = useMemo(() => {
+        const result = [];
+        let selectableCount = 0;
+        result.push({ kind: "header", label: "AGENTS", selectableIndex: -1 });
+        let definitionCount = 0;
+        for (const scope of SCOPE_ORDER) {
+            const defs = agentDefinitions
+                .filter((d) => d.scope === scope)
+                .sort((a, b) => a.name.localeCompare(b.name));
+            if (defs.length === 0)
+                continue;
+            result.push({
+                kind: "header",
+                label: SCOPE_LABELS[scope],
+                scope,
+                selectableIndex: -1,
+            });
+            for (const def of defs) {
+                result.push({
+                    kind: "definition",
+                    label: def.name,
+                    model: def.model,
+                    sub: def.description,
+                    scope: def.scope,
+                    selectableIndex: selectableCount++,
+                    definition: def,
+                });
+                definitionCount++;
+            }
+        }
+        if (definitionCount === 0) {
+            result.push({
+                kind: "empty",
+                label: "No agents available",
+                selectableIndex: -1,
+            });
+        }
+        return result;
+    }, [agentDefinitions]);
+    const itemCount = entries.filter((e) => e.selectableIndex >= 0).length;
+    // Window slice: center the selected item within the visible area, clamping
+    // to the terminal's available rows (reusable pattern from
+    // BackgroundTaskManager).
+    const availableRows = stdout?.rows ?? 24;
+    const maxVisible = Math.max(3, Math.min(15, availableRows - 12));
+    const selectedFlatIndex = entries.findIndex((e) => e.selectableIndex === state.selectedIndex);
+    const startIndex = Math.max(0, Math.min(selectedFlatIndex - Math.floor(maxVisible / 2), Math.max(0, entries.length - maxVisible)));
+    const visibleEntries = entries.slice(startIndex, startIndex + maxVisible);
+    useInput((input, key) => {
+        dispatch({ type: "HANDLE_KEY", input, key, itemCount });
+    });
+    const selectedEntry = entries.find((e) => e.selectableIndex === state.selectedIndex);
+    // Detail view — body renders fully expanded with no height limit, no
+    // clipping and no scrolling (aligned with Claude Code's AgentDetail).
+    if (state.viewMode === "detail" && selectedEntry) {
+        const def = selectedEntry.definition;
+        return (_jsxs(Box, { flexDirection: "column", borderStyle: "single", borderColor: "cyan", borderBottom: false, borderLeft: false, borderRight: false, paddingTop: 1, gap: 1, children: [_jsx(Box, { children: _jsxs(Text, { color: "cyan", bold: true, children: ["Agent: ", selectedEntry.label] }) }), _jsxs(Box, { flexDirection: "column", gap: 1, children: [def?.description && (_jsx(Box, { children: _jsxs(Text, { children: [_jsx(Text, { color: "blue", children: "Description:" }), " ", def.description] }) })), _jsx(Box, { children: _jsxs(Text, { children: [_jsx(Text, { color: "blue", children: "Model:" }), " ", def?.model || "default (not explicitly configured)"] }) }), _jsx(Box, { children: _jsxs(Text, { children: [_jsx(Text, { color: "blue", children: "Scope:" }), " ", def ? SCOPE_LABELS[def.scope] : ""] }) }), def?.tools && def.tools.length > 0 && (_jsx(Box, { children: _jsxs(Text, { wrap: "wrap", children: [_jsx(Text, { color: "blue", children: "Tools:" }), " ", def.tools.join(", ")] }) })), def?.filePath && (_jsx(Box, { children: _jsxs(Text, { wrap: "wrap", children: [_jsx(Text, { color: "blue", children: "File:" }), " ", def.filePath] }) }))] }), def && (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { color: "blue", bold: true, children: "System Prompt:" }), _jsx(Box, { marginLeft: 2, marginRight: 2, children: _jsx(Markdown, { children: def.systemPrompt }) })] })), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "Esc or Enter to go back" }) })] }));
+    }
+    if (itemCount === 0) {
+        return (_jsxs(Box, { flexDirection: "column", borderStyle: "single", borderColor: "cyan", borderBottom: false, borderLeft: false, borderRight: false, paddingTop: 1, children: [_jsx(Text, { color: "cyan", bold: true, children: "Agents" }), _jsx(Text, { children: "No agents available" }), _jsx(Text, { dimColor: true, children: "Press Escape to close" })] }));
+    }
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "single", borderColor: "cyan", borderBottom: false, borderLeft: false, borderRight: false, paddingTop: 1, gap: 1, children: [_jsx(Box, { children: _jsx(Text, { color: "cyan", bold: true, children: "Agents" }) }), _jsx(Text, { dimColor: true, children: "Select an agent to view details" }), _jsx(Box, { flexDirection: "column", children: visibleEntries.map((entry, index) => {
+                    const isSelected = entry.selectableIndex === state.selectedIndex;
+                    if (entry.kind === "header") {
+                        return (_jsx(Text, { dimColor: true, bold: true, children: entry.label }, `${entry.kind}-${entry.label}-${index}`));
+                    }
+                    if (entry.kind === "empty") {
+                        return (_jsx(Text, { dimColor: true, children: entry.label }, `empty-${index}`));
+                    }
+                    return (_jsxs(Text, { color: isSelected ? "black" : "white", backgroundColor: isSelected ? "cyan" : undefined, wrap: "truncate-end", children: [isSelected ? "▶ " : "  ", entry.selectableIndex + 1, ". ", entry.label, entry.model ? (_jsxs(Text, { color: isSelected ? "black" : "gray", children: [" ", "\u00B7 ", entry.model] })) : null, entry.sub ? ` · ${entry.sub}` : ""] }, `${entry.kind}-${entry.selectableIndex}`));
+                }) }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "\u2191/\u2193 to select \u00B7 Enter to view details \u00B7 Esc to close" }) })] }));
+};

package/dist/components/ChatInterface.js

@@ -57,5 +57,5 @@ export const ChatInterface = () => {
     ]);
     if (!sessionId)
         return null;
-    return (_jsxs(Box, { ref: chatInterfaceRef, flexDirection: "column", children: [_jsx(MessageList, { messages: displayMessages, isExpanded: isExpanded, version: version, workdir: workdir, forceStatic: forceStatic }, remountKey), !isConfirmationVisible && !isExpanded && (_jsxs(_Fragment, { children: [(isLoading || isCommandRunning || isCompacting) && (_jsx(LoadingIndicator, { isLoading: isLoading, isCommandRunning: isCommandRunning, isCompacting: isCompacting, latestTotalTokens: latestTotalTokens })), _jsx(TaskList, {}), _jsx(QueuedMessageList, {}), _jsx(InputBox, { isLoading: isLoading, isCommandRunning: isCommandRunning, isCompacting: isCompacting, sendMessage: sendMessage, abortMessage: abortMessage, mcpServers: mcpServers, connectMcpServer: connectMcpServer, disconnectMcpServer: disconnectMcpServer, slashCommands: slashCommands, hasSlashCommand: hasSlashCommand, latestTotalTokens: latestTotalTokens, maxInputTokens: maxInputTokens, showLoginHint: showLoginHint })] })), isConfirmationVisible && (_jsxs(_Fragment, { children: [forceStatic ? (_jsx(Static, { items: [{ key: "confirmation-details" }], children: () => (_jsx(ConfirmationDetails, { toolName: confirmingTool.name, toolInput: confirmingTool.input, planContent: confirmingTool.planContent, isExpanded: isExpanded }, "confirmation-details")) })) : (_jsx(ConfirmationDetails, { toolName: confirmingTool.name, toolInput: confirmingTool.input, planContent: confirmingTool.planContent, isExpanded: isExpanded })), _jsx(ConfirmationSelector, { toolName: confirmingTool.name, toolInput: confirmingTool.input, suggestedPrefix: confirmingTool.suggestedPrefix, hidePersistentOption: confirmingTool.hidePersistentOption, permissionMode: confirmingTool.permissionMode, isExpanded: isExpanded, onDecision: handleConfirmationDecision, onCancel: handleConfirmationCancel })] }))] }));
+    return (_jsxs(Box, { ref: chatInterfaceRef, flexDirection: "column", children: [_jsx(MessageList, { messages: displayMessages, isExpanded: isExpanded, version: version, workdir: workdir, forceStatic: forceStatic }, remountKey), !isConfirmationVisible && !isExpanded && (_jsxs(_Fragment, { children: [(isLoading || isCommandRunning || isCompacting) && (_jsx(LoadingIndicator, { isLoading: isLoading, isCommandRunning: isCommandRunning, isCompacting: isCompacting, latestTotalTokens: latestTotalTokens })), _jsx(TaskList, {}), _jsx(QueuedMessageList, {}), _jsx(InputBox, { isLoading: isLoading, isCommandRunning: isCommandRunning, isCompacting: isCompacting, sendMessage: sendMessage, abortMessage: abortMessage, mcpServers: mcpServers, connectMcpServer: connectMcpServer, disconnectMcpServer: disconnectMcpServer, slashCommands: slashCommands, hasSlashCommand: hasSlashCommand, latestTotalTokens: latestTotalTokens, maxInputTokens: maxInputTokens, showLoginHint: showLoginHint })] })), isConfirmationVisible && (_jsxs(_Fragment, { children: [forceStatic ? (_jsx(Static, { items: [{ key: "confirmation-details" }], children: () => (_jsx(ConfirmationDetails, { toolName: confirmingTool.name, toolInput: confirmingTool.input, planContent: confirmingTool.planContent, warning: confirmingTool.warning, isExpanded: isExpanded }, "confirmation-details")) })) : (_jsx(ConfirmationDetails, { toolName: confirmingTool.name, toolInput: confirmingTool.input, planContent: confirmingTool.planContent, warning: confirmingTool.warning, isExpanded: isExpanded })), _jsx(ConfirmationSelector, { toolName: confirmingTool.name, toolInput: confirmingTool.input, suggestedPrefix: confirmingTool.suggestedPrefix, hidePersistentOption: confirmingTool.hidePersistentOption, permissionMode: confirmingTool.permissionMode, isExpanded: isExpanded, onDecision: handleConfirmationDecision, onCancel: handleConfirmationCancel })] }))] }));
 };

package/dist/components/ConfirmationDetails.d.ts

@@ -3,6 +3,7 @@ export interface ConfirmationDetailsProps {
     toolName: string;
     toolInput?: Record<string, unknown>;
     planContent?: string;
+    warning?: string;
     isExpanded?: boolean;
 }
 export declare const ConfirmationDetails: React.FC<ConfirmationDetailsProps>;

package/dist/components/ConfirmationDetails.js

@@ -1,6 +1,6 @@
 import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
 import { Box, Text } from "ink";
-import { BASH_TOOL_NAME, EDIT_TOOL_NAME, WRITE_TOOL_NAME, EXIT_PLAN_MODE_TOOL_NAME, ENTER_PLAN_MODE_TOOL_NAME, ASK_USER_QUESTION_TOOL_NAME, } from "wave-agent-sdk";
+import { BASH_TOOL_NAME, EDIT_TOOL_NAME, WRITE_TOOL_NAME, EXIT_PLAN_MODE_TOOL_NAME, ENTER_PLAN_MODE_TOOL_NAME, ASK_USER_QUESTION_TOOL_NAME, ARTIFACT_TOOL_NAME, } from "wave-agent-sdk";
 import { DiffDisplay } from "./DiffDisplay.js";
 import { PlanDisplay } from "./PlanDisplay.js";
 import { highlightToAnsi } from "../utils/highlightUtils.js";
@@ -22,14 +22,16 @@ const getActionDescription = (toolName, toolInput) => {
             return "Enter plan mode for complex task planning";
         case ASK_USER_QUESTION_TOOL_NAME:
             return "Answer questions to clarify intent";
+        case ARTIFACT_TOOL_NAME:
+            return `Publish file: ${toolInput.file_path || "unknown file"}`;
         default:
             return "Execute operation";
     }
 };
-export const ConfirmationDetails = ({ toolName, toolInput, planContent, isExpanded = false, }) => {
+export const ConfirmationDetails = ({ toolName, toolInput, planContent, warning, isExpanded = false, }) => {
     const startLineNumber = toolInput?.startLineNumber ??
         (toolName === WRITE_TOOL_NAME ? 1 : undefined);
-    const content = (_jsxs(Box, { flexDirection: "column", borderStyle: "single", borderColor: "yellow", borderBottom: false, borderLeft: false, borderRight: false, children: [_jsxs(Text, { color: "yellow", bold: true, children: ["Tool: ", toolName] }), _jsx(Text, { color: "yellow", children: getActionDescription(toolName, toolInput) }), _jsx(DiffDisplay, { toolName: toolName, parameters: JSON.stringify(toolInput), startLineNumber: startLineNumber }), toolName !== WRITE_TOOL_NAME &&
+    const content = (_jsxs(Box, { flexDirection: "column", borderStyle: "single", borderColor: "yellow", borderBottom: false, borderLeft: false, borderRight: false, children: [_jsxs(Text, { color: "yellow", bold: true, children: ["Tool: ", toolName] }), _jsx(Text, { color: "yellow", children: getActionDescription(toolName, toolInput) }), warning && _jsxs(Text, { color: "red", children: ["\u26A0 ", warning] }), _jsx(DiffDisplay, { toolName: toolName, parameters: JSON.stringify(toolInput), startLineNumber: startLineNumber }), toolName !== WRITE_TOOL_NAME &&
                 toolName !== EDIT_TOOL_NAME &&
                 toolName !== EXIT_PLAN_MODE_TOOL_NAME &&
                 toolName !== ENTER_PLAN_MODE_TOOL_NAME &&

package/dist/components/ConfirmationSelector.js

@@ -1,9 +1,10 @@
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
-import { useEffect, useReducer } from "react";
+import { useEffect, useReducer, useRef } from "react";
 import { Box, Text, useInput } from "ink";
 import { BASH_TOOL_NAME, EXIT_PLAN_MODE_TOOL_NAME, ENTER_PLAN_MODE_TOOL_NAME, ASK_USER_QUESTION_TOOL_NAME, } from "wave-agent-sdk";
 import { confirmationReducer } from "../reducers/confirmationReducer.js";
 import { questionReducer } from "../reducers/questionReducer.js";
+import { createBracketedPasteDetector } from "../utils/bracketedPaste.js";
 const getHeaderColor = (header) => {
     const colors = ["red", "green", "blue", "magenta", "cyan"];
     let hash = 0;
@@ -64,15 +65,28 @@ export const ConfirmationSelector = ({ toolName, toolInput, suggestedPrefix, hid
         }
         return "Yes, and auto-accept edits";
     };
+    const pasteDetectorRef = useRef(createBracketedPasteDetector());
     useInput((input, key) => {
         if (key.escape) {
             onCancel();
             return;
         }
+        const result = pasteDetectorRef.current.process(input);
+        if (result.kind === "consume") {
+            // Content of an in-flight bracketed paste: hold it, never submit.
+            return;
+        }
+        let cleanInput;
+        if (result.kind === "paste") {
+            cleanInput = (result.leadingInput ?? "") + result.text;
+        }
+        else {
+            cleanInput = result.input;
+        }
         if (toolName === ASK_USER_QUESTION_TOOL_NAME) {
             questionDispatch({
                 type: "HANDLE_KEY",
-                input,
+                input: cleanInput,
                 key,
                 questions,
             });
@@ -80,7 +94,7 @@ export const ConfirmationSelector = ({ toolName, toolInput, suggestedPrefix, hid
         else {
             dispatch({
                 type: "HANDLE_KEY",
-                input,
+                input: cleanInput,
                 key,
                 toolName,
                 toolInput,

package/dist/components/InputBox.js

@@ -7,6 +7,7 @@ import { CommandSelector } from "./CommandSelector.js";
 import { HistorySearch } from "./HistorySearch.js";
 import { BackgroundTaskManager } from "./BackgroundTaskManager.js";
 import { McpManager } from "./McpManager.js";
+import { AgentsManager } from "./AgentsManager.js";
 import { RewindCommand } from "./RewindCommand.js";
 import { HelpView } from "./HelpView.js";
 import { StatusCommand } from "./StatusCommand.js";
@@ -22,7 +23,7 @@ import { useChat } from "../contexts/useChat.js";
 export const INPUT_PLACEHOLDER_TEXT = "Type your message (use /help for more info)...";
 export const INPUT_PLACEHOLDER_TEXT_PREFIX = INPUT_PLACEHOLDER_TEXT.substring(0, 10);
 export const InputBox = ({ isLoading, isCommandRunning, isCompacting, sendMessage = () => { }, abortMessage = () => { }, mcpServers = [], connectMcpServer = async () => false, disconnectMcpServer = async () => false, slashCommands = [], hasSlashCommand = () => false, latestTotalTokens = 0, maxInputTokens = 200000, showLoginHint = false, }) => {
-    const { permissionMode: chatPermissionMode, setPermissionMode: setChatPermissionMode, handleRewindSelect, backgroundCurrentTask, messages, getFullMessageThread, sessionId, workingDirectory, askBtw, clearMessages, compact, addDir, currentModel, configuredModels, setModel, recreateAgent, recallQueuedMessage, queuedMessages, setIsBtwActive, } = useChat();
+    const { permissionMode: chatPermissionMode, setPermissionMode: setChatPermissionMode, handleRewindSelect, backgroundCurrentTask, messages, getFullMessageThread, sessionId, workingDirectory, askBtw, clearMessages, compact, addDir, currentModel, configuredModels, setModel, recreateAgent, recallQueuedMessage, queuedMessages, setIsBtwActive, agentDefinitions, } = useChat();
     // Ref to hold setInputText so queue callbacks can access it before useInputManager returns
     const setInputTextRef = useRef(() => { });
     const hasQueuedMessages = (queuedMessages?.length ?? 0) > 0;
@@ -45,7 +46,7 @@ export const InputBox = ({ isLoading, isCommandRunning, isCompacting, sendMessag
     // History search
     showHistorySearch, historySearchQuery, 
     // Task/MCP Manager
-    showBackgroundTaskManager, showMcpManager, showRewindManager, showHelp, showStatusCommand, showLoginCommand, showPluginManager, showModelSelector, showWorkflowManager, setShowBackgroundTaskManager, setShowMcpManager, setShowRewindManager, setShowHelp, setShowStatusCommand, setShowLoginCommand, setShowPluginManager, setShowModelSelector, setShowWorkflowManager, 
+    showBackgroundTaskManager, showMcpManager, showAgentsManager, showRewindManager, showHelp, showStatusCommand, showLoginCommand, showPluginManager, showModelSelector, showWorkflowManager, setShowBackgroundTaskManager, setShowMcpManager, setShowAgentsManager, setShowRewindManager, setShowHelp, setShowStatusCommand, setShowLoginCommand, setShowPluginManager, setShowModelSelector, setShowWorkflowManager, 
     // Permission mode
     permissionMode, setPermissionMode, 
     // BTW state
@@ -101,6 +102,7 @@ export const InputBox = ({ isLoading, isCommandRunning, isCompacting, sendMessag
             showModelSelector ||
             showBackgroundTaskManager ||
             showMcpManager ||
+            showAgentsManager ||
             showWorkflowManager) {
             return;
         }
@@ -132,32 +134,16 @@ export const InputBox = ({ isLoading, isCommandRunning, isCompacting, sendMessag
         }
         await handleRewindSelect(index);
     };
-    if (showRewindManager) {
-        return (_jsx(RewindCommand, { messages: messages, onSelect: handleRewindSelectWithClose, onCancel: handleRewindCancel, getFullMessageThread: getFullMessageThread }));
-    }
-    if (showHelp) {
-        return (_jsx(HelpView, { onCancel: () => setShowHelp(false), commands: slashCommands }));
-    }
-    if (showStatusCommand) {
-        return _jsx(StatusCommand, { onCancel: () => setShowStatusCommand(false) });
-    }
-    if (showLoginCommand) {
-        return _jsx(LoginCommand, { onCancel: () => setShowLoginCommand(false) });
-    }
-    if (showPluginManager) {
-        return (_jsx(PluginManagerShell, { onCancel: () => setShowPluginManager(false), onPluginInstalled: recreateAgent }));
-    }
-    if (showModelSelector) {
-        return (_jsx(ModelSelector, { onCancel: () => setShowModelSelector(false), currentModel: currentModel, configuredModels: configuredModels, onSelectModel: setModel }));
-    }
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(BtwDisplay, { btwState: btwState }), showFileSelector && (_jsx(FileSelector, { files: filteredFiles, searchQuery: searchQuery, isLoading: isFileSearching, onSelect: handleFileSelect, onCancel: handleCancelFileSelect })), showCommandSelector && (_jsx(CommandSelector, { searchQuery: commandSearchQuery, onSelect: handleCommandSelect, onInsert: handleCommandInsert, onCancel: handleCancelCommandSelect, commands: slashCommands })), showHistorySearch && (_jsx(HistorySearch, { searchQuery: historySearchQuery, onSelect: handleHistorySearchSelect, onCancel: handleCancelHistorySearch })), showBackgroundTaskManager && (_jsx(BackgroundTaskManager, { onCancel: () => setShowBackgroundTaskManager(false) })), showMcpManager && (_jsx(McpManager, { onCancel: () => setShowMcpManager(false), servers: mcpServers, onConnectServer: connectMcpServer, onDisconnectServer: disconnectMcpServer })), showWorkflowManager && (_jsx(WorkflowManager, { onCancel: () => setShowWorkflowManager(false) })), btwState.question || btwState.answer
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(BtwDisplay, { btwState: btwState }), showFileSelector && (_jsx(FileSelector, { files: filteredFiles, searchQuery: searchQuery, isLoading: isFileSearching, onSelect: handleFileSelect, onCancel: handleCancelFileSelect })), showCommandSelector && (_jsx(CommandSelector, { searchQuery: commandSearchQuery, onSelect: handleCommandSelect, onInsert: handleCommandInsert, onCancel: handleCancelCommandSelect, commands: slashCommands })), showHistorySearch && (_jsx(HistorySearch, { searchQuery: historySearchQuery, onSelect: handleHistorySearchSelect, onCancel: handleCancelHistorySearch })), showBackgroundTaskManager && (_jsx(BackgroundTaskManager, { onCancel: () => setShowBackgroundTaskManager(false) })), showMcpManager && (_jsx(McpManager, { onCancel: () => setShowMcpManager(false), servers: mcpServers, onConnectServer: connectMcpServer, onDisconnectServer: disconnectMcpServer })), showAgentsManager && (_jsx(AgentsManager, { onCancel: () => setShowAgentsManager(false), agentDefinitions: agentDefinitions })), showWorkflowManager && (_jsx(WorkflowManager, { onCancel: () => setShowWorkflowManager(false) })), showRewindManager && (_jsx(RewindCommand, { messages: messages, onSelect: handleRewindSelectWithClose, onCancel: handleRewindCancel, getFullMessageThread: getFullMessageThread })), showHelp && (_jsx(HelpView, { onCancel: () => setShowHelp(false), commands: slashCommands })), showStatusCommand && (_jsx(StatusCommand, { onCancel: () => setShowStatusCommand(false) })), showLoginCommand && (_jsx(LoginCommand, { onCancel: () => setShowLoginCommand(false) })), showPluginManager && (_jsx(PluginManagerShell, { onCancel: () => setShowPluginManager(false), onPluginInstalled: recreateAgent })), showModelSelector && (_jsx(ModelSelector, { onCancel: () => setShowModelSelector(false), currentModel: currentModel, configuredModels: configuredModels, onSelectModel: setModel })), btwState.question || btwState.answer
                 ? null
                 : showBackgroundTaskManager ||
                     showMcpManager ||
+                    showAgentsManager ||
                     showRewindManager ||
                     showHelp ||
                     showStatusCommand ||
                     showLoginCommand ||
                     showPluginManager ||
+                    showModelSelector ||
                     showWorkflowManager || (_jsxs(Box, { flexDirection: "column", children: [escClearPending && _jsx(Text, { color: "gray", children: "\u518D\u6B21\u6309 Esc \u6E05\u7A7A\u8F93\u5165" }), _jsx(Box, { borderStyle: "single", borderColor: "gray", borderLeft: false, borderRight: false, children: _jsx(Text, { color: isPlaceholder ? "gray" : "white", children: shouldShowCursor ? (_jsxs(_Fragment, { children: [beforeCursor, _jsx(Text, { backgroundColor: "white", color: "black", children: atCursor }), afterCursor] })) : (displayText) }) }), _jsxs(Box, { justifyContent: "space-between", children: [_jsx(StatusLine, { permissionMode: permissionMode, isShellCommand: isShellCommand }), _jsx(Notifications, { latestTotalTokens: latestTotalTokens, maxInputTokens: maxInputTokens, showLoginHint: showLoginHint })] })] }))] }));
 };

package/dist/components/LoginCommand.js

@@ -4,6 +4,7 @@ import { Box, Text, useInput } from "ink";
 import { execFile } from "child_process";
 import { promisify } from "util";
 import { authService } from "wave-agent-sdk";
+import { createBracketedPasteDetector } from "../utils/bracketedPaste.js";
 const execFileAsync = promisify(execFile);
 function openBrowser(url) {
     const platform = process.platform;
@@ -26,6 +27,11 @@ export const LoginCommand = ({ onCancel }) => {
     const [tokenInput, setTokenInput] = useState("");
     const isLoadingRef = useRef(isLoading);
     isLoadingRef.current = isLoading;
+    // Detects and strips bracketed paste markers (\x1b[200~ ... \x1b[201~)
+    // that terminals wrap pasted text in. Unlike the main InputBox pipeline,
+    // this overlay's token input goes through raw ink useInput, which only
+    // strips ONE leading ESC, leaving the markers (e.g. "[200~") in the input.
+    const pasteDetectorRef = useRef(createBracketedPasteDetector());
     // Resolve/reject refs for the token promise
     const tokenResolveRef = useRef(null);
     const tokenRejectRef = useRef(null);
@@ -64,9 +70,31 @@ export const LoginCommand = ({ onCancel }) => {
             setTokenInput((prev) => prev.slice(0, -1));
             return;
         }
-        // Regular character input (single or pasted multi-char)
+        // Regular character input (single or pasted multi-char). Run through the
+        // bracketed paste detector: a pasted token arrives wrapped in
+        // \x1b[200~ ... \x1b[201~ markers (possibly split across chunks), which
+        // must be stripped instead of being appended to the token.
         if (input && !key.ctrl && !key.meta && !key.return && input.length > 0) {
-            setTokenInput((prev) => prev + input);
+            const result = pasteDetectorRef.current.process(input);
+            if (result.kind === "consume") {
+                // In-flight bracketed paste content: hold it; the final chunk
+                // delivers the complete text.
+                return;
+            }
+            if (result.kind === "paste") {
+                // Tokens never contain carriage returns — drop \r (CRLF terminals
+                // send \r, not \n, in pasted text).
+                const leading = result.leadingInput?.replace(/\r/g, "");
+                if (leading) {
+                    setTokenInput((prev) => prev + leading);
+                }
+                const text = result.text.replace(/\r/g, "");
+                if (text) {
+                    setTokenInput((prev) => prev + text);
+                }
+                return;
+            }
+            setTokenInput((prev) => prev + result.input);
         }
     });
     const handleEnter = async () => {
@@ -84,6 +112,7 @@ export const LoginCommand = ({ onCancel }) => {
         setError("");
         setAuthUrl("");
         setTokenInput("");
+        pasteDetectorRef.current.reset();
         setMessage("Starting authentication...");
         // Promise that resolves when user presses Enter with token input
         const readToken = () => new Promise((resolve, reject) => {

package/dist/components/MarketplaceAddForm.js

@@ -1,8 +1,9 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useReducer, useEffect } from "react";
+import { useReducer, useEffect, useRef } from "react";
 import { Box, Text, useInput } from "ink";
 import { usePluginManagerContext } from "../contexts/PluginManagerContext.js";
 import { marketplaceAddFormReducer, SCOPES, } from "../reducers/marketplaceAddFormReducer.js";
+import { createBracketedPasteDetector } from "../utils/bracketedPaste.js";
 export const MarketplaceAddForm = () => {
     const { state: ctxState, actions } = usePluginManagerContext();
     const [state, dispatch] = useReducer(marketplaceAddFormReducer, {
@@ -23,11 +24,24 @@ export const MarketplaceAddForm = () => {
         }
         dispatch({ type: "CLEAR_PENDING_ACTION" });
     }, [state.pendingAction, actions]);
+    const pasteDetectorRef = useRef(createBracketedPasteDetector());
     useInput((input, key) => {
+        const result = pasteDetectorRef.current.process(input);
+        if (result.kind === "consume") {
+            // Content of an in-flight bracketed paste: hold it, never submit.
+            return;
+        }
+        let cleanInput;
+        if (result.kind === "paste") {
+            cleanInput = (result.leadingInput ?? "") + result.text;
+        }
+        else {
+            cleanInput = result.input;
+        }
         dispatch({
             type: "HANDLE_KEY",
             key,
-            input,
+            input: cleanInput,
             isLoading: ctxState.isLoading,
         });
     });

package/dist/components/RewindCommand.js

@@ -16,10 +16,17 @@ export const RewindCommand = ({ messages: initialMessages, onSelect, onCancel, g
         }
     }, [getFullMessageThread]);
     // Filter user messages as checkpoints, excluding meta messages and
-    // system-generated user-role messages (task notifications, hook injections)
-    const checkpoints = messages
-        .map((msg, index) => ({ msg, index }))
-        .filter(({ msg }) => isUserCheckpointMessage(msg));
+    // system-generated user-role messages (task notifications, hook injections).
+    // Compaction is append-only: the same message id appears twice on the full
+    // thread (pre-compact history + post-compact append), so dedupe by id and
+    // keep the last occurrence (matching the folded view the user sees).
+    const checkpointMap = new Map();
+    messages.forEach((msg, index) => {
+        if (!isUserCheckpointMessage(msg))
+            return;
+        checkpointMap.set(msg.id ?? `index:${index}`, { msg, index });
+    });
+    const checkpoints = Array.from(checkpointMap.values());
     const MAX_VISIBLE_ITEMS = 3;
     const [state, dispatch] = useReducer(rewindSelectorReducer, {
         selectedIndex: checkpoints.length - 1,

package/dist/constants/commands.js

@@ -11,6 +11,12 @@ export const AVAILABLE_COMMANDS = [
         description: "View and manage MCP servers",
         handler: () => { }, // Handler here won't be used, actual processing is in the hook
     },
+    {
+        id: "agents",
+        name: "agents",
+        description: "List available agents and active subagents",
+        handler: () => { }, // Handler here won't be used, actual processing is in the hook
+    },
     {
         id: "rewind",
         name: "rewind",

package/dist/contexts/useChat.d.ts

@@ -1,5 +1,5 @@
 import React from "react";
-import type { Message, McpServerStatus, BackgroundTask, Task, SlashCommand, PermissionDecision, PermissionMode, QueuedMessage, WorkflowRun } from "wave-agent-sdk";
+import type { Message, McpServerStatus, BackgroundTask, Task, SlashCommand, SubagentConfiguration, PermissionDecision, PermissionMode, QueuedMessage, WorkflowRun, ToolBlockUpdateCallbackParams } from "wave-agent-sdk";
 import { BaseAppProps } from "../types.js";
 export interface ChatContextType {
     messages: Message[];
@@ -46,6 +46,7 @@ export interface ChatContextType {
     stopBackgroundTask: (taskId: string) => boolean;
     slashCommands: SlashCommand[];
     hasSlashCommand: (commandId: string) => boolean;
+    agentDefinitions: SubagentConfiguration[];
     permissionMode: PermissionMode;
     setPermissionMode: (mode: PermissionMode) => void;
     isConfirmationVisible: boolean;
@@ -57,8 +58,9 @@ export interface ChatContextType {
         hidePersistentOption?: boolean;
         planContent?: string;
         permissionMode?: PermissionMode;
+        warning?: string;
     };
-    showConfirmation: (toolName: string, toolInput?: Record<string, unknown>, suggestedPrefix?: string, hidePersistentOption?: boolean, planContent?: string, permissionMode?: PermissionMode) => Promise<PermissionDecision>;
+    showConfirmation: (toolName: string, toolInput?: Record<string, unknown>, suggestedPrefix?: string, hidePersistentOption?: boolean, planContent?: string, permissionMode?: PermissionMode, warning?: string) => Promise<PermissionDecision>;
     hideConfirmation: () => void;
     handleConfirmationDecision: (decision: PermissionDecision) => void;
     handleConfirmationCancel: () => void;
@@ -82,4 +84,18 @@ export declare const useChat: () => ChatContextType;
 export interface ChatProviderProps extends BaseAppProps {
     children: React.ReactNode;
 }
+/**
+ * Per-tool window-concat throttle for pure-delta tool parameter streaming:
+ * `parametersChunk` deltas are accumulated independently per tool block id
+ * within the cooldown window, so interleaved multi-tool streams lose no delta
+ * (a plain throttle's single last-args slot would drop every earlier tool's
+ * deltas, leaving the first tool without streaming parameters). `start` /
+ * `running` apply immediately (one-shot snapshots); `end` flushes pending
+ * streaming deltas first, then applies the authoritative parameters/result.
+ */
+export declare function createToolStreamingThrottle(fn: (params: ToolBlockUpdateCallbackParams) => void, wait: number): {
+    (params: ToolBlockUpdateCallbackParams): void;
+    cancel: () => void;
+    flush: () => void;
+};
 export declare const ChatProvider: React.FC<ChatProviderProps>;