jeo-code 0.7.24 → 0.7.26

package/CHANGELOG.md

@@ -6,6 +6,27 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 The README mirrors the latest 5 entries — regenerate with `bun run changelog:sync`.
 
+## [0.7.26] - 2026-07-02
+_Esc/Ctrl+C reliably clears the input box (fixes a gate the earlier reorder missed), and un-bracketed multi-line pastes no longer shred into premature per-line submits._
+
+### Fixed
+- **Esc (and meta-mapped Cmd+C) at the prompt intermittently did nothing.** A prior fix reordered the Esc check ahead of the `previewPending` reentrancy gate, but missed an earlier, more totalizing `!previewArmed || pickerActive` gate that Ctrl+C already bypassed (checked first) while Esc did not — so a fresh session's very first Esc after typing could be silently swallowed. The Esc/meta+C check now runs immediately after the Ctrl+C check, before that gate, mirroring Ctrl+C's existing precedent. Verified live in a real `jeo` TUI (tmux-driven keystrokes): 10/10 fresh-session repro attempts now clear the box; previously flaky.
+- **Un-bracketed multi-line paste shredded into separate premature submits.** Terminals/paths that deliver a multi-line paste as ONE stdin chunk WITHOUT bracketed-paste markers (DECSET 2004) — e.g. a raw X11 primary-selection middle-click paste, some SSH clients, or a tmux `paste-buffer` binding without `-p` — hit `filterPromptInputChunk`'s bare `\r`/`\n` pass-through and had each embedded line submitted as its own message mid-composition instead of landing as one multi-line draft. Reproduced live: pasting `"first line\nsecond line\nthird line"` via an un-bracketed tmux paste immediately submitted line 1 to the model, leaving the rest to leak in as orphaned lines. Fixed with a guard in `src/commands/launch/input.ts`: outside an active bracketed paste, a linebreak with MORE data after it in the SAME synchronous chunk (impossible for a genuine standalone Enter keypress, which always arrives as the last byte of its read) now folds to the multi-line sentinel instead of submitting — matching the bracketed-paste contract (review the whole block, then press Enter once). A trailing linebreak with nothing after it is unaffected and still submits normally.
+
+### Verified
+- `bun run typecheck` clean; full suite green — 2077 pass / 0 fail across 239 files (4 new cases in `test/prompt-key-filter.test.ts` covering the un-bracketed paste guard, including a no-false-positive check for ordinary single-line typing).
+- Both fixes reproduced and confirmed live in a real running `jeo --no-session` TUI inside tmux (not just unit tests): the exact 3-line un-bracketed paste that previously triggered a premature submit now stays as one multi-line draft, and Esc immediately clears it.
+
+## [0.7.25] - 2026-07-02
+_Shift+Enter now reliably distinguishable from Enter on kitty/WezTerm/iTerm2/xterm via modifyOtherKeys + kitty keyboard protocol; row-aware Home/End and Cmd+Left/Right in multi-row drafts._
+
+### Added
+- **modifyOtherKeys + kitty keyboard protocol on launch.** `enableModifyOtherKeys()` (`CSI >4;2m`) and `enableKittyKeyboard()` (`CSI >1u`) are sent to the terminal at REPL startup so Shift+Enter is distinguishable from plain Enter on every modern terminal that supports either protocol. Terminals that support neither silently ignore both sequences. Both modes are restored to defaults (`CSI >4;0m` / `CSI >0u`) on process exit via `process.once("exit", …)`. Four new exports in `src/tui/terminal.ts`: `enableModifyOtherKeys`, `disableModifyOtherKeys`, `enableKittyKeyboard`, `disableKittyKeyboard`.
+- **Row-aware Home/End (and macOS Cmd+Left/Right) in multi-row input.** `ROW_HOME_SEQS` / `ROW_END_SEQS` sequences are now caught by `filterPromptInputChunk` _before_ the old whole-buffer `CURSOR_COMBO_REWRITES` path. `rowBoundaryOffset()` (new export in `input-box.ts`) walks the same `caretCells` grid as vertical navigation and jumps the caret to the start/end of the current **visual row**, degenerating to `0`/`length` on a single-row draft — matching macOS/editor convention of "start/end of THIS line".
+
+### Verified
+- `bun run typecheck` clean; full suite green — 2073 pass / 0 fail across 239 files — including two new test files: `test/row-boundary.test.ts` (9 cases for `rowBoundaryOffset`) and `test/row-home-end-filter.test.ts` (5 cases for filter-level row-aware Home/End).
+
 ## [0.7.24] - 2026-07-02
 _OAuth callback page redesign with embedded jeo wordmark + Close button; memory budget O(n²)→O(n) incremental tracking fix._
 

