@aragon-agent/cli 0.6.27 → 0.6.28

package/CHANGELOG.md

@@ -77,6 +77,42 @@ were written.
 
 ### Fixed
 
+- **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/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/paste-parse.d.ts

@@ -56,16 +56,28 @@ export declare function classifyChunk(text: string, minBurstChars?: number): 'pa
  *    newline in pasted text, and a lone LF is dropped by Ink's key parser
  *    entirely, so both have to be normalised here or a pasted line break either
  *    submits the message or silently vanishes.
- * 2. Every C0 byte except `\n` and `\t` is removed. Ink writes `<Text>` children
- *    to the terminal without escaping anything, so a surviving `\r` overwrites
- *    the row it is drawn on and a surviving `\x1b` repaints the frame's colours.
- * 3. DEL and every C1 byte (U+0080..U+009F) go too, and that is NOT padding:
- *    U+009B is the single-byte CSI and U+0085 is NEL, and a terminal that decodes
- *    them acts on them exactly as it acts on `\x1b[`. A file pasted out of a
- *    non-UTF-8 editor walks straight through a "strip C0" rule.
- * 4. TAB is KEPT. Indentation is content, and it is what the model receives.
+ * 2. Every escape SEQUENCE is removed AS A SEQUENCE (`stripControlSequences`).
+ *    Deleting only the introducer byte is what produced the reported defect:
+ *    `ESC [ 3 8 ; 2 ; 1 8 ; 5 2 ; 8 6 m` minus its ESC is `[38;2;18;52;86m`,
+ *    a run of digits Ink then writes to the terminal as ordinary text -- and it
+ *    reached the model, the prompt history and the session file too, because
+ *    this function is the only cleaning the payload ever gets.
+ * 3. Every remaining C0 byte except `\n` and `\t` is removed. Ink writes
+ *    `<Text>` children to the terminal without escaping anything, so a
+ *    surviving `\r` overwrites the row it is drawn on and a surviving `ESC`
+ *    repaints the frame colours. Sequences are gone by this point, so what is
+ *    left for this step is a stray byte, never half of one.
+ * 4. DEL and every C1 byte (U+0080..U+009F) go too, and that is NOT padding:
+ *    U+009B is the single-byte CSI and U+0085 is NEL, and a terminal that
+ *    decodes them acts on them exactly as it acts on `ESC [`. A file pasted out
+ *    of a non-UTF-8 editor walks straight through a "strip C0" rule.
+ * 5. TAB is KEPT. Indentation is content, and it is what the model receives.
+ *    Expanding it is the RENDERERS' job (`ui/display-tab.ts`), so the model
+ *    keeps the original indentation while the screen, the composer and the
+ *    terminal all agree on what column a TAB lands on.
  *
  * Applied to PAYLOAD ONLY, never to keystrokes, so `Ctrl+A` and Escape keep
- * working. Non-ASCII text (CJK, emoji) is untouched.
+ * working. Non-ASCII text (CJK, emoji) is untouched. Idempotent, so the
+ * second pass in `ui/paste-frames.ts` stays a byte-identical no-op.
  */
 export declare function sanitisePaste(raw: string): string;

package/dist/input/paste-parse.js

@@ -16,6 +16,7 @@
  * `DECSET 2004`. Both are about what a keyboard can physically emit.
  */
 import { PASTE_MIN_BURST_CHARS } from './limits.js';
+import { stripControlSequences } from './control-sequences.js';
 /** `DECSET 2004` wraps a paste in these two markers. */
 export const PASTE_BEGIN_MARK = '\x1b[200~';
 export const PASTE_END_MARK = '\x1b[201~';
