@aragon-agent/cli 0.6.11 → 0.6.12

package/CHANGELOG.md

@@ -5,7 +5,16 @@ All notable changes to `@aragon-agent/cli` are documented here. Entries at
 — those releases really were published under that name, so they are left as they
 were written.
 
-## Unreleased
+## Unreleased
+
+### TUI 输入与排队可靠性
+
+- Shift+Enter 与粘贴按输入顺序处理；普通 Enter 保持弹层兼容，混合输入最多提交一次，
+  余稿及拒绝提交的正文保留。结束输入流时完整排空，不泄漏内部控制标记。
+- 超限粘贴拒绝同一外部输入块的正文和 Enter，避免误提交旧稿；未闭合粘贴继续按正文消费。
+- 拖选后仅 Ctrl+C 复制；文字变化与丢失鼠标释放时取消无效高亮，避免卡住视口。
+- 固定 Queue 状态行按消息 ID 回执更新，支持窄屏、暂停与多条消息计数。
+- 保存和退出保留所有未发送全文；恢复先验证存档，旧 queued 作为警告展示且不自动重放。
 
 ### Removed
 

package/README.md

@@ -493,10 +493,10 @@ 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:
+输入支持 `Ctrl+J`、`Alt+Enter` 和可独立编码的 `Shift+Enter` 换行。如果终端把
+Shift+Enter 与 Enter 都发送为 CR，应用无法区分；请用 `/terminal-setup` 查看绑定，
+让 Shift+Enter 发送 `\u001b[13;2u`。合并到已有终端配置，不要覆盖其他快捷键；
+终端拦截某个组合键时可使用另外两种方式。参考绑定如下：
 
 - **Windows Terminal** — `settings.json`, `actions`:
   `{ "keys": "shift+enter", "command": { "action": "sendInput", "input": "\u001b[13;2u" } }`
