wave-code 1.0.0 → 1.0.1

package/dist/contexts/useChat.js

@@ -22,27 +22,104 @@ export const ChatProvider = ({ children, bypassPermissions, permissionMode: init
     const [isExpanded, setIsExpanded] = useState(false);
     const isExpandedRef = useRef(isExpanded);
     const [isTaskListVisible, setIsTaskListVisible] = useState(true);
+    const [isBtwActive, setIsBtwActive] = useState(false);
     const [messages, setMessages] = useState([]);
     const [latestTotalTokens, setLatestTotalTokens] = useState(0);
     const [maxInputTokens, setMaxInputTokens] = useState(200000);
-    const throttledSetMessages = useMemo(() => throttle(() => {
-        if (!isExpandedRef.current && agentRef.current) {
-            const msgs = [...agentRef.current.messages];
-            setMessages(msgs);
-            setLatestTotalTokens(extractLatestTotalTokens(msgs));
-        }
-    }, 500, { leading: true, trailing: true }), []);
+    // Throttled incremental streaming updaters — 500ms leading+trailing, the same interval
+    // as the pre-incremental throttledSetMessages. `stage === "end"` flushes the final
+    // update immediately so completion results are never delayed.
+    const throttledContentUpdate = useMemo(() => throttle((params) => {
+        const { messageId, accumulated, stage } = params;
+        setMessages((prev) => prev.map((m) => {
+            if (m.id !== messageId)
+                return m;
+            const textBlockIndex = m.blocks.findIndex((b) => b.type === "text");
+            if (textBlockIndex === -1) {
+                return {
+                    ...m,
+                    blocks: [
+                        ...m.blocks,
+                        { type: "text", content: accumulated, stage },
+                    ],
+                };
+            }
+            return {
+                ...m,
+                blocks: m.blocks.map((b, idx) => idx === textBlockIndex && b.type === "text"
+                    ? { ...b, content: accumulated, stage }
+                    : b),
+            };
+        }));
+    }, 500), []);
+    const throttledReasoningUpdate = useMemo(() => throttle((params) => {
+        const { messageId, accumulated, stage } = params;
+        setMessages((prev) => prev.map((m) => {
+            if (m.id !== messageId)
+                return m;
+            const reasoningBlockIndex = m.blocks.findIndex((b) => b.type === "reasoning");
+            if (reasoningBlockIndex === -1) {
+                return {
+                    ...m,
+                    blocks: [
+                        ...m.blocks,
+                        { type: "reasoning", content: accumulated, stage },
+                    ],
+                };
+            }
+            return {
+                ...m,
+                blocks: m.blocks.map((b, idx) => idx === reasoningBlockIndex && b.type === "reasoning"
+                    ? { ...b, content: accumulated, stage }
+                    : b),
+            };
+        }));
+    }, 500), []);
+    const throttledToolBlockUpdate = useMemo(() => throttle((params) => {
+        const { messageId, id: toolBlockId, ...updates } = params;
+        setMessages((prev) => prev.map((m) => {
+            if (m.id !== messageId)
+                return m;
+            const toolBlockIndex = m.blocks.findIndex((b) => b.type === "tool" && b.id === toolBlockId);
+            if (toolBlockIndex === -1) {
+                return {
+                    ...m,
+                    blocks: [
+                        ...m.blocks,
+                        {
+                            type: "tool",
+                            id: toolBlockId,
+                            name: updates.name || "",
+                            stage: updates.stage || "start",
+                            parameters: updates.parameters || "",
+                            result: updates.result || "",
+                            ...updates,
+                        },
+                    ],
+                };
+            }
+            return {
+                ...m,
+                blocks: m.blocks.map((b, idx) => idx === toolBlockIndex && b.type === "tool"
+                    ? { ...b, ...updates }
+                    : b),
+            };
+        }));
+    }, 500), []);
     useEffect(() => {
         isExpandedRef.current = isExpanded;
         if (isExpanded) {
-            throttledSetMessages.cancel();
+            // Cancel pending throttled updates so the frozen expanded view isn't overwritten
+            throttledContentUpdate.cancel();
+            throttledReasoningUpdate.cancel();
+            throttledToolBlockUpdate.cancel();
         }
-    }, [isExpanded, throttledSetMessages]);
-    useEffect(() => {
-        return () => {
-            throttledSetMessages.cancel();
-        };
-    }, [throttledSetMessages]);
+    }, [
+        isExpanded,
+        throttledContentUpdate,
+        throttledReasoningUpdate,
+        throttledToolBlockUpdate,
+    ]);
     const [isLoading, setIsLoading] = useState(false);
     const [sessionId, setSessionId] = useState("");
     const [isCommandRunning, setIsCommandRunning] = useState(false);
