@aragon-agent/cli 0.6.27 → 0.6.29

package/CHANGELOG.md

@@ -77,6 +77,170 @@ were written.
 
 ### Fixed
 
+- **A long answer lost two characters at every hard wrap point - silently, in
+  exactly the content a user copies out.** The transcript's content column had no
+  width of its own, so Yoga laid each line out at the width it computed from the
+  parent while `virtual-window` estimated heights against `cols - GUTTER_WIDTH`:
+  two authorities for one number, and the clip kept the difference. A 240-digit
+  run in a 100-column transcript rendered as 97 + 97 + 42 = 236 digits, dropping
+  the characters at column 97 and 194 - URLs, git hashes, base64, paths and code
+  lines broke where nothing looked broken, because a paragraph with spaces re-wraps
+  at word boundaries and hides it. The column now takes `flexBasis={0}
+  flexGrow={1}` and keeps `flexShrink={0}` (invariant I-2: without it
+  `measureElement` can squeeze the column to the viewport and scrolling dies with
+  no error), so the available width is computed once, by yoga, from the parent.
+  Measured on the shipped component: 97 + 97 + 46 = 240/240, first divergence at
+  index -1.
+- **A bracketed paste could type its own markers into the draft as `[200~hello
+  world`.** The startup `ESC[?2004h` is correct, but when a read boundary landed
+  inside the six-byte marker - ordinary on a Windows console, over SSH, or in tmux
+  under load - the 12 ms pending flush released the lone `ESC` as the Esc key (it
+  must never be held hostage), and the `[200~` that followed had nothing left to
+  recognise: `indexOf` needs the ESC. The filter now remembers a marker head it has
+  just released and, on the NEXT chunk only, splices it back in front for one
+  re-scan inside the same `feed()` - so the marker is consumed before its bytes
+  become text, `PENDING_FLUSH_MS` stays at 12 ms, and a new
+  `PASTE_MARKER_RESCAN_TTL_MS` (250 ms, structural, in `input/limits.ts`) bounds
+  when that is still believable. The visible garbage is gone in all three draft
+  measurements (`> hello world_`); the one residual is stated rather than hidden -
+  a write cannot be retracted, so the Esc keypress the release already produced
+  still happens, and a marker torn into three parts still leaves its middle
+  fragment behind (both recorded in `docs/diagnoses/.../analysis.md` §D-2).
+- **A turn that only called a tool left a bare `●` bubble behind - on screen, in
+  the height table and in the saved session.** `turnStart` always appends an
+  assistant entry, so a tool-only turn, or one the user interrupted mid-stream,
+  left a bubble that `AssistantEntry` then refused to draw: the row was estimated
+  anyway (two for an aborted one, of which nothing drew the second), the scroll
+  position counted it, and `/save` exported it, so `/resume` brought it back. The
+  reducer now prunes a settled assistant entry with no text and no thinking, at
+  the three settle points only (`turnEnd`, `runEnd`, `abortMark`) - pruning earlier
+  would delete the live target of every `textDelta`, and the entry a `streamRestart`
+  is still filling in must survive. `abortMark` is the one settle path that does not
+  clear `streamingId` itself, so the helper returns the id and the caller writes it
+  back (I-L1-1); `runEnd` and `turnEnd` clear it anyway. A render-layer guard stays
+  as the second line of defence for a session file that already contains one.
+- **An empty transcript still drew a full-height scrollbar track.** One rail
+  column of track glyphs from the second row down told the user there was more
+  below when there was nothing, and cost a column of width. `thumb === null` now
+  means no cells at all - the one-column BOX is still rendered, because the
+  reserved column (not the glyphs) is what keeps the content width constant; hiding
+  the column instead would re-wrap every line, change the measured height and feed
+  that back into the decision to show it.
+- **Under `--no-color` the command palette's selected row was invisible, and a
+  bare `@` never opened file completion.** The selection was expressed only as
+  `inverse`, which is the identity at colour level 0 - and every `theme.*` colour is
+  `undefined` there too - so six commands looked identical and Enter was a guess
+  (`/clear` sits next to `/cwd`). The selected row now carries the same
+  `glyphs.caret` prefix the `/model` picker uses (`>` in the ASCII tier), with two
+  cells of padding on the unselected rows so no row changes width. Separately,
+  `README` has always promised that `@` opens a file-path completion popup while
+  the code required one more character: the `>= 1` gate and the `< 1` early return
+  are gone, and an empty `@` query lists the shallowest paths first (depth, then
+  length, then alphabetical) instead of the first twenty the filesystem happened to
+  hand back.
+- **The completion menu was pinned at six rows on every terminal.** `App` handed
+  the popup a literal `6` while the frame budget had already computed the slot
+  capacity: a 30-row terminal showed 6 of 57 commands and 14 more hidden, so
+  browsing meant holding an arrow key. The cap is now derived from
+  `frameBudget.popupMaxHeight` through `POPUP_CAPACITY_SHARE` (2) in
+  `layout/budget.ts` - 6 rows at 20 lines, 11 at 30, 16 at 40. Handing over the
+  whole capacity was measured and rejected: `popupCapacity` reserves exactly one
+  message row, so at 20 rows it grants 13, the transcript collapses to a single row
+  and the TODO rail disappears. A divisor keeps the menu derived from the frame
+  budget instead of becoming a second authority beside it, and since it does not
+  depend on `popupRows` it cannot oscillate with it.
+- **A fenced code block's language tag rendered as a body row, indented one cell
+  past the code.** The chip background and its padding spaces drew `  |  ts` above
+  code rows starting `| export ...`, so the fence header read as an extra line of
+  source. It is now a muted bold TITLE on the same rail, aligned with the code, and
+  it deliberately keeps its own row: the height estimator counts raw markdown
+  lines and has no code-block branch, so the fence line must still occupy exactly
+  one. The fence grammar was too narrow as well - `(\w*)` rejected `c++`,
+  `objective-c` and four-backtick fences, degrading the whole block to prose and
+  swallowing the closing fence, and `split('\n')` left a `\r` on every CRLF code
+  line; a block now opens for 3+ backticks with any non-backtick info string, only
+  a run at least as long as its opener closes it, and the document is split
+  CRLF-safe.
+- **A Markdown table rendered as space-separated plain text.** The `|---|` divider
+  was consumed by the parser to read alignment and never drawn, so a table had no
+  header marker, no column boundary and no rule - and under `--no-color`, where
+  bold is dropped too, nothing at all distinguished the header. `formatTable` now
+  returns `[header, divider, ...body]`, draws the rule from the caller's glyph and
+  separates columns with a visible `|` (both injected by `Markdown.tsx` from
+  `pickGlyphs`, so the parser stays ASCII-only and the pure default is `|`/`-`),
+  and pads by DISPLAY columns rather than `String.length`, which misaligned every
+  CJK cell. The separator costs one column per boundary; a table wide enough to
+  exceed the transcript is truncated rather than wrapped, which is the deliberate
+  trade recorded in §D-6.
+- **A command that succeeded said nothing, and its notice then displaced
+  `Idle` / `Running` until the next one.** `/theme light` changed the SGR, `/todo
+  panel on` changed the layout, `/expand 1` with nothing to expand did nothing -
+  and the only feedback was the echoed command, so "it worked", "the argument was
+  wrong" and "the key was never received" looked identical. Worse, the body had
+  been reaching `status-layout` all along but only rendered on the second status
+  row, behind Ctrl+G and off by default, while the phase word was REPLACED by the
+  feedback label: after `/copy` the row said `Copied` and never went back to
+  `Idle`, which is the one thing that row exists to answer. Notification kinds
+  (`notice`, `copied`, `copy-sent`, `copying`) now keep the phase word and add the
+  body as their own field, clipped to 32 display cells; action kinds (`confirm`,
+  `stopping`, `force-stop`, `exit`, `clear-input`, `copy-error`, `copy-cleanup`)
+  still take the phase slot, because "what the next key does" IS the phase. The
+  body is dropped before the phase word would be, and a copy error no longer paints
+  `Idle` red.
+- **`/help` turned 8 rows per PgDn on a 19-row window - 42% of a page.** Reading
+  the 93-row shortcut list took twelve presses and overlapped eleven rows every
+  time, while PgUp/PgDn in the transcript moved a whole page. The step is now
+  `overlayPageSize(overlayBodyRows(...))` - one window minus the two context rows
+  `scroll.pageSize` already keeps - and it reaches BOTH consumers, the keyboard
+  branch and the Shift+wheel notch (`getOverlayPage`), from the one function
+  `OverlayFrame` renders its window with, so the two cannot disagree.
+- **On a narrow terminal the header's right-hand hints collided with the
+  truncated caption.** The left half is `wrap="truncate"` and draws its ellipsis in
+  the last cell it owns, and the hint column started in the very next cell, so 52
+  columns read `aragon...Details off` as one string and 60 columns read
+  `glm-5.^L branch`. The row now spends a new `HEADER_HINT_LIMITS.separatorCells`
+  (2) between the halves, taken out of both the left half's width and the planner's
+  budget - a separate constant from `gapCells`, which spaces two hint clauses
+  inside the right column, because one constant carrying two meanings is how a
+  later spacing change silently re-lays-out the whole row. The `^I Index`
+  thresholds move with it: 54 columns collapsed and 64 expanded, two later than
+  before.
+- **A large paste arrived as runs of digits the moment it was sent - on screen,
+  in the model's input, in the prompt history and in the session file.**
+  `sanitisePaste` deleted the C0/C1 *introducer byte* and kept the parameter
+  bytes, so `ESC[38;2;18;52;86m` reached the transcript as the literal text
+  `[38;2;18;52;86m`. The composer collapses a large paste into
+  `[Pasted text #N +20 lines]`, so nothing was visible until submit expanded
+  it: a measured 20-line coloured log produced 80 runs of digits, and the same
+  string was what `/context`, the ↑ history and the session checkpoint stored.
+  Cleaning is now SEQUENCE-based and has one owner (new
+  `input/control-sequences.ts`, ASCII-only, no new dependency): a complete
+  escape goes as a unit, a truncated one loses its introducer and parameters
+  but never the character after them, an unterminated OSC/DCS/APC/PM/SOS goes
+  to the end of its line and never across it, and bare text that merely looks
+  like a sequence body (`[38;2m` with no ESC) is left exactly as it is.
+  `tools/terminal-output.ts`'s `stripAnsi` becomes a thin wrapper over the same
+  syntax, so a tool row and a paste cannot drift apart (both directions are
+  pinned by a cross-check test, and `terminal-output.test.ts` is unchanged).
+  A **single-line** paste carrying ESC - which `classifyChunk` sent down the
+  keystroke path with no cleaning at all - is now framed and cleaned like any
+  other paste; measured on the real component that path either put a live ESC
+  plus `[38;2;18;52;86m` into the draft or threw an uncaught `TypeError` inside
+  Ink's key parser. win32-input-mode records inside a frame are translated
+  rather than deleted, so a `?9001h` paste yields its characters instead of 15
+  visible digits per key (or, with cleaning but no translation, nothing at all).
+- **A pasted TAB-indented block or TSV table lined up differently before and
+  after sending.** One byte had three readings: the composer painted
+  four-column tab stops, the transcript handed the raw `\t` to the terminal
+  (eight), and the exit replay counted code units. New `ui/display-tab.ts`
+  expands a TAB by DISPLAY column (`string-width`, so a `CJK<TAB>X` line lands
+  where the terminal paints it); the composer's stop is the terminal's eight, and
+  `UserEntry`, `QueuedEntry` and the exit replay expand at paint time only -
+  the stored payload keeps its `\t`, so the model still receives the original
+  indentation. `wrappedRows` counts display columns too (with an ASCII fast
+  path, without which a 10 000-entry transcript timed out), because an estimate
+  that reads a TAB as one column keeps the row short while the painted row
+  grows - the under-estimate that file names as the unsafe direction.
 - **`Ctrl+L` opened a window that failed with a PowerShell `ParserError` on
   Windows.** The script handed to `-EncodedCommand` was the argv joined with
   quotes but with no call operator, and PowerShell reads a quoted string in command