@@ -76,20 +77,31 @@ export function classifyChunk(text, minBurstChars = PASTE_MIN_BURST_CHARS) {
  *    newline in pasted text, and a lone LF is dropped by Ink's key parser
  *    entirely, so both have to be normalised here or a pasted line break either
  *    submits the message or silently vanishes.
- * 2. Every C0 byte except `\n` and `\t` is removed. Ink writes `<Text>` children
- *    to the terminal without escaping anything, so a surviving `\r` overwrites
- *    the row it is drawn on and a surviving `\x1b` repaints the frame's colours.
- * 3. DEL and every C1 byte (U+0080..U+009F) go too, and that is NOT padding:
- *    U+009B is the single-byte CSI and U+0085 is NEL, and a terminal that decodes
- *    them acts on them exactly as it acts on `\x1b[`. A file pasted out of a
- *    non-UTF-8 editor walks straight through a "strip C0" rule.
- * 4. TAB is KEPT. Indentation is content, and it is what the model receives.
+ * 2. Every escape SEQUENCE is removed AS A SEQUENCE (`stripControlSequences`).
+ *    Deleting only the introducer byte is what produced the reported defect:
+ *    `ESC [ 3 8 ; 2 ; 1 8 ; 5 2 ; 8 6 m` minus its ESC is `[38;2;18;52;86m`,
+ *    a run of digits Ink then writes to the terminal as ordinary text -- and it
+ *    reached the model, the prompt history and the session file too, because
+ *    this function is the only cleaning the payload ever gets.
+ * 3. Every remaining C0 byte except `\n` and `\t` is removed. Ink writes
+ *    `<Text>` children to the terminal without escaping anything, so a
+ *    surviving `\r` overwrites the row it is drawn on and a surviving `ESC`
+ *    repaints the frame colours. Sequences are gone by this point, so what is
+ *    left for this step is a stray byte, never half of one.
+ * 4. DEL and every C1 byte (U+0080..U+009F) go too, and that is NOT padding:
+ *    U+009B is the single-byte CSI and U+0085 is NEL, and a terminal that
+ *    decodes them acts on them exactly as it acts on `ESC [`. A file pasted out
+ *    of a non-UTF-8 editor walks straight through a "strip C0" rule.
+ * 5. TAB is KEPT. Indentation is content, and it is what the model receives.
+ *    Expanding it is the RENDERERS' job (`ui/display-tab.ts`), so the model
+ *    keeps the original indentation while the screen, the composer and the
+ *    terminal all agree on what column a TAB lands on.
  *
  * Applied to PAYLOAD ONLY, never to keystrokes, so `Ctrl+A` and Escape keep
- * working. Non-ASCII text (CJK, emoji) is untouched.
+ * working. Non-ASCII text (CJK, emoji) is untouched. Idempotent, so the
+ * second pass in `ui/paste-frames.ts` stays a byte-identical no-op.
  */
 export function sanitisePaste(raw) {
-    return raw
-        .replace(/\r\n?/g, '\n')
+    return stripControlSequences(raw.replace(/\r\n?/g, '\n'))
         .replace(/[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F-\u009F]/g, '');
 }

package/dist/input/stdin-filter.js

@@ -33,8 +33,9 @@
  */
 import { PassThrough } from 'node:stream';
 import { MAX_PENDING_MOUSE_CHARS, splitMouseEvents, isMousePrefix, } from './mouse-events.js';
-import { ENTER_NEWLINE_FRAME, PASTE_ASSEMBLY_MAX_MS, PASTE_BURST_MS, PASTE_CLOSE, PASTE_MAX_BYTES, PASTE_OPEN, formatPasteSize, } from './limits.js';
+import { ENTER_NEWLINE_FRAME, INDEX_KEY_FRAME, 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 { hasPasteOnlySequence } from './control-sequences.js';
 import { splitEnterSequences, trailingEnterPrefixLength } from './enter-sequences.js';
 import { splitCsiUKeys, trailingCsiUPrefixLength, translateCsiUKey } from './csiu-keys.js';
 import { splitWin32KeySequences, trailingWin32PrefixLength, translateWin32Key, } from './win32-input-mode.js';
@@ -206,8 +207,8 @@ export function createStdinFilter(real, features, bridge, onWarn) {
     // The scan (section 5.1, and the ORDER below is the specification)
     // -----------------------------------------------------------------------
     /**
-     * Text that reached the pass-through: Tier 2 classification, then mouse
-     * stripping, then Ink.
+     * Text that reached the pass-through: a sequence a KEYBOARD cannot produce
+     * first (R-2), then Tier 2 classification, then mouse stripping, then Ink.
      *
      * MOUSE PARSING IS SUSPENDED FOR THE DURATION OF ANY PASTE BODY (I-3), burst
      * and bracketed alike. The Tier 2 population is precisely the terminals with
@@ -225,6 +226,23 @@ export function createStdinFilter(real, features, bridge, onWarn) {
             burstTimer = arm(flushBurst, PASTE_BURST_MS);
             return;
         }
+        // A SEQUENCE A KEYBOARD CANNOT PRODUCE IS A PASTE, FRAMED OR NOT (R-2).
+        //
+        // WHY THE CLASSIFIER BELOW IS NOT ENOUGH. `classifyChunk` needs either a
+        // line break or a chunk with no control byte but TAB, and a SINGLE-LINE
+        // paste carrying ESC satisfies neither -- so it travels the keystroke path
+        // with `sanitisePaste` never called. Measured on the real component that
+        // cost either a draft holding `[38;2;18;52;86m` ALONGSIDE A LIVE ESC (which
+        // then reached the model, the history and the session file) or an uncaught
+        // `TypeError` in Ink's parser, because `parse-keypress.js` maps `ESC [ 3 2 m`
+        // to a ctrl key whose `name` is undefined. Framing it here routes it through
+        // the ONE cleaning path every other paste already takes.
+        if (features.paste && hasPasteOnlySequence(text)) {
+            paste = { kind: 'burst', body: text, bytes: byteLength(text) };
+            burstTimer = clearTimer(burstTimer);
+            burstTimer = arm(flushBurst, PASTE_BURST_MS);
+            return;
+        }
         if (features.paste && classifyChunk(text) === 'paste') {
             paste = { kind: 'burst', body: text, bytes: byteLength(text) };
             burstTimer = clearTimer(burstTimer);
@@ -300,14 +318,47 @@ export function createStdinFilter(real, features, bridge, onWarn) {
             }
         }
     };
+    /**
+     * win32-input-mode records that arrived INSIDE a paste frame (R-4).
+     *
+     * DATA FIDELITY, NOT POLISH. Every character of a `?9001h` session arrives as
+     * `ESC [ vk ; sc ; char ; down ; mods ; rep _`, and once the frame opens
+     * nothing translated them: `sanitisePaste` then removed each record's ESC and
+     * left 15 visible characters of digits per key. Translating them is also what
+     * keeps the fix honest in the OTHER direction -- a whole-sequence stripper
+     * deletes such a record outright, so "clean" would have meant the user's
+     * characters silently vanishing. A record carrying a key FRAME (modified
+     * Enter, Ctrl+I) becomes the byte that frame stands for, because a frame
+     * inside a body is content and never a key.
+     */
+    const translateInPaste = (text) => {
+        if (!enhancedKeys || !text.includes('\x1b['))
+            return text;
+        let out = '';
+        for (const segment of splitWin32KeySequences(text)) {
+            if (segment.kind === 'text') {
+                out += segment.text;
+                continue;
+            }
+            const legacy = translateWin32Key(segment.record);
+            if (legacy === ENTER_NEWLINE_FRAME)
+                out += '\n';
+            else if (legacy === INDEX_KEY_FRAME)
+                out += '\t';
+            else
+                out += legacy;
+        }
+        return out;
+    };
     const appendBracketed = (text) => {
         if (paste.kind !== 'bracketed' || text.length === 0 || discardBracketed)
             return;
-        const bytes = paste.bytes + byteLength(text);
+        const body = translateInPaste(text);
+        const bytes = paste.bytes + byteLength(body);
         const overflow = paste.overflow || bytes > PASTE_MAX_BYTES;
         paste = {
             kind: 'bracketed',
-            body: overflow ? paste.body : paste.body + text,
+            body: overflow ? paste.body : paste.body + body,
             bytes,
             overflow,
         };

package/dist/tools/terminal-output.d.ts

@@ -65,6 +65,14 @@ export interface SanitizeResult {
 /**
  * Remove every escape sequence and control byte except `\t` `\n` `\r`.
  *
+ * SEQUENCE SYNTAX HAS ONE OWNER (`input/control-sequences.ts`); this function
+ * adds only the control-byte sweep a DISPLAY row wants. Both call sites in this
+ * module already cut an unfinished escape off into the carry before calling it
+ * (`partialEscapeStart`), so the shared one-shot rule for a truncated sequence
+ * is exactly what they need -- and it fixes AC-24's failure in place: the old
+ * two-byte rule consumed the `\x1b[` of an unfinished CSI and left the
+ * PARAMETERS behind, so `\x1b[31m` split across chunks rendered as `red 3`.
+ *
  * Exported for the tests, and used by `toDisplayRow` as the second line of
  * defence over a carry that ends mid-escape.
  */

package/dist/tools/terminal-output.js

@@ -22,6 +22,7 @@
  * interpreting cursor motion would mean owning a screen buffer. Neither is a
  * presentation round's job.
  */
+import { stripControlSequences } from '../input/control-sequences.js';
 /** Columns a live row may occupy before it is clipped. */
 export const LIVE_ROW_MAX_CHARS = 200;
 /** Tab stop width, matching every terminal's default. */
@@ -57,22 +58,24 @@ export const TRUNCATION_MARK = '...';
  * and holding it forever would pin the carry.
  */
 const MAX_PARTIAL_ESCAPE = 64;
-/** CSI: `\x1b[` params intermediates final. */
-const CSI = /\x1b\[[0-?]*[ -/]*[@-~]/g;
-/** OSC: `\x1b]` ... terminated by BEL or ST. */
-const OSC = /\x1b\][\s\S]*?(?:\x07|\x1b\\)/g;
-/** The two-byte forms: `\x1b` followed by one character. */
-const ESC_PAIR = /\x1b[\s\S]/g;
 /** C1, plus every C0 control except `\t` `\n` `\r`. */
 const CONTROLS = /[\x00-\x08\x0b\x0c\x0e-\x1f\x7f-\x9f]/g;
 /**
  * Remove every escape sequence and control byte except `\t` `\n` `\r`.
  *
+ * SEQUENCE SYNTAX HAS ONE OWNER (`input/control-sequences.ts`); this function
+ * adds only the control-byte sweep a DISPLAY row wants. Both call sites in this
+ * module already cut an unfinished escape off into the carry before calling it
+ * (`partialEscapeStart`), so the shared one-shot rule for a truncated sequence
+ * is exactly what they need -- and it fixes AC-24's failure in place: the old
+ * two-byte rule consumed the `\x1b[` of an unfinished CSI and left the
+ * PARAMETERS behind, so `\x1b[31m` split across chunks rendered as `red 3`.
+ *
  * Exported for the tests, and used by `toDisplayRow` as the second line of
  * defence over a carry that ends mid-escape.
  */
 export function stripAnsi(text) {
-    return text.replace(CSI, '').replace(OSC, '').replace(ESC_PAIR, '').replace(CONTROLS, '');
+    return stripControlSequences(text).replace(CONTROLS, '');
 }
 /**
  * Index at which a trailing INCOMPLETE escape begins, or `-1`.

package/dist/ui/display-tab.d.ts

@@ -0,0 +1,51 @@
+/**
+ * TAB expansion that agrees with the TERMINAL, not with UTF-16 (fix A'-2 of
+ * paste-control-sequence-residue).
+ *
+ * WHY THIS IS A MODULE OF ITS OWN. A TAB has no width; it advances the pen to
+ * the next tab stop, so what it occupies depends on where the line currently
+ * is. That makes "one TAB" a property of a CURSOR, and the same character was
+ * being read three different ways in this package:
+ *
+ * - `ui/editor-navigation.ts` painted it at FOUR-column stops in the composer,
+ * - `entries/UserEntry.tsx` handed the raw byte to `<Text>`, so the terminal
+ *   painted it at EIGHT-column stops in the transcript,
+ * - `tools/terminal-output.ts` expanded it by UTF-16 code-unit count, so a
+ *   pasted `中文<TAB>X` table came out two columns short.
+ *
+ * A user who pastes a TAB-indented block or an Excel/Word table therefore saw
+ * the draft and the sent message disagree about their own text. One function,
+ * used by the composer AND by every renderer of stored text, is what makes the
+ * "before send" and "after send" rows character-identical.
+ *
+ * `input/` is the wrong home for it: `cli/input` may depend on `node:stream`
+ * and nothing else (`.claude-index/index.md`), and column arithmetic needs the
+ * width table. `ui/` already owns that (`selection/selection.ts` uses
+ * `string-width` for exactly this reason).
+ *
+ * Pure, React-free, Ink-free.
+ */
+/**
+ * Tab stop width, matching every terminal's default.
+ *
+ * A COPY OF `tools/terminal-output.ts`'s number, on purpose and in the same
+ * shape `composer-limits.ts` copies `budget.ts::HINT_MIN_ROWS`: importing the
+ * tools module here would point an arrow from `ui/` into `tools/` for one
+ * integer, and the two are asserted equal by a test instead. (`tools/` keeps
+ * its own expander because its rows are clipped to 200 columns before anyone
+ * looks at them, so a code-unit approximation there cannot reach a user.)
+ */
+export declare const TAB_WIDTH = 8;
+/**
+ * Expand every TAB in `text` to spaces up to the next `TAB_WIDTH` stop, given
+ * the display column the first character will be painted at.
+ *
+ * `fromColumn` is a DISPLAY column, not an offset: a caller that has already
+ * painted `中文` must pass 4. Lines are independent -- a `\n` resets the column
+ * to zero, because the terminal's pen returns to column 0.
+ *
+ * Non-ASCII text is measured with `string-width`, which is the whole point: a
+ * CJK glyph occupies two cells, and counting it as one space is what left
+ * CJK-plus-TAB tables misaligned.
+ */
+export declare function expandTabs(text: string, fromColumn?: number): string;

package/dist/ui/display-tab.js

@@ -0,0 +1,82 @@
+/**
+ * TAB expansion that agrees with the TERMINAL, not with UTF-16 (fix A'-2 of
+ * paste-control-sequence-residue).
+ *
+ * WHY THIS IS A MODULE OF ITS OWN. A TAB has no width; it advances the pen to
+ * the next tab stop, so what it occupies depends on where the line currently
+ * is. That makes "one TAB" a property of a CURSOR, and the same character was
+ * being read three different ways in this package:
+ *
+ * - `ui/editor-navigation.ts` painted it at FOUR-column stops in the composer,
+ * - `entries/UserEntry.tsx` handed the raw byte to `<Text>`, so the terminal
+ *   painted it at EIGHT-column stops in the transcript,
+ * - `tools/terminal-output.ts` expanded it by UTF-16 code-unit count, so a
+ *   pasted `中文<TAB>X` table came out two columns short.
+ *
+ * A user who pastes a TAB-indented block or an Excel/Word table therefore saw
+ * the draft and the sent message disagree about their own text. One function,
+ * used by the composer AND by every renderer of stored text, is what makes the
+ * "before send" and "after send" rows character-identical.
+ *
+ * `input/` is the wrong home for it: `cli/input` may depend on `node:stream`
+ * and nothing else (`.claude-index/index.md`), and column arithmetic needs the
+ * width table. `ui/` already owns that (`selection/selection.ts` uses
+ * `string-width` for exactly this reason).
+ *
+ * Pure, React-free, Ink-free.
+ */
+import stringWidth from 'string-width';
+/**
+ * Tab stop width, matching every terminal's default.
+ *
+ * A COPY OF `tools/terminal-output.ts`'s number, on purpose and in the same
+ * shape `composer-limits.ts` copies `budget.ts::HINT_MIN_ROWS`: importing the
+ * tools module here would point an arrow from `ui/` into `tools/` for one
+ * integer, and the two are asserted equal by a test instead. (`tools/` keeps
+ * its own expander because its rows are clipped to 200 columns before anyone
+ * looks at them, so a code-unit approximation there cannot reach a user.)
+ */
+export const TAB_WIDTH = 8;
+/**
+ * Expand every TAB in `text` to spaces up to the next `TAB_WIDTH` stop, given
+ * the display column the first character will be painted at.
+ *
+ * `fromColumn` is a DISPLAY column, not an offset: a caller that has already
+ * painted `中文` must pass 4. Lines are independent -- a `\n` resets the column
+ * to zero, because the terminal's pen returns to column 0.
+ *
+ * Non-ASCII text is measured with `string-width`, which is the whole point: a
+ * CJK glyph occupies two cells, and counting it as one space is what left
+ * CJK-plus-TAB tables misaligned.
+ */
+export function expandTabs(text, fromColumn = 0) {
+    if (text.indexOf('\t') === -1)
+        return text;
+    let out = '';
+    let column = Math.max(0, Math.floor(fromColumn));
+    let run = '';
+    for (const part of graphemesOf(text)) {
+        if (part === '\t') {
+            out += run;
+            run = '';
+            const width = TAB_WIDTH - (column % TAB_WIDTH);
+            out += ' '.repeat(width);
+            column += width;
+            continue;
+        }
+        run += part;
+        if (part === '\n')
+            column = 0;
+        else
+            column += stringWidth(part);
+    }
+    return out + run;
+}
+const segmenter = new Intl.Segmenter(undefined, { granularity: 'grapheme' });
+/**
+ * Grapheme clusters rather than code units, so a combining mark or an emoji ZWJ
+ * sequence advances the column once, exactly as the terminal draws it.
+ */
+function graphemesOf(text) {
+    return Array.from(segmenter.segment(text), ({ segment }) => segment);
+}

package/dist/ui/editor-navigation.d.ts

@@ -25,7 +25,17 @@ export interface EditorVisualMap {
     readonly positions: VisualPosition[];
     readonly cursor: VisualPosition;
 }
-/** Map graphemes to hard-wrapped rows, sharing tab stops and caret reservation. */
+/**
+ * Map graphemes to hard-wrapped rows, sharing tab stops and caret reservation.
+ *
+ * THE TAB STOP IS THE TERMINAL'S (`TAB_WIDTH`), NOT AN EDITOR-SIZED FOUR. It
+ * used to be four, while the transcript handed the raw `\t` to `<Text>` and
+ * the terminal painted it at eight: the same pasted table sat one column off
+ * from itself before and after sending. A tab that would cross the right edge
+ * is still clipped to the row (the caret cannot point past the last cell), so
+ * a tab STRADDLING the wrap is the one shape where the draft and the stored
+ * text can differ by the remainder of the advance.
+ */
 export declare function buildEditorVisualMap(input: {
     buffer: string;
     cols: number;

package/dist/ui/editor-navigation.js

@@ -1,5 +1,6 @@
 /** Shared UTF-16 grapheme boundaries and terminal-cell layout for the editor. */
 import stringWidth from 'string-width';
+import { TAB_WIDTH } from './display-tab.js';
 const segmenter = new Intl.Segmenter(undefined, { granularity: 'grapheme' });
 /** Segment text without changing its UTF-16 offsets or stored whitespace. */
 export function graphemes(text) {
@@ -31,7 +32,17 @@ export function graphemeWidth(text) {
         return 1;
     return stringWidth(text);
 }
-/** Map graphemes to hard-wrapped rows, sharing tab stops and caret reservation. */
+/**
+ * Map graphemes to hard-wrapped rows, sharing tab stops and caret reservation.
+ *
+ * THE TAB STOP IS THE TERMINAL'S (`TAB_WIDTH`), NOT AN EDITOR-SIZED FOUR. It
+ * used to be four, while the transcript handed the raw `\t` to `<Text>` and
+ * the terminal painted it at eight: the same pasted table sat one column off
+ * from itself before and after sending. A tab that would cross the right edge
+ * is still clipped to the row (the caret cannot point past the last cell), so
+ * a tab STRADDLING the wrap is the one shape where the draft and the stored
+ * text can differ by the remainder of the advance.
+ */
 export function buildEditorVisualMap(input) {
     const cols = Math.max(1, Math.floor(input.cols));
     const cursor = snapGrapheme(input.buffer, input.cursor);
@@ -50,12 +61,12 @@ export function buildEditorVisualMap(input) {
             breakRow();
             continue;
         }
-        let width = part.text === '\t' ? Math.min(cols, 4 - column % 4)
+        let width = part.text === '\t' ? Math.min(cols, TAB_WIDTH - column % TAB_WIDTH)
             : graphemeWidth(part.text);
         if (column > 0 && column + width > cols) {
             breakRow();
             if (part.text === '\t')
-                width = Math.min(cols, 4);
+                width = Math.min(cols, TAB_WIDTH);
         }
         locate(part.index);
         rows[rows.length - 1].push({ ...part,

package/dist/ui/entries/QueuedEntry.js

@@ -13,10 +13,13 @@ import { jsx as _jsx } from "react/jsx-runtime";
 import React from 'react';
 import { Text } from 'ink';
 import { pickGlyphs } from '../glyphs.js';
+import { expandTabs } from '../display-tab.js';
 function QueuedEntryImpl({ text, theme, caps, }) {
     const glyphs = pickGlyphs(caps);
     const lines = text.split('\n');
-    const first = lines[0] ?? '';
+    // Same reason as `UserEntry`: a queued draft is a draft, so its TABs must
+    // occupy the columns the composer showed them at.
+    const first = expandTabs(lines[0] ?? '');
     const extra = lines.length - 1;
     const suffix = extra > 0 ? ` ${glyphs.ellipsis}+${extra} line${extra === 1 ? '' : 's'}` : '';
     return (_jsx(Text, { wrap: "truncate", color: theme.muted, children: `Queue: ${first}${suffix}` }));

package/dist/ui/entries/UserEntry.js

@@ -14,9 +14,16 @@ import React from 'react';
 import { Box, Text } from 'ink';
 import { pickGlyphs } from '../glyphs.js';
 import { USER_ENTRY_MAX_ROWS } from '../composer-limits.js';
+import { expandTabs } from '../display-tab.js';
 function UserEntryImpl({ text, theme, caps, }) {
     const glyphs = pickGlyphs(caps);
-    const all = text.split('\n');
+    // TAB IS EXPANDED HERE, AT THE RENDER BOUNDARY, AND NOWHERE ABOVE IT.
+    // The payload keeps its `\t` (the model must receive the original
+    // indentation), so `<Text>` used to hand the raw byte to the terminal and
+    // the terminal painted an EIGHT-column stop while the composer painted a
+    // FOUR-column one. Splitting first and expanding per line keeps this row
+    // identical to the row the user saw in the draft.
+    const all = text.split('\n').map((line) => expandTabs(line));
     // A submitted 5 000-line paste otherwise asks Yoga to lay out 5 000 nodes
     // inside a measured entry -- the hazard `render-cache.ts:37` already records
     // in the same words ("a multi-megabyte 'code block' is almost always a pasted

package/dist/ui/layout/virtual-window.js

@@ -32,9 +32,11 @@
  * `selectWindow` takes `offset` as an INPUT, would close a loop from the offset
  * through the mounted set and the measured heights back to the offset.
  */
+import stringWidth from 'string-width';
 import { FAST_LIMITS } from '../../fast/limits.js';
 import { COMPACTION_LIMITS } from '../../compaction/limits.js';
 import { GUTTER_WIDTH } from './Gutter.js';
+import { expandTabs } from '../display-tab.js';
 import { USER_ENTRY_MAX_ROWS } from '../composer-limits.js';
 export const VIRTUAL_LIMITS = {
     /**
@@ -159,21 +161,52 @@ export function entryRevision(entry) {
 export function heightKey(entry, cols, expanded, density, flags = '') {
     return `${entry.id}|${entryRevision(entry)}|${cols}|${expanded ? 1 : 0}|${density}|${flags}`;
 }
-/** Rows a string occupies at `usable` columns, wrapping included. At least 1. */
+/**
+ * Rows a string occupies at `usable` columns, wrapping included. At least 1.
+ *
+ * COUNTED IN DISPLAY COLUMNS, NOT UTF-16 CODE UNITS, and the difference is a
+ * correctness bug rather than a nicety: a CJK glyph is one code unit and two
+ * cells, and a TAB is one code unit and up to `TAB_WIDTH` cells. Counting code
+ * units therefore UNDER-estimates, which this file's own note names as the
+ * unsafe direction ("an over-estimate makes the scroll position slightly
+ * conservative and self-corrects ... an under-estimate can put the newest
+ * output off the bottom of a viewport the user believes is pinned"). It also
+ * had to change together with the renderers: a stored `\t` is now expanded at
+ * paint time, so measuring the unexpanded string would keep the estimate short
+ * while the painted row got taller.
+ */
 function wrappedRows(text, usable) {
     const width = Math.max(1, usable);
     let rows = 0;
-    let lineLen = 0;
-    for (let i = 0; i < text.length; i += 1) {
-        if (text.charCodeAt(i) === 10) {
-            rows += Math.max(1, Math.ceil(lineLen / width));
-            lineLen = 0;
-        }
-        else {
-            lineLen += 1;
-        }
+    let start = 0;
+    for (;;) {
+        const end = text.indexOf('\n', start);
+        const line = end === -1 ? text.slice(start) : text.slice(start, end);
+        rows += Math.max(1, Math.ceil(displayColumns(line) / width));
+        if (end === -1)
+            return rows;
+        start = end + 1;
     }
-    return rows + Math.max(1, Math.ceil(lineLen / width));
+}
+/**
+ * Printable ASCII with no TAB: one code unit is one cell, so the width table is
+ * not consulted at all.
+ *
+ * THE FAST PATH IS LOAD-BEARING, not a micro-optimisation. `stringWidth`
+ * strips ANSI and walks the East-Asian width table for every code point, and
+ * this function runs over EVERY unmeasured entry of a 10 000-entry document
+ * (`render-budget.test.tsx` mounts exactly that); measuring them all with the
+ * table turned that test into a timeout. Transcript text is overwhelmingly
+ * ASCII, so the branch is taken almost always.
+ */
+const PLAIN_ASCII = /^[\x20-\x7e]*$/;
+/** Display columns of one logical line: TABs expanded, CJK counted twice. */
+function displayColumns(line) {
+    if (line.indexOf('\t') === -1 && PLAIN_ASCII.test(line))
+        return line.length;
+    // `expandTabs` mirrors what `entries/*` paints; `stringWidth` is the width
+    // table the composer already wraps with, so the two agree on CJK and emoji.
+    return stringWidth(expandTabs(line));
 }
 /** Collapsed preview rows in `ToolCard`; duplicated as a NUMBER, not imported. */
 const TOOL_COLLAPSED_LINES = 8;

package/dist/ui/paste-frames.d.ts

@@ -82,6 +82,10 @@ export declare function hasPasteFrame(input: string): boolean;
  * nothing on screen to explain it.
  *
  * This is strictly better than v0.6.3 for both consumers: a pasted key carrying a
- * stray CR or an ANSI sequence is now cleaned rather than stored raw.
+ * stray CR or an ANSI sequence is now cleaned rather than stored raw. The
+ * unframed branch strips escape SEQUENCES before the control sweep, because
+ * deleting only the introducer left `[0m` in the stored value -- and in a
+ * settings field that residue is invisible behind `maskDot` while the value
+ * handed to `registerSecret()` is silently wrong.
  */
 export declare function stripPasteFrames(input: string): string;

package/dist/ui/paste-frames.js

@@ -7,6 +7,7 @@
  */
 import { PASTE_CLOSE, PASTE_OPEN } from '../input/limits.js';
 import { sanitisePaste } from '../input/paste-parse.js';
+import { stripControlSequences } from '../input/control-sequences.js';
 /**
  * Remove every C0 byte, DEL and C1 byte from text that arrived OUTSIDE a frame
  * (I-14). NO CR -> LF conversion, and that omission is the point.
@@ -101,11 +102,15 @@ export function hasPasteFrame(input) {
  * nothing on screen to explain it.
  *
  * This is strictly better than v0.6.3 for both consumers: a pasted key carrying a
- * stray CR or an ANSI sequence is now cleaned rather than stored raw.
+ * stray CR or an ANSI sequence is now cleaned rather than stored raw. The
+ * unframed branch strips escape SEQUENCES before the control sweep, because
+ * deleting only the introducer left `[0m` in the stored value -- and in a
+ * settings field that residue is invisible behind `maskDot` while the value
+ * handed to `registerSecret()` is silently wrong.
  */
 export function stripPasteFrames(input) {
     if (!hasPasteFrame(input))
-        return sanitiseTyped(input);
+        return sanitiseTyped(stripControlSequences(input));
     return splitPasteFrames(input)
         .map((segment) => (segment.kind === 'paste' ? sanitiseTyped(segment.text) : segment.text))
         .join('');

package/dist/ui/transcript-text.js

@@ -1,12 +1,21 @@
 import { formatCost, formatDuration, formatTokens, promptTokensOf } from '../agent/usage.js';
 import { formatRetryLine } from '../agent/retry-view.js';
+import { expandTabs } from './display-tab.js';
 const DEFAULT_MAX_ENTRIES = 200;
 const CONTINUATION_INDENT = '  ';
 const TOOL_INDENT = '  ';
 const MAX_ARG_CHARS = 60;
-/** Prefix the first line with `marker`, indent the rest to line up under it. */
+/**
+ * Prefix the first line with `marker`, indent the rest to line up under it.
+ *
+ * `expandTabs` RUNS BEFORE THE PREFIX IS ADDED, so a stored line lands on the
+ * same columns the TUI drew it at. Without it this replay -- the only record
+ * left once the alternate screen is torn down -- disagreed with the screen
+ * about every TAB, because the terminal painted an eight-column stop under text
+ * the composer had laid out at four.
+ */
 function block(marker, text) {
-    const lines = text.replace(/\r\n/g, '\n').split('\n');
+    const lines = expandTabs(text.replace(/\r\n/g, '\n')).split('\n');
     const head = `${marker} ${lines[0] ?? ''}`.trimEnd();
     const rest = lines.slice(1).map((l) => `${CONTINUATION_INDENT}${l}`.trimEnd());
     return [head, ...rest];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aragon-agent/cli",
-  "version": "0.6.27",
+  "version": "0.6.28",
   "description": "AragonAgent CLI — a Claude-Code / Codex-style interactive terminal UI (TUI) on top of the @aragon-agent/core engine. Installable and runnable via npm / npx.",
   "license": "MIT",
   "author": "AragonAgent contributors",
@@ -56,7 +56,7 @@
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
-    "@aragon-agent/core": "^0.2.39",
+    "@aragon-agent/core": "^0.2.40",
     "chalk": "^5.6.2",
     "cli-highlight": "^2.0.0",
     "commander": "^12.1.0",