package/README.ja.md

@@ -205,11 +205,11 @@ CI は `.github/workflows/npm-publish.yml` で公開します — GitHub リリ
 ## 変更履歴 (Changelog)
 
 <!-- CHANGELOG:START (auto-generated from CHANGELOG.md — run `bun run changelog:sync`) -->
+- **[0.7.26]** (2026-07-02) — Esc/Ctrl+C reliably clears the input box (fixes a gate the earlier reorder missed), and un-bracketed multi-line pastes no longer shred into premature per-line submits.
+- **[0.7.25]** (2026-07-02) — Shift+Enter now reliably distinguishable from Enter on kitty/WezTerm/iTerm2/xterm via modifyOtherKeys + kitty keyboard protocol; row-aware Home/End and Cmd+Left/Right in multi-row drafts.
 - **[0.7.24]** (2026-07-02) — OAuth callback page redesign with embedded jeo wordmark + Close button; memory budget O(n²)→O(n) incremental tracking fix.
 - **[0.7.23]** (2026-07-01) — Anthropic 5th-generation model catalog: adds Sonnet 5, Fable 5, and Mythos 5, promotes the 4.6 generation to 1M context / 128k output, and retires the superseded 4.5/3.5/4.1 ids. Bumps the default model to Sonnet 4.6, prices the new tiers, and fixes the thinking transport for Haiku 4.5 and every 5th-gen model.
 - **[0.7.22]** (2026-06-30) — gajae-code 0.7.3–0.7.8 parity sweep: terminal-bell notifications, a gruvbox-dark TUI theme, a resilient `jeo update` runtime check, and an ultragoal artifact gate. Ports the user-facing improvements from upstream gajae-code that jeo did not yet have, re-implemented to fit jeo's config, command, theming, and skill surfaces.
-- **[0.7.21]** (2026-06-26) — Global llm-wiki vault integration, Gemini/Antigravity thinking indicators, generous file-reading windows, and autopilot flag validation. Adds a shared global wiki root configuration with a /wiki slash command, fires reasoning start signals up front for Gemini/Antigravity models, adjusts the large-file reading discipline to use generous windows, and validates autopilot goal and integer flags.
-- **[0.7.20]** (2026-06-26) — OKF concept-memory retrieval gains a hybrid reranker ported from memsearch. Injection priority no longer rides one raw keyword score — it fuses two complementary ranked channels by Reciprocal Rank Fusion (RRF): IDF-weighted lexical relevance (the sparse/BM25 channel, so rare discriminating terms steer recall) and concept-graph proximity (the local dense/semantic-neighbour channel, so a hub linked from multiple query hits surfaces even with no keyword of its own). All embedding-free and deterministic, layered atop the existing failure-first tier and pinned-invariant reserved budget.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/README.ko.md

@@ -205,11 +205,11 @@ CI는 `.github/workflows/npm-publish.yml`로 배포합니다 — GitHub 릴리
 ## 변경 이력 (Changelog)
 
 <!-- CHANGELOG:START (auto-generated from CHANGELOG.md — run `bun run changelog:sync`) -->
