wave-code 0.19.9 → 1.0.1

package/src/managers/inputReducer.ts

@@ -27,6 +27,16 @@ export interface BtwState {
   isLoading: boolean;
 }
 
+/**
+ * True while the /btw overlay is up (a question is on display, loading or
+ * answered). App's Ctrl+C exit handler checks this so Ctrl+C does not quit
+ * the app while the overlay owns the keys. Synced from useInputManager via
+ * an effect.
+ */
+export const btwOverlayActiveRef: { current: boolean } = { current: false };
+
+export const ESC_DOUBLE_PRESS_TIMEOUT_MS = 1000;
+
 export type PendingEffect =
   | {
       type: "SEND_MESSAGE";
@@ -34,9 +44,15 @@ export type PendingEffect =
       images?: Array<{ path: string; mimeType: string }>;
       longTextMap: Record<string, string>;
     }
+  | {
+      type: "SAVE_PROMPT_HISTORY";
+      content: string;
+      longTextMap: Record<string, string>;
+    }
   | { type: "ABORT_MESSAGE" }
   | { type: "BACKGROUND_CURRENT_TASK" }
   | { type: "ASK_BTW"; question: string }
+  | { type: "ABORT_BTW" }
   | { type: "PERMISSION_MODE_CHANGE"; mode: PermissionMode }
   | { type: "FETCH_HISTORY" }
   | { type: "PASTE_IMAGE" }