package/README.md

@@ -539,7 +539,7 @@ completes, `Up` / `Down` moves the selection, `Esc` closes it.
 | `Ctrl+W`, `Alt+Backspace` | Delete the previous word |
 | `Ctrl+U` / `Ctrl+K` | Kill to line start / end |
 | `Up` / `Down` | 按视觉行移动；空草稿或正在浏览历史时，才在边界召回历史，避免覆盖新草稿 |
-| Paste | Inserted as-is up to 6 lines / 400 chars; larger collapses to `[Pasted text #1 +15 lines]`, which deletes as one unit and expands in full when you send. `--no-paste` restores the pre-0.6.3 behaviour |
+| Paste | Inserted up to 6 lines / 400 chars; larger collapses to `[Pasted text #1 +15 lines]`, which deletes as one unit and expands in full when you send. Escape sequences are removed as sequences (so a coloured log arrives as its text, not as `[38;2;18;52;86m`), and a TAB is kept in the payload but laid out at the terminal's 8-column tab stops, so the draft and the echoed message line up. `--no-paste` restores the pre-0.6.3 behaviour |
 | `?` | Open help (empty input) |
 
 In **full-screen mode**, PgUp/PgDn, Shift+Up/Down and the right-edge scrollbar
@@ -2219,7 +2219,7 @@ env / `.env` → CLI flags**.
 | `planModeDefault` | `false` | Start every session in plan mode. `--no-plan` still overrides it for a single run. |
 | `planModeMaxAskRounds` | `4` | `ask_user` rounds allowed per user message, clamped to `[1, 10]`. The counter resets on your next message; steering does **not** reset it. |
 | `planModeHumanTimeoutMs` | `1800000` | Ceiling on a single question / plan wait, clamped to `[60000, 7200000]`. Thirty minutes is far outside "went to get coffee", but a ceiling has to exist so an unattended terminal cannot wedge a CI job forever. |
