@aragon-agent/cli 0.6.12 → 0.6.14

package/dist/ui/composer-rows.js

@@ -18,65 +18,11 @@
  * spaces, so it destroys indentation and makes the character-index-to-screen-cell
  * mapping the caret depends on impossible to state, let alone compute.
  */
-import stringWidth from 'string-width';
+import { buildEditorVisualMap, graphemes, graphemeWidth } from './editor-navigation.js';
 import { tokenSpans } from './paste-tokens.js';
-/**
- * Columns a TAB advances to.
- *
- * TABS ARE EXPANDED TO SPACES FOR DISPLAY ONLY -- the buffer keeps the tab, so
- * the model receives exactly what was pasted. The alternative is to emit the raw
- * tab and let the terminal expand it, which puts the terminal's tab stop (8) and
- * this module's column arithmetic in disagreement: the row would overflow its box
- * and the terminal would wrap it a second time, which is the corruption the whole
- * feature exists to remove.
- */
-const TAB_WIDTH = 4;
-/**
- * Display width of one code point.
- *
- * The ASCII fast path matters: `layoutComposer` runs on every keystroke and a
- * recalled prompt-history entry can be thousands of characters, so one
- * `string-width` call per character would be the cost this package spent
- * `tui-render-performance` removing.
- */
-function charWidth(ch) {
-    const code = ch.codePointAt(0) ?? 0;
-    if (code >= 0x20 && code < 0x7f)
-        return 1;
-    return stringWidth(ch);
-}
-/** Total display width of a run, using the same table the layout used. */
+/** Width of a displayed run, measured by complete graphemes. */
 export function displayWidth(text) {
-    let w = 0;
-    for (const ch of text)
-        w += charWidth(ch);
-    return w;
-}
-/** Normalize only the visual projection; the editor keeps its UTF-16 index. */
-function visualCursor(buffer, cursor) {
-    let index = Math.max(0, Math.min(buffer.length, cursor));
-    const code = buffer.charCodeAt(index);
-    const previous = buffer.charCodeAt(index - 1);
-    if (code >= 0xdc00 && code <= 0xdfff && previous >= 0xd800 && previous <= 0xdbff)
-        index -= 1;
-    if (index === buffer.length || buffer[index] === '\n')
-        return index;
-    const ch = String.fromCodePoint(buffer.codePointAt(index));
-    if (ch === '\t' || charWidth(ch) > 0)
-        return index;
-    const start = buffer.lastIndexOf('\n', index - 1) + 1;
-    let nearest = -1;
-    let i = start;
-    while (i < buffer.length && buffer[i] !== '\n') {
-        const point = String.fromCodePoint(buffer.codePointAt(i));
-        if (point === '\t' || charWidth(point) > 0) {
-            if (i > index)
-                return nearest >= 0 ? nearest : i;
-            nearest = i;
-        }
-        i += point.length;
-    }
-    return nearest >= 0 ? nearest : i;
+    return graphemes(text).reduce((width, part) => width + graphemeWidth(part.text), 0);
 }
 /**
  * Wrap `buffer` into rows, locate the caret, and select a window of at most
@@ -89,88 +35,29 @@ function visualCursor(buffer, cursor) {
  */
 export function layoutComposer(input) {
     const { buffer, active } = input;
-    const cursor = visualCursor(buffer, input.cursor);
-    const cols = Math.max(1, Math.floor(input.cols));
     const maxRows = input.maxRows >= 1 ? Math.floor(input.maxRows) : 1;
+    const map = buildEditorVisualMap(input);
+    const cursorRowAbs = active ? map.cursor.row : -1;
+    const cursorCol = map.cursor.column;
     const spans = tokenSpans(buffer);
     let spanIndex = 0;
-    /** Monotonic in `index`, which is why the pointer is safe. */
-    const kindAt = (index) => {
-        while (spanIndex < spans.length && spans[spanIndex].end <= index)
-            spanIndex += 1;
-        const span = spans[spanIndex];
-        return span && index >= span.start && index < span.end ? 'token' : 'text';
-    };
-    const rows = [];
-    let segments = [];
-    let col = 0;
-    let cursorRowAbs = -1;
-    let cursorCol = 0;
-    const breakRow = () => {
-        rows.push({ segments });
-        segments = [];
-        col = 0;
-    };
-    const append = (text, width, kind) => {
-        const last = segments[segments.length - 1];
-        if (last && last.kind === kind)
-            segments[segments.length - 1] = { text: last.text + text, kind };
-        else
-            segments.push({ text, kind });
-        col += width;
-    };
-    const ensureRoom = (width) => {
-        if (col > 0 && col + width > cols)
-            breakRow();
-    };
-    const length = buffer.length;
-    let i = 0;
-    while (i <= length) {
-        const atCursor = active && i === cursor && cursorRowAbs === -1;
-        if (i === length) {
-            if (atCursor) {
-                ensureRoom(1);
-                cursorRowAbs = rows.length;
-                cursorCol = col;
-            }
-            break;
-        }
-        const ch = String.fromCodePoint(buffer.codePointAt(i));
-        if (ch === '\n') {
-            if (atCursor) {
-                ensureRoom(1);
-                cursorRowAbs = rows.length;
-                cursorCol = col;
-            }
-            breakRow();
-            i += 1;
-            continue;
-        }
-        const kind = kindAt(i);
-        if (ch === '\t') {
-            let advance = TAB_WIDTH - (col % TAB_WIDTH);
-            if (col > 0 && col + advance > cols) {
-                breakRow();
-                advance = TAB_WIDTH;
-            }
-            if (atCursor) {
-                cursorRowAbs = rows.length;
-                cursorCol = col;
-            }
-            append(' '.repeat(advance), advance, kind);
-            i += 1;
-            continue;
-        }
-        const width = charWidth(ch);
-        ensureRoom(width);
-        if (atCursor) {
-            cursorRowAbs = rows.length;
-            cursorCol = col;
+    const rows = map.rows.map((cells) => {
+        const segments = [];
+        for (const cell of cells) {
+            while (spanIndex < spans.length && spans[spanIndex].end <= cell.index)
+                spanIndex += 1;
+            const span = spans[spanIndex];
+            const kind = span && cell.index >= span.start && cell.index < span.end ? 'token' : 'text';
+            const last = segments[segments.length - 1];
+            if (last && last.kind === kind)
+                segments[segments.length - 1] = {
+                    text: last.text + cell.text, kind,
+                };
+            else
+                segments.push({ text: cell.text, kind });
         }
-        append(ch, width, kind);
-        i += ch.length;
-    }
-    rows.push({ segments });
+        return { segments };
+    });
     const totalRows = rows.length;
     const cap = Math.max(1, Math.min(maxRows, totalRows));
     let start = Math.max(0, totalRows - cap);
@@ -213,8 +100,8 @@ export function splitRowAtColumn(row, column) {
     const cells = [];
     let leading = '';
     for (const segment of row.segments) {
-        for (const ch of segment.text) {
-            if (charWidth(ch) === 0) {
+        for (const { text: ch } of graphemes(segment.text)) {
+            if (graphemeWidth(ch) === 0) {
                 const last = cells[cells.length - 1];
                 if (last)
                     cells[cells.length - 1] = { ...last, text: last.text + ch };

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

@@ -0,0 +1,45 @@
+export interface EditorGrapheme {
+    readonly text: string;
+    readonly index: number;
+    readonly end: number;
+}
+/** Segment text without changing its UTF-16 offsets or stored whitespace. */
+export declare function graphemes(text: string): EditorGrapheme[];
+/** Snap an arbitrary UTF-16 offset to a complete grapheme boundary. */
+export declare function snapGrapheme(text: string, cursor: number, right?: boolean): number;
+/** Move one complete grapheme, leaving the two buffer edges unchanged. */
+export declare function stepGrapheme(text: string, cursor: number, direction: 'left' | 'right'): number;
+/** Width of one grapheme (ASCII avoids the Unicode width-table lookup). */
+export declare function graphemeWidth(text: string): number;
+export interface VisualCell extends EditorGrapheme {
+    readonly column: number;
+    readonly width: number;
+}
+export interface VisualPosition {
+    readonly index: number;
+    readonly row: number;
+    readonly column: number;
+}
+export interface EditorVisualMap {
+    readonly rows: VisualCell[][];
+    readonly positions: VisualPosition[];
+    readonly cursor: VisualPosition;
+}
+/** Map graphemes to hard-wrapped rows, sharing tab stops and caret reservation. */
+export declare function buildEditorVisualMap(input: {
+    buffer: string;
+    cols: number;
+    cursor: number;
+    active?: boolean;
+}): EditorVisualMap;
+/** Move to the closest boundary at or left of the preferred display column. */
+export declare function moveVisualCursor(input: {
+    buffer: string;
+    cursor: number;
+    cols: number;
+    direction: 'up' | 'down';
+    preferredVisualColumn?: number;
+}): {
+    cursor: number;
+    preferredVisualColumn: number;
+} | null;

package/dist/ui/editor-navigation.js

@@ -0,0 +1,85 @@
+/** Shared UTF-16 grapheme boundaries and terminal-cell layout for the editor. */
+import stringWidth from 'string-width';
+const segmenter = new Intl.Segmenter(undefined, { granularity: 'grapheme' });
+/** Segment text without changing its UTF-16 offsets or stored whitespace. */
+export function graphemes(text) {
+    return Array.from(segmenter.segment(text), ({ segment, index }) => ({
+        text: segment, index, end: index + segment.length,
+    }));
+}
+/** Snap an arbitrary UTF-16 offset to a complete grapheme boundary. */
+export function snapGrapheme(text, cursor, right = false) {
+    const clamped = Math.max(0, Math.min(text.length, cursor));
+    for (const part of segmenter.segment(text)) {
+        const end = part.index + part.segment.length;
+        if (clamped > part.index && clamped < end)
+            return right ? end : part.index;
+        if (part.index >= clamped)
+            break;
+    }
+    return clamped;
+}
+/** Move one complete grapheme, leaving the two buffer edges unchanged. */
+export function stepGrapheme(text, cursor, direction) {
+    if (direction === 'left')
+        return snapGrapheme(text, Math.max(0, cursor - 1));
+    return snapGrapheme(text, Math.min(text.length, cursor + 1), true);
+}
+/** Width of one grapheme (ASCII avoids the Unicode width-table lookup). */
+export function graphemeWidth(text) {
+    if (text.length === 1 && text >= ' ' && text <= '~')
+        return 1;
+    return stringWidth(text);
+}
+/** Map graphemes to hard-wrapped rows, sharing tab stops and caret reservation. */
+export function buildEditorVisualMap(input) {
+    const cols = Math.max(1, Math.floor(input.cols));
+    const cursor = snapGrapheme(input.buffer, input.cursor);
+    const rows = [[]];
+    const positions = [];
+    let column = 0;
+    const breakRow = () => { rows.push([]); column = 0; };
+    const locate = (index) => {
+        positions.push({ index, row: rows.length - 1, column });
+    };
+    for (const part of graphemes(input.buffer)) {
+        if (part.text === '\n') {
+            if (input.active !== false && part.index === cursor && column >= cols)
+                breakRow();
+            locate(part.index);
+            breakRow();
+            continue;
+        }
+        let width = part.text === '\t' ? Math.min(cols, 4 - column % 4)
+            : graphemeWidth(part.text);
+        if (column > 0 && column + width > cols) {
+            breakRow();
+            if (part.text === '\t')
+                width = Math.min(cols, 4);
+        }
+        locate(part.index);
+        rows[rows.length - 1].push({ ...part,
+            text: part.text === '\t' ? ' '.repeat(width) : part.text, column, width });
+        column += width;
+    }
+    if (input.active !== false && cursor === input.buffer.length && column >= cols)
+        breakRow();
+    locate(input.buffer.length);
+    const caret = positions.find((position) => position.index === cursor);
+    return { rows, positions, cursor: caret };
+}
+/** Move to the closest boundary at or left of the preferred display column. */
+export function moveVisualCursor(input) {
+    const map = buildEditorVisualMap(input);
+    const row = map.cursor.row + (input.direction === 'up' ? -1 : 1);
+    if (row < 0 || row >= map.rows.length)
+        return null;
+    const preferredVisualColumn = input.preferredVisualColumn ?? map.cursor.column;
+    const candidates = map.positions.filter((position) => position.row === row);
+    let target = candidates[0];
+    for (const position of candidates) {
+        if (position.column <= preferredVisualColumn)
+            target = position;
+    }
+    return target ? { cursor: target.index, preferredVisualColumn } : null;
+}

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

@@ -26,6 +26,7 @@ import { type PasteRecord } from './paste-tokens.js';
 export interface EditorState {
     buffer: string;
     cursor: number;
+    preferredVisualColumn?: number;
     historyIndex: number | null;
     dismissed: boolean;
     sel: number;
@@ -70,9 +71,12 @@ export type EditorAction = {
     cursor: number;
 } | {
     type: 'backspace';
+} | {
+    type: 'delete';
 } | {
     type: 'moveCursor';
     cursor: number;
+    preferredVisualColumn?: number;
 } | {
     type: 'recall';
     buffer: string;

package/dist/ui/editor-reducer.js

@@ -23,6 +23,7 @@
  * Extracted from the component so it is unit-testable without mounting Ink.
  */
 import { expandRangeOverTokens, formatPasteToken, makePasteRecord, referencedIds, shouldCollapse, snapOutOfToken, } from './paste-tokens.js';
+import { snapGrapheme, stepGrapheme } from './editor-navigation.js';
 const NO_PASTES = new Map();
 export const INITIAL_EDITOR_STATE = {
     buffer: '',
@@ -42,7 +43,9 @@ export const INITIAL_EDITOR_STATE = {
  * typing again, so suggestions should come back), and re-homes the selection
  * (the candidate list is about to be recomputed).
  */
-const DRAFT_FLAGS = { historyIndex: null, dismissed: false, sel: 0 };
+const DRAFT_FLAGS = {
+    historyIndex: null, dismissed: false, sel: 0, preferredVisualColumn: undefined,
+};
 /**
  * Drop payloads the buffer no longer references (I-7).
  *
@@ -87,12 +90,13 @@ export function editorReducer(state, action) {
         case 'insert': {
             // D-8: typing can never land INSIDE a token. A no-op on a buffer with no
             // tokens, which is every buffer until the first collapse.
-            const cursor = snapOutOfToken(state.buffer, state.cursor);
+            const cursor = snapOutOfToken(state.buffer, snapGrapheme(state.buffer, state.cursor));
+            const buffer = state.buffer.slice(0, cursor) + action.text + state.buffer.slice(cursor);
             return withPrune({
                 ...state,
                 ...DRAFT_FLAGS,
-                buffer: state.buffer.slice(0, cursor) + action.text + state.buffer.slice(cursor),
-                cursor: cursor + action.text.length,
+                buffer,
+                cursor: snapGrapheme(buffer, cursor + action.text.length, true),
             });
         }
         case 'replace':
@@ -100,24 +104,29 @@ export function editorReducer(state, action) {
                 ...state,
                 ...DRAFT_FLAGS,
                 buffer: action.buffer,
-                cursor: action.cursor,
+                cursor: snapGrapheme(action.buffer, action.cursor),
             });
-        case 'backspace': {
-            if (state.cursor <= 0)
+        case 'backspace':
+        case 'delete': {
+            const cursor = snapGrapheme(state.buffer, state.cursor);
+            const backwards = action.type === 'backspace';
+            if (backwards ? cursor <= 0 : cursor >= state.buffer.length)
                 return state;
             // G5: one `Backspace` immediately after `...lines]` removes the whole
             // token and releases its payload, in ONE dispatch.
-            const range = expandRangeOverTokens(state.buffer, state.cursor - 1, state.cursor);
+            const other = stepGrapheme(state.buffer, cursor, backwards ? 'left' : 'right');
+            const range = expandRangeOverTokens(state.buffer, backwards ? other : cursor, backwards ? cursor : other);
+            const buffer = state.buffer.slice(0, range.from) + state.buffer.slice(range.to);
             return withPrune({
                 ...state,
                 ...DRAFT_FLAGS,
-                buffer: state.buffer.slice(0, range.from) + state.buffer.slice(range.to),
-                cursor: range.from,
+                buffer,
+                cursor: snapGrapheme(buffer, range.from),
             });
         }
         case 'input': {
             let buffer = state.buffer;
-            let cursor = snapOutOfToken(buffer, state.cursor);
+            let cursor = snapOutOfToken(buffer, snapGrapheme(buffer, state.cursor));
             let pastes = null;
             for (const segment of action.segments) {
                 const collapse = segment.kind === 'paste' && shouldCollapse(segment.text);
@@ -129,7 +138,7 @@ export function editorReducer(state, action) {
                     pastes.set(record.id, record);
                 }
                 buffer = buffer.slice(0, cursor) + text + buffer.slice(cursor);
-                cursor += text.length;
+                cursor = snapGrapheme(buffer, cursor + text.length, true);
             }
             return withPrune({
                 ...state,
@@ -139,11 +148,15 @@ export function editorReducer(state, action) {
                 ...(pastes ? { pastes } : {}),
             });
         }
-        case 'moveCursor':
+        case 'moveCursor': {
             // NO DRAFT-FLAG RESET. Moving the caret is not an edit: clearing
             // `historyIndex` here would end a history walk the moment the user pressed
             // ← to look at what they recalled.
-            return state.cursor === action.cursor ? state : { ...state, cursor: action.cursor };
+            const cursor = snapGrapheme(state.buffer, action.cursor);
+            const preferredVisualColumn = action.preferredVisualColumn;
+            return state.cursor === cursor && state.preferredVisualColumn === preferredVisualColumn
+                ? state : { ...state, cursor, preferredVisualColumn };
+        }
         case 'recall':
             // `historyIndex` is SET, not reset, which is why recall cannot reuse
             // `replace` — the two differ in exactly the field that keeps the walk
@@ -155,7 +168,8 @@ export function editorReducer(state, action) {
             return withPrune({
                 ...state,
                 buffer: action.buffer,
-                cursor: action.cursor,
+                cursor: snapGrapheme(action.buffer, action.cursor),
+                preferredVisualColumn: undefined,
                 historyIndex: action.historyIndex,
             });
         case 'select':

package/dist/ui/glyphs.js

@@ -24,18 +24,20 @@ const UNICODE_GLYPHS = {
     thinking: '✱',
     toolPending: '◦',
     toolRunning: '◍',
-    toolDone: '✔',
-    toolError: '✖',
-    info: 'ℹ',
+    // U+2714 has conflicting emoji widths in Ink and string-width. U+2713 is
+    // consistently one cell, including beside the right-edge scrollbar.
+    toolDone: '✓',
+    toolError: '×',
+    info: 'ⓘ',
     warn: '▲',
-    error: '✖',
+    error: '×',
     bullet: '•',
     spinnerStill: '·',
     gaugeFull: '█',
     gaugeEmpty: '░',
     keyOn: '●',
     keyOff: '○',
-    boxChecked: '☑',
+    boxChecked: '☒',
     boxEmpty: '☐',
     wordmark: '◇',
     ellipsis: '…',
@@ -60,10 +62,10 @@ const UNICODE_GLYPHS = {
     maskDot: '•',
     boxStyle: 'round',
     teamAgent: '◆',
-    teamMail: '✉',
+    teamMail: '⇄',
     todoPending: '○',
     todoActive: '▸',
-    todoDone: '✔',
+    todoDone: '✓',
     retry: '↻',
     compaction: '⤓',
     queued: '◷',
@@ -78,7 +80,7 @@ const UNICODE_GLYPHS = {
         ask_user: '?',
         submit_plan: '◈',
         task: '◆',
-        todo_write: '☰',
+        todo_write: '≡',
     },
     toolDefault: '•',
 };

package/dist/ui/ink-runtime.d.ts

@@ -1 +1,4 @@
+import type { TermCapabilities } from './capabilities.js';
 export declare const render: (node: import("react").ReactNode, options?: NodeJS.WriteStream | import("ink").RenderOptions) => import("ink").Instance;
+/** Mount the TUI with its resolved colors, restoring all renderers on exit. */
+export declare function renderTui(node: Parameters<typeof render>[0], options: Parameters<typeof render>[1], caps: TermCapabilities): ReturnType<typeof render>;

package/dist/ui/ink-runtime.js

@@ -19,3 +19,33 @@ async function loadInk() {
     }
 }
 export const { render } = await loadInk();
+// Keep asynchronous dependency resolution after Ink's CI initialization. A
+// static import here would let sibling UI modules load Ink before CI is reset.
+const { useTuiColors } = await import('./color-runtime.js');
+/** Mount the TUI with its resolved colors, restoring all renderers on exit. */
+export function renderTui(node, options, caps) {
+    const restore = useTuiColors(caps.colorLevel);
+    try {
+        // Ink creates its exit promise lazily and does not replay earlier exits.
+        // Mount the host first, then subscribe before application render or layout
+        // effects can fail or call useApp().exit().
+        const instance = render(null, options);
+        void instance.waitUntilExit().then(restore, restore);
+        instance.rerender(node);
+        return {
+            ...instance,
+            unmount() {
+                try {
+                    instance.unmount();
+                }
+                finally {
+                    restore();
+                }
+            },
+        };
+    }
+    catch (error) {
+        restore();
+        throw error;
+    }
+}

package/dist/ui/interaction-copy.d.ts

@@ -0,0 +1,77 @@
+/** Product copy is centralized here; Unicode escapes keep UI source ASCII-only. */
+export declare const interactionCopy: {
+    readonly copied: "已复制";
+    readonly lines: "行";
+    readonly copySent: "复制请求已发送，无法确认剪贴板";
+    readonly copyReasons: {
+        readonly empty: "没有可复制的内容";
+        readonly unavailable: "剪贴板工具不可用";
+        readonly write: "写入剪贴板失败";
+        readonly timeout: "剪贴板工具超时";
+        readonly 'too-large': "内容超过剪贴板限制";
+        readonly cancelled: "复制已取消";
+    };
+    readonly stopServicesShort: "^C 停服务";
+    readonly approveTool: "y 批准";
+    readonly rejectTool: "n/Enter 拒绝";
+    readonly saveSettings: "Enter 保存";
+    readonly modeLabel: "切换模式";
+    readonly idle: readonly ["空闲", "空闲"];
+    readonly starting: readonly ["启动", "启动中"];
+    readonly waiting: readonly ["等待", "等待模型"];
+    readonly thinking: readonly ["思考", "正在思考"];
+    readonly generating: readonly ["生成", "正在生成内容"];
+    readonly preparingTool: readonly ["工具", "正在准备工具"];
+    readonly tool: readonly ["工具", "正在运行工具"];
+    readonly confirming: readonly ["确认", "等待用户确认"];
+    readonly stopping: readonly ["停止中", "停止中"];
+    readonly compacting: readonly ["压缩", "正在压缩上下文"];
+    readonly retrying: readonly ["重试", "等待重试"];
+    readonly ended: readonly ["结束", "已结束"];
+    readonly interrupted: readonly ["中断", "已中断"];
+    readonly failed: readonly ["失败", "运行失败"];
+    readonly readFile: readonly ["读文件", "正在读取文件"];
+    readonly writeFile: readonly ["改文件", "正在修改文件"];
+    readonly command: readonly ["命令", "正在执行命令"];
+    readonly queue: "队";
+    readonly pending: "待处理";
+    readonly context: "上下文";
+    readonly contextUnknown: "上下文未知";
+    readonly sessionInput: "会话 输入";
+    readonly output: "输出";
+    readonly estimatedCost: "会话估算 USD";
+    readonly speed: "本轮均速";
+    readonly elapsed: "耗时";
+    readonly services: "服务";
+    readonly send: "Enter 发送";
+    readonly enqueue: "Enter 入队";
+    readonly newline: "^J 换行";
+    readonly sendLong: "Enter：发送";
+    readonly enqueueLong: "Enter：加入队列";
+    readonly newlineLong: "Ctrl+J：换行";
+    readonly interrupt: "Esc×2 中断";
+    readonly interruptAgain: "再按 Esc 中断";
+    readonly forceStop: "再按 Esc 强制停止";
+    readonly startingHint: "启动中，请稍候";
+    readonly cancelStart: "Esc×2 取消启动";
+    readonly cancelStartAgain: "再按 Esc 取消启动";
+    readonly copy: "Ctrl+C 复制";
+    readonly copying: "正在复制";
+    readonly copyFailed: "复制失败";
+    readonly copyCleanup: "复制失败，正在清理";
+    readonly close: "Esc 关闭";
+    readonly closeCompletion: "Esc 关闭补全";
+    readonly executeCommand: "Enter 执行命令";
+    readonly complete: "Tab 补全";
+    readonly select: "Up/Down 选择";
+    readonly scroll: "PgUp/PgDn 滚动";
+    readonly confirm: "Enter 确认";
+    readonly stopServices: "Ctrl+C 停止服务";
+    readonly exit: "Ctrl+C×2 退出";
+    readonly help: "/help 帮助";
+    readonly shiftNewline: "Shift+Enter 换行需终端支持";
+    readonly mode: "Shift+Tab 切换模式";
+    readonly update: "/update 更新";
+    readonly idlePlaceholder: "输入任务或问题…";
+    readonly runningPlaceholder: "输入补充说明…";
+};

package/dist/ui/interaction-copy.js

@@ -0,0 +1,40 @@
+/** Product copy is centralized here; Unicode escapes keep UI source ASCII-only. */
+export const interactionCopy = {
+    copied: '\u5df2\u590d\u5236', lines: '\u884c',
+    copySent: '\u590d\u5236\u8bf7\u6c42\u5df2\u53d1\u9001\uff0c\u65e0\u6cd5\u786e\u8ba4\u526a\u8d34\u677f',
+    copyReasons: {
+        empty: '\u6ca1\u6709\u53ef\u590d\u5236\u7684\u5185\u5bb9',
+        unavailable: '\u526a\u8d34\u677f\u5de5\u5177\u4e0d\u53ef\u7528',
+        write: '\u5199\u5165\u526a\u8d34\u677f\u5931\u8d25',
+        timeout: '\u526a\u8d34\u677f\u5de5\u5177\u8d85\u65f6',
+        'too-large': '\u5185\u5bb9\u8d85\u8fc7\u526a\u8d34\u677f\u9650\u5236',
+        cancelled: '\u590d\u5236\u5df2\u53d6\u6d88',
+    },
+    stopServicesShort: '^C \u505c\u670d\u52a1',
+    approveTool: 'y \u6279\u51c6', rejectTool: 'n/Enter \u62d2\u7edd',
+    saveSettings: 'Enter \u4fdd\u5b58',
+    modeLabel: '\u5207\u6362\u6a21\u5f0f',
+    idle: ['\u7a7a\u95f2', '\u7a7a\u95f2'], starting: ['\u542f\u52a8', '\u542f\u52a8\u4e2d'], waiting: ['\u7b49\u5f85', '\u7b49\u5f85\u6a21\u578b'],
+    thinking: ['\u601d\u8003', '\u6b63\u5728\u601d\u8003'], generating: ['\u751f\u6210', '\u6b63\u5728\u751f\u6210\u5185\u5bb9'],
+    preparingTool: ['\u5de5\u5177', '\u6b63\u5728\u51c6\u5907\u5de5\u5177'], tool: ['\u5de5\u5177', '\u6b63\u5728\u8fd0\u884c\u5de5\u5177'],
+    confirming: ['\u786e\u8ba4', '\u7b49\u5f85\u7528\u6237\u786e\u8ba4'], stopping: ['\u505c\u6b62\u4e2d', '\u505c\u6b62\u4e2d'],
+    compacting: ['\u538b\u7f29', '\u6b63\u5728\u538b\u7f29\u4e0a\u4e0b\u6587'], retrying: ['\u91cd\u8bd5', '\u7b49\u5f85\u91cd\u8bd5'],
+    ended: ['\u7ed3\u675f', '\u5df2\u7ed3\u675f'], interrupted: ['\u4e2d\u65ad', '\u5df2\u4e2d\u65ad'], failed: ['\u5931\u8d25', '\u8fd0\u884c\u5931\u8d25'],
+    readFile: ['\u8bfb\u6587\u4ef6', '\u6b63\u5728\u8bfb\u53d6\u6587\u4ef6'], writeFile: ['\u6539\u6587\u4ef6', '\u6b63\u5728\u4fee\u6539\u6587\u4ef6'],
+    command: ['\u547d\u4ee4', '\u6b63\u5728\u6267\u884c\u547d\u4ee4'],
+    queue: '\u961f', pending: '\u5f85\u5904\u7406', context: '\u4e0a\u4e0b\u6587', contextUnknown: '\u4e0a\u4e0b\u6587\u672a\u77e5',
+    sessionInput: '\u4f1a\u8bdd \u8f93\u5165', output: '\u8f93\u51fa', estimatedCost: '\u4f1a\u8bdd\u4f30\u7b97 USD',
+    speed: '\u672c\u8f6e\u5747\u901f', elapsed: '\u8017\u65f6', services: '\u670d\u52a1',
+    send: 'Enter \u53d1\u9001', enqueue: 'Enter \u5165\u961f', newline: '^J \u6362\u884c',
+    sendLong: 'Enter\uff1a\u53d1\u9001', enqueueLong: 'Enter\uff1a\u52a0\u5165\u961f\u5217', newlineLong: 'Ctrl+J\uff1a\u6362\u884c',
+    interrupt: 'Esc\u00d72 \u4e2d\u65ad', interruptAgain: '\u518d\u6309 Esc \u4e2d\u65ad', forceStop: '\u518d\u6309 Esc \u5f3a\u5236\u505c\u6b62',
+    startingHint: '\u542f\u52a8\u4e2d\uff0c\u8bf7\u7a0d\u5019', cancelStart: 'Esc\u00d72 \u53d6\u6d88\u542f\u52a8',
+    cancelStartAgain: '\u518d\u6309 Esc \u53d6\u6d88\u542f\u52a8',
+    copy: 'Ctrl+C \u590d\u5236', copying: '\u6b63\u5728\u590d\u5236', copyFailed: '\u590d\u5236\u5931\u8d25', copyCleanup: '\u590d\u5236\u5931\u8d25\uff0c\u6b63\u5728\u6e05\u7406',
+    close: 'Esc \u5173\u95ed', closeCompletion: 'Esc \u5173\u95ed\u8865\u5168', executeCommand: 'Enter \u6267\u884c\u547d\u4ee4',
+    complete: 'Tab \u8865\u5168', select: 'Up/Down \u9009\u62e9', scroll: 'PgUp/PgDn \u6eda\u52a8',
+    confirm: 'Enter \u786e\u8ba4', stopServices: 'Ctrl+C \u505c\u6b62\u670d\u52a1', exit: 'Ctrl+C\u00d72 \u9000\u51fa',
+    help: '/help \u5e2e\u52a9', shiftNewline: 'Shift+Enter \u6362\u884c\u9700\u7ec8\u7aef\u652f\u6301',
+    mode: 'Shift+Tab \u5207\u6362\u6a21\u5f0f', update: '/update \u66f4\u65b0',
+    idlePlaceholder: '\u8f93\u5165\u4efb\u52a1\u6216\u95ee\u9898\u2026', runningPlaceholder: '\u8f93\u5165\u8865\u5145\u8bf4\u660e\u2026',
+};