wave-code 0.19.9 → 1.0.1

package/dist/cli.js

@@ -7,6 +7,16 @@ export async function startCli(options) {
     const { restoreSessionId, continueLastSession, bypassPermissions, permissionMode, pluginDirs, tools, allowedTools, disallowedTools, worktreeSession, workdir, originalCwd, version, model, mcpServers, } = options;
     // Continue with ink-based UI for normal mode
     let shouldRemoveWorktree = false;
+    // Enable bracketed paste (DECSET 2004) so terminals wrap pasted text in
+    // \x1b[200~ ... \x1b[201~ markers. The input pipeline uses these to insert
+    // pasted text without submitting (a pasted trailing \r is not an Enter).
+    // Terminals without bracketed-paste support ignore the sequence and paste
+    // without markers, falling back to legacy behavior. No-op when stdout is
+    // not a TTY (piped input, stdio mode).
+    const stdoutIsTTY = process.stdout.isTTY === true;
+    if (stdoutIsTTY) {
+        process.stdout.write("\x1b[?2004h");
+    }
     const handleExit = (shouldRemove) => {
         shouldRemoveWorktree = shouldRemove;
         unmount();
@@ -14,7 +24,16 @@ export async function startCli(options) {
     // Render the application
     const { unmount, waitUntilExit } = render(_jsx(App, { restoreSessionId: restoreSessionId, continueLastSession: continueLastSession, bypassPermissions: bypassPermissions, permissionMode: permissionMode, pluginDirs: pluginDirs, tools: tools, allowedTools: allowedTools, disallowedTools: disallowedTools, worktreeSession: worktreeSession, workdir: workdir, originalCwd: originalCwd, version: version, model: model, mcpServers: mcpServers, onExit: handleExit }), { exitOnCtrlC: false });
     // Wait for the app to finish unmounting
-    await waitUntilExit();
+    try {
+        await waitUntilExit();
+    }
+    finally {
+        // Disable bracketed paste (DECSET 2004) so the terminal returns to its
+        // previous paste handling.
+        if (stdoutIsTTY) {
+            process.stdout.write("\x1b[?2004l");
+        }
+    }
     try {
         // Clean up old log files
         await cleanupLogs().catch((error) => {

package/dist/components/App.js

@@ -6,6 +6,7 @@ import { ChatProvider, useChat } from "../contexts/useChat.js";
 import { AppProvider } from "../contexts/useAppConfig.js";
 import { WorktreeExitPrompt } from "./WorktreeExitPrompt.js";
 import { hasUncommittedChanges, hasNewCommits, getDefaultRemoteBranch, } from "wave-agent-sdk";
+import { btwOverlayActiveRef } from "../managers/inputReducer.js";
 /** Wraps ChatInterface with worktree exit handling, using useChat() for hook access. */
 const ChatWithExitPrompt = ({ worktreeSession, onExit }) => {
     const { triggerWorktreeRemoveHook } = useChat();
@@ -28,6 +29,9 @@ const ChatWithExitPrompt = ({ worktreeSession, onExit }) => {
         }
     }, [worktreeSession, onExit]);
     useInput((input, key) => {
+        // While the /btw overlay is up it owns the keys; Ctrl+C must not quit
+        if (btwOverlayActiveRef.current)
+            return;
         if (input === "c" && key.ctrl) {
             handleSignal();
         }
@@ -54,6 +58,9 @@ const AppWithProviders = ({ bypassPermissions, permissionMode, pluginDirs, tools
     // Handle Ctrl-C for non-worktree sessions (immediate exit)
     // Ink runs terminal in raw mode, so Ctrl+C arrives as useInput event, not SIGINT
     useInput((input, key) => {
+        // While the /btw overlay is up it owns the keys; Ctrl+C must not quit
+        if (btwOverlayActiveRef.current)
+            return;
         if (!worktreeSession && input === "c" && key.ctrl) {
             onExit(false);
             return true;

package/dist/components/BtwDisplay.js

@@ -1,9 +1,19 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
 import { Box, Text } from "ink";
 import { Markdown } from "./Markdown.js";
 export const BtwDisplay = ({ btwState }) => {
-    if (!btwState.question) {
+    // Rendered for a real question (loading or answered) and for the bare
+    // `/btw` usage message (question === "", answer set).
+    if (!btwState.question && !btwState.answer) {
         return null;
     }
-    return (_jsxs(Box, { flexDirection: "column", marginTop: 0, marginBottom: 0, children: [btwState.question && (_jsxs(Box, { children: [_jsx(Text, { color: btwState.isLoading ? "yellow" : "green", children: "/ " }), _jsxs(Text, { italic: true, color: "gray", children: ["btw ", btwState.question] })] })), btwState.answer && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Markdown, { children: btwState.answer }), _jsx(Text, { color: "gray", dimColor: true, children: "ESC to dismiss" })] }))] }));
+    const answer = btwState.answer ?? "";
+    // The SDK surfaces failure as the answer string; classify by prefix so it
+    // renders in error color (aligned with Claude Code's error display).
+    const isError = !btwState.isLoading &&
+        (answer.startsWith("(API error") ||
+            answer.startsWith("(The model tried to call") ||
+            answer === "No response received");
+    return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [btwState.question && (_jsxs(Box, { children: [_jsxs(Text, { color: "warning", bold: true, children: ["/btw", " "] }), _jsx(Text, { dimColor: true, children: btwState.question })] })), _jsx(Box, { marginTop: 1, flexDirection: "column", children: btwState.isLoading ? (_jsx(Text, { color: "gray", children: "\u273B Answering..." })) : isError ? (_jsx(Text, { color: "error", children: answer })) : (_jsx(Markdown, { children: answer })) }), btwState.question && btwState.answer && (_jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "Escape to dismiss" }) })), !btwState.question && btwState.answer && (_jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "Escape to dismiss" }) }))] }));
 };