@@ -518,20 +518,31 @@ 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:
+Agent 运行中发送的消息会进入队列。固定状态行显示最早待接收消息的首个非空行，
+多条时显示剩余数量；即使转录滚动离开底部，提示仍可见，且没有自动消失的时间限制。
+转录同时保留每条完整消息：
 
 ```
 ◷ 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.
+仅当 Core 将消息写入对话历史并发出对应消息 ID 的接收回执，Queue 状态才移除。
+这表示引擎已接管后续处理，不表示回答完成；`turn_start`、动画和提示超时都不能代替回执。
+相同正文的两次发送仍是两条消息。中断或失败后尚未接收的消息显示 `Queue (paused)`。
+
+窄屏使用 `P>B` / `B>P` 表示待切换模式，`E2` / `E!` 表示两次 Esc 中断 / 再按 Esc 强停，
+`S+` / `T+` 表示后台服务 / TODO 存在，`Queue(p)` 表示暂停；`(+99+)` 表示至少还有
+100 条消息。完整服务和 TODO 数量分别可用 `/bg` 与 `/todo status` 查看。
+
+`/clear` 清转录和 TODO，但保留待接收队列。保存和退出会补回被清屏或保留环裁剪的
+未发送全文。恢复存档时，queued 一律成为 `Queued but never sent: ...` 警告，
+不会自动重发；需要发送时请复制正文重新提交。运行尚未退出时 `/reset`、`/resume`
+会拒绝切换，损坏存档在替换当前会话之前报错。
+
+应用捕获鼠标时，拖选只保留高亮，按 Ctrl+C 才复制；本次按键不会停止服务或退出。
+选中文字改变、滚轮、其他按键或关闭选区会取消高亮。`--no-mouse` 或宿主原生选择的
+选中即复制由终端设置控制。OSC 52 发送成功仅证明请求已发出，不保证远程终端剪贴板
+已写入；SSH/tmux 是否允许该请求需在实际环境中验证。
 
 ## Themes
 

package/dist/agent/controller.d.ts

@@ -214,8 +214,11 @@ export declare class AgentController {
      * Cleared at the next `agent_start`.
      */
     private abortRequested;
-    /** User messages queued since the last `turn_start` (§3.5.4a guard 2). */
-    private userSteerCount;
+    /** Only exact acceptance receipts release user messages from reviewer protection. */
+    private readonly pendingUserSteering;
+    /** Session changes must not make a delayed receipt match a new message. */
+    private readonly steeringPrefix;
+    private steeringSequence;
     constructor(config: CliConfig, deps?: ControllerDeps);
     private resolveKey;
     /**
@@ -360,7 +363,11 @@ export declare class AgentController {
      * which it has to be, since a normal quit reaches it twice.
      */
     reapServicesSync(): void;
+    /** Queue automation/user guidance with the same protection as visible input. */
     steer(text: string): void;
+    /** Return the opaque ID used by the view to match Core's acceptance receipt. */
+    queueUserMessage(text: string): string;
+    private enqueueSteering;
     followUp(text: string): void;
     isRunning(): boolean;
     getAgentMode(): AgentMode;

package/dist/agent/controller.js

@@ -1,13 +1,4 @@
-/**
- * AgentController — builds the core `Agent`, wires the built-in toolset, and
- * exposes a small run/abort/steer surface plus the pre-flight validation that
- * turns the most common failure (no API key) into a guided action instead of a
- * blank screen (spec §3.3.1 / R2).
- *
- * The controller never inspects the resolved promise of `agent.prompt()` for
- * success — that promise resolves even on failure. Success/failure is derived
- * from the event stream by the reducer (TUI) and the headless writer.
- */
+import { randomUUID } from 'node:crypto';
 import { Agent, initProviders, ModelRegistry, } from '@aragon-agent/core';
 import { clampCompactionConfig, clampFastConfig, clampRetryConfig, clampTeamConfig, clampTodoConfig, isAdapterProvider, toRetryPolicy, } from '../config/schema.js';
 import { makeGetApiKey } from '../config/load.js';
@@ -252,8 +243,11 @@ export class AgentController {
      * Cleared at the next `agent_start`.
      */
     abortRequested = false;
-    /** User messages queued since the last `turn_start` (§3.5.4a guard 2). */
-    userSteerCount = 0;
+    /** Only exact acceptance receipts release user messages from reviewer protection. */
+    pendingUserSteering = new Set();
+    /** Session changes must not make a delayed receipt match a new message. */
+    steeringPrefix = randomUUID();
+    steeringSequence = 0;
     constructor(config, deps = {}) {
         this.config = config;
         this.cwd = config.cwd;
@@ -634,33 +628,26 @@ export class AgentController {
                 isPricedModel: (ref) => this.isPricedModel(ref),
                 subscribe: (listener) => this.agent.subscribe(listener),
                 complete: (providerId, request) => this.providerRegistry.complete(providerId, request),
-                // THE REVIEWER GOES THROUGH THIS METHOD, NOT `agent.steer()` DIRECTLY,
-                // so its own block is counted alongside the user's — which is what
-                // `userSteerCount` would otherwise mis-report and what would make
-                // guard 2 clear a queue it does not own (D-21).
-                //
-                // It is decremented back out below: the counter must answer "did the
-                // USER queue anything", and the reviewer's own message is not that.
-                steer: (text) => {
-                    this.steer(text);
-                    this.userSteerCount -= 1;
-                },
+                // Reviewer advice shares skill activation, but cannot own a user ID.
+                steer: (text) => this.enqueueSteering(text, false),
                 isRunning: () => this.isRunning(),
                 isAbortRequested: () => this.abortRequested,
-                userSteerCount: () => this.userSteerCount,
+                userSteerCount: () => this.pendingUserSteering.size,
                 clearAllQueues: () => this.clearAllQueues(),
                 notify: (level, text) => deps.notify?.(level, text),
                 onPromptChanged: () => this.rebuildSystemPrompt(),
             })
             : null;
         // The two guards' bookkeeping, and the only reason this class subscribes to
-        // its own agent. `turn_start` is where a user steer stops being pending;
+        // its own agent. A receipt is where a user steer stops being pending;
         // `agent_start` is where a requested abort stops being in force.
         this.agent.subscribe((event) => {
             if (event.type === 'agent_start')
                 this.abortRequested = false;
-            if (event.type === 'turn_start')
-                this.userSteerCount = 0;
+            if (event.type === 'steering_accepted') {
+                for (const id of event.ids)
+                    this.pendingUserSteering.delete(id);
+            }
             // The authoritative result arrives with this event, so from this instant
             // the tail is superseded and its slot must be released (§3.1.1). Clearing
             // HERE rather than on read is what keeps the store's size a function of
@@ -1052,21 +1039,23 @@ export class AgentController {
     reapServicesSync() {
         this.procs.reapSync();
     }
+    /** Queue automation/user guidance with the same protection as visible input. */
     steer(text) {
-        // Mid-run interjection: promote the queue, keep what is already in force
-        // (D-G3). Clearing here would make "ask a follow-up" the way around the
-        // ceiling; skipping the promotion would miss slash commands, which the TUI
-        // routes through `steer` whenever the agent happens to be running.
+        this.enqueueSteering(text, true);
+    }
+    /** Return the opaque ID used by the view to match Core's acceptance receipt. */
+    queueUserMessage(text) {
+        return this.enqueueSteering(text, true);
+    }
+    enqueueSteering(text, user) {
+        // Both reviewer and user guidance can activate queued skill frames.
         if (this.skillsEnabled)
             this.skills.absorbPendingFrames();
-        // COUNTED so the reviewer can prove it owns the queue before clearing it
-        // (§3.5.4a guard 2 / D-21). This method is the only other writer of
-        // `steeringQueue` in the package, and `Agent` exposes no way to remove ONE
-        // message — so `userSteerCount === 0` is the only sound licence for
-        // `clearAllQueues()`, and with a user message in there the reviewer must
-        // leave its own residue rather than destroy something the user typed.
-        this.userSteerCount += 1;
-        this.agent.steer(text);
+        const id = user ? `${this.steeringPrefix}:${++this.steeringSequence}` : undefined;
+        if (id !== undefined)
+            this.pendingUserSteering.add(id);
+        this.agent.steer(text, id);
+        return id;
     }
     followUp(text) {
         this.agent.followUp(text);
@@ -1524,6 +1513,7 @@ export class AgentController {
     }
     clearAllQueues() {
         this.agent.clearAllQueues();
+        this.pendingUserSteering.clear();
     }
     // -----------------------------------------------------------------------
     // Model / provider info

package/dist/agent/queued-messages.d.ts

@@ -0,0 +1,8 @@
+import type { Entry } from './reducer.js';
+/** Full user text retained until Core acknowledges its opaque ID. */
+export interface PendingSteering {
+    readonly queueId: string;
+    readonly text: string;
+}
+/** Supplement trimmed/cleared history for save and exit without deduplicating text. */
+export declare function mergePendingEntries(entries: Entry[], pending: readonly PendingSteering[]): Entry[];

package/dist/agent/queued-messages.js

@@ -0,0 +1,28 @@
+/** Supplement trimmed/cleared history for save and exit without deduplicating text. */
+export function mergePendingEntries(entries, pending) {
+    if (pending.length === 0)
+        return entries;
+    const positions = new Map(pending.map((item, index) => [item.queueId, index]));
+    const visible = new Map(entries.flatMap((entry) => entry.kind === 'queued' && entry.queueId !== undefined
+        ? [[entry.queueId, entry]] : []));
+    const merged = [];
+    let cursor = 0;
+    const appendThrough = (last) => {
+        while (cursor <= last) {
+            const item = pending[cursor++];
+            const existing = visible.get(item.queueId);
+            merged.push(existing ? { ...existing, text: item.text } :
+                { id: `pending:${item.queueId}`, kind: 'queued', ...item });
+        }
+    };
+    for (const entry of entries) {
+        const position = entry.kind === 'queued' && entry.queueId !== undefined
+            ? positions.get(entry.queueId) : undefined;
+        if (position === undefined)
+            merged.push(entry);
+        else
+            appendThrough(position);
+    }
+    appendThrough(pending.length - 1);
+    return merged;
+}

package/dist/agent/reducer.d.ts

@@ -10,6 +10,7 @@
  *   - `agent_end` after a turn that produced no `turn_end` and no error notice
  *     synthesizes a generic error notice (a swallowed throw is never a no-op).
  */
+import type { PendingSteering } from './queued-messages.js';
 import type { AgentEvent, ModelCost, ToolResult, TokenUsage } from '@aragon-agent/core';
 import type { AgentMode } from './agent-mode.js';
 import type { DispatchOutcome, SubagentRun, SubagentSpec, TeamSnapshot } from '../team/types.js';
@@ -40,7 +41,7 @@ export type Entry = {
 /**
  * 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
+ * id, into the `user` entry above by the matching receipt that proves Core
  * accepted it -- so the id-based height cache re-measures rather than
  * freezes, and the settled boundary (positional, monotonic) never moves.
  *
@@ -51,6 +52,7 @@ export type Entry = {
     id: string;
     kind: 'queued';
     text: string;
+    queueId?: string;
 } | {
     id: string;
     kind: 'assistant';
@@ -275,6 +277,7 @@ export interface RetrySnapshot {
 }
 export interface ViewState {
     entries: Entry[];
+    pendingSteering: PendingSteering[];
     status: 'idle' | 'running';
     usageTotal: UsageTotal;
     /**
@@ -402,7 +405,11 @@ export type ViewAction = {
  */
  | {
     type: 'steerQueued';
+    queueId: string;
     text: string;
+} | {
+    type: 'steeringAccepted';
+    ids: readonly string[];
 } | {
     type: 'runStart';
 } | {

package/dist/agent/reducer.js

@@ -46,6 +46,7 @@ const EMPTY_USAGE_TOTAL = {
 export function initialViewState(seed = {}) {
     return {
         entries: [],
+        pendingSteering: [],
         status: 'idle',
         usageTotal: EMPTY_USAGE_TOTAL,
         context: emptyContextUsage(),
@@ -127,6 +128,8 @@ function firstLine(text) {
  */
 export function reduceEvent(event, cost, patches) {
     switch (event.type) {
+        case 'steering_accepted':
+            return [{ type: 'steeringAccepted', ids: event.ids }];
         case 'agent_start':
             return [{ type: 'runStart' }];
         case 'turn_start':
@@ -289,29 +292,6 @@ 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).
  *
@@ -450,12 +430,27 @@ export function viewReducer(state, action) {
         }
         case 'steerQueued': {
             const { id, seq } = nextId(state);
-            const entry = { id, kind: 'queued', text: action.text };
+            const entry = { id, kind: 'queued', queueId: action.queueId, 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) };
+            return {
+                ...state, seq, ...appendEntry(state, state.entries, entry),
+                pendingSteering: [...state.pendingSteering, { queueId: action.queueId, text: action.text }],
+            };
+        }
+        case 'steeringAccepted': {
+            const receipts = new Set(action.ids);
+            const ids = new Set(state.pendingSteering
+                .filter((item) => receipts.has(item.queueId)).map((item) => item.queueId));
+            if (ids.size === 0)
+                return state;
+            const pendingSteering = state.pendingSteering.filter((item) => !ids.has(item.queueId));
+            const entries = state.entries.map((entry) => entry.kind === 'queued' && entry.queueId !== undefined && ids.has(entry.queueId)
+                ? { id: entry.id, kind: 'user', text: entry.text }
+                : entry);
+            return { ...state, pendingSteering, entries };
         }
         case 'runStart':
             return {
@@ -467,14 +462,6 @@ 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',
@@ -483,7 +470,7 @@ export function viewReducer(state, action) {
                 thinkingOpen: false,
                 streaming: true,
             };
-            return { ...state, seq, ...appendEntry(state, entries, entry), streamingId: id };
+            return { ...state, seq, ...appendEntry(state, state.entries, entry), streamingId: id };
         }
         case 'thinkingStart': {
             if (!state.streamingId)
@@ -777,6 +764,7 @@ export function viewReducer(state, action) {
         case 'resetConversation':
             return {
                 ...state,
+                pendingSteering: [],
                 entries: [],
                 droppedEntries: 0,
                 streamingId: undefined,
@@ -1295,6 +1283,7 @@ export function viewReducer(state, action) {
             return {
                 ...state,
                 entries: restored.entries,
+                pendingSteering: [],
                 droppedEntries: restored.dropped,
                 seq: maxSeq,
                 teamEntryId: undefined,

package/dist/commands/builtins.js

@@ -9,6 +9,7 @@ import { isAbsolute, resolve } from 'node:path';
 import { resolveOutputTokens } from '@aragon-agent/core';
 import { clampThinkingLevel, clampTheme, isAdapterProvider, isThemeName, parseMaxTokensInput, ADAPTER_PROVIDERS, DEFAULT_MAX_TOKENS, HARD_MAX_RETRIES, LEGACY_DARK_THEME, THEME_NAMES, THINKING_LEVELS, } from '../config/schema.js';
 import { computeCost, formatCost, formatDuration, formatTokens } from '../agent/usage.js';
+import { mergePendingEntries } from '../agent/queued-messages.js';
 import { TODO_FOLLOW_LIMITS } from '../todo/limits.js';
 import { buildContinuationMessage } from '../todo/follow-through.js';
 import { MODE_LABEL, nextMode } from '../agent/agent-mode.js';
@@ -882,6 +883,10 @@ const COMMANDS = [
         name: 'reset',
         description: 'Start a new conversation',
         run: (ctx) => {
+            if (ctx.controller.isRunning()) {
+                ctx.notify('warn', 'Cannot reset while the agent is running. Wait for it to stop.');
+                return;
+            }
             ctx.controller.clearMessages();
             ctx.controller.clearAllQueues();
             ctx.dispatch({ type: 'resetConversation' });
@@ -920,7 +925,7 @@ const COMMANDS = [
                         ...(cfg.baseUrl ? { baseUrl: cfg.baseUrl } : {}),
                     },
                     messages: ctx.controller.getMessages(),
-                    entries: ctx.state.entries,
+                    entries: mergePendingEntries(ctx.state.entries, ctx.state.pendingSteering),
                     // `/resume` restores `messages`, so the belief that justifies the
                     // panel comes back — and the panel has to come back with it (§3.13).
                     todos: ctx.controller.getTodoSnapshot()?.items ?? [],
@@ -936,16 +941,22 @@ const COMMANDS = [
         name: 'resume',
         description: 'Load a saved session',
         run: (ctx) => {
+            if (ctx.controller.isRunning()) {
+                ctx.notify('warn', 'Cannot resume while the agent is running. Wait for it to stop.');
+                return;
+            }
             try {
                 const path = resolveSessionPath(ctx.args, ctx.controller.getCwd());
                 const session = loadSession(path);
+                if (ctx.controller.isRunning()) {
+                    ctx.notify('warn', 'Cannot resume while the agent is running. Wait for it to stop.');
+                    return;
+                }
+                // Loading has validated and normalized every external value. Commit
+                // synchronously so no new run can start between clearing and restoring.
+                ctx.controller.clearAllQueues();
                 ctx.controller.replaceMessages(session.messages);
-                // IN THE SAME `try`, IMMEDIATELY AFTER `replaceMessages`, so a malformed
-                // file fails the whole resume rather than half of it — and AN ABSENT
-                // `todos` CLEARS RATHER THAN SKIPPING (P0-2 / D-22). `replaceMessages`
-                // has just discarded the conversation the current list belonged to, so
-                // leaving the rail up produces a panel that disagrees with the model,
-                // which §1.2 ranks below having no panel at all.
+                // Absence clears the previous conversation's list, including old files.
                 ctx.controller.restoreTodos(session.todos ?? []);
                 ctx.dispatch({ type: 'restoreEntries', entries: session.entries });
                 if (session.model?.providerId && session.model?.modelId) {
@@ -1049,6 +1060,9 @@ const COMMANDS = [
                 '  Windows Terminal  settings.json, actions array:',
                 '    { "keys": "shift+enter", "command": { "action": "sendInput",',
                 '      "input": "\\u001b[13;2u" } }',
+                '    PowerShell runs inside the terminal; configure this binding in',
+                '    Windows Terminal, not in the PowerShell profile. If both keys',
+                '    send CR, the application cannot distinguish Shift+Enter from Enter.',
                 '  VS Code terminal  keybindings.json:',
                 '    { "key": "shift+enter",',
                 '      "command": "workbench.action.terminal.sendSequence",',

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

@@ -38,16 +38,17 @@ export interface EnterSequenceSpec {
  * `'\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 type EnterSequenceSegment = {