@@ -76,10 +92,13 @@ export interface InputManagerCallbacks {
   onAbortMessage?: () => void;
   onBackgroundCurrentTask?: () => void;
   onPermissionModeChange?: (mode: PermissionMode) => void;
-  onAskBtw?: (question: string) => Promise<string>;
+  onAskBtw?: (
+    question: string,
+    abortSignal?: AbortSignal,
+    onContent?: (content: string) => void,
+  ) => Promise<string>;
   onClearMessages?: () => Promise<void>;
   onCompact?: (instructions?: string) => Promise<void>;
-  onGoalCommand?: (args?: string) => Promise<void>;
   sessionId?: string;
   workdir?: string;
   getFullMessageThread?: () => Promise<{
@@ -88,6 +107,7 @@ export interface InputManagerCallbacks {
   }>;
   logger?: Logger;
   hasQueuedMessages?: boolean;
+  isIdle?: boolean;
   onRecallQueuedMessage?: () => void;
 }
 
@@ -118,9 +138,6 @@ export interface InputState {
   showWorkflowManager: boolean;
   permissionMode: PermissionMode;
   selectorJustUsed: boolean;
-  isPasting: boolean;
-  pasteBuffer: string;
-  initialPasteCursorPosition: number;
   history: PromptEntry[];
   historyIndex: number;
   originalInputText: string;
@@ -128,6 +145,7 @@ export interface InputState {
   isFileSearching: boolean;
   btwState: BtwState;
   pendingEffect: PendingEffect | null;
+  escClearPending: boolean;
 }
 
 export const initialState: InputState = {
@@ -157,9 +175,6 @@ export const initialState: InputState = {
   showWorkflowManager: false,
   permissionMode: "default",
   selectorJustUsed: false,
-  isPasting: false,
-  pasteBuffer: "",
-  initialPasteCursorPosition: 0,
   history: [],
   historyIndex: -1,
   originalInputText: "",
@@ -170,8 +185,199 @@ export const initialState: InputState = {
     isLoading: false,
   },
   pendingEffect: null,
+  escClearPending: false,
 };
 
+/**
+ * Insert text at the cursor position, folding text longer than 200 chars
+ * into a [LongText#N] placeholder. Shared by the INSERT_TEXT_WITH_PLACEHOLDER
+ * action and multi-char chunk inserts (typed bursts, terminal paste, tmux
+ * send-keys).
+ */
+function insertTextWithPlaceholder(
+  textToInsert: string,
+  state: InputState,
+): InputState {
+  let text = textToInsert;
+  let newLongTextCounter = state.longTextCounter;
+  const newLongTextMap = { ...state.longTextMap };
+
+  if (text.length > 200) {
+    newLongTextCounter += 1;
+    const placeholderLabel = `[LongText#${newLongTextCounter}]`;
+    newLongTextMap[placeholderLabel] = text;
+    text = placeholderLabel;
+  }
+
+  const beforeCursor = state.inputText.substring(0, state.cursorPosition);
+  const afterCursor = state.inputText.substring(state.cursorPosition);
+  const newText = beforeCursor + text + afterCursor;
+  const newCursorPosition = state.cursorPosition + text.length;
+
+  const newState: InputState = {
+    ...state,
+    inputText: newText,
+    cursorPosition: newCursorPosition,
+    longTextCounter: newLongTextCounter,
+    longTextMap: newLongTextMap,
+    historyIndex: -1,
+  };
+
+  // Sync selectors
+  const atPos = getAtSelectorPosition(newText, newCursorPosition);
+  if (atPos !== -1 && !newState.showFileSelector) {
+    newState.showFileSelector = true;
+    newState.atPosition = atPos;
+    newState.isFileSearching = true;
+  }
+
+  const slashPos = getSlashSelectorPosition(newText, newCursorPosition);
+  if (slashPos !== -1 && !newState.showCommandSelector) {
+    newState.showCommandSelector = true;
+    newState.slashPosition = slashPos;
+  }
+
+  if (newState.showFileSelector && newState.atPosition >= 0) {
+    newState.fileSearchQuery = newText.substring(
+      newState.atPosition + 1,
+      newCursorPosition,
+    );
+  } else if (newState.showCommandSelector && newState.slashPosition >= 0) {
+    newState.commandSearchQuery = newText.substring(
+      newState.slashPosition + 1,
+      newCursorPosition,
+    );
+  }
+
+  return newState;
+}
+
+/**
+ * Submit the current input text: extract [Image #N] references, route /btw
+ * and CLI-internal slash commands, otherwise send as a message. Returns null
+ * when there is nothing to submit (empty text).
+ */
+function submitInput(state: InputState): InputState | null {
+  if (!state.inputText.trim()) {
+    return null;
+  }
+  const imageRegex = /\[Image #(\d+)\]/g;
+  const matches = [...state.inputText.matchAll(imageRegex)];
+  const referencedImages = matches
+    .map((match) => {
+      const imageId = parseInt(match[1], 10);
+      return state.attachedImages.find((img) => img.id === imageId);
+    })
+    .filter((img): img is AttachedImage => img !== undefined)
+    .map((img) => ({ path: img.path, mimeType: img.mimeType }));
+
+  const contentWithPlaceholders = state.inputText
+    .replace(imageRegex, "")
+    .trim();
+
+  if (contentWithPlaceholders.startsWith("/btw ")) {
+    const question = contentWithPlaceholders.substring(5).trim();
+    if (!question) {
+      // "/btw " with no question text — show usage (aligned with Claude Code)
+      return {
+        ...state,
+        inputText: "",
+        cursorPosition: 0,
+        historyIndex: -1,
+        longTextMap: {},
+        attachedImages: [],
+        btwState: {
+          question: "",
+          isLoading: false,
+          answer: "Usage: /btw <your question>",
+        },
+      };
+    }
+
+    return {
+      ...state,
+      inputText: "",
+      cursorPosition: 0,
+      historyIndex: -1,
+      longTextMap: {},
+      attachedImages: [],
+      btwState: {
+        question,
+        isLoading: true,
+        answer: undefined,
+      },
+      pendingEffect: { type: "ASK_BTW", question },
+    };
+  }
+
+  if (contentWithPlaceholders === "/btw") {
+    // Bare /btw — show usage (aligned with Claude Code)
+    return {
+      ...state,
+      inputText: "",
+      cursorPosition: 0,
+      historyIndex: -1,
+      longTextMap: {},
+      attachedImages: [],
+      btwState: {
+        question: "",
+        isLoading: false,
+        answer: "Usage: /btw <your question>",
+      },
+    };
+  }
+
+  // Check if the content is a CLI-internal slash command (help, tasks,
+  // etc.) that should be executed locally rather than sent as a message.
+  // Agent slash commands and unknown /commands always go to SEND_MESSAGE.
+  if (contentWithPlaceholders.startsWith("/")) {
+    const spaceIndex = contentWithPlaceholders.indexOf(" ");
+    const commandName =
+      spaceIndex === -1
+        ? contentWithPlaceholders.substring(1)
+        : contentWithPlaceholders.substring(1, spaceIndex);
+
+    const isInternalCommand = AVAILABLE_COMMANDS.some(
+      (cmd) => cmd.id === commandName,
+    );
+    if (isInternalCommand) {
+      const argsText =
+        spaceIndex === -1
+          ? undefined
+          : contentWithPlaceholders.substring(spaceIndex + 1).trim() ||
+            undefined;
+      return {
+        ...state,
+        inputText: "",
+        cursorPosition: 0,
+        historyIndex: -1,
+        longTextMap: {},
+        attachedImages: [],
+        pendingEffect: {
+          type: "EXECUTE_COMMAND",
+          command: commandName,
+          args: argsText,
+        },
+      };
+    }
+  }
+
+  return {
+    ...state,
+    inputText: "",
+    cursorPosition: 0,
+    historyIndex: -1,
+    longTextMap: {},
+    attachedImages: [],
+    pendingEffect: {
+      type: "SEND_MESSAGE",
+      content: contentWithPlaceholders,
+      images: referencedImages.length > 0 ? referencedImages : undefined,
+      longTextMap: state.longTextMap,
+    },
+  };
+}
+
 export type InputAction =
   | { type: "SET_INPUT_TEXT"; payload: string }
   | { type: "SET_CURSOR_POSITION"; payload: number }
@@ -205,13 +411,6 @@ export type InputAction =
   | { type: "INSERT_TEXT_WITH_PLACEHOLDER"; payload: string }
   | { type: "CLEAR_LONG_TEXT_MAP" }
   | { type: "CLEAR_INPUT" }
-  | { type: "START_PASTE"; payload: { buffer: string; cursorPosition: number } }
-  | { type: "APPEND_PASTE_BUFFER"; payload: string }
-  | {
-      type: "APPEND_PASTE_CHUNK";
-      payload: { chunk: string; cursorPosition: number };
-    }
-  | { type: "END_PASTE" }
   | {
       type: "ADD_IMAGE_AND_INSERT_PLACEHOLDER";
       payload: { path: string; mimeType: string };
@@ -225,6 +424,7 @@ export type InputAction =
   | { type: "SELECT_FILE"; payload: string }
   | { type: "SET_BTW_STATE"; payload: Partial<BtwState> }
   | { type: "CLEAR_PENDING_EFFECT" }
+  | { type: "RESET_ESC_CLEAR_PENDING" }
   | {
       type: "HANDLE_KEY";
       payload: {
@@ -232,6 +432,7 @@ export type InputAction =
         key: Key;
         hasSlashCommand: (cmd: string) => boolean;
         hasQueuedMessages?: boolean;
+        isIdle?: boolean;
       };
     };
 
@@ -433,60 +634,8 @@ export function inputReducer(
       return { ...state, permissionMode: action.payload };
     case "SET_SELECTOR_JUST_USED":
       return { ...state, selectorJustUsed: action.payload };
-    case "INSERT_TEXT_WITH_PLACEHOLDER": {
-      let textToInsert = action.payload;
-      let newLongTextCounter = state.longTextCounter;
-      const newLongTextMap = { ...state.longTextMap };
-
-      if (textToInsert.length > 200) {
-        newLongTextCounter += 1;
-        const placeholderLabel = `[LongText#${newLongTextCounter}]`;
-        newLongTextMap[placeholderLabel] = textToInsert;
-        textToInsert = placeholderLabel;
-      }
-
-      const beforeCursor = state.inputText.substring(0, state.cursorPosition);
-      const afterCursor = state.inputText.substring(state.cursorPosition);
-      const newText = beforeCursor + textToInsert + afterCursor;
-      const newCursorPosition = state.cursorPosition + textToInsert.length;
-
-      const newState: InputState = {
-        ...state,
-        inputText: newText,
-        cursorPosition: newCursorPosition,
-        longTextCounter: newLongTextCounter,
-        longTextMap: newLongTextMap,
-        historyIndex: -1,
-      };
-
-      // Sync selectors
-      const atPos = getAtSelectorPosition(newText, newCursorPosition);
-      if (atPos !== -1 && !newState.showFileSelector) {
-        newState.showFileSelector = true;
-        newState.atPosition = atPos;
-        newState.isFileSearching = true;
-      }
-
-      const slashPos = getSlashSelectorPosition(newText, newCursorPosition);
-      if (slashPos !== -1 && !newState.showCommandSelector) {
-        newState.showCommandSelector = true;
-        newState.slashPosition = slashPos;
-      }
-
-      if (newState.showFileSelector && newState.atPosition >= 0) {
-        newState.fileSearchQuery = newText.substring(
-          newState.atPosition + 1,
-          newCursorPosition,
-        );
-      } else if (newState.showCommandSelector && newState.slashPosition >= 0) {
-        newState.commandSearchQuery = newText.substring(
-          newState.slashPosition + 1,
-          newCursorPosition,
-        );
-      }
-
-      return newState;
-    }
+    case "INSERT_TEXT_WITH_PLACEHOLDER":
+      return insertTextWithPlaceholder(action.payload, state);
     case "CLEAR_LONG_TEXT_MAP":
       return { ...state, longTextMap: {} };
     case "CLEAR_INPUT":
@@ -496,39 +645,6 @@ export function inputReducer(
         cursorPosition: 0,
         historyIndex: -1,
       };
-    case "APPEND_PASTE_CHUNK": {
-      // The reducer determines if this is a new paste or a continuation
-      // by checking if pasteBuffer is already set. This avoids the
-      // handler needing to track isPasting state, which can be stale
-      // when multiple dispatches fire before React state updates.
-      const isNewPaste = !state.pasteBuffer;
-      return {
-        ...state,
-        isPasting: true,
-        pasteBuffer: state.pasteBuffer + action.payload.chunk,
-        initialPasteCursorPosition: isNewPaste
-          ? action.payload.cursorPosition
-          : state.initialPasteCursorPosition,
-      };
-    }
-    case "START_PASTE":
-      return {
-        ...state,
-        isPasting: true,
-        pasteBuffer: action.payload.buffer,
-        initialPasteCursorPosition: action.payload.cursorPosition,
-      };
-    case "APPEND_PASTE_BUFFER":
-      return {
-        ...state,
-        pasteBuffer: state.pasteBuffer + action.payload,
-      };
-    case "END_PASTE":
-      return {
-        ...state,
-        isPasting: false,
-        pasteBuffer: "",
-      };
     case "ADD_IMAGE_AND_INSERT_PLACEHOLDER": {
       const newImage: AttachedImage = {
         id: state.imageIdCounter,
@@ -685,14 +801,115 @@ export function inputReducer(
       };
     case "CLEAR_PENDING_EFFECT":
       return { ...state, pendingEffect: null };
+    case "RESET_ESC_CLEAR_PENDING":
+      return { ...state, escClearPending: false };
     case "HANDLE_KEY": {
       const { input, key } = action.payload;
       const hasQueuedMessages = action.payload.hasQueuedMessages ?? false;
+      const isIdle = action.payload.isIdle ?? false;
 
-      // 1. Escape Handling
-      if (key.escape) {
-        // Dismiss btw answer
-        if (state.btwState.question && !state.btwState.isLoading) {
+      // 0. Raw DEL (\x7f) filtering.
+      // SSH/tmux auto-repeat backspace coalesces multiple DEL bytes into one
+      // chunk (e.g. "\x7f\x7f") that ink cannot parse into a key event, so it
+      // arrives as raw input and would otherwise be treated as a paste and
+      // inserted literally. Treat each DEL as a synchronous backspace instead
+      // (aligned with Claude Code Issue #1853).
+      if (!key.backspace && !key.delete && input.includes("\x7f")) {
+        const delCount = (input.match(/\x7f/g) || []).length;
+
+        if (state.showHistorySearch) {
+          return {
+            ...state,
+            historySearchQuery: state.historySearchQuery.slice(0, -delCount),
+          };
+        }
+
+        if (state.cursorPosition > 0) {
+          const newCursorPosition = Math.max(
+            0,
+            state.cursorPosition - delCount,
+          );
+          const newInputText =
+            state.inputText.substring(0, newCursorPosition) +
+            state.inputText.substring(state.cursorPosition);
+
+          const newState = {
+            ...state,
+            inputText: newInputText,
+            cursorPosition: newCursorPosition,
+            historyIndex: -1,
+          };
+
+          // Deactivate selectors if their trigger character was deleted
+          if (
+            newState.showFileSelector &&
+            newCursorPosition <= newState.atPosition
+          ) {
+            newState.showFileSelector = false;
+            newState.atPosition = -1;
+            newState.fileSearchQuery = "";
+            newState.isFileSearching = false;
+          }
+          if (
+            newState.showCommandSelector &&
+            newCursorPosition <= newState.slashPosition
+          ) {
+            newState.showCommandSelector = false;
+            newState.slashPosition = -1;
+            newState.commandSearchQuery = "";
+          }
+
+          // Reactivate selectors if cursor is within a trigger word
+          const atPos = getAtSelectorPosition(newInputText, newCursorPosition);
+          if (atPos !== -1 && !state.showFileSelector) {
+            newState.showFileSelector = true;
+            newState.atPosition = atPos;
+            newState.isFileSearching = true;
+          }
+          const slashPos = getSlashSelectorPosition(
+            newInputText,
+            newCursorPosition,
+          );
+          if (slashPos !== -1 && !state.showCommandSelector) {
+            newState.showCommandSelector = true;
+            newState.slashPosition = slashPos;
+          }
+
+          // Update queries
+          if (newState.showFileSelector && newState.atPosition >= 0) {
+            newState.fileSearchQuery = newInputText.substring(
+              newState.atPosition + 1,
+              newCursorPosition,
+            );
+          }
+          if (newState.showCommandSelector && newState.slashPosition >= 0) {
+            newState.commandSearchQuery = newInputText.substring(
+              newState.slashPosition + 1,
+              newCursorPosition,
+            );
+          }
+
+          return newState;
+        }
+        return state;
+      }
+
+      // 1. /btw overlay handling (active while a question is displayed, or
+      // the bare-/btw usage message). Only Escape dismisses (or aborts the
+      // in-flight side question while loading); every other key is ignored.
+      if (state.btwState.question || state.btwState.answer) {
+        if (key.escape) {
+          if (state.btwState.isLoading) {
+            return {
+              ...state,
+              btwState: {
+                question: "",
+                answer: undefined,
+                isLoading: false,
+              },
+              pendingEffect: { type: "ABORT_BTW" },
+            };
+          }
           return {
             ...state,
             btwState: {
@@ -702,6 +919,13 @@ export function inputReducer(
             },
           };
         }
+
+        // Any other key while the overlay is up is ignored
+        return state;
+      }
+
+      // 1. Escape Handling
+      if (key.escape) {
         if (state.showFileSelector) {
           return {
             ...state,
@@ -754,7 +978,39 @@ export function inputReducer(
             state.showWorkflowManager
           )
         ) {
-          return { ...state, pendingEffect: { type: "ABORT_MESSAGE" } };
+          // While AI is running (or any busy state) Esc keeps the abort
+          // semantics. Only when idle does Esc fall through to the text-level
+          // double-press clear (aligned with Claude Code's mutual-exclusion
+          // design: Esc aborts only when a task is running).
+          if (!isIdle) {
+            return {
+              ...state,
+              escClearPending: false,
+              pendingEffect: { type: "ABORT_MESSAGE" },
+            };
+          }
+          // Idle: double-press Esc clears the input and saves to history.
+          if (state.inputText) {
+            if (state.escClearPending) {
+              const originalText = state.inputText;
+              const originalLongTextMap = state.longTextMap;
+              return {
+                ...state,
+                inputText: "",
+                cursorPosition: 0,
+                historyIndex: -1,
+                longTextMap: {},
+                escClearPending: false,
+                pendingEffect: {
+                  type: "SAVE_PROMPT_HISTORY",
+                  content: originalText,
+                  longTextMap: originalLongTextMap,
+                },
+              };
+            }
+            return { ...state, escClearPending: true };
+          }
+          return state;
         }
         return state;
       }
@@ -797,6 +1053,59 @@ export function inputReducer(
         };
       }
 
+      // Emacs-style line editing (aligned with Claude Code): Ctrl+A/E move the
+      // cursor to line start/end, Ctrl+U/K delete to line start/end, Ctrl+W
+      // deletes the word before the cursor. Skipped while a selector is open.
+      if (
+        key.ctrl &&
+        input &&
+        !state.showFileSelector &&
+        !state.showCommandSelector &&
+        !state.showHistorySearch
+      ) {
+        const editKey = input.toLowerCase();
+        if (editKey === "a") {
+          return { ...state, cursorPosition: 0 };
+        }
+        if (editKey === "e") {
+          return { ...state, cursorPosition: state.inputText.length };
+        }
+        if (editKey === "u") {
+          return {
+            ...state,
+            inputText: state.inputText.substring(state.cursorPosition),
+            cursorPosition: 0,
+            historyIndex: -1,
+          };
+        }
+        if (editKey === "k") {
+          return {
+            ...state,
+            inputText: state.inputText.substring(0, state.cursorPosition),
+            historyIndex: -1,
+          };
+        }
+        if (editKey === "w") {
+          // Find the start of the word before the cursor (skip trailing
+          // whitespace, then the word itself).
+          let start = state.cursorPosition - 1;
+          while (start >= 0 && /\s/.test(state.inputText[start])) {
+            start--;
+          }
+          while (start >= 0 && !/\s/.test(state.inputText[start])) {
+            start--;
+          }
+          return {
+            ...state,
+            inputText:
+              state.inputText.substring(0, start + 1) +
+              state.inputText.substring(state.cursorPosition),
+            cursorPosition: start + 1,
+            historyIndex: -1,
+          };
+        }
+      }
+
       // 4. History Navigation
       if (
         key.upArrow &&
@@ -980,101 +1289,7 @@ export function inputReducer(
 
       // 6. Return / Submit
       if (key.return) {
-        if (state.inputText.trim()) {
-          const imageRegex = /\[Image #(\d+)\]/g;
-          const matches = [...state.inputText.matchAll(imageRegex)];
-          const referencedImages = matches
-            .map((match) => {
-              const imageId = parseInt(match[1], 10);
-              return state.attachedImages.find((img) => img.id === imageId);
-            })
-            .filter((img): img is AttachedImage => img !== undefined)
-            .map((img) => ({ path: img.path, mimeType: img.mimeType }));
-
-          const contentWithPlaceholders = state.inputText
-            .replace(imageRegex, "")
-            .trim();
-
-          if (contentWithPlaceholders.startsWith("/btw ")) {
-            const question = contentWithPlaceholders.substring(5).trim();
-            if (!question) {
-              // Bare /btw with no question text — ignore
-              return state;
-            }
-
-            return {
-              ...state,
-              inputText: "",
-              cursorPosition: 0,
-              historyIndex: -1,
-              longTextMap: {},
-              attachedImages: [],
-              btwState: {
-                question,
-                isLoading: true,
-                answer: undefined,
-              },
-              pendingEffect: { type: "ASK_BTW", question },
-            };
-          }
-
-          if (contentWithPlaceholders === "/btw") {
-            // Bare /btw — ignore
-            return state;
-          }
-
-          // Check if the content is a CLI-internal slash command (help, tasks,
-          // etc.) that should be executed locally rather than sent as a message.
-          // Agent slash commands and unknown /commands always go to SEND_MESSAGE.
-          if (contentWithPlaceholders.startsWith("/")) {
-            const spaceIndex = contentWithPlaceholders.indexOf(" ");
-            const commandName =
-              spaceIndex === -1
-                ? contentWithPlaceholders.substring(1)
-                : contentWithPlaceholders.substring(1, spaceIndex);
-
-            const isInternalCommand = AVAILABLE_COMMANDS.some(
-              (cmd) => cmd.id === commandName,
-            );
-            if (isInternalCommand) {
-              const argsText =
-                spaceIndex === -1
-                  ? undefined
-                  : contentWithPlaceholders.substring(spaceIndex + 1).trim() ||
-                    undefined;
-              return {
-                ...state,
-                inputText: "",
-                cursorPosition: 0,
-                historyIndex: -1,
-                longTextMap: {},
-                attachedImages: [],
-                pendingEffect: {
-                  type: "EXECUTE_COMMAND",
-                  command: commandName,
-                  args: argsText,
-                },
-              };
-            }
-          }
-
-          return {
-            ...state,
-            inputText: "",
-            cursorPosition: 0,
-            historyIndex: -1,
-            longTextMap: {},
-            attachedImages: [],
-            pendingEffect: {
-              type: "SEND_MESSAGE",
-              content: contentWithPlaceholders,
-              images:
-                referencedImages.length > 0 ? referencedImages : undefined,
-              longTextMap: state.longTextMap,
-            },
-          };
-        }
-        return state;
+        return submitInput(state) ?? state;
       }
 
       // 7. Regular Input
@@ -1090,19 +1305,32 @@ export function inputReducer(
         !("home" in key && key.home) &&
         !("end" in key && key.end)
       ) {
-        const isPasteOperation =
-          input.length > 1 || input.includes("\n") || input.includes("\r");
+        // SSH-coalesced Enter: on slow links, "text" + Enter arrive as one
+        // chunk ("o\r"). ink's parseKeypress only matches a lone \r, so
+        // key.return is false here. Text with exactly one trailing \r is a
+        // coalesced Enter — strip the \r, insert, and submit immediately
+        // (aligned with Claude Code's useTextInput).
+        const isCoalescedEnter =
+          input.length > 1 &&
+          input.endsWith("\r") &&
+          !input.slice(0, -1).includes("\r") &&
+          // Backslash+CR is a stale VS Code Shift+Enter binding, not a
+          // coalesced Enter — keep it as regular input.
+          input[input.length - 2] !== "\\";
 
-        if (isPasteOperation) {
-          const isNewPaste = !state.pasteBuffer;
-          return {
-            ...state,
-            isPasting: true,
-            pasteBuffer: state.pasteBuffer + input,
-            initialPasteCursorPosition: isNewPaste
-              ? state.cursorPosition
-              : state.initialPasteCursorPosition,
-          };
+        if (isCoalescedEnter) {
+          const insertedState = insertTextWithPlaceholder(
+            input.slice(0, -1),
+            state,
+          );
+          return submitInput(insertedState) ?? insertedState;
+        }
+
+        if (input.length > 1) {
+          // Multi-char chunk (typed burst, terminal paste, tmux send-keys):
+          // insert immediately — no debounce or paste buffer. \r → \n
+          // normalizes carriage returns from CRLF terminals.
+          return insertTextWithPlaceholder(input.replace(/\r/g, "\n"), state);
         } else {
           let char = input;
           if (char === "！" && state.cursorPosition === 0) {