+BtwDisplay.displayName = "BtwDisplay";

package/dist/components/ChatInterface.js

@@ -1,6 +1,7 @@
 import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
-import { useState, useRef, useEffect } from "react";
+import { useState, useRef, useEffect, useCallback } from "react";
 import { Box, useStdout, measureElement, Static } from "ink";
+import { authService } from "wave-agent-sdk";
 import { MessageList } from "./MessageList.js";
 import { InputBox } from "./InputBox.js";
 import { LoadingIndicator } from "./LoadingIndicator.js";
@@ -10,12 +11,29 @@ import { ConfirmationDetails } from "./ConfirmationDetails.js";
 import { ConfirmationSelector } from "./ConfirmationSelector.js";
 import { useChat } from "../contexts/useChat.js";
 export const ChatInterface = () => {
-    const { messages, isLoading, isCommandRunning, isCompacting, sendMessage, abortMessage, mcpServers, connectMcpServer, disconnectMcpServer, isExpanded, sessionId, latestTotalTokens, maxInputTokens, slashCommands, hasSlashCommand, isConfirmationVisible, hasPendingConfirmations, confirmingTool, handleConfirmationDecision, handleConfirmationCancel, version, workdir, remountKey, requestRemount, isGoalActive, goalElapsed, isGoalEvaluating, } = useChat();
+    const { messages, isLoading, isCommandRunning, isCompacting, sendMessage, abortMessage, mcpServers, connectMcpServer, disconnectMcpServer, isExpanded, sessionId, latestTotalTokens, maxInputTokens, slashCommands, hasSlashCommand, isConfirmationVisible, hasPendingConfirmations, confirmingTool, handleConfirmationDecision, handleConfirmationCancel, version, workdir, remountKey, requestRemount, getGatewayConfig, } = useChat();
     const displayMessages = messages;
     const [forceStatic, setForceStatic] = useState(false);
     const { stdout } = useStdout();
     const terminalHeight = stdout?.rows ?? 24;
     const chatInterfaceRef = useRef(null);
+    // Compute whether the user has any usable auth/direct-API config,
+    // so the welcome page can prompt /login when neither is present.
+    const computeAuthState = useCallback(() => {
+        if (authService.isSSOAuthenticated())
+            return true;
+        const gateway = getGatewayConfig();
+        return Boolean(gateway.apiKey || gateway.baseURL);
+    }, [getGatewayConfig]);
+    const [hasAuth, setHasAuth] = useState(computeAuthState);
+    // Keep the /login hint in sync with auth state changes (login/logout).
+    useEffect(() => {
+        const unsubscribe = authService.onAuthChange(() => {
+            setHasAuth(computeAuthState());
+        });
+        return unsubscribe;
+    }, [computeAuthState]);
+    const showLoginHint = !hasAuth;
     // Handle forceStatic mode for overflow and request remount when exiting
     useEffect(() => {
         if (isConfirmationVisible && chatInterfaceRef.current) {
@@ -37,8 +55,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 ||
-                        isGoalEvaluating) && (_jsx(LoadingIndicator, { isLoading: isLoading, isCommandRunning: isCommandRunning, isCompacting: isCompacting, isGoalEvaluating: isGoalEvaluating, latestTotalTokens: latestTotalTokens })), _jsx(TaskList, {}), _jsx(QueuedMessageList, {}), _jsx(InputBox, { isLoading: isLoading, isCommandRunning: isCommandRunning, sendMessage: sendMessage, abortMessage: abortMessage, mcpServers: mcpServers, connectMcpServer: connectMcpServer, disconnectMcpServer: disconnectMcpServer, slashCommands: slashCommands, hasSlashCommand: hasSlashCommand, latestTotalTokens: latestTotalTokens, maxInputTokens: maxInputTokens, isGoalActive: isGoalActive, goalElapsed: goalElapsed })] })), 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, 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, showLoginHint: showLoginHint }, 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 })] })), 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, isExpanded: isExpanded, onDecision: handleConfirmationDecision, onCancel: handleConfirmationCancel })] }))] }));
 };

