@aragon-agent/cli 0.6.9 → 0.6.11

package/README.md

@@ -432,14 +432,14 @@ completes, `Up` / `Down` moves the selection, `Esc` closes it.
 
 | Key | Action |
 | --- | --- |
-| `Enter` | Submit (idle) / queue a steering message (running) |
-| `Alt+Enter` / `Shift+Enter` | Insert a newline |
+| `Enter` | Submit (idle) / queue a steering message (running) — shown as `Queue: …` until the agent picks it up |
+| `Ctrl+J` / `Alt+Enter` / `Shift+Enter` | Insert a newline. `Ctrl+J` and `Alt+Enter` work everywhere; a distinct `Shift+Enter` needs a one-line terminal binding — see [`/terminal-setup`](#terminal-setup) |
 | `Shift+Tab` | Toggle **plan mode** (`BUILD` <-> `PLAN`). Equivalent: `/plan`. On Windows this needs a console flag Node < 22.17 does not set; aragon sets it at startup — see [Requirements](#requirements) |
 | `Ctrl+P` | The same toggle, over a channel no Windows console can swallow. Use it if `Shift+Tab` does nothing |
 | `Esc` | Close an overlay or popup; otherwise ask for interruption confirmation. While idle, cancel pending auto-continuation |
 | `Esc` ×2 | Interrupt the run when pressed within 1.5 seconds. Other keys or closing a menu cancel the first press |
 | `Esc` again after interruption | **Force-stop** a run that is still stopping, kill foreground shell commands and return to `idle`; background services remain running |
-| `Ctrl+C` | Stop the background **services** the agent started, when there are any. It does not arm exit |
+| `Ctrl+C` | **Copy the selection** when a drag-selection is waiting (release no longer copies by itself). Otherwise: stop the background **services** the agent started, when there are any. It does not arm exit |
 | `Ctrl+C` ×2 | Exit (first press warns), once no services are running |
 | `Ctrl+L` | Redraw the frame |
 | `Ctrl+T` | Show / hide thinking (**off by default**) for the entire session |
@@ -474,10 +474,12 @@ open. It never touches your draft, and it never recalls prompt history: that is
 Two things follow from the app owning the mouse, and they are worth knowing
 before you meet them:
 
-- **Dragging text selects and copies it when mouse selection is enabled.**
-  Dragging the last-column scrollbar scrolls instead. `--no-mouse-select` disables
-  text selection while preserving scrollbar dragging. `Shift`+drag uses the
-  terminal's native selection on hosts that support that convention.
+- **Dragging selects; `Ctrl+C` copies.** Releasing the mouse keeps the
+  highlight (and freezes the rows under it) until you commit: `Ctrl+C` over a
+  pending selection copies it and never arms exit; any other key drops it.
+  Dragging the last-column scrollbar scrolls instead. `--no-mouse-select`
+  disables text selection while preserving scrollbar dragging. `Shift`+drag
+  uses the terminal's native selection on hosts that support that convention.
 - **`tmux` with `mouse on` keeps the wheel for itself**, so the app never sees
   it. `set -g mouse off` hands it back.
 - **A Windows console on Node below 22.17.0 cannot report the wheel at all**,
@@ -489,6 +491,48 @@ Turn the whole thing off with `--no-mouse`, `ARAGON_MOUSE=0`, or
 nothing in full-screen mode — it does not fall back to editing your draft, which
 is what it used to do. Inline mode is unaffected either way.
 
+## Terminal setup for Shift+Enter
+
+`Ctrl+J` and `Alt+Enter` insert a newline in every terminal with no setup. A
+dedicated `Shift+Enter` key needs the terminal to send the CSI-u sequence
+`\u001b[13;2u` instead of a plain `Enter` — run `/terminal-setup` inside aragon
+for copy-paste bindings per terminal:
+
+- **Windows Terminal** — `settings.json`, `actions`:
+  `{ "keys": "shift+enter", "command": { "action": "sendInput", "input": "\u001b[13;2u" } }`
+- **VS Code integrated terminal** — `keybindings.json`:
+  `{ "key": "shift+enter", "command": "workbench.action.terminal.sendSequence", "args": { "text": "\u001b[13;2u" } }`
+- **iTerm2** — Settings > Profiles > Keys > Key Mappings, `Shift+Enter` ->
+  *Send Escape Sequence* `[13;2u`
+- **kitty / WezTerm / foot** — native once keyboard-enhancement mode is on
+  (kitty: `map shift+enter send_text all \u001b[13;2u`)
+- **Alacritty** — `[keyboard]` bindings in `alacritty.toml`:
+  `{ key = "Enter", mods = "Shift", chars = "\u001b[13;2u" }`
+- **macOS Terminal.app / legacy conhost** — cannot rebind `Enter`; use
+  `Ctrl+J` or `Alt+Enter`
+
+aragon deliberately does not push kitty keyboard mode or `modifyOtherKeys=2`
+onto the terminal itself: mode 2 re-encodes *every* modified key as CSI-u and
+would blind this app's (and Ink's) key parsing for the whole session. One
+user-side binding reaches the same result for the one key that needs it.
+
+## Queued messages while the agent runs
+
+Sending a message while a run is in flight **queues** it for the agent's next
+turn. The transcript shows the queue honestly:
+
+```
+◷ Queue: also check the tests
+```
+
+The row stays until Core actually accepts the message into the conversation —
+the next `turn_start` — at which point it is rewritten **in place** into the
+user message it became, followed by the answer. Interrupting the run does not
+clear it: the message really is still queued, and it will be picked up when
+you continue the session. Messages still queued when the session is saved are
+restored as `Queued but never sent: …` warnings, because the in-memory queue
+does not survive a restart.
+
 ## Themes
 
 Three palettes plus `auto`:
@@ -540,12 +584,12 @@ beside it (it takes the place of the idle hint row below the box, so starting a
 run never moves the layout):
 
 ```
-  ⠋ Percolating… · ⏎ steer · esc×2 interrupt · ctrl+c×2 exit            PLAN
+  ⠋ Percolating… · ⏎ queue · esc×2 interrupt · ctrl+c×2 exit            PLAN
 ```
 
 The row scrolls with the input box. On a narrow terminal whole clauses are dropped
 from the end (`exit` first) and only the phrase is shortened with an ellipsis, so
-`steer` and `interrupt` are never cut mid-word. When you scroll history until the
+`queue` and `interrupt` are never cut mid-word. When you scroll history until the
 input box is out of view, the animation moves to the fixed row at the bottom, so
 there is always exactly one spinner on screen. Terminals shorter than 20 rows, and
 `--no-hints`, keep the animation on that fixed row instead.

package/dist/agent/reducer.d.ts

@@ -36,6 +36,21 @@ export type Entry = {
     id: string;
     kind: 'user';
     text: string;
+}
+/**
+ * A message submitted while a run was in flight (tui-shift-enter-copy-queue
+ * 5.2). It renders as `Queue: <first line>` and is rewritten IN PLACE, same
+ * id, into the `user` entry above by the `turnStart` that proves Core
+ * accepted it -- so the id-based height cache re-measures rather than
+ * freezes, and the settled boundary (positional, monotonic) never moves.
+ *
+ * NOT A LIVE TARGET: no id pointer in `ViewState` names it, so the trim
+ * ring and the `appendEntry` assertions need no new member.
+ */
+ | {
+    id: string;
+    kind: 'queued';
+    text: string;
 } | {
     id: string;
     kind: 'assistant';
@@ -379,6 +394,15 @@ export declare function initialViewState(seed?: ViewStateSeed): ViewState;
 export type ViewAction = {
     type: 'submit';
     text: string;
+}
+/**
+ * `controller.steer` was accepted; append the persistent queue marker
+ * (5.2.2). Dispatched from exactly one place -- `App.submitMessage`'s
+ * running branch -- beside the `controller.steer` call it mirrors.
+ */
+ | {
+    type: 'steerQueued';
+    text: string;
 } | {
     type: 'runStart';
 } | {

package/dist/agent/reducer.js

@@ -289,6 +289,29 @@ function nextId(state) {
 function mapEntry(entries, id, fn) {
     return entries.map((e) => (e.id === id ? fn(e) : e));
 }
+/**
+ * Rewrite every `queued` entry in place as the user message it became
+ * (tui-shift-enter-copy-queue 5.2.3).
+ *
+ * SAME ID, NEW OBJECT -- the `mapEntry` discipline for a non-append change:
+ * the position (and therefore the settled boundary, which advances by
+ * POSITION and never by identity) is untouched, while the new object
+ * reference is what lets `React.memo` and the height cache see that this
+ * one row changed. ALL of them at once, because `drainSteering` is a full
+ * drain: converting only some would show a partial acceptance that never
+ * happened. Identity-preserving when nothing is queued -- `turnStart` fires
+ * every turn, and this must stay free for the common case.
+ */
+function convertQueuedEntries(entries) {
+    let touched = false;
+    const next = entries.map((e) => {
+        if (e.kind !== 'queued')
+            return e;
+        touched = true;
+        return { id: e.id, kind: 'user', text: e.text };
+    });
+    return touched ? next : entries;
+}
 /**
  * Seal `thinkingMs`, once, as a spreadable patch (§3.1.2).
  *
@@ -425,6 +448,15 @@ export function viewReducer(state, action) {
                 aborted: false,
             };
         }
+        case 'steerQueued': {
+            const { id, seq } = nextId(state);
+            const entry = { id, kind: 'queued', text: action.text };
+            // NOTHING ELSE RESETS. This is not a new turn -- `turnProduced`,
+            // `errorNoticed` and `aborted` describe the run that is still in
+            // flight, and clearing them here would let the next `runEnd` failure
+            // guard misfire on a turn that produced plenty.
+            return { ...state, seq, ...appendEntry(state, state.entries, entry) };
+        }
         case 'runStart':
             return {
                 ...state,
@@ -435,6 +467,14 @@ export function viewReducer(state, action) {
             };
         case 'turnStart': {
             const { id, seq } = nextId(state);
+            // CONVERT, THEN APPEND, IN THAT ORDER AND IN THIS ONE ACTION
+            // (5.2.3): `turn_start` is the authoritative "the steering queue was
+            // drained into the conversation" signal (the loop drains at its top,
+            // immediately before emitting it), so the user message and the answer
+            // that follows it must land in the same commit, in render order, or a
+            // frame can exist where the message has vanished and the answer has
+            // not appeared.
+            const entries = convertQueuedEntries(state.entries);
             const entry = {
                 id,
                 kind: 'assistant',
@@ -443,7 +483,7 @@ export function viewReducer(state, action) {
                 thinkingOpen: false,
                 streaming: true,
             };
-            return { ...state, seq, ...appendEntry(state, state.entries, entry), streamingId: id };
+            return { ...state, seq, ...appendEntry(state, entries, entry), streamingId: id };
         }
         case 'thinkingStart': {
             if (!state.streamingId)

package/dist/cli.js

@@ -56,7 +56,6 @@ import { renderTranscriptText } from './ui/transcript-text.js';
 import { detectCapabilities } from './ui/capabilities.js';
 import { pickGlyphs } from './ui/glyphs.js';
 import { getTheme } from './ui/theme.js';
-import { copyText } from './ui/clipboard.js';
 import { createSelectionController, } from './ui/selection/selection-controller.js';
 import { DENY_ALL_HUMAN_INPUT } from './tools/human-input.js';
 // A VALUE import, and the one deliberate exception to the paragraph above
@@ -630,10 +629,10 @@ function runInteractive(flags, extras = {}) {
             // correct. That is rung 2 of the fail-safe ladder doing its job.
             repaint: () => frameWriter?.repaint() ?? false,
             requestRedraw: () => selectionBridge.requestRedraw?.(),
-            // `?? undefined` and not a wrapper: `copyText` skips OSC 52 entirely when
-            // it has no door, and reports `'native'`/`'none'` accordingly.
-            copy: (text) => copyText(text, writeForeign ?? undefined),
-            onCopied: (via, lines, chars) => selectionBridge.onCopied?.(via, lines, chars),
+            // The copy decision moved UP to `App` (tui-shift-enter-copy-queue
+            // 4.2.4): Ctrl+C with a settled selection is routed there, through
+            // the SAME `copyText` door and the SAME bridge `onCopied` toast
+            // funnel -- the controller keeps only the selection state machine.
             // Read at PAINT time, not captured: `/theme` rebuilds the theme mid-session.
             theme: () => getTheme(config.theme, detectCapabilities(process.env, process.stdout)),
             caps: detectCapabilities(process.env, process.stdout),
@@ -1412,7 +1411,7 @@ function buildProgram() {
         .option('--no-live-tool-output', 'Keep a running tool card to one line')
         .option('--mouse', 'Wheel scrolls the transcript (full-screen mode)')
         .option('--no-mouse', 'Leave the mouse to the terminal (the wheel does nothing)')
-        .option('--mouse-select', 'Drag with the mouse to select text; releasing copies it')
+        .option('--mouse-select', 'Drag with the mouse to select text; Ctrl+C copies it')
         .option('--no-mouse-select', 'Keep wheel scrolling, but leave drag-select off')
         // Positive form FIRST, same tri-state reason as `--mouse-select` above:
         // `paste` is persisted and defaults to `true`, so a lone `--no-paste` would

package/dist/commands/builtins.d.ts

@@ -1,7 +1,8 @@
 /**
  * Built-in slash commands (spec §5.2):
  * /help /model /settings /thinking /max-tokens /tools /clear /reset /cwd /save
- * /resume /copy /exit (/quit), plus the /team, /fast and /todo subsystems.
+ * /resume /copy /terminal-setup /exit (/quit), plus the /team, /fast and
+ * /todo subsystems.
  */
 import { CommandRegistry } from './registry.js';
 export declare function registerBuiltinCommands(registry: CommandRegistry): void;

package/dist/commands/builtins.js

@@ -1,7 +1,8 @@
 /**
  * Built-in slash commands (spec §5.2):
  * /help /model /settings /thinking /max-tokens /tools /clear /reset /cwd /save
- * /resume /copy /exit (/quit), plus the /team, /fast and /todo subsystems.
+ * /resume /copy /terminal-setup /exit (/quit), plus the /team, /fast and
+ * /todo subsystems.
  */
 import { existsSync, statSync } from 'node:fs';
 import { isAbsolute, resolve } from 'node:path';
@@ -1013,7 +1014,10 @@ const COMMANDS = [
             const captured = port.captured();
             const lines = [
                 `Mouse capture: ${captured ? 'on' : 'off'}`,
-                `  drag-select  ${port.selectEnabled() ? 'on' : 'off (mouseSelect is false)'}`,
+                // The wording follows tui-shift-enter-copy-queue 4.4: releasing no
+                // longer copies, so this row must name the commit key -- leaving the
+                // bare `on` would keep teaching the gesture that was removed.
+                `  drag-select  ${port.selectEnabled() ? 'on (drag to select, ctrl+c to copy)' : 'off (mouseSelect is false)'}`,
                 '  /mouse off   hand the mouse to your terminal for this session',
                 '  /mouse on    take it back',
                 '  --no-mouse   never capture it (also ARAGON_MOUSE=0)',
@@ -1022,6 +1026,47 @@ const COMMANDS = [
             ctx.notify('info', lines.join('\n'));
         },
     },
+    {
+        name: 'terminal-setup',
+        description: 'How to make Shift+Enter send a newline in your terminal',
+        run: (ctx) => {
+            // READ-ONLY BY DESIGN (3.6): pushing kitty keyboard mode or
+            // modifyOtherKeys=2 would re-encode EVERY modified key as CSI-u and
+            // blind Ink's parser for the whole session. One user-side binding
+            // reaches the same result for the one key that needs it.
+            //
+            // Ctrl+J and Alt+Enter work with no setup at all; CSI-u terminals
+            // (kitty / WezTerm / foot with keyboard enhancement on) need none
+            // either. The lines below are for the terminals that send a plain
+            // CR for Shift+Enter and CAN be configured.
+            const lines = [
+                'Shift+Enter newline - terminal setup',
+                '',
+                'Ctrl+J and Alt+Enter insert a newline in every terminal, with no',
+                'setup. To get a dedicated Shift+Enter key, make the terminal send',
+                'the CSI-u sequence \\u001b[13;2u for it:',
+                '',
+                '  Windows Terminal  settings.json, actions array:',
+                '    { "keys": "shift+enter", "command": { "action": "sendInput",',
+                '      "input": "\\u001b[13;2u" } }',
+                '  VS Code terminal  keybindings.json:',
+                '    { "key": "shift+enter",',
+                '      "command": "workbench.action.terminal.sendSequence",',
+                '      "args": { "text": "\\u001b[13;2u" } }',
+                '  iTerm2            Settings > Profiles > Keys > Key Mappings:',
+                '    Shift+Enter -> Send Escape Sequence: [13;2u',
+                '  kitty/WezTerm/foot  native once keyboard enhancement is on',
+                '    (kitty: map shift+enter send_text all \\u001b[13;2u)',
+                '  Alacritty         alacritty.toml, [keyboard] bindings:',
+                '    { key = "Enter", mods = "Shift", chars = "\\u001b[13;2u" }',
+                '  macOS Terminal.app / conhost  cannot rebind Enter; use Ctrl+J',
+                '    or Alt+Enter',
+                '',
+                'This command only prints advice; it changes no terminal modes.',
+            ];
+            ctx.notify('info', lines.join('\n'));
+        },
+    },
     {
         name: 'logs',
         description: 'Show where this session is being logged',

package/dist/input/enter-sequences.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Enter-family sequence recognition (tui-shift-enter-copy-queue §3.3) -- pure,
+ * stream-free, no node/React imports, callable from any test environment.
+ *
+ * WHY THIS LIVES BELOW INK. Ink 5's `parse-keypress.js` calls `parseKeypress`
+ * ONCE per stdin chunk and hard-codes `shift: false` for the exact string
+ * `'\r'`, so a component can never see `key.return && key.shift` -- the
+ * `PromptInput` branch for it is dead code. Worse, terminals that DO encode a
+ * distinct Shift+Enter send CSI-u (`\x1b[13;2u`), which Ink's `fnKeyRe` does
+ * not match: the ESC is stripped by `use-input.js` and `'[13;2u'` falls through
+ * to the PRINTABLE branch, typing garbage into the draft. The only layer that
+ * sees the bytes before Ink mangles them is the stdin filter, which is where
+ * the mouse-report and paste-marker dialects are already translated.
+ *
+ * THE CONTRACT: rewrite every recognized sequence to ONE normalized token --
+ * `ENTER_NEWLINE_FRAME` for "this was a modified Enter, the user wants a
+ * newline" and `'\r'` for the unmodified CSI-u Enter some other program left
+ * behind. No state, no partial-output: `rewriteEnterSequences` is idempotent
+ * because its output contains none of its inputs.
+ */
+/** What one recognized sequence means, for tests and `/terminal-setup` copy. */
+export interface EnterSequenceSpec {
+    /** The exact byte sequence a terminal sends for this key. */
+    readonly seq: string;
+    /** The chord it names, e.g. `'shift+enter'`, `'ctrl+alt+enter'`, `'enter'`. */
+    readonly meaning: string;
+    /** What `rewriteEnterSequences` replaces it with. */
+    readonly to: string;
+}
+/**
+ * The recognition table (§3.3). CSI-u modifiers 2-8 cover Shift(2), Alt(3),
+ * Shift+Alt(4), Ctrl(5), Ctrl+Shift(6), Ctrl+Alt(7), Ctrl+Alt+Shift(8) as
+ * emitted by kitty/WezTerm keyboard-enhancement mode and by
+ * `modifyOtherKeys=2`; every one of them means "Enter with a modifier", and a
+ * modified Enter must NEVER submit the draft. `\x1b\r` / `\x1b\n` are the
+ * classic Alt+Enter encodings. `\x1b[13u` (no modifier field) is what a
+ * leftover kitty mode sends for a PLAIN Enter: it must submit, so it maps to
+ * `'\r'` rather than to a newline.
+ */
+export declare const ENTER_SEQUENCES: readonly EnterSequenceSpec[];
+/**
+ * Rewrite every recognized Enter-family sequence to its normalized token.
+ *
+ * ONE ANCHORED REGEX, not a per-sequence scan and not a state machine: the
+ * CSI-u family shares one shape and the two literal Alt+Enter encodings cannot
+ * nest inside it, so a single left-to-right pass is unambiguous. `\x1b[13;9u`
+ * and other unknown modifiers are deliberately left untouched -- rewriting an
+ * unrecognized sequence would be guessing at a terminal dialect we have not
+ * seen.
+ */
+export declare function rewriteEnterSequences(text: string): string;
+/**
+ * Length of the trailing run of `text` that is a proper prefix of an
+ * Enter-family sequence, or 0.
+ *
+ * LONGEST MATCH, not shortest: unlike the mouse and paste families, a torn
+ * CSI-u sequence diverges from its siblings only at the LAST byte
+ * (`\x1b[13;` + `2u`), so every byte before the divergence point must be held
+ * back for the next chunk or the sequence is destroyed a byte early. Feeding
+ * the result into the filter's `keep = max(...)` alongside the other two
+ * families keeps every family's hold intact.
+ */
+export declare function trailingEnterPrefixLength(text: string): number;

package/dist/input/enter-sequences.js

@@ -0,0 +1,151 @@
+/**
+ * Enter-family sequence recognition (tui-shift-enter-copy-queue §3.3) -- pure,
+ * stream-free, no node/React imports, callable from any test environment.
+ *
+ * WHY THIS LIVES BELOW INK. Ink 5's `parse-keypress.js` calls `parseKeypress`
+ * ONCE per stdin chunk and hard-codes `shift: false` for the exact string
+ * `'\r'`, so a component can never see `key.return && key.shift` -- the
+ * `PromptInput` branch for it is dead code. Worse, terminals that DO encode a
+ * distinct Shift+Enter send CSI-u (`\x1b[13;2u`), which Ink's `fnKeyRe` does
+ * not match: the ESC is stripped by `use-input.js` and `'[13;2u'` falls through
+ * to the PRINTABLE branch, typing garbage into the draft. The only layer that
+ * sees the bytes before Ink mangles them is the stdin filter, which is where
+ * the mouse-report and paste-marker dialects are already translated.
+ *
+ * THE CONTRACT: rewrite every recognized sequence to ONE normalized token --
+ * `ENTER_NEWLINE_FRAME` for "this was a modified Enter, the user wants a
+ * newline" and `'\r'` for the unmodified CSI-u Enter some other program left
+ * behind. No state, no partial-output: `rewriteEnterSequences` is idempotent
+ * because its output contains none of its inputs.
+ */
+import { ENTER_NEWLINE_FRAME } from './limits.js';
+/**
+ * The recognition table (§3.3). CSI-u modifiers 2-8 cover Shift(2), Alt(3),
+ * Shift+Alt(4), Ctrl(5), Ctrl+Shift(6), Ctrl+Alt(7), Ctrl+Alt+Shift(8) as
+ * emitted by kitty/WezTerm keyboard-enhancement mode and by
+ * `modifyOtherKeys=2`; every one of them means "Enter with a modifier", and a
+ * modified Enter must NEVER submit the draft. `\x1b\r` / `\x1b\n` are the
+ * classic Alt+Enter encodings. `\x1b[13u` (no modifier field) is what a
+ * leftover kitty mode sends for a PLAIN Enter: it must submit, so it maps to
+ * `'\r'` rather than to a newline.
+ */
+export const ENTER_SEQUENCES = [
+    {
+        seq: '\x1b[13;2u',
+        meaning: 'shift+enter',
+        to: ENTER_NEWLINE_FRAME,
+    },
+    {
+        seq: '\x1b[13;3u',
+        meaning: 'alt+enter',
+        to: ENTER_NEWLINE_FRAME,
+    },
+    {
+        seq: '\x1b[13;4u',
+        meaning: 'shift+alt+enter',
+        to: ENTER_NEWLINE_FRAME,
+    },
+    {
+        seq: '\x1b[13;5u',
+        meaning: 'ctrl+enter',
+        to: ENTER_NEWLINE_FRAME,
+    },
+    {
+        seq: '\x1b[13;6u',
+        meaning: 'ctrl+shift+enter',
+        to: ENTER_NEWLINE_FRAME,
+    },
+    {
+        seq: '\x1b[13;7u',
+        meaning: 'ctrl+alt+enter',
+        to: ENTER_NEWLINE_FRAME,
+    },
+    {
+        seq: '\x1b[13;8u',
+        meaning: 'ctrl+alt+shift+enter',
+        to: ENTER_NEWLINE_FRAME,
+    },
+    {
+        seq: '\x1b\r',
+        meaning: 'alt+enter',
+        to: ENTER_NEWLINE_FRAME,
+    },
+    {
+        seq: '\x1b\n',
+        meaning: 'alt+enter',
+        to: ENTER_NEWLINE_FRAME,
+    },
+    {
+        seq: '\x1b[13u',
+        meaning: 'enter',
+        to: '\r',
+    },
+];
+/**
+ * Longest strict prefix any recognized sequence can have. Derived from the
+ * table rather than hard-coded so adding a sequence can never leave the hold
+ * ceiling behind: the longest sequence is 7 bytes, so a torn sequence can hold
+ * up to 6 of them.
+ */
+const MAX_ENTER_PREFIX = Math.max(...ENTER_SEQUENCES.map((s) => s.seq.length)) - 1;
+/** `\x1b[13;2u` .. `\x1b[13;8u`, or `\x1b[13u` when the modifier is absent. */
+const CSI_U_ENTER = /\x1b\[13(?:;[2-8])?u/g;
+/**
+ * Rewrite every recognized Enter-family sequence to its normalized token.
+ *
+ * ONE ANCHORED REGEX, not a per-sequence scan and not a state machine: the
+ * CSI-u family shares one shape and the two literal Alt+Enter encodings cannot
+ * nest inside it, so a single left-to-right pass is unambiguous. `\x1b[13;9u`
+ * and other unknown modifiers are deliberately left untouched -- rewriting an
+ * unrecognized sequence would be guessing at a terminal dialect we have not
+ * seen.
+ */
+export function rewriteEnterSequences(text) {
+    if (!text.includes('\x1b'))
+        return text;
+    // ONE PASS, TWO TARGETS: a MODIFIED Enter is a newline intent, while the
+    // modifier-less CSI-u Enter a leftover kitty mode emits is a PLAIN Enter
+    // and must still submit (`\r`). The `;` is the discriminator the table
+    // above records in each entry's `to` field.
+    let out = text.replace(CSI_U_ENTER, (seq) => (seq.includes(';') ? ENTER_NEWLINE_FRAME : '\r'));
+    // Only the two literal Alt+Enter encodings remain. `\x1b\n` is checked
+    // before `\x1b\r` is replaced; they share no bytes, so order is free, but
+    // splitting the escapes keeps each replacement self-evident.
+    if (out.includes('\x1b\n'))
+        out = out.split('\x1b\n').join(ENTER_NEWLINE_FRAME);
+    if (out.includes('\x1b\r'))
+        out = out.split('\x1b\r').join(ENTER_NEWLINE_FRAME);
+    return out;
+}
+/** True when `s` is a PROPER prefix of some recognized sequence (never whole). */
+function isEnterPrefix(s) {
+    if (s.length === 0 || s.length > MAX_ENTER_PREFIX)
+        return false;
+    for (const spec of ENTER_SEQUENCES) {
+        // `length >`, not `startsWith` alone: `startsWith` accepts the WHOLE
+        // sequence too, and holding a complete sequence back would add 12 ms
+        // of latency to a key that is ready to be rewritten right now.
+        if (spec.seq.length > s.length && spec.seq.startsWith(s))
+            return true;
+    }
+    return false;
+}
+/**
+ * Length of the trailing run of `text` that is a proper prefix of an
+ * Enter-family sequence, or 0.
+ *
+ * LONGEST MATCH, not shortest: unlike the mouse and paste families, a torn
+ * CSI-u sequence diverges from its siblings only at the LAST byte
+ * (`\x1b[13;` + `2u`), so every byte before the divergence point must be held
+ * back for the next chunk or the sequence is destroyed a byte early. Feeding
+ * the result into the filter's `keep = max(...)` alongside the other two
+ * families keeps every family's hold intact.
+ */
+export function trailingEnterPrefixLength(text) {
+    const max = Math.min(text.length, MAX_ENTER_PREFIX);
+    for (let k = max; k >= 1; k -= 1) {
+        if (isEnterPrefix(text.slice(text.length - k)))
+            return k;
+    }
+    return 0;
+}

package/dist/input/limits.d.ts

@@ -53,6 +53,17 @@ export declare const PASTE_ASSEMBLY_MAX_MS = 2000;
  */
 export declare const PASTE_OPEN = "\0[";
 export declare const PASTE_CLOSE = "\0]";
+/**
+ * The inline frame that carries ONE newline intent from the stdin filter to the
+ * composer (tui-shift-enter-copy-queue 3.2).
+ *
+ * SAME FAMILY AS `PASTE_OPEN`, with the same guarantee and for the same reason:
+ * NUL is the delimiter because no terminal delivers it for any key, and because
+ * `sanitisePaste` strips every NUL out of every payload -- so pasted text can
+ * never forge this frame either. A newline intent is single, atomic and carries
+ * no payload, so one constant replaces the OPEN/CLOSE pair.
+ */
+export declare const ENTER_NEWLINE_FRAME = "\0n";
 /**
  * The one channel from the stdin filter to `App`'s notice dispatch (P1-3 / I-15).
  *

package/dist/input/limits.js

@@ -53,6 +53,17 @@ export const PASTE_ASSEMBLY_MAX_MS = 2_000;
  */
 export const PASTE_OPEN = '\u0000[';
 export const PASTE_CLOSE = '\u0000]';
+/**
+ * The inline frame that carries ONE newline intent from the stdin filter to the
+ * composer (tui-shift-enter-copy-queue 3.2).
+ *
+ * SAME FAMILY AS `PASTE_OPEN`, with the same guarantee and for the same reason:
+ * NUL is the delimiter because no terminal delivers it for any key, and because
+ * `sanitisePaste` strips every NUL out of every payload -- so pasted text can
+ * never forge this frame either. A newline intent is single, atomic and carries
+ * no payload, so one constant replaces the OPEN/CLOSE pair.
+ */
+export const ENTER_NEWLINE_FRAME = '\u0000n';
 /** Human-readable byte size for the refusal toast (`4.1 MB`, `812.0 KB`, `7 B`). */
 export function formatPasteSize(bytes) {
     if (bytes >= 1024 * 1024)

package/dist/input/stdin-filter.js

@@ -35,6 +35,7 @@ import { PassThrough } from 'node:stream';
 import { MAX_PENDING_MOUSE_CHARS, splitMouseEvents, isMousePrefix, } from './mouse-events.js';
 import { PASTE_ASSEMBLY_MAX_MS, PASTE_BURST_MS, PASTE_CLOSE, PASTE_MAX_BYTES, PASTE_OPEN, formatPasteSize, } from './limits.js';
 import { PASTE_BEGIN_MARK, PASTE_END_MARK, classifyChunk, sanitisePaste, trailingPastePrefixLength, } from './paste-parse.js';
+import { rewriteEnterSequences, trailingEnterPrefixLength } from './enter-sequences.js';
 /**
  * How long a possible-prefix tail is held before being flushed as text.
  *
@@ -192,6 +193,17 @@ export function createStdinFilter(real, features, bridge, onWarn) {
     const handleOutsidePaste = (text, holdTail) => {
         if (text.length === 0)
             return;
+        // ENTER-FAMILY REWRITE, AND IT IS FIRST FOR A REASON
+        // (tui-shift-enter-copy-queue 3.4). The Alt+Enter encoding contains a CR,
+        // and `classifyChunk`'s primary rule -- "longer than one character AND
+        // contains a line break" -- would buffer that two-byte key as a Tier 2
+        // paste body whose sanitiser then strips the ESC, silently swallowing the
+        // keystroke. After the rewrite the frame is NUL-led and classifies as
+        // `keys` under both rules. The cost is that an UNBRACKETED paste whose
+        // body happens to contain the literal Alt+Enter bytes loses that one
+        // pair's newline; a bracketed body never reaches this function at all
+        // (I-3), and losing two bytes of a heuristic tier beats eating the key.
+        text = rewriteEnterSequences(text);
         if (paste.kind === 'burst') {
             paste = { kind: 'burst', body: paste.body + text, bytes: paste.bytes + byteLength(text) };
             burstTimer = clearTimer(burstTimer);
@@ -266,7 +278,13 @@ export function createStdinFilter(real, features, bridge, onWarn) {
             const strayEnd = rest.indexOf(PASTE_END_MARK);
             const first = begin === -1 ? strayEnd : strayEnd === -1 ? begin : Math.min(begin, strayEnd);
             if (first === -1) {
-                const keep = Math.max(trailingPastePrefixLength(rest), features.mouse ? trailingMousePrefixLength(rest) : 0);
+                // THIRD PREFIX FAMILY: a torn CSI-u Enter sequence
+                // (tui-shift-enter-copy-queue 3.4). `keep = max(...)` holds the longest
+                // tail any family might still complete; the three families share only
+                // the ESC / ESC-[ head bytes, which the max keeps for whoever needs
+                // them. The existing 12 ms flush and the 32-char ceiling bound the
+                // hold, so no new timer is needed.
+                const keep = Math.max(trailingPastePrefixLength(rest), features.mouse ? trailingMousePrefixLength(rest) : 0, trailingEnterPrefixLength(rest));
                 const tail = rest.slice(rest.length - keep);
                 handleOutsidePaste(rest.slice(0, rest.length - keep), true);
                 pending += tail;

package/dist/session/persist.js

@@ -193,6 +193,26 @@ export function normalizeLoadedEntries(entries) {
             (entry.status === 'starting' || entry.status === 'ready' || entry.status === 'running')) {
             return { ...entry, status: 'stopped', rows: [] };
         }
+        // THE SEVENTH CLAUSE (tui-shift-enter-copy-queue 5.2.5). Core's steering
+        // queue is memory-only, so a `queued` entry on disk is a promise this
+        // process can no longer keep: the message was never accepted into any
+        // conversation. Downgrade to a WARN NOTICE carrying the first line
+        // rather than to a `user` entry -- pretending it was sent is the lie
+        // that loses the user's words with a straight face.
+        //
+        // THE ID IS KEPT: `restoreEntries` splices these positions into the
+        // live transcript, and a fresh id here would collide with the next
+        // `e<n>` the reducer allocates.
+        if (entry.kind === 'queued') {
+            const firstLine = entry.text.split('\n', 1)[0] ?? '';
+            const downgraded = {
+                id: entry.id,
+                kind: 'notice',
+                level: 'warn',
+                text: `Queued but never sent: ${firstLine}`,
+            };
+            return downgraded;
+        }
         return entry;
     });
 }