+- **[0.7.26]** (2026-07-02) — Esc/Ctrl+C reliably clears the input box (fixes a gate the earlier reorder missed), and un-bracketed multi-line pastes no longer shred into premature per-line submits.
+- **[0.7.25]** (2026-07-02) — Shift+Enter now reliably distinguishable from Enter on kitty/WezTerm/iTerm2/xterm via modifyOtherKeys + kitty keyboard protocol; row-aware Home/End and Cmd+Left/Right in multi-row drafts.
 - **[0.7.24]** (2026-07-02) — OAuth callback page redesign with embedded jeo wordmark + Close button; memory budget O(n²)→O(n) incremental tracking fix.
 - **[0.7.23]** (2026-07-01) — Anthropic 5th-generation model catalog: adds Sonnet 5, Fable 5, and Mythos 5, promotes the 4.6 generation to 1M context / 128k output, and retires the superseded 4.5/3.5/4.1 ids. Bumps the default model to Sonnet 4.6, prices the new tiers, and fixes the thinking transport for Haiku 4.5 and every 5th-gen model.
 - **[0.7.22]** (2026-06-30) — gajae-code 0.7.3–0.7.8 parity sweep: terminal-bell notifications, a gruvbox-dark TUI theme, a resilient `jeo update` runtime check, and an ultragoal artifact gate. Ports the user-facing improvements from upstream gajae-code that jeo did not yet have, re-implemented to fit jeo's config, command, theming, and skill surfaces.
-- **[0.7.21]** (2026-06-26) — Global llm-wiki vault integration, Gemini/Antigravity thinking indicators, generous file-reading windows, and autopilot flag validation. Adds a shared global wiki root configuration with a /wiki slash command, fires reasoning start signals up front for Gemini/Antigravity models, adjusts the large-file reading discipline to use generous windows, and validates autopilot goal and integer flags.
-- **[0.7.20]** (2026-06-26) — OKF concept-memory retrieval gains a hybrid reranker ported from memsearch. Injection priority no longer rides one raw keyword score — it fuses two complementary ranked channels by Reciprocal Rank Fusion (RRF): IDF-weighted lexical relevance (the sparse/BM25 channel, so rare discriminating terms steer recall) and concept-graph proximity (the local dense/semantic-neighbour channel, so a hub linked from multiple query hits surfaces even with no keyword of its own). All embedding-free and deterministic, layered atop the existing failure-first tier and pinned-invariant reserved budget.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/README.md