package/dist/components/HelpView.js

@@ -47,11 +47,17 @@ export const HelpView = ({ onCancel, commands = [], }) => {
         { key: "Ctrl+B", description: "Background current task" },
         { key: "Ctrl+V", description: "Paste image" },
         { key: "Ctrl+J", description: "Newline" },
+        { key: "Ctrl+A", description: "Cursor to line start" },
+        { key: "Ctrl+E", description: "Cursor to line end" },
+        { key: "Ctrl+U", description: "Delete to line start" },
+        { key: "Ctrl+K", description: "Delete to line end" },
+        { key: "Ctrl+W", description: "Delete word before cursor" },
         { key: "Shift+Tab", description: "Cycle permission mode" },
         {
             key: "Esc",
             description: "Interrupt AI or command / Cancel selector / Close help",
         },
+        { key: "Esc ×2", description: "Clear input (idle)" },
     ];
     const footerText = [
         "Tab switch",

package/dist/components/InputBox.d.ts

@@ -5,6 +5,7 @@ export declare const INPUT_PLACEHOLDER_TEXT_PREFIX: string;
 export interface InputBoxProps {
     isLoading?: boolean;
     isCommandRunning?: boolean;
+    isCompacting?: boolean;
     workdir?: string;
     sendMessage?: (message: string, images?: Array<{
         path: string;
@@ -18,7 +19,5 @@ export interface InputBoxProps {
     hasSlashCommand?: (commandId: string) => boolean;
     latestTotalTokens?: number;
     maxInputTokens?: number;
-    isGoalActive?: boolean;
-    goalElapsed?: string;
 }
 export declare const InputBox: React.FC<InputBoxProps>;

package/dist/components/InputBox.js

@@ -20,11 +20,14 @@ import { useInputManager } from "../hooks/useInputManager.js";
 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 = ({ sendMessage = () => { }, abortMessage = () => { }, mcpServers = [], connectMcpServer = async () => false, disconnectMcpServer = async () => false, slashCommands = [], hasSlashCommand = () => false, latestTotalTokens = 0, maxInputTokens = 200000, isGoalActive, goalElapsed, }) => {
-    const { permissionMode: chatPermissionMode, setPermissionMode: setChatPermissionMode, handleRewindSelect, backgroundCurrentTask, messages, getFullMessageThread, sessionId, workingDirectory, askBtw, clearMessages, compact, goalCommand, currentModel, configuredModels, setModel, recreateAgent, recallQueuedMessage, queuedMessages, } = useChat();
+export const InputBox = ({ isLoading, isCommandRunning, isCompacting, sendMessage = () => { }, abortMessage = () => { }, mcpServers = [], connectMcpServer = async () => false, disconnectMcpServer = async () => false, slashCommands = [], hasSlashCommand = () => false, latestTotalTokens = 0, maxInputTokens = 200000, }) => {
+    const { permissionMode: chatPermissionMode, setPermissionMode: setChatPermissionMode, handleRewindSelect, backgroundCurrentTask, messages, getFullMessageThread, sessionId, workingDirectory, askBtw, clearMessages, compact, currentModel, configuredModels, setModel, recreateAgent, recallQueuedMessage, queuedMessages, setIsBtwActive, } = useChat();
     // Ref to hold setInputText so queue callbacks can access it before useInputManager returns
     const setInputTextRef = useRef(() => { });
     const hasQueuedMessages = (queuedMessages?.length ?? 0) > 0;
+    // Idle means no AI work in flight. Esc double-press clear only applies when
+    // idle; while busy, Esc keeps its abort semantics.
+    const isIdle = !(isLoading || isCommandRunning || isCompacting);
     const onRecallQueuedMessage = useCallback(() => {
         const msg = recallQueuedMessage();
         if (msg) {
@@ -46,6 +49,8 @@ export const InputBox = ({ sendMessage = () => { }, abortMessage = () => { }, mc
     permissionMode, setPermissionMode, 
     // BTW state
     btwState, 
+    // Esc double-press clear pending
+    escClearPending, 
     // Main handler
     handleInput, 
     // Manager ready state
@@ -56,7 +61,6 @@ export const InputBox = ({ sendMessage = () => { }, abortMessage = () => { }, mc
         onAskBtw: askBtw,
         onClearMessages: clearMessages,
         onCompact: compact,
-        onGoalCommand: goalCommand,
         onHasSlashCommand: hasSlashCommand,
         onAbortMessage: abortMessage,
         onBackgroundCurrentTask: backgroundCurrentTask,
@@ -65,12 +69,19 @@ export const InputBox = ({ sendMessage = () => { }, abortMessage = () => { }, mc
         workdir: workingDirectory,
         getFullMessageThread,
         hasQueuedMessages,
+        isIdle,
         onRecallQueuedMessage,
     });
     // Keep setInputText ref updated for queue callbacks
     useEffect(() => {
         setInputTextRef.current = setInputText;
     }, [setInputText]);
+    // Sync the btw overlay's visibility to ChatContext so siblings (TaskList)
+    // can hide while the side-question is on display (aligned with Claude Code,
+    // which suppresses the expanded task list while a local-jsx command shows).
+    useEffect(() => {
+        setIsBtwActive(btwState.question !== "" || btwState.answer !== undefined);
+    }, [btwState.question, btwState.answer, setIsBtwActive]);
     // Sync permission mode from useChat to InputManager
     useEffect(() => {
         setPermissionMode(chatPermissionMode);
@@ -137,7 +148,7 @@ export const InputBox = ({ sendMessage = () => { }, abortMessage = () => { }, mc
     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
+    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
                 ? null
                 : showBackgroundTaskManager ||
                     showMcpManager ||
@@ -146,5 +157,5 @@ export const InputBox = ({ sendMessage = () => { }, abortMessage = () => { }, mc
                     showStatusCommand ||
                     showLoginCommand ||
                     showPluginManager ||
-                    showWorkflowManager || (_jsxs(Box, { flexDirection: "column", children: [_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) }) }), _jsx(StatusLine, { permissionMode: permissionMode, isShellCommand: isShellCommand, isGoalActive: isGoalActive, goalElapsed: goalElapsed, latestTotalTokens: latestTotalTokens, maxInputTokens: maxInputTokens })] }))] }));
+                    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) }) }), _jsx(StatusLine, { permissionMode: permissionMode, isShellCommand: isShellCommand, latestTotalTokens: latestTotalTokens, maxInputTokens: maxInputTokens })] }))] }));
 };