+    kind: 'text';
+    text: string;
+} | {
+    kind: 'newline';
+} | {
+    kind: 'submit';
+};
+/** Split explicit keys using the recognition table; bare CR/LF remain text. */
+export declare function splitEnterSequences(text: string): EnterSequenceSegment[];
+/** Normalize explicit Enter keys without changing unknown sequences. */
 export declare function rewriteEnterSequences(text: string): string;
 /**
  * Length of the trailing run of `text` that is a proper prefix of an

package/dist/input/enter-sequences.js

@@ -30,6 +30,7 @@ import { ENTER_NEWLINE_FRAME } from './limits.js';
  * `'\r'` rather than to a newline.
  */
 export const ENTER_SEQUENCES = [
+    { seq: '\x1b[13;1u', meaning: 'enter', to: '\r' },
     {
         seq: '\x1b[13;2u',
         meaning: 'shift+enter',
@@ -88,34 +89,35 @@ export const ENTER_SEQUENCES = [
  * 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.
- */
+/** Split explicit keys using the recognition table; bare CR/LF remain text. */
+export function splitEnterSequences(text) {
+    const segments = [];
+    let start = 0;
+    let index = 0;
+    while (index < text.length) {
+        const match = text[index] === '\x1b'
+            ? ENTER_SEQUENCES.find((spec) => text.startsWith(spec.seq, index)) : undefined;
+        if (!match) {
+            index += 1;
+            continue;
+        }
+        if (index > start)
+            segments.push({ kind: 'text', text: text.slice(start, index) });
+        segments.push({ kind: match.to === '\r' ? 'submit' : 'newline' });
+        index += match.seq.length;
+        start = index;
+    }
+    if (start < text.length)
+        segments.push({ kind: 'text', text: text.slice(start) });
+    return segments;
+}
+/** Normalize explicit Enter keys without changing unknown sequences. */
 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;
+    return splitEnterSequences(text).map((segment) => {
+        if (segment.kind === 'text')
+            return segment.text;
+        return segment.kind === 'submit' ? '\r' : ENTER_NEWLINE_FRAME;
+    }).join('');
 }
 /** True when `s` is a PROPER prefix of some recognized sequence (never whole). */
 function isEnterPrefix(s) {