@@ -232,11 +232,11 @@ Huge thanks to [gajae-code](https://github.com/Yeachan-Heo/gajae-code) for the i
 ## Changelog
 
 <!-- CHANGELOG:START (auto-generated from CHANGELOG.md — run `bun run changelog:sync`) -->
+- **[0.7.26]** (2026-07-02) — Esc/Ctrl+C reliably clears the input box (fixes a gate the earlier reorder missed), and un-bracketed multi-line pastes no longer shred into premature per-line submits.
+- **[0.7.25]** (2026-07-02) — Shift+Enter now reliably distinguishable from Enter on kitty/WezTerm/iTerm2/xterm via modifyOtherKeys + kitty keyboard protocol; row-aware Home/End and Cmd+Left/Right in multi-row drafts.
 - **[0.7.24]** (2026-07-02) — OAuth callback page redesign with embedded jeo wordmark + Close button; memory budget O(n²)→O(n) incremental tracking fix.
 - **[0.7.23]** (2026-07-01) — Anthropic 5th-generation model catalog: adds Sonnet 5, Fable 5, and Mythos 5, promotes the 4.6 generation to 1M context / 128k output, and retires the superseded 4.5/3.5/4.1 ids. Bumps the default model to Sonnet 4.6, prices the new tiers, and fixes the thinking transport for Haiku 4.5 and every 5th-gen model.
 - **[0.7.22]** (2026-06-30) — gajae-code 0.7.3–0.7.8 parity sweep: terminal-bell notifications, a gruvbox-dark TUI theme, a resilient `jeo update` runtime check, and an ultragoal artifact gate. Ports the user-facing improvements from upstream gajae-code that jeo did not yet have, re-implemented to fit jeo's config, command, theming, and skill surfaces.
-- **[0.7.21]** (2026-06-26) — Global llm-wiki vault integration, Gemini/Antigravity thinking indicators, generous file-reading windows, and autopilot flag validation. Adds a shared global wiki root configuration with a /wiki slash command, fires reasoning start signals up front for Gemini/Antigravity models, adjusts the large-file reading discipline to use generous windows, and validates autopilot goal and integer flags.
-- **[0.7.20]** (2026-06-26) — OKF concept-memory retrieval gains a hybrid reranker ported from memsearch. Injection priority no longer rides one raw keyword score — it fuses two complementary ranked channels by Reciprocal Rank Fusion (RRF): IDF-weighted lexical relevance (the sparse/BM25 channel, so rare discriminating terms steer recall) and concept-graph proximity (the local dense/semantic-neighbour channel, so a hub linked from multiple query hits surfaces even with no keyword of its own). All embedding-free and deterministic, layered atop the existing failure-first tier and pinned-invariant reserved budget.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/README.zh.md

@@ -205,11 +205,11 @@ CI 通过 `.github/workflows/npm-publish.yml` 发布 — GitHub 发布 release
 ## 更新日志 (Changelog)
 
 <!-- CHANGELOG:START (auto-generated from CHANGELOG.md — run `bun run changelog:sync`) -->
+- **[0.7.26]** (2026-07-02) — Esc/Ctrl+C reliably clears the input box (fixes a gate the earlier reorder missed), and un-bracketed multi-line pastes no longer shred into premature per-line submits.
+- **[0.7.25]** (2026-07-02) — Shift+Enter now reliably distinguishable from Enter on kitty/WezTerm/iTerm2/xterm via modifyOtherKeys + kitty keyboard protocol; row-aware Home/End and Cmd+Left/Right in multi-row drafts.
 - **[0.7.24]** (2026-07-02) — OAuth callback page redesign with embedded jeo wordmark + Close button; memory budget O(n²)→O(n) incremental tracking fix.
 - **[0.7.23]** (2026-07-01) — Anthropic 5th-generation model catalog: adds Sonnet 5, Fable 5, and Mythos 5, promotes the 4.6 generation to 1M context / 128k output, and retires the superseded 4.5/3.5/4.1 ids. Bumps the default model to Sonnet 4.6, prices the new tiers, and fixes the thinking transport for Haiku 4.5 and every 5th-gen model.
 - **[0.7.22]** (2026-06-30) — gajae-code 0.7.3–0.7.8 parity sweep: terminal-bell notifications, a gruvbox-dark TUI theme, a resilient `jeo update` runtime check, and an ultragoal artifact gate. Ports the user-facing improvements from upstream gajae-code that jeo did not yet have, re-implemented to fit jeo's config, command, theming, and skill surfaces.
-- **[0.7.21]** (2026-06-26) — Global llm-wiki vault integration, Gemini/Antigravity thinking indicators, generous file-reading windows, and autopilot flag validation. Adds a shared global wiki root configuration with a /wiki slash command, fires reasoning start signals up front for Gemini/Antigravity models, adjusts the large-file reading discipline to use generous windows, and validates autopilot goal and integer flags.
-- **[0.7.20]** (2026-06-26) — OKF concept-memory retrieval gains a hybrid reranker ported from memsearch. Injection priority no longer rides one raw keyword score — it fuses two complementary ranked channels by Reciprocal Rank Fusion (RRF): IDF-weighted lexical relevance (the sparse/BM25 channel, so rare discriminating terms steer recall) and concept-graph proximity (the local dense/semantic-neighbour channel, so a hub linked from multiple query hits surfaces even with no keyword of its own). All embedding-free and deterministic, layered atop the existing failure-first tier and pinned-invariant reserved budget.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "jeo-code",
-  "version": "0.7.24",
+  "version": "0.7.26",
+
   "description": "Clean, highly optimized AI coding agent using spec-first loop",
   "type": "module",
   "main": "src/cli.ts",

package/src/commands/launch/input.ts

@@ -1,4 +1,5 @@
-import { verticalCursorOffset } from "../../tui/components/input-box";
+import { verticalCursorOffset, rowBoundaryOffset } from "../../tui/components/input-box";
+
 
 export interface InFlightAbortHarness {
   controller: AbortController;
@@ -556,6 +557,17 @@ export function decideCtrlC(
  *  `modifyOtherKeys` form (`CSI 27;2;13~`) and the kitty keyboard-protocol form
  *  (`CSI 13;2u`). Shared by the live input filter and its tests so they can't drift. */
 export const SHIFT_ENTER_SEQS: readonly string[] = ["\u001b[27;2;13~", "\u001b[13;2u"];
+/** Sequences that should jump the caret to the START of the current VISUAL ROW: macOS
+ *  Cmd+Left (`CSI 1;9D`) and the platform-neutral Home key in both its xterm (`CSI H`)
+ *  and vt220 (`CSI 1~`) forms, plus the SS3 variant (`ESC O H`) some terminals send in
+ *  application-cursor-keys mode. Windows terminals have no Cmd-combo equivalent — bare
+ *  Home is the "적절한 윈도우 단축키" for this action, so it must get the SAME row-aware
+ *  treatment as Cmd+Left, not just readline's native (whole-buffer) binding. */
+export const ROW_HOME_SEQS: readonly string[] = ["\u001b[1;9D", "\u001b[H", "\u001b[1~", "\u001bOH"];
+/** Mirror of {@link ROW_HOME_SEQS} for the END of the current visual row: macOS
+ *  Cmd+Right (`CSI 1;9C`) and the xterm/vt220/SS3 End key forms. */
+export const ROW_END_SEQS: readonly string[] = ["\u001b[1;9C", "\u001b[F", "\u001b[4~", "\u001bOF"];
+
 
 /** Minimal readline view the prompt key-filter reads (and mutates `cursor` on a
  *  vertical-nav "move"). The live filter passes the real readline interface; tests
@@ -697,6 +709,30 @@ export function filterPromptInputChunk(
       if (data.startsWith(seq, i)) { out += MULTILINE_SENTINEL; i += seq.length; matched = true; break; }
     }
     if (matched) continue;
+    // Row-aware Home/End: macOS Cmd+Left/Right and the bare Home/End keys (the Windows/
+    // Linux equivalent — there is no Cmd-combo there) jump to the START/END of the
+    // CURRENT VISUAL ROW, not the whole buffer. Native readline binds these to
+    // beginning-of-line/end-of-line, which is only correct on a single-row draft; on a
+    // multi-row draft (Shift+Enter breaks or box soft-wrap) it overshoots past the
+    // current row. Checked BEFORE `matchCursorCombo` (which would otherwise rewrite
+    // Cmd+Left/Right to the whole-buffer Ctrl+A/E) so this always wins when `rl` can
+    // supply a cursor to compute from; without `rl` it falls through to that rewrite
+    // (or, for bare Home/End, straight to readline's native binding) as a safe degrade.
+    const rowEdge = ROW_HOME_SEQS.find(seq => data.startsWith(seq, i)) !== undefined ? "start"
+      : ROW_END_SEQS.find(seq => data.startsWith(seq, i)) !== undefined ? "end"
+      : undefined;
+    if (rowEdge && rl) {
+      const seq = (rowEdge === "start" ? ROW_HOME_SEQS : ROW_END_SEQS).find(s => data.startsWith(s, i))!;
+      const line = rl.line ?? "";
+      const winCols = Math.max(24, env.columns - 1);
+      const textWidth = Math.max(1, Math.max(24, winCols) - 6);
+      const cur = typeof rl.cursor === "number" ? rl.cursor : line.length;
+      const expanded = line.split(MULTILINE_SENTINEL).join("\n");
+      rl.cursor = rowBoundaryOffset(expanded, cur, textWidth, rowEdge);
+      i += seq.length;
+      continue;
+    }
+
     const combo = matchCursorCombo(data, i);
     if (combo) { out += combo[1]; i += combo[0].length; continue; }
     // Up/Down between the box's visual rows (textarea feel) for any MULTI-ROW draft;
@@ -715,7 +751,25 @@ export function filterPromptInputChunk(
       }
       out += data.slice(i, i + 3); i += 3; continue;
     }
+    // Un-bracketed multi-line paste guard: some terminals/multiplexers (a raw X11
+    // primary-selection middle-click paste, certain SSH clients, or a tmux binding
+    // that omits `-p`) deliver a multi-line paste as ONE stdin chunk WITHOUT the
+    // bracketed-paste markers this filter otherwise relies on (PASTE_START/PASTE_END
+    // above). Outside an active bracketed paste, readline treats every bare `\r`/`\n`
+    // as Enter — so an un-bracketed 3-line paste submitted line 1 immediately, mid-
+    // composition, and left the rest to leak in as separate prompts (the "붙여넣기가
+    // 잘 안됨" bug: works for single-line/bracketed paste, corrupts multi-line paste
+    // when the terminal doesn't negotiate DECSET 2004). A genuine Enter keypress is
+    // always the LAST byte of its chunk — raw mode delivers one keystroke per read —
+    // so a linebreak with MORE data after it in the SAME synchronous chunk can only be
+    // a paste (or a scripted multi-line feed); fold it to the sentinel instead of
+    // submitting, matching the bracketed-paste contract (review the whole block, then
+    // press Enter once to submit). A trailing linebreak (nothing after it) keeps the
+    // existing behavior below — including the opt-in lone-LF Shift+Enter rule.
+    const bareBreakLen = data.startsWith("\r\n", i) ? 2 : (data[i] === "\r" || data[i] === "\n") ? 1 : 0;
+    if (bareBreakLen > 0 && i + bareBreakLen < data.length) { out += MULTILINE_SENTINEL; i += bareBreakLen; continue; }
     if (env.loneLfShiftEnter && data[i] === "\n") { out += MULTILINE_SENTINEL; i += 1; continue; } // lone LF = Shift+Enter (opt-in)
+
     // Ctrl+L (form feed): the prompt redraw hotkey, handled on the process.stdin keypress
     // listener — never forward it to readline as a literal char.
     if (data[i] === "\u000c") { i += 1; continue; }

package/src/commands/launch.ts

@@ -101,7 +101,8 @@ import {
   sessionPath,
   appendCompaction,
 } from "../agent/session";
-import { clearLine, cursorUp, toColumn, truncate as truncateAnsi, size as terminalSize, resetMouseTracking, clearScreen, clearVisible, clearToEnd } from "../tui/terminal";
+import { clearLine, cursorUp, toColumn, truncate as truncateAnsi, size as terminalSize, resetMouseTracking, clearScreen, clearVisible, clearToEnd, enableModifyOtherKeys, disableModifyOtherKeys, enableKittyKeyboard, disableKittyKeyboard } from "../tui/terminal";
+
 
 import {
   type LaunchFlags,
@@ -1563,7 +1564,19 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
     // 'keypress' too so the footer-redraw / paste-marker / picker listeners (registered
     // on process.stdin below) still fire.
     emitKeypressEvents(process.stdin);
+    // Ask the terminal to make Shift+Enter DISTINGUISHABLE from plain Enter — without
+    // this, `SHIFT_ENTER_SEQS`/the lone-LF opt-in never see anything to match, because
+    // most terminals send NOTHING (or a byte identical to Enter) for Shift+Enter unless
+    // one of these protocols is explicitly requested. Both are safe to send unconditionally:
+    // a terminal that doesn't implement either silently ignores the unrecognized private-mode
+    // sequence. Restored on exit so a shell/editor started afterward isn't left with an
+    // unexpected keyboard-encoding mode.
+    process.stdout.write(enableModifyOtherKeys() + enableKittyKeyboard());
+    process.once("exit", () => {
+      try { process.stdout.write(disableKittyKeyboard() + disableModifyOtherKeys()); } catch { /* terminal gone */ }
+    });
   }