package/dist/components/LoadingIndicator.d.ts

@@ -2,10 +2,9 @@ export interface LoadingIndicatorProps {
     isLoading?: boolean;
     isCommandRunning?: boolean;
     isCompacting?: boolean;
-    isGoalEvaluating?: boolean;
     latestTotalTokens?: number;
 }
 export declare const LoadingIndicator: {
-    ({ isLoading, isCommandRunning, isCompacting, isGoalEvaluating, latestTotalTokens, }: LoadingIndicatorProps): import("react/jsx-runtime").JSX.Element;
+    ({ isLoading, isCommandRunning, isCompacting, latestTotalTokens, }: LoadingIndicatorProps): import("react/jsx-runtime").JSX.Element;
     displayName: string;
 };

package/dist/components/LoadingIndicator.js

@@ -1,6 +1,6 @@
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
 import { Box, Text } from "ink";
-export const LoadingIndicator = ({ isLoading = false, isCommandRunning = false, isCompacting = false, isGoalEvaluating = false, latestTotalTokens = 0, }) => {
-    return (_jsxs(Box, { flexDirection: "column", children: [isLoading && !isCompacting && !isGoalEvaluating && (_jsxs(Box, { children: [_jsx(Text, { color: "yellow", children: "\u273B AI is thinking... " }), latestTotalTokens > 0 && (_jsxs(_Fragment, { children: [_jsxs(Text, { color: "gray", dimColor: true, children: ["|", " "] }), _jsx(Text, { color: "blue", bold: true, children: latestTotalTokens.toLocaleString() }), _jsxs(Text, { color: "gray", dimColor: true, children: [" ", "tokens", " "] })] })), _jsxs(Text, { color: "gray", dimColor: true, children: ["|", " "] }), _jsx(Text, { color: "red", bold: true, children: "Esc" }), _jsxs(Text, { color: "gray", dimColor: true, children: [" ", "to abort"] })] })), isCommandRunning && _jsx(Text, { color: "blue", children: "\u273B Command is running..." }), isCompacting && (_jsx(Text, { color: "magenta", children: "\u273B Compacting message history..." })), isGoalEvaluating && _jsx(Text, { color: "cyan", children: "\u273B Evaluating goal..." })] }));
+export const LoadingIndicator = ({ isLoading = false, isCommandRunning = false, isCompacting = false, latestTotalTokens = 0, }) => {
+    return (_jsxs(Box, { flexDirection: "column", children: [isLoading && !isCompacting && (_jsxs(Box, { children: [_jsx(Text, { color: "yellow", children: "\u273B AI is thinking... " }), latestTotalTokens > 0 && (_jsxs(_Fragment, { children: [_jsxs(Text, { color: "gray", dimColor: true, children: ["|", " "] }), _jsx(Text, { color: "blue", bold: true, children: latestTotalTokens.toLocaleString() }), _jsxs(Text, { color: "gray", dimColor: true, children: [" ", "tokens", " "] })] })), _jsxs(Text, { color: "gray", dimColor: true, children: ["|", " "] }), _jsx(Text, { color: "red", bold: true, children: "Esc" }), _jsxs(Text, { color: "gray", dimColor: true, children: [" ", "to abort"] })] })), isCommandRunning && _jsx(Text, { color: "blue", children: "\u273B Command is running..." }), isCompacting && (_jsx(Text, { color: "magenta", children: "\u273B Compacting message history..." }))] }));
 };
 LoadingIndicator.displayName = "LoadingIndicator";

package/dist/components/Markdown.js

@@ -1,9 +1,10 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import React, { useMemo } from "react";
-import { Box, Text } from "ink";
+import { Box, Text, useStdout } from "ink";
 import { Renderer, marked } from "marked";
 import chalk from "chalk";
 import { highlightToAnsi } from "../utils/highlightUtils.js";
+import { renderMarkdownTable } from "../utils/markdownTable.js";
 const unescapeHtml = (html) => {
     return html
         .replace(/&/g, "&")
@@ -14,6 +15,10 @@ const unescapeHtml = (html) => {
         .replace(/'/g, "'");
 };
 class AnsiRenderer extends Renderer {
+    constructor(columns) {
+        super();
+        this.columns = columns;
+    }
     code({ text, lang }) {
         const prefix = lang ? `\`\`\`${lang}` : "```";
         const suffix = "```";
@@ -67,18 +72,8 @@ class AnsiRenderer extends Renderer {
         return `\n${text}\n`;
     }
     table(token) {
-        const header = token.header.map((cell) => this.tablecell(cell)).join("");
-        const body = token.rows
-            .map((row) => row.map((cell) => this.tablecell(cell)).join("") + "\n")
-            .join("");
-        return `\n${header}\n${body}\n`;
-    }
-    tablerow({ text }) {
-        return text + "\n";
-    }
-    tablecell(token) {
-        const text = token.header ? chalk.bold(token.text) : token.text;
-        return text + " | ";
+        const table = renderMarkdownTable(token, this.columns, (tokens) => this.parser.parseInline(tokens));
+        return `\n${table}\n`;
     }
     strong({ tokens }) {
         const text = this.parser.parseInline(tokens);
@@ -114,16 +109,18 @@ class AnsiRenderer extends Renderer {
             : unescapeHtml(token.text);
     }
 }
-const renderer = new AnsiRenderer();
+const createRenderer = (columns) => new AnsiRenderer(columns);
 // Markdown component using custom ANSI renderer
 export const Markdown = React.memo(({ children }) => {
+    const { stdout } = useStdout();
+    const columns = stdout?.columns ?? 80;
     const ansiContent = useMemo(() => {
         return marked.parse(children, {
-            renderer,
+            renderer: createRenderer(columns),
             gfm: true,
             breaks: true,
         });
-    }, [children]);
+    }, [children, columns]);
     return (_jsx(Box, { flexDirection: "column", children: _jsx(Text, { children: ansiContent.trim() }) }));
 });
 // Add display name for debugging

package/dist/components/MessageList.d.ts

@@ -6,5 +6,6 @@ export interface MessageListProps {
     forceStatic?: boolean;
     version?: string;
     workdir?: string;
+    showLoginHint?: boolean;
 }
-export declare const MessageList: React.MemoExoticComponent<({ messages, isExpanded, forceStatic, version, workdir, }: MessageListProps) => import("react/jsx-runtime").JSX.Element>;
+export declare const MessageList: React.MemoExoticComponent<({ messages, isExpanded, forceStatic, version, workdir, showLoginHint, }: MessageListProps) => import("react/jsx-runtime").JSX.Element>;

package/dist/components/MessageList.js

@@ -5,7 +5,7 @@ import { Box, Text, Static } from "ink";
 import { MessageBlockItem } from "./MessageBlockItem.js";
 const MAX_MESSAGES_COLLAPSED = 30;
 const MAX_MESSAGES_EXPANDED = 10;
-export const MessageList = React.memo(({ messages, isExpanded = false, forceStatic = false, version, workdir, }) => {
+export const MessageList = React.memo(({ messages, isExpanded = false, forceStatic = false, version, workdir, showLoginHint = false, }) => {
     const maxMessages = isExpanded
         ? MAX_MESSAGES_EXPANDED
         : MAX_MESSAGES_COLLAPSED;
@@ -74,7 +74,7 @@ export const MessageList = React.memo(({ messages, isExpanded = false, forceStat
                         return null;
                     }
                     return (_jsx(MessageBlockItem, { block: item.block, message: item.message, isExpanded: isExpanded, paddingTop: 1 }, item.key));
-                } })), dynamicBlocks.length > 0 && (_jsx(Box, { flexDirection: "column", children: dynamicBlocks.map((item) => (_jsx(MessageBlockItem, { block: item.block, message: item.message, isExpanded: isExpanded, paddingTop: 1 }, item.key))) }))] }));
+                } })), showLoginHint && _jsx(Text, { color: "gray", children: "Type /login to authenticate" }), dynamicBlocks.length > 0 && (_jsx(Box, { flexDirection: "column", children: dynamicBlocks.map((item) => (_jsx(MessageBlockItem, { block: item.block, message: item.message, isExpanded: isExpanded, paddingTop: 1 }, item.key))) }))] }));
 });
 // Add display name for debugging
 MessageList.displayName = "MessageList";