-| `paste` | `true` | Recognise pasted text before Ink's key parser sees it: line breaks become buffer newlines instead of fifteen separate messages, control bytes are stripped instead of overwriting the row they land on, and a paste above 6 lines or 400 characters collapses to a one-line placeholder that expands when you send. `false` treats pasted bytes as keystrokes, which is what 0.6.2 did. |
+| `paste` | `true` | Recognise pasted text before Ink's key parser sees it: line breaks become buffer newlines instead of fifteen separate messages, escape SEQUENCES are removed whole (deleting only the introducer byte is what put `[38;2;18;52;86m` on screen and in the model's input) as are stray control bytes, and a paste above 6 lines or 400 characters collapses to a one-line placeholder that expands when you send. `false` treats pasted bytes as keystrokes, which is what 0.6.2 did. |
 | `historyEnabled` | `true` | Record submitted prompts to `prompt-history.jsonl` for `↑` recall. Setting it to `false` stops new writes; it does not delete what is already stored (that is `aragon history clear --yes`) and does not stop reading. See [Prompt history](#prompt-history). |
 | `team.enabled` | `true` | Master switch for team subagents. `false` means the `task` tool is never registered — `/team on` in such a session saves the setting for next launch and says so, rather than advertising a tool that is not there. |
 | `team.maxSubagents` | `5` | Subagents per dispatch, clamped to `[1, 10]`. The 10 is the hard ceiling and is enforced twice — on the config value and again on what the model asks for — so hand-editing this file cannot raise it. |

package/dist/agent/reducer.js

@@ -402,6 +402,36 @@ function releaseLiveTails(entries) {
     });
     return touched ? next : entries;
 }