+
   const rl = createInterface({
     input: keyFilter ?? process.stdin,
     // Single-box input: gate readline's output while the boxed footer is armed so its own
@@ -1889,12 +1902,16 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
   // the prompt never carries a trailing/floating blank block.
   const setFooterRows = (n: number) => {
     n = Math.max(1, Math.min(n, footerRows));
+
     if (!previewArmed || n === footerRendered) return;
+
     let s = footerParkedRow > 0 ? cursorUp(footerParkedRow) : "";
     s += toColumn(1) + clearToEnd(); // wipe old region; cursor now at its top (after output)
     if (n > 1) s += "\n".repeat(n - 1) + cursorUp(n - 1);
     s += toColumn(1);
+
     out.write(s);
+
     footerRendered = n;
     footerParkedRow = 0;
     lastFooterKey = ""; // force a full repaint into the resized region
@@ -2099,6 +2116,7 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
     // Re-pin the reservation to the height the latest preview/panel wants (compact at
     // idle, grown for a dropdown) BEFORE painting, so no reserved blank trails the prompt.
     setFooterRows(footerWantRows);
+
     // ALWAYS paint exactly footerRendered rows so the reservation is fully covered
     // and no row can spill past it — the bug fix that kept `@folder<more text>`
     // typing from scrolling the input box (and prior output) off the top.
@@ -2173,7 +2191,9 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
   const clearTypedInput = (): boolean => {
     const rli = rl as unknown as { line: string; cursor: number; _refreshLine?: () => void };
     const hadPastedQueue = queuedPromptInput.pastedLines.length > 0;
+
     if (!promptHasContent()) return false;
+
     // ESC is the escape hatch for an accidental giant paste: drop the queued batch.
     if (hadPastedQueue) {
       const dropped = queuedPromptInput.pastedLines.splice(0).length;
@@ -2719,6 +2739,20 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
         handleCtrlC();
         return;
       }
+      // ESC (or a meta-mapped Cmd+C) at the prompt: wipe the typed text. Checked HERE,
+      // before the `!previewArmed || pickerActive` gate below — mirroring Ctrl+C right
+      // above, which already bypasses that gate. Without this, a transient window where
+      // `previewArmed` is momentarily false (the same class of race Ctrl+C was already
+      // immune to) silently swallowed the ESC keypress: the box stayed unaffected and
+      // `clearTypedInput()` never ran (the "esc 입력 후 안 먹힘" bug — Esc after typing
+      // intermittently did nothing). `clearTypedInput()` itself already no-ops safely
+      // when there is nothing to clear or no armed box to redraw into, so running it
+      // unconditionally here is safe even mid-picker or pre-arm.
+      if (key && ((key.name === "escape" && !key.ctrl) || (key.meta && key.name === "c"))) {
+        clearTypedInput();
+        return;
+      }
+
       if (!previewArmed || pickerActive) return;
       // Drag-and-drop file attach: a terminal delivers a dropped file as its PATH typed
       // into the box, wrapped in a bracketed paste. On paste-end, swap any readable image
@@ -2826,16 +2860,10 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
         return;
       }
       if (previewPending) return;
-      // ESC (or a meta-mapped Cmd+C) at the prompt: wipe the typed text. A bare
-      // ESC decodes as `escape` (meta is set for a lone ESC byte — accept both)
-      // only after readline's escape-sequence timeout, so arrow/wheel sequences
-      // never trigger this.
-      if (key && ((key.name === "escape" && !key.ctrl) || (key.meta && key.name === "c"))) {
-        clearTypedInput();
-        return;
-      }
+
       // Ctrl+C is handled above (clear-or-exit); keep this guard for defensive ordering only.
       if (key?.ctrl && key.name === "c") return;
+
       previewPending = true;
       setImmediate(() => {
         previewPending = false;

package/src/tui/components/input-box.ts

@@ -242,3 +242,30 @@ export function verticalCursorOffset(
   }
   return best !== -1 ? best : firstOnRow;
 }
+/** Caret offset at the START or END of the VISUAL ROW containing `cursor`, using the
+ *  SAME wrapping rule as the input box (`caretCells`/`wrapWithCursor`). This is the
+ *  row-aware counterpart to Home/End (and macOS Cmd+Left/Right): on a single-row draft
+ *  it degenerates to the whole buffer's start/end (0 / length), but on a multi-row draft
+ *  (Shift+Enter hard breaks OR a long line the box soft-wraps) it stops at the CURRENT
+ *  row's boundary instead of jumping past other rows — matching the platform convention
+ *  (macOS Cmd+←/→, editors' Home/End) of "start/end of THIS line", not "start/end of the
+ *  whole document". */
+export function rowBoundaryOffset(
+  text: string,
+  cursor: number,
+  width: number,
+  edge: "start" | "end",
+): number {
+  const cells = caretCells(text, Math.max(1, width));
+  if (cells.length === 0) return 0;
+  const pos = Math.max(0, Math.min(cursor, cells.length - 1));
+  const row = cells[pos]!.row;
+  let start = pos;
+  let end = pos;
+  for (let p = 0; p < cells.length; p++) {
+    if (cells[p]!.row !== row) continue;
+    if (p < start) start = p;
+    if (p > end) end = p;
+  }
+  return edge === "start" ? start : end;
+}

package/src/tui/terminal.ts

@@ -100,3 +100,38 @@ export function isTTY(): boolean {
 export function truncate(line: string, cols: number): string {
   return truncateToWidth(line, cols);
 }
+/** Request xterm's `modifyOtherKeys` mode 2 (`CSI > 4 ; 2 m`): the terminal starts
+ *  encoding "inert" combos — Shift+Enter among them — as a full `CSI 27;<mod>;<code>~`
+ *  sequence instead of sending a byte indistinguishable from plain Enter (or nothing at
+ *  all). Without this, jeo's Shift+Enter → newline handling (`SHIFT_ENTER_SEQS` in
+ *  `commands/launch/input.ts`) never actually fires on most terminals — the terminal
+ *  never emits a sequence to match because nothing asked it to. Terminals that don't
+ *  implement the mode (Windows Terminal's legacy conpty path, some minimal emulators)
+ *  silently ignore the unrecognized private-mode sequence — safe to send unconditionally. */
+export function enableModifyOtherKeys(): string {
+  return `${ESC}>4;2m`;
+}
+
+/** Restore `modifyOtherKeys` to its default (mode 0 — "no special encoding") on exit,
+ *  the counterpart to {@link enableModifyOtherKeys}. */
+export function disableModifyOtherKeys(): string {
+  return `${ESC}>4;0m`;
+}
+
+/** Enable the kitty keyboard protocol's "disambiguate escape codes" flag (bit 1 of
+ *  `CSI > flags u`): the modern, more widely supported (kitty, wezterm, foot, contour,
+ *  ghostty, iTerm2, and increasingly Windows Terminal) alternative delivery mechanism
+ *  for the same Shift+Enter sequence jeo already recognizes (`CSI 13;2u`,
+ *  `SHIFT_ENTER_SEQS`). Terminals without kitty-protocol support ignore the private-mode
+ *  `u`-suffixed CSI sequence — safe to send unconditionally alongside
+ *  {@link enableModifyOtherKeys} so whichever protocol the terminal supports (if either)
+ *  makes Shift+Enter distinguishable from plain Enter. */
+export function enableKittyKeyboard(): string {
+  return `${ESC}>1u`;
+}
+
+/** Reset the kitty keyboard protocol flags to 0 (disabled) on exit, the counterpart to
+ *  {@link enableKittyKeyboard}. */
+export function disableKittyKeyboard(): string {
+  return `${ESC}>0u`;
+}