@@ -50,29 +127,6 @@ export const ChatProvider = ({ children, bypassPermissions, permissionMode: init
     const [currentModel, setCurrentModelState] = useState("");
     const [configuredModels, setConfiguredModels] = useState([]);
     const [queuedMessages, setQueuedMessages] = useState([]);
-    const [isGoalActive, setIsGoalActive] = useState(false);
-    const [goalElapsed, setGoalElapsed] = useState();
-    const [isGoalEvaluating, setIsGoalEvaluating] = useState(false);
-    const goalStartedAt = useRef(null);
-    // Update goal elapsed time every 30s while active
-    useEffect(() => {
-        if (!isGoalActive || goalStartedAt.current === null)
-            return;
-        const formatElapsed = (ms) => {
-            const minutes = Math.floor(ms / 60000);
-            if (minutes < 1)
-                return "<1m";
-            if (minutes < 60)
-                return `${minutes}m`;
-            const hours = Math.floor(minutes / 60);
-            const remainingMin = minutes % 60;
-            return `${hours}h${remainingMin}m`;
-        };
-        const update = () => setGoalElapsed(formatElapsed(Date.now() - goalStartedAt.current));
-        update();
-        const timer = setInterval(update, 30000);
-        return () => clearInterval(timer);
-    }, [isGoalActive]);
     // MCP State
     const [mcpServerStatuses, setMcpServerStatuses] = useState([]);
     // Background tasks state
@@ -119,6 +173,16 @@ export const ChatProvider = ({ children, bypassPermissions, permissionMode: init
     // Status metadata state
     const [workingDirectory, setWorkingDirectory] = useState("");
     const agentRef = useRef(null);
+    // Full-list refresh — one-shot pull from the agent, used only for structural
+    // changes (compact/clear/rewind/collapse/init). Streaming updates flow through
+    // the incremental callbacks in initializeAgent below.
+    const refreshMessages = useCallback(() => {
+        if (!isExpandedRef.current && agentRef.current) {
+            const msgs = [...agentRef.current.messages];
+            setMessages(msgs);
+            setLatestTotalTokens(extractLatestTotalTokens(msgs));
+        }
+    }, []);
     // Permission confirmation methods with queue support
     const showConfirmation = useCallback(async (toolName, toolInput, suggestedPrefix, hidePersistentOption, planContent) => {
         return new Promise((resolve, reject) => {
@@ -139,8 +203,123 @@ export const ChatProvider = ({ children, bypassPermissions, permissionMode: init
     const initializeAgent = useCallback(async (restoreSessionIdOverride) => {
         const effectiveRestoreSessionId = restoreSessionIdOverride ?? restoreSessionId;
         const callbacks = {
-            onMessagesChange: () => {
-                throttledSetMessages();
+            // ── Incremental message updates (no full-list pushes) ──────
+            onUserMessageAdded: () => {
+                if (isExpandedRef.current || !agentRef.current)
+                    return;
+                const msgs = agentRef.current.messages;
+                const last = msgs[msgs.length - 1];
+                if (!last || last.role !== "user")
+                    return;
+                setMessages((prev) => prev.some((m) => m.id === last.id) ? prev : [...prev, last]);
+            },
+            onAssistantMessageAdded: (messageId) => {
+                if (isExpandedRef.current || !agentRef.current)
+                    return;
+                const msg = agentRef.current.messages.find((m) => m.id === messageId);
+                if (!msg)
+                    return;
+                setMessages((prev) => prev.some((m) => m.id === messageId) ? prev : [...prev, msg]);
+            },
+            onAssistantContentUpdated: (params) => {
+                if (isExpandedRef.current)
+                    return;
+                throttledContentUpdate(params);
+                if (params.stage === "end")
+                    throttledContentUpdate.flush();
+            },
+            onAssistantReasoningUpdated: (params) => {
+                if (isExpandedRef.current)
+                    return;
+                throttledReasoningUpdate(params);
+                if (params.stage === "end")
+                    throttledReasoningUpdate.flush();
+            },
+            onToolBlockUpdated: (params) => {
+                if (isExpandedRef.current)
+                    return;
+                throttledToolBlockUpdate(params);
+                if (params.stage === "end")
+                    throttledToolBlockUpdate.flush();
+            },
+            onErrorBlockAdded: (error) => {
+                if (isExpandedRef.current)
+                    return;
+                setMessages((prev) => {
+                    // Append to the last assistant message, or create one if none exists
+                    for (let i = prev.length - 1; i >= 0; i--) {
+                        if (prev[i].role === "assistant") {
+                            return prev.map((m, idx) => idx === i
+                                ? {
+                                    ...m,
+                                    blocks: [
+                                        ...m.blocks,
+                                        { type: "error", content: error },
+                                    ],
+                                }
+                                : m);
+                        }
+                    }
+                    return [
+                        ...prev,
+                        {
+                            id: `msg-${Date.now()}-${Math.random().toString(36).slice(2, 11)}`,
+                            role: "assistant",
+                            timestamp: new Date().toISOString(),
+                            blocks: [{ type: "error", content: error }],
+                        },
+                    ];
+                });
+            },
+            onAddBangMessage: (command, messageId) => {
+                if (isExpandedRef.current)
+                    return;
+                setMessages((prev) => prev.some((m) => m.id === messageId)
+                    ? prev
+                    : [
+                        ...prev,
+                        {
+                            id: messageId,
+                            role: "user",
+                            timestamp: new Date().toISOString(),
+                            blocks: [
+                                {
+                                    type: "bang",
+                                    command,
+                                    output: "",
+                                    stage: "running",
+                                    exitCode: null,
+                                },
+                            ],
+                        },
+                    ]);
+            },
+            onUpdateBangMessage: (command, output, messageId) => {
+                if (isExpandedRef.current)
+                    return;
+                setMessages((prev) => prev.map((m) => m.id === messageId
+                    ? {
+                        ...m,
+                        blocks: m.blocks.map((b, idx) => idx === m.blocks.length - 1 && b.type === "bang"
+                            ? { ...b, command, output }
+                            : b),
+                    }
+                    : m));
+            },
+            onCompleteBangMessage: (command, exitCode, messageId) => {
+                if (isExpandedRef.current)
+                    return;
+                setMessages((prev) => prev.map((m) => m.id === messageId
+                    ? {
+                        ...m,
+                        blocks: m.blocks.map((b, idx) => idx === m.blocks.length - 1 && b.type === "bang"
+                            ? { ...b, command, exitCode, stage: "end" }
+                            : b),
+                    }
+                    : m));
+            },
+            onLatestTotalTokensChange: (tokens) => {
+                setLatestTotalTokens(tokens);
             },
             onMcpServersChange: (servers) => {
                 setMcpServerStatuses([...servers]);
@@ -185,19 +364,6 @@ export const ChatProvider = ({ children, bypassPermissions, permissionMode: init
             onQueuedMessagesChange: (messages) => {
                 setQueuedMessages([...messages]);
             },
-            onGoalStateChange: (active, _condition, elapsed) => {
-                setIsGoalActive(active);
-                if (active) {
-                    goalStartedAt.current = Date.now();
-                }
-                else {
-                    goalStartedAt.current = null;
-                }
-                setGoalElapsed(elapsed);
-            },
-            onGoalEvaluating: (evaluating) => {
-                setIsGoalEvaluating(evaluating);
-            },
         };
         try {
             // Create the permission callback inside the try block to access showConfirmation
@@ -283,7 +449,10 @@ export const ChatProvider = ({ children, bypassPermissions, permissionMode: init
         originalCwd,
         model,
         initialPermissionMode,
-        throttledSetMessages,
+        refreshMessages,
+        throttledContentUpdate,
+        throttledReasoningUpdate,
+        throttledToolBlockUpdate,
         mcpServers,
     ]);
     // Recreate agent (e.g. after plugin install) — destroys current agent and reinitializes
@@ -318,6 +487,9 @@ export const ChatProvider = ({ children, bypassPermissions, permissionMode: init
     // Cleanup on unmount
     useEffect(() => {
         return () => {
+            throttledContentUpdate.cancel();
+            throttledReasoningUpdate.cancel();
+            throttledToolBlockUpdate.cancel();
             if (agentRef.current) {
                 try {
                     // Display usage summary before cleanup
@@ -331,7 +503,11 @@ export const ChatProvider = ({ children, bypassPermissions, permissionMode: init
                 agentRef.current.destroy();
             }
         };
-    }, []);
+    }, [
+        throttledContentUpdate,
+        throttledReasoningUpdate,
+        throttledToolBlockUpdate,
+    ]);
     // Trigger WorktreeRemove hook BEFORE agent destruction
     const triggerWorktreeRemoveHook = useCallback(async (worktreePath) => {
         await agentRef.current?.triggerWorktreeRemoveHook(worktreePath);
@@ -368,30 +544,20 @@ export const ChatProvider = ({ children, bypassPermissions, permissionMode: init
             console.error("Failed to send message:", error);
         }
     }, []);
-    const askBtw = useCallback(async (question) => {
+    const askBtw = useCallback(async (question, abortSignal, onContent) => {
         if (!agentRef.current) {
             throw new Error("Agent not initialized");
         }
-        return await agentRef.current.askBtw(question);
+        return await agentRef.current.askBtw(question, abortSignal, onContent);
     }, []);
     const clearMessages = useCallback(async () => {
         await agentRef.current?.clearMessages();
-    }, []);
+        refreshMessages();
+    }, [refreshMessages]);
     const compact = useCallback(async (instructions) => {
         await agentRef.current?.compact(instructions);
-    }, []);
-    const goalCommand = useCallback(async (args) => {
-        const trimmed = args?.trim() ?? "";
-        if (!trimmed) {
-            await agentRef.current?.showGoalStatus();
-        }
-        else if (["clear", "stop", "off", "reset", "none", "cancel"].includes(trimmed)) {
-            await agentRef.current?.clearGoal();
-        }
-        else {
-            await agentRef.current?.setGoal(trimmed);
-        }
-    }, []);
+        refreshMessages();
+    }, [refreshMessages]);
     // Unified interrupt method, interrupt both AI messages and command execution
     const abortMessage = useCallback(() => {
         agentRef.current?.abortMessage();
@@ -484,13 +650,14 @@ export const ChatProvider = ({ children, bypassPermissions, permissionMode: init
         if (agentRef.current) {
             try {
                 await agentRef.current.truncateHistory(index);
+                refreshMessages();
                 requestRemount();
             }
             catch (error) {
                 logger.error("Failed to rewind:", error);
             }
         }
-    }, [requestRemount]);
+    }, [requestRemount, refreshMessages]);
     const getFullMessageThread = useCallback(async () => {
         if (agentRef.current) {
             return await agentRef.current.getFullMessageThread();
@@ -530,16 +697,11 @@ export const ChatProvider = ({ children, bypassPermissions, permissionMode: init
             isExpandedRef.current = nextExpanded;
             if (nextExpanded) {
                 // Transitioning to EXPANDED: Freeze the current view
-                // Cancel any pending throttled updates to avoid overwriting the frozen state
-                throttledSetMessages.cancel();
+                // Incremental updates are skipped while expanded (isExpandedRef guard)
             }
             else {
                 // Transitioning to COLLAPSED: Restore from agent's actual state
-                if (agentRef.current) {
-                    const msgs = [...agentRef.current.messages];
-                    setMessages(msgs);
-                    setLatestTotalTokens(extractLatestTotalTokens(msgs));
-                }
+                refreshMessages();
             }
             // Force remount directly (bypass throttle) to ensure Static items re-render
             // The throttled requestRemount can be dropped if pressed too quickly after
@@ -563,13 +725,14 @@ export const ChatProvider = ({ children, bypassPermissions, permissionMode: init
         isExpanded,
         isTaskListVisible,
         setIsTaskListVisible,
+        isBtwActive,
+        setIsBtwActive,
         queuedMessages,
         sessionId,
         sendMessage,
         askBtw,
         clearMessages,
         compact,
-        goalCommand,
         abortMessage,
         recallQueuedMessage,
         removeQueuedMessageById,
@@ -612,9 +775,6 @@ export const ChatProvider = ({ children, bypassPermissions, permissionMode: init
         workdir,
         recreateAgent,
         triggerWorktreeRemoveHook,
-        isGoalActive,
-        goalElapsed,
-        isGoalEvaluating,
     };
     return (_jsx(ChatContext.Provider, { value: contextValue, children: children }));
 };

package/dist/daemon-cli.d.ts

@@ -0,0 +1,10 @@
+/**
+ * daemon-cli.ts — Entry point for `wave --daemon <socket-path>` mode.
+ *
+ * Starts a DaemonServer that serves JSON-RPC over a unix socket. The desktop
+ * app launches this on a remote host via nohup/setsid and tunnels the socket
+ * back with `ssh -L`; multiple attach/detach cycles share one process, so
+ * sessions and pending permissions survive client disconnects. The net server
+ * keeps the process alive — there is no stdin to wait on.
+ */
+export declare function startDaemonCli(socketPath: string): Promise<void>;

package/dist/daemon-cli.js

@@ -0,0 +1,15 @@
+/**
+ * daemon-cli.ts — Entry point for `wave --daemon <socket-path>` mode.
+ *
+ * Starts a DaemonServer that serves JSON-RPC over a unix socket. The desktop
+ * app launches this on a remote host via nohup/setsid and tunnels the socket
+ * back with `ssh -L`; multiple attach/detach cycles share one process, so
+ * sessions and pending permissions survive client disconnects. The net server
+ * keeps the process alive — there is no stdin to wait on.
+ */
+import { DaemonServer } from "./stdio/daemonServer.js";
+export async function startDaemonCli(socketPath) {
+    const server = new DaemonServer({ socketPath });
+    await server.start();
+    // Ready — any error that follows goes to the daemon log via stderr.
+}

package/dist/hooks/useInputManager.js

@@ -1,10 +1,20 @@
-import { useEffect, useReducer, useCallback } from "react";
-import { inputReducer, initialState, ESC_DOUBLE_PRESS_TIMEOUT_MS, } from "../managers/inputReducer.js";
+import { useEffect, useReducer, useCallback, useRef } from "react";
+import { inputReducer, initialState, ESC_DOUBLE_PRESS_TIMEOUT_MS, btwOverlayActiveRef, } from "../managers/inputReducer.js";
+import { createBracketedPasteDetector } from "../utils/bracketedPaste.js";
 import { searchFiles as searchFilesUtil, PromptHistoryManager, } from "wave-agent-sdk";
 import * as handlers from "../managers/inputHandlers.js";
 export const useInputManager = (callbacks = {}) => {
     const [state, dispatch] = useReducer(inputReducer, initialState);
-    const { onInputTextChange, onCursorPositionChange, onFileSelectorStateChange, onCommandSelectorStateChange, onHistorySearchStateChange, onBackgroundTaskManagerStateChange, onMcpManagerStateChange, onRewindManagerStateChange, onHelpStateChange, onStatusCommandStateChange, onPluginManagerStateChange, onModelSelectorStateChange, onWorkflowManagerStateChange, onImagesStateChange, onSendMessage, onHasSlashCommand, onAbortMessage, onBackgroundCurrentTask, onPermissionModeChange, onAskBtw, sessionId, workdir, getFullMessageThread, logger, hasQueuedMessages: hasQueuedMessagesProp, onRecallQueuedMessage, onClearMessages, onCompact, onGoalCommand, isIdle: isIdleProp, } = callbacks;
+    // Detects bracketed paste (DECSET 2004) markers so pasted text is inserted
+    // without triggering submit — a pasted trailing \r must not be treated as
+    // Enter (see utils/bracketedPaste.ts).
+    const pasteDetectorRef = useRef(createBracketedPasteDetector());
+    // Abort plumbing for the /btw side question: ABORT_BTW (set when the overlay
+    // is dismissed while loading) aborts the in-flight onAskBtw call; the
+    // dismissed ref suppresses the late SET_BTW_STATE dispatch / error logging.
+    const btwAbortRef = useRef(null);
+    const btwDismissedRef = useRef(false);
+    const { onInputTextChange, onCursorPositionChange, onFileSelectorStateChange, onCommandSelectorStateChange, onHistorySearchStateChange, onBackgroundTaskManagerStateChange, onMcpManagerStateChange, onRewindManagerStateChange, onHelpStateChange, onStatusCommandStateChange, onPluginManagerStateChange, onModelSelectorStateChange, onWorkflowManagerStateChange, onImagesStateChange, onSendMessage, onHasSlashCommand, onAbortMessage, onBackgroundCurrentTask, onPermissionModeChange, onAskBtw, sessionId, workdir, getFullMessageThread, logger, hasQueuedMessages: hasQueuedMessagesProp, onRecallQueuedMessage, onClearMessages, onCompact, isIdle: isIdleProp, } = callbacks;
     // Handle debounced file search
     useEffect(() => {
         if (state.showFileSelector) {
@@ -67,25 +77,49 @@ export const useInputManager = (callbacks = {}) => {
                     case "BACKGROUND_CURRENT_TASK":
                         onBackgroundCurrentTask?.();
                         break;
-                    case "ASK_BTW":
+                    case "ASK_BTW": {
+                        const controller = new AbortController();
+                        btwAbortRef.current = controller;
+                        btwDismissedRef.current = false;
                         try {
-                            const answer = await onAskBtw?.(effect.question);
-                            dispatch({
-                                type: "SET_BTW_STATE",
-                                payload: { answer, isLoading: false },
+                            const answer = await onAskBtw?.(effect.question, controller.signal, (content) => {
+                                // Stream partial answers into the overlay so the user sees
+                                // the response grow in real time (same visual language as
+                                // assistant text / thinking blocks) instead of a static
+                                // "Answering..." indicator.
+                                if (!btwDismissedRef.current) {
+                                    dispatch({
+                                        type: "SET_BTW_STATE",
+                                        payload: { answer: content, isLoading: true },
+                                    });
+                                }
                             });
+                            if (!btwDismissedRef.current) {
+                                dispatch({
+                                    type: "SET_BTW_STATE",
+                                    payload: { answer, isLoading: false },
+                                });
+                            }
                         }
                         catch (error) {
-                            console.error("Failed to ask side question:", error);
-                            dispatch({
-                                type: "SET_BTW_STATE",
-                                payload: {
-                                    answer: "Error: Failed to get an answer for your side question.",
-                                    isLoading: false,
-                                },
-                            });
+                            if (!btwDismissedRef.current) {
+                                console.error("Failed to ask side question:", error);
+                                dispatch({
+                                    type: "SET_BTW_STATE",
+                                    payload: {
+                                        answer: "Error: Failed to get an answer for your side question.",
+                                        isLoading: false,
+                                    },
+                                });
+                            }
                         }
                         break;
+                    }
+                    case "ABORT_BTW":
+                        btwDismissedRef.current = true;
+                        btwAbortRef.current?.abort();
+                        btwAbortRef.current = null;
+                        break;
                     case "PERMISSION_MODE_CHANGE":
                         onPermissionModeChange?.(effect.mode);
                         break;
@@ -155,6 +189,18 @@ export const useInputManager = (callbacks = {}) => {
                             else if (command === "logout") {
                                 dispatch({ type: "SET_SHOW_LOGIN_COMMAND", payload: true });
                             }
+                            else if (command === "btw") {
+                                // Bare /btw executed via the command selector — show usage
+                                // (aligned with Claude Code's empty-args message).
+                                dispatch({
+                                    type: "SET_BTW_STATE",
+                                    payload: {
+                                        question: "",
+                                        isLoading: false,
+                                        answer: "Usage: /btw <your question>",
+                                    },
+                                });
+                            }
                             else if (command === "plugin") {
                                 dispatch({ type: "SET_SHOW_PLUGIN_MANAGER", payload: true });
                             }
@@ -170,9 +216,6 @@ export const useInputManager = (callbacks = {}) => {
                             else if (command === "compact") {
                                 await onCompact?.(effect.args);
                             }
-                            else if (command === "goal") {
-                                await onGoalCommand?.(effect.args);
-                            }
                         }
                         break;
                     case "RECALL_QUEUED_MESSAGE":
@@ -200,7 +243,6 @@ export const useInputManager = (callbacks = {}) => {
         onRecallQueuedMessage,
         onClearMessages,
         onCompact,
-        onGoalCommand,
     ]);
     useEffect(() => {
         onFileSelectorStateChange?.(state.showFileSelector, state.filteredFiles, state.fileSearchQuery, state.atPosition);
@@ -253,7 +295,13 @@ export const useInputManager = (callbacks = {}) => {
     useEffect(() => {
         onImagesStateChange?.(state.attachedImages);
     }, [state.attachedImages, onImagesStateChange]);
-    // /btw side question is handled via pendingEffect "ASK_BTW" above
+    // Keep the shared overlay-active flag in sync so App's Ctrl+C exit handler
+    // can defer to the /btw overlay (ink runs ALL useInput handlers per keypress
+    // with no propagation control).
+    useEffect(() => {
+        btwOverlayActiveRef.current =
+            state.btwState.question !== "" || state.btwState.answer !== undefined;
+    }, [state.btwState.question, state.btwState.answer]);
     // Methods
     const insertTextAtCursor = useCallback((text) => {
         dispatch({ type: "INSERT_TEXT", payload: text });
@@ -397,10 +445,39 @@ export const useInputManager = (callbacks = {}) => {
         dispatch({ type: "CLEAR_LONG_TEXT_MAP" });
     }, []);
     const handleInput = useCallback(async (input, key) => {
+        const result = pasteDetectorRef.current.process(input);
+        if (result.kind === "consume") {
+            // Content of an in-flight bracketed paste (or an empty paste):
+            // hold it, never submit or insert prematurely.
+            return true;
+        }
+        if (result.kind === "paste") {
+            if (result.leadingInput) {
+                dispatch({
+                    type: "HANDLE_KEY",
+                    payload: {
+                        input: result.leadingInput,
+                        key,
+                        hasSlashCommand: (cmd) => !!onHasSlashCommand?.(cmd),
+                        hasQueuedMessages: hasQueuedMessagesProp ?? false,
+                        isIdle: isIdleProp ?? false,
+                    },
+                });
+            }
+            if (result.text !== "") {
+                // Insert-only: \r → \n normalizes CRLF terminals, matching the
+                // canonical paste path (inputHandlers.handlePasteInput).
+                dispatch({
+                    type: "INSERT_TEXT_WITH_PLACEHOLDER",
+                    payload: result.text.replace(/\r/g, "\n"),
+                });
+            }
+            return true;
+        }
         dispatch({
             type: "HANDLE_KEY",
             payload: {
-                input,
+                input: result.input,
                 key,
                 hasSlashCommand: (cmd) => !!onHasSlashCommand?.(cmd),
                 hasQueuedMessages: hasQueuedMessagesProp ?? false,

package/dist/index.js

@@ -44,6 +44,11 @@ export async function main() {
             type: "boolean",
             default: false,
             global: false,
+        })
+            .option("daemon", {
+            description: "Start as a background daemon (JSON-RPC over a unix socket at PATH)",
+            type: "string",
+            global: false,
         })
             .option("show-stats", {
             description: "Show timing and usage statistics in print mode",
@@ -300,6 +305,11 @@ export async function main() {
             const { startStdioCli } = await import("./stdio-cli.js");
             return startStdioCli();
         }
+        // Handle daemon mode (remote background sessions)
+        if (typeof argv.daemon === "string") {
+            const { startDaemonCli } = await import("./daemon-cli.js");
+            return startDaemonCli(argv.daemon);
+        }
         await startCli({
             restoreSessionId: argv.restore,
             continueLastSession: argv.continue,