package/dist/components/RewindCommand.js

@@ -3,6 +3,7 @@ import { useState, useReducer, useEffect } from "react";
 import { Box, Text, useInput } from "ink";
 import { getMessageContent } from "wave-agent-sdk";
 import { rewindSelectorReducer } from "../reducers/rewindSelectorReducer.js";
+import { isUserCheckpointMessage } from "../utils/rewindCheckpoints.js";
 export const RewindCommand = ({ messages: initialMessages, onSelect, onCancel, getFullMessageThread, }) => {
     const [messages, setMessages] = useState(initialMessages);
     const [isLoading, setIsLoading] = useState(!!getFullMessageThread);
@@ -14,10 +15,11 @@ export const RewindCommand = ({ messages: initialMessages, onSelect, onCancel, g
             });
         }
     }, [getFullMessageThread]);
-    // Filter user messages as checkpoints, excluding meta messages
+    // 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 }) => msg.role === "user" && !msg.isMeta);
+        .filter(({ msg }) => isUserCheckpointMessage(msg));
     const MAX_VISIBLE_ITEMS = 3;
     const [state, dispatch] = useReducer(rewindSelectorReducer, {
         selectedIndex: checkpoints.length - 1,

package/dist/components/StatusLine.d.ts

@@ -2,8 +2,6 @@ import React from "react";
 export interface StatusLineProps {
     permissionMode: string;
     isShellCommand: boolean;
-    isGoalActive?: boolean;
-    goalElapsed?: string;
     latestTotalTokens?: number;
     maxInputTokens?: number;
 }

package/dist/components/StatusLine.js

@@ -1,13 +1,13 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Box, Text } from "ink";
-export const StatusLine = ({ permissionMode, isShellCommand, isGoalActive, goalElapsed, latestTotalTokens = 0, maxInputTokens = 200000, }) => {
+export const StatusLine = ({ permissionMode, isShellCommand, latestTotalTokens = 0, maxInputTokens = 200000, }) => {
     const percentage = latestTotalTokens > 0
         ? Math.min(Math.round((latestTotalTokens / maxInputTokens) * 100), 100)
         : 0;
     const contextColor = percentage > 95 ? "red" : percentage > 80 ? "yellow" : "gray";
-    return (_jsxs(Box, { paddingRight: 1, justifyContent: "space-between", width: "100%", children: [isShellCommand ? (_jsxs(Text, { color: "gray", children: ["Shell: ", _jsx(Text, { color: "yellow", children: "Run shell command" })] })) : (_jsxs(Box, { children: [isGoalActive && (_jsxs(Text, { color: "gray", children: [_jsx(Text, { color: "cyan", children: "\u25CE /goal" }), " active", " ", goalElapsed && _jsxs(Text, { children: ["(", goalElapsed, ")"] }), " |", " "] })), _jsxs(Text, { color: "gray", children: ["Mode:", " ", _jsx(Text, { color: permissionMode === "plan"
-                                    ? "yellow"
-                                    : permissionMode === "bypassPermissions"
-                                        ? "red"
-                                        : "cyan", bold: permissionMode === "bypassPermissions", children: permissionMode }), " ", "(Shift+Tab to cycle)"] })] })), percentage > 0 && (_jsxs(Text, { color: contextColor, children: [percentage, "% context"] }))] }));
+    return (_jsxs(Box, { paddingRight: 1, justifyContent: "space-between", width: "100%", children: [isShellCommand ? (_jsxs(Text, { color: "gray", children: ["Shell: ", _jsx(Text, { color: "yellow", children: "Run shell command" })] })) : (_jsx(Box, { children: _jsxs(Text, { color: "gray", children: ["Mode:", " ", _jsx(Text, { color: permissionMode === "plan"
+                                ? "yellow"
+                                : permissionMode === "bypassPermissions"
+                                    ? "red"
+                                    : "cyan", bold: permissionMode === "bypassPermissions", children: permissionMode }), " ", "(Shift+Tab to cycle)"] }) })), percentage > 0 && (_jsxs(Text, { color: contextColor, children: [percentage, "% context"] }))] }));
 };

package/dist/components/TaskList.js

@@ -75,7 +75,7 @@ function getDisplayLimit(rows) {
 }
 export const TaskList = () => {
     const tasks = useTasks();
-    const { isTaskListVisible } = useChat();
+    const { isTaskListVisible, isBtwActive } = useChat();
     const { stdout } = useStdout();
     const completionTimestampsRef = React.useRef(new Map());
     const previousCompletedIdsRef = React.useRef(null);
@@ -156,6 +156,7 @@ export const TaskList = () => {
     }, [allCompleted, autoHidden, activeTasks.length]);
     if (tasks.length === 0 ||
         !isTaskListVisible ||
+        isBtwActive ||
         autoHidden ||
         (allCompleted && !hadIncompleteRef.current)) {
         return null;

package/dist/components/ToolDisplay.d.ts

@@ -4,5 +4,6 @@ interface ToolDisplayProps {
     block: ToolBlock;
     isExpanded?: boolean;
 }
+export declare const getToolStatusColor: (stage: ToolBlock["stage"], success?: boolean, error?: string | Error) => string;
 export declare const ToolDisplay: React.FC<ToolDisplayProps>;
 export {};

package/dist/components/ToolDisplay.js

@@ -2,19 +2,27 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Box, Text } from "ink";
 import { getLastLines } from "wave-agent-sdk";
 import { DiffDisplay } from "./DiffDisplay.js";
+// Status dot color for a tool block. In-flight stages (start/streaming/running)
+// never show red — the outcome isn't known until the tool reaches "end".
+// An explicit error overrides everything.
+export const getToolStatusColor = (stage, success, error) => {
+    if (error)
+        return "red";
+    if (stage === "start" || stage === "streaming")
+        return "gray";
+    if (stage === "running")
+        return "yellow";
+    if (success)
+        return "green";
+    if (success === false)
+        return "red";
+    return "gray"; // Unknown state or no state information
+};
 export const ToolDisplay = ({ block, isExpanded = false, }) => {
     const { parameters, result, compactParams, stage, success, error, name } = block;
     // Directly use compactParams
     // (no change needed as we destructured it above)
-    const getStatusColor = () => {
-        if (stage === "running")
-            return "yellow";
-        if (success)
-            return "green";
-        if (error || success === false)
-            return "red";
-        return "gray"; // Unknown state or no state information
-    };
+    const getStatusColor = () => getToolStatusColor(stage, success, error);
     const hasImages = () => {
         return block.images && block.images.length > 0;
     };

package/dist/constants/commands.js

@@ -77,10 +77,4 @@ export const AVAILABLE_COMMANDS = [
         description: "Compact conversation history to reduce context usage",
         handler: () => { },
     },
-    {
-        id: "goal",
-        name: "goal",
-        description: "Set, check, or clear an autonomous goal for the session",
-        handler: () => { },
-    },
 ];

package/dist/contexts/useChat.d.ts

@@ -9,16 +9,17 @@ export interface ChatContextType {
     isExpanded: boolean;
     isTaskListVisible: boolean;
     setIsTaskListVisible: (visible: boolean) => void;
+    isBtwActive: boolean;
+    setIsBtwActive: (active: boolean) => void;
     queuedMessages: QueuedMessage[];
     sessionId: string;
     sendMessage: (content: string, images?: Array<{
         path: string;
         mimeType: string;
     }>, longTextMap?: Record<string, string>) => Promise<void>;
-    askBtw: (question: string) => Promise<string>;
+    askBtw: (question: string, abortSignal?: AbortSignal, onContent?: (content: string) => void) => Promise<string>;
     clearMessages: () => Promise<void>;
     compact: (instructions?: string) => Promise<void>;
-    goalCommand: (args?: string) => Promise<void>;
     abortMessage: () => void;
     recallQueuedMessage: () => QueuedMessage | null;
     removeQueuedMessageById: (id: string) => boolean;
@@ -74,9 +75,6 @@ export interface ChatContextType {
     workdir?: string;
     recreateAgent: () => void;
     triggerWorktreeRemoveHook: (worktreePath: string) => Promise<void>;
-    isGoalActive: boolean;
-    goalElapsed?: string;
-    isGoalEvaluating: boolean;
 }
 export declare const useChat: () => ChatContextType;
 export interface ChatProviderProps extends BaseAppProps {