+/**
+ * Drop settled assistant entries that render nothing at all (defect 5).
+ *
+ * `turnStart` ALWAYS creates an entry, so a turn that only called a tool leaves a
+ * bubble behind that `AssistantEntry` then refuses to draw. A rendered absence is
+ * not the same thing as an absent entry: `virtual-window.ts:305` still estimates a
+ * row for it (two when `aborted`, and nothing draws the second), and `/save`
+ * exports a blank bubble. Settle is the only safe moment to prune — before it the
+ * entry is still the target of every `textDelta` / `thinkingDelta`.
+ *
+ * I-L1-1 — `streamingId` COMES BACK WITH THE ARRAY. If the dropped entry is the
+ * one that id pointed at, the id is cleared: leaving it set would point the whole
+ * reducer at an entry no `mapEntry` can ever match again, silently, because a
+ * `mapEntry` on a missing id is a no-op. `turnEnd` and `runEnd` clear the id
+ * themselves; `abortMark` does not, which is why the caller writes this back.
+ *
+ * Returns the SAME array when nothing was dropped, so every settled entry keeps
+ * its identity and `EntryView`'s memo boundary stays intact.
+ */
+function pruneEmptyAssistant(entries, streamingId) {
+    const isEmptySettledAssistant = (entry) => entry.kind === 'assistant' &&
+        !entry.streaming &&
+        entry.text.trim() === '' &&
+        (entry.thinking ?? '').trim() === '';
+    const kept = entries.filter((entry) => !isEmptySettledAssistant(entry));
+    if (kept.length === entries.length)
+        return { entries, streamingId };
+    const liveGone = streamingId !== undefined && !kept.some((entry) => entry.id === streamingId);
+    return { entries: kept, streamingId: liveGone ? undefined : streamingId };
+}
 function findToolEntryId(state, toolCallId) {
     for (let i = state.entries.length - 1; i >= 0; i -= 1) {
         const e = state.entries[i];
@@ -673,7 +703,10 @@ export function viewReducer(state, action) {
                 // branch ever had. Two branches writing one number is what P0-1 was.
                 usageTotal: addUsage(state.usageTotal, action.usage, action.costDelta),
                 // The turn produced an answer, so whatever it had to retry, it recovered.
-                ...settleRetryCard(state, entries, 'recovered'),
+                // Defect 5: prune AFTER the mapEntry above has settled the entry, so an
+                // assistant bubble this turn never filled in is gone before the retry card
+                // is settled and before the height table ever sees it.
+                ...settleRetryCard(state, pruneEmptyAssistant(entries, state.streamingId).entries, 'recovered'),
             };
         }
         case 'runEnd': {
@@ -681,6 +714,12 @@ export function viewReducer(state, action) {
             let entries = state.streamingId
                 ? mapEntry(state.entries, state.streamingId, (e) => e.kind === 'assistant' ? { ...e, streaming: false, ...sealThinkingMs(e) } : e)
                 : state.entries;
+            /*
+             * Defect 5, and BEFORE the silent-failure guard below so the guard and the
+             * retry settle both see the pruned array. `streamingId: undefined` is set in
+             * the returned state either way, so the returned id is not needed here.
+             */
+            entries = pruneEmptyAssistant(entries, state.streamingId).entries;
             let seq = state.seq;
             let droppedEntries = state.droppedEntries;
             // Silent-failure guard (R2): a swallowed throw shows nothing otherwise.
@@ -750,13 +789,19 @@ export function viewReducer(state, action) {
             const marked = state.streamingId
                 ? mapEntry(state.entries, state.streamingId, (e) => e.kind === 'assistant' ? { ...e, streaming: false, aborted: true } : e)
                 : state.entries;
+            // Defect 5 / I-L1-1: prune AFTER the entry is settled, and write the
+            // returned id back below -- `abortMark` is the one settle path that does
+            // NOT clear `streamingId`, so a prune without that write-back would leave
+            // it naming an entry this branch has just removed.
+            const pruned = pruneEmptyAssistant(marked, state.streamingId);
             return {
                 ...state,
                 aborted: true,
+                streamingId: pruned.streamingId,
                 // An abort during a tool call is the COMMON way a tail is stranded --
                 // `Esc` while `npm test` runs -- so this is the clause manual row 9
                 // exercises (D-35 / AC-40).
-                ...settleRetryCard(state, releaseLiveTails(marked), 'interrupted'),
+                ...settleRetryCard(state, releaseLiveTails(pruned.entries), 'interrupted'),
             };
         }
         // `teamEntryId` is dropped with the entries it pointed at. Keeping it would

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

@@ -0,0 +1,71 @@
+/**
+ * Control-SEQUENCE removal for text that crosses a boundary where a terminal
+ * escape must never become content (paste-control-sequence-residue, fix A'-1).
+ *
+ * WHY A DELETE-THE-WHOLE-SEQUENCE RULE EXISTS. Deleting only the introducer
+ * byte turns an escape into visible text: `ESC [ 3 8 ; 2 m` loses its ESC and
+ * leaves `[38;2m`, which is a run of digits and semicolons somebody then reads
+ * on screen and sends to the model. The bytes were never content; the sequence
+ * has to go as a unit.
+ *
+ * WHY IT IS NOT `tools/terminal-output.ts`'s REGEXES MOVED HERE. Those four
+ * regexes answer "what does this look like" for a terminal row that is still
+ * being written, and they are fed text whose unfinished tail has ALREADY been
+ * cut off and parked in a carry by the caller (`sanitizeChunk`,
+ * `toDisplayRow`). Pasted text is one-shot: there is no next chunk, so a
+ * truncated sequence needs a rule of its own. Measured against the stream
+ * version of the same input, `ESC [ 3 8 ; 2 ; 1 8 ; 5 2 ; 8 6` followed by
+ * prose loses the first letter of the prose (`n`), and an unterminated OSC
+ * leaves its whole body behind.
+ *
+ * THE FOUR DECISIONS THIS MODULE ENCODES:
+ *
+ * 1. A sequence introduced by a real introducer byte (`0x1B`, `0x9B`, `0x9D`,
+ *    ...) is removed as a unit; bare text that merely LOOKS like the inside of
+ *    one (`[38;2;18;52;86m` typed or pasted without an ESC) is left exactly as
+ *    it is, character for character.
+ * 2. A string-type sequence (OSC / DCS / SOS / PM / APC) runs to BEL or ST, and
+ *    an unterminated one is removed UP TO THE END OF ITS LINE. It never crosses
+ *    `\n` and never guesses at a terminator: a truncated sequence is the most
+ *    common shape in a clipboard, and the only safe reading of it is "the rest
+ *    of this line was never text".
+ * 3. A truncated CSI loses its introducer and its parameter bytes and NOTHING
+ *    ELSE. `ESC [ 3 1 m` split mid-parameter is parameters, not prose, but the
+ *    byte after them is the user's own character and must survive.
+ * 4. A C1 CSI (`0x9B`) with no parameter byte at all is treated as the stray
+ *    control byte it is most likely to be rather than as a sequence, because a
+ *    lone `0x9B` followed by one letter is otherwise indistinguishable from a
+ *    non-UTF-8 file's stray byte followed by content -- and consuming that
+ *    letter would be the very data loss this module exists to prevent.
+ *
+ * Pure, ASCII-only, React-free, Ink-free, and TOTAL: it never throws and it
+ * never reorders or mangles the bytes it keeps. No new dependency.
+ */
+/**
+ * Remove every escape/control sequence, keeping all other bytes in order.
+ *
+ * KEEPS `\t`, `\n` AND `\r`: they are line structure, and `\t` inside pasted
+ * indentation is content the model is supposed to receive. Stray C0/C1 bytes
+ * (and DEL) are NOT this function's job -- they are removed by the caller that
+ * wants them gone, so one rule has one owner.
+ */
+export declare function stripControlSequences(text: string): string;
+/**
+ * True when `text` carries a sequence a KEYBOARD cannot physically produce.
+ *
+ * Used at the keystroke branch of the stdin filter: a single-line paste that
+ * carries ESC fails `classifyChunk`'s two rules (no line break, and
+ * `HAS_CONTROL_EXCEPT_TAB`) and would otherwise reach Ink as raw bytes --
+ * either typing `[38;2;18;52;86m` with a live ESC into the draft, or throwing
+ * an uncaught `TypeError` inside Ink's key parser.
+ *
+ * THREE THINGS MUST NOT MATCH, and the shapes below are why:
+ * - SGR mouse reports (`ESC [ < 0 ; 1 ; 2 m`) are stripped by `splitMouseEvents`
+ *   BEFORE this test, and `<` is not a parameter byte, so the SGR rule cannot
+ *   see them anyway.
+ * - Arrow / function / Home / End keys (`ESC [ A`, `ESC [ 1 ; 5 D`, `ESC [ 3 ~`,
+ *   `ESC [ Z`) never end in `m`.
+ * - `Alt`+letter (`ESC` followed by one character) has no introducer body, so
+ *   the string-type rule does not fire.
+ */
+export declare function hasPasteOnlySequence(text: string): boolean;

package/dist/input/control-sequences.js

@@ -0,0 +1,222 @@
+/**
+ * Control-SEQUENCE removal for text that crosses a boundary where a terminal
+ * escape must never become content (paste-control-sequence-residue, fix A'-1).
+ *
+ * WHY A DELETE-THE-WHOLE-SEQUENCE RULE EXISTS. Deleting only the introducer
+ * byte turns an escape into visible text: `ESC [ 3 8 ; 2 m` loses its ESC and
+ * leaves `[38;2m`, which is a run of digits and semicolons somebody then reads
+ * on screen and sends to the model. The bytes were never content; the sequence
+ * has to go as a unit.
+ *
+ * WHY IT IS NOT `tools/terminal-output.ts`'s REGEXES MOVED HERE. Those four
+ * regexes answer "what does this look like" for a terminal row that is still
+ * being written, and they are fed text whose unfinished tail has ALREADY been
+ * cut off and parked in a carry by the caller (`sanitizeChunk`,
+ * `toDisplayRow`). Pasted text is one-shot: there is no next chunk, so a
+ * truncated sequence needs a rule of its own. Measured against the stream
+ * version of the same input, `ESC [ 3 8 ; 2 ; 1 8 ; 5 2 ; 8 6` followed by
+ * prose loses the first letter of the prose (`n`), and an unterminated OSC
+ * leaves its whole body behind.
+ *
+ * THE FOUR DECISIONS THIS MODULE ENCODES:
+ *
+ * 1. A sequence introduced by a real introducer byte (`0x1B`, `0x9B`, `0x9D`,
+ *    ...) is removed as a unit; bare text that merely LOOKS like the inside of
+ *    one (`[38;2;18;52;86m` typed or pasted without an ESC) is left exactly as
+ *    it is, character for character.
+ * 2. A string-type sequence (OSC / DCS / SOS / PM / APC) runs to BEL or ST, and
+ *    an unterminated one is removed UP TO THE END OF ITS LINE. It never crosses
+ *    `\n` and never guesses at a terminator: a truncated sequence is the most
+ *    common shape in a clipboard, and the only safe reading of it is "the rest
+ *    of this line was never text".
+ * 3. A truncated CSI loses its introducer and its parameter bytes and NOTHING
+ *    ELSE. `ESC [ 3 1 m` split mid-parameter is parameters, not prose, but the
+ *    byte after them is the user's own character and must survive.
+ * 4. A C1 CSI (`0x9B`) with no parameter byte at all is treated as the stray
+ *    control byte it is most likely to be rather than as a sequence, because a
+ *    lone `0x9B` followed by one letter is otherwise indistinguishable from a
+ *    non-UTF-8 file's stray byte followed by content -- and consuming that
+ *    letter would be the very data loss this module exists to prevent.
+ *
+ * Pure, ASCII-only, React-free, Ink-free, and TOTAL: it never throws and it
+ * never reorders or mangles the bytes it keeps. No new dependency.
+ */
+/** ESC -- the introducer every terminal shares. */
+const ESC = 0x1b;
+/** LF. No rule in this module may consume it (decision 2). */
+const LF = 0x0a;
+/** BEL terminates an OSC. */
+const BEL = 0x07;
+/** `[` after ESC is CSI, and `\` after ESC is the two-byte ST. */
+const BRACKET = 0x5b;
+const BACKSLASH = 0x5c;
+/** The ASCII second byte of each string-type sequence (`ESC ]`, `ESC P`, ...). */
+const ESC_DCS = 0x50;
+const ESC_SOS = 0x58;
+const ESC_OSC = 0x5d;
+const ESC_PM = 0x5e;
+const ESC_APC = 0x5f;
+/** C1 introducers, as written by a source that is not UTF-8 clean. */
+const C1_CSI = 0x9b;
+const C1_ST = 0x9c;
+const C1_OSC = 0x9d;
+const C1_DCS = 0x90;
+const C1_SOS = 0x98;
+const C1_PM = 0x9e;
+const C1_APC = 0x9f;
+/** Every byte that can START a sequence this module removes. */
+const ANY_INTRODUCER = /[\u001b\u0090\u0098\u009b\u009d\u009e\u009f]/;
+/**
+ * `CSI ... m` (SGR), in both encodings: `ESC [ digits ; m` and the single-byte
+ * C1 form `0x9B digits ; m`. NO KEY PRESS PRODUCES ONE, which is what makes it
+ * usable as the discriminator for an unframed paste in `stdin-filter.ts`.
+ */
+const SGR_SEQUENCE = /\u001b\[[0-9;]*m|\u009b[0-9;]*m/;
+/**
+ * A string-type introducer followed by at least one body byte. An `Alt`+key
+ * press is exactly two bytes, so "introducer plus a body" is already outside
+ * what a keyboard can emit.
+ */
+const STRING_SEQUENCE = /(?:\u001b[\u0050\u0058\u005d\u005e\u005f]|[\u0090\u0098\u009d\u009e\u009f])[\s\S]/;
+/** CSI final byte: `@` through `~`. */
+function isFinalByte(code) {
+    return code >= 0x40 && code <= 0x7e;
+}
+/** CSI parameter byte: `0` through `?`. */
+function isParamByte(code) {
+    return code >= 0x30 && code <= 0x3f;
+}
+/**
+ * CSI intermediate byte: `!` through `/`.
+ *
+ * SPACE (`0x20`) IS DELIBERATELY EXCLUDED (decision 3). The standard allows it,
+ * but a pasted sequence cut mid-parameter is followed by ` ` and then prose,
+ * and the first letter of that prose is a legal final byte -- so honouring the
+ * space would silently eat it. `CSI Ps SP q` (cursor style) is the only shape
+ * that gets worse, and no child process writes that to its stdout.
+ */
+function isIntermediateByte(code) {
+    return code >= 0x21 && code <= 0x2f;
+}
+/** True for the C1 introducers that open a string, not a CSI. */
+function isC1StringIntroducer(code) {
+    return code === C1_OSC || code === C1_DCS || code === C1_SOS || code === C1_PM || code === C1_APC;
+}
+/**
+ * End of the string-type sequence whose body starts at `from`.
+ *
+ * Stops AT the line break rather than past it, and reports "consumed to here"
+ * for a body that never terminates (decision 2).
+ */
+function stringEnd(text, from) {
+    let i = from;
+    while (i < text.length) {
+        const code = text.charCodeAt(i);
+        if (code === BEL || code === C1_ST)
+            return i + 1;
+        if (code === LF)
+            return i;
+        if (code === ESC && text.charCodeAt(i + 1) === BACKSLASH)
+            return i + 2;
+        i += 1;
+    }
+    return i;
+}
+/**
+ * End of the CSI whose parameter run starts at `from`.
+ *
+ * `requireParams` implements decision 4: with no parameter byte at all, a C1
+ * CSI is only the introducer byte, and its "final byte" is content.
+ */
+function csiEnd(text, from, requireParams) {
+    let i = from;
+    let sawParams = false;
+    while (i < text.length && isParamByte(text.charCodeAt(i))) {
+        sawParams = true;
+        i += 1;
+    }
+    if (requireParams && !sawParams)
+        return from;
+    while (i < text.length && isIntermediateByte(text.charCodeAt(i)))
+        i += 1;
+    if (i < text.length && isFinalByte(text.charCodeAt(i)))
+        return i + 1;
+    return i;
+}
+/** End of the sequence starting with ESC at `index` (decision 1 / 3). */
+function escapeEnd(text, index) {
+    if (index + 1 >= text.length)
+        return index + 1;
+    const next = text.charCodeAt(index + 1);
+    if (next === BRACKET)
+        return csiEnd(text, index + 2, false);
+    if (next === ESC_OSC || next === ESC_DCS || next === ESC_SOS || next === ESC_PM
+        || next === ESC_APC) {
+        return stringEnd(text, index + 2);
+    }
+    if (next === LF)
+        return index + 1;
+    return index + 2;
+}
+/**
+ * End of the sequence starting at `index`, or `-1` when no sequence starts
+ * there.
+ */
+function sequenceEnd(text, index) {
+    const code = text.charCodeAt(index);
+    if (code === ESC)
+        return escapeEnd(text, index);
+    if (code === C1_CSI)
+        return csiEnd(text, index + 1, true);
+    if (isC1StringIntroducer(code)) {
+        return index + 1 >= text.length ? index + 1 : stringEnd(text, index + 1);
+    }
+    return -1;
+}
+/**
+ * Remove every escape/control sequence, keeping all other bytes in order.
+ *
+ * KEEPS `\t`, `\n` AND `\r`: they are line structure, and `\t` inside pasted
+ * indentation is content the model is supposed to receive. Stray C0/C1 bytes
+ * (and DEL) are NOT this function's job -- they are removed by the caller that
+ * wants them gone, so one rule has one owner.
+ */
+export function stripControlSequences(text) {
+    if (!ANY_INTRODUCER.test(text))
+        return text;
+    let out = '';
+    let kept = 0;
+    let i = 0;
+    while (i < text.length) {
+        const end = sequenceEnd(text, i);
+        if (end === -1) {
+            i += 1;
+            continue;
+        }
+        out += text.slice(kept, i);
+        i = end;
+        kept = end;
+    }
+    return kept === 0 ? text : out + text.slice(kept);
+}
+/**
+ * True when `text` carries a sequence a KEYBOARD cannot physically produce.
+ *
+ * Used at the keystroke branch of the stdin filter: a single-line paste that
+ * carries ESC fails `classifyChunk`'s two rules (no line break, and
+ * `HAS_CONTROL_EXCEPT_TAB`) and would otherwise reach Ink as raw bytes --
+ * either typing `[38;2;18;52;86m` with a live ESC into the draft, or throwing
+ * an uncaught `TypeError` inside Ink's key parser.
+ *
+ * THREE THINGS MUST NOT MATCH, and the shapes below are why:
+ * - SGR mouse reports (`ESC [ < 0 ; 1 ; 2 m`) are stripped by `splitMouseEvents`
+ *   BEFORE this test, and `<` is not a parameter byte, so the SGR rule cannot
+ *   see them anyway.
+ * - Arrow / function / Home / End keys (`ESC [ A`, `ESC [ 1 ; 5 D`, `ESC [ 3 ~`,
+ *   `ESC [ Z`) never end in `m`.
+ * - `Alt`+letter (`ESC` followed by one character) has no introducer body, so
+ *   the string-type rule does not fire.
+ */
+export function hasPasteOnlySequence(text) {
+    return SGR_SEQUENCE.test(text) || STRING_SEQUENCE.test(text);
+}

package/dist/input/limits.d.ts

@@ -39,6 +39,26 @@ export declare const PASTE_BURST_MS = 15;
  * which is the rule `MAX_PENDING_MOUSE_CHARS` already encodes for mouse reports.
  */
 export declare const PASTE_ASSEMBLY_MAX_MS = 2000;
+/**
+ * How long a paste-marker head that was ALREADY released to the pass-through as
+ * ordinary text may still be recognised as the head of a marker (defect 2: the
+ * torn-marker rescue in `stdin-filter.ts`).
+ *
+ * STRUCTURAL, NOT POLICY: no config key exposes it, because it bounds what the
+ * byte stream can physically do -- a marker split across two reads -- and not
+ * what a user prefers. What it does NOT do is delay a keystroke: the 12 ms
+ * pending-flush window in `stdin-filter.ts` still releases a lone ESC exactly as
+ * before, and this window only governs whether that release may be spliced back
+ * in front of the next chunk so an assembled marker is consumed, not typed.
+ *
+ * THE FALSE POSITIVE IS THE TRADE-OFF, AND IT IS ACCEPTED. Firing the rescue
+ * wrongly needs the user to press Esc and then TYPE the literal characters
+ * `[200~` or `[201~` inside this window -- a sequence no keyboard produces, and
+ * at worst five characters of lost typing. Paying that buys a fix for visible
+ * `[200~` / `[201~` garbage in the draft, which is the failure the whole paste
+ * feature exists to prevent.
+ */
+export declare const PASTE_MARKER_RESCAN_TTL_MS = 250;
 /**
  * The inline frame the filter writes into the stream Ink reads (D-3 / I-5).
  *

package/dist/input/limits.js

@@ -39,6 +39,26 @@ export const PASTE_BURST_MS = 15;
  * which is the rule `MAX_PENDING_MOUSE_CHARS` already encodes for mouse reports.
  */
 export const PASTE_ASSEMBLY_MAX_MS = 2_000;
+/**
+ * How long a paste-marker head that was ALREADY released to the pass-through as
+ * ordinary text may still be recognised as the head of a marker (defect 2: the
+ * torn-marker rescue in `stdin-filter.ts`).
+ *
+ * STRUCTURAL, NOT POLICY: no config key exposes it, because it bounds what the
+ * byte stream can physically do -- a marker split across two reads -- and not
+ * what a user prefers. What it does NOT do is delay a keystroke: the 12 ms
+ * pending-flush window in `stdin-filter.ts` still releases a lone ESC exactly as
+ * before, and this window only governs whether that release may be spliced back
+ * in front of the next chunk so an assembled marker is consumed, not typed.
+ *
+ * THE FALSE POSITIVE IS THE TRADE-OFF, AND IT IS ACCEPTED. Firing the rescue
+ * wrongly needs the user to press Esc and then TYPE the literal characters
+ * `[200~` or `[201~` inside this window -- a sequence no keyboard produces, and
+ * at worst five characters of lost typing. Paying that buys a fix for visible
+ * `[200~` / `[201~` garbage in the draft, which is the failure the whole paste
+ * feature exists to prevent.
+ */
+export const PASTE_MARKER_RESCAN_TTL_MS = 250;
 /**
  * The inline frame the filter writes into the stream Ink reads (D-3 / I-5).
  *