klyro 1.0.20 → 1.0.21

package/dist/tools/git/run-git.js

@@ -4,13 +4,32 @@ export function runGit(args, cwd, timeoutMs = 15_000) {
         const child = spawn('git', args, { cwd, stdio: ['ignore', 'pipe', 'pipe'], windowsHide: true, shell: false });
         const out = [];
         const err = [];
-        const timer = setTimeout(() => { try {
-            child.kill('SIGKILL');
-        }
-        catch { /* noop */ } }, timeoutMs);
+        let done = false;
+        const timer = setTimeout(() => {
+            if (done)
+                return;
+            done = true;
+            try {
+                child.kill('SIGKILL');
+            }
+            catch { /* noop */ }
+            resolve({ code: 1, out: Buffer.concat(out).toString('utf-8'), err: 'git timed out' });
+        }, timeoutMs);
         child.stdout.on('data', (b) => out.push(b));
         child.stderr.on('data', (b) => err.push(b));
+        // Missing git binary / bad cwd emits 'error' with no 'close' — without
+        // this every caller hangs to its own timeout instead of failing fast.
+        child.on('error', (e) => {
+            if (done)
+                return;
+            done = true;
+            clearTimeout(timer);
+            resolve({ code: 1, out: Buffer.concat(out).toString('utf-8'), err: String(e?.message ?? e) });
+        });
         child.on('close', (code) => {
+            if (done)
+                return;
+            done = true;
             clearTimeout(timer);
             resolve({ code: code ?? 1, out: Buffer.concat(out).toString('utf-8'), err: Buffer.concat(err).toString('utf-8') });
         });

package/dist/tools/shell/background.js

@@ -1,21 +1,58 @@
 /**
  * 4.3 — Background shell: shell(run_in_background), bash_output, kill_shell, /jobs
  */
-import { spawn } from 'node:child_process';
+import { spawn, spawnSync } from 'node:child_process';
 import { findBlockedReason, filteredEnv } from './shell-exec.js';
 const jobs = new Map();
 let counter = 0;
 const MAX_JOBS = 5;
 const JOB_TTL_MS = 10 * 60 * 1000;
+/** Tree-kill: proc.kill() alone leaves grandchildren behind (shell:true). */
+function killTree(proc) {
+    try {
+        if (process.platform === 'win32') {
+            if (proc.pid !== undefined) {
+                spawnSync('taskkill', ['/F', '/T', '/PID', String(proc.pid)], { windowsHide: true });
+            }
+        }
+        else if (proc.pid !== undefined) {
+            // Detached group kill when we own the group, else single kill.
+            try {
+                process.kill(-proc.pid, 'SIGKILL');
+            }
+            catch {
+                try {
+                    proc.kill('SIGKILL');
+                }
+                catch { /* ignore */ }
+            }
+        }
+        else {
+            try {
+                proc.kill('SIGKILL');
+            }
+            catch { /* ignore */ }
+        }
+    }
+    catch { /* ignore */ }
+}
+function watchJob(job) {
+    // A failed spawn (bad cwd, missing shell) emits 'error' with no 'close'
+    // guarantee — without a listener Node throws and takes down the process.
+    job.proc.on('error', (e) => {
+        job.output += `\n[spawn failed: ${e?.message ?? e}]`;
+    });
+    job.proc.on('close', () => {
+        setTimeout(() => { if (jobs.get(job.id)?.proc.exitCode !== null)
+            jobs.delete(job.id); }, JOB_TTL_MS);
+    });
+}
 function pruneJobs() {
     if (jobs.size <= MAX_JOBS)
         return;
     const sorted = [...jobs.values()].sort((a, b) => a.start - b.start);
     for (const j of sorted.slice(0, jobs.size - MAX_JOBS)) {
-        try {
-            j.proc.kill('SIGKILL');
-        }
-        catch { /* ignore */ }
+        killTree(j.proc);
         jobs.delete(j.id);
     }
     for (const j of [...jobs.values()]) {
@@ -33,18 +70,19 @@ export function startBackground(command, cwd) {
         throw new Error(`Command blocked: ${blocked}`);
     const id = `job-${++counter}-${Date.now().toString(36)}`;
     // Filtered env, same call shape as shell_exec — background children must
-    // not inherit secrets from the parent process.
-    const proc = spawn(command, { cwd, shell: true, windowsHide: true, env: filteredEnv() });
+    // not inherit secrets from the parent process. Detached on POSIX so
+    // killTree can take the whole group (mirrors shell_exec).
+    const proc = spawn(command, {
+        cwd, shell: true, windowsHide: true, env: filteredEnv(),
+        ...(process.platform === 'win32' ? {} : { detached: true }),
+    });
     const job = { id, command, cwd, proc, output: '', start: Date.now() };
     jobs.set(id, job);
     proc.stdout?.on('data', (b) => { job.output += b.toString(); if (job.output.length > 1_000_000)
         job.output = job.output.slice(-1_000_000); });
     proc.stderr?.on('data', (b) => { job.output += b.toString(); if (job.output.length > 1_000_000)
         job.output = job.output.slice(-1_000_000); });
-    proc.on('close', () => {
-        setTimeout(() => { if (jobs.get(id)?.proc.exitCode !== null)
-            jobs.delete(id); }, JOB_TTL_MS);
-    });
+    watchJob(job);
     return id;
 }
 /**
@@ -66,10 +104,7 @@ export function startBackgroundArgv(argv, cwd) {
         job.output = job.output.slice(-1_000_000); });
     proc.stderr?.on('data', (b) => { job.output += b.toString(); if (job.output.length > 1_000_000)
         job.output = job.output.slice(-1_000_000); });
-    proc.on('close', () => {
-        setTimeout(() => { if (jobs.get(id)?.proc.exitCode !== null)
-            jobs.delete(id); }, JOB_TTL_MS);
-    });
+    watchJob(job);
     return id;
 }
 export function getOutput(id, filter) {
@@ -84,10 +119,7 @@ export function killJob(id) {
     const job = jobs.get(id);
     if (!job)
         throw new Error(`No job ${id}`);
-    try {
-        job.proc.kill('SIGKILL');
-    }
-    catch { /* ignore */ }
+    killTree(job.proc);
     jobs.delete(id);
 }
 /**
@@ -98,10 +130,7 @@ export function killJob(id) {
 export function killAllJobs() {
     const killed = [];
     for (const job of [...jobs.values()]) {
-        try {
-            job.proc.kill('SIGKILL');
-        }
-        catch { /* ignore */ }
+        killTree(job.proc);
         jobs.delete(job.id);
         killed.push(job.id);
     }

package/dist/tools/verify/run-verify.js

@@ -10,6 +10,7 @@ import { spawn, spawnSync } from 'node:child_process';
 import { z } from 'zod';
 import { defineTool } from '../types.js';
 import { safe, TOOL_ERROR_CODES } from '../normalize.js';
+import { resolveWithinCwd } from '../../policy/path-guard.js';
 import { filteredVerifyEnv } from '../../verification/registry.js';
 const InputSchema = z.object({
     command: z.string().min(1).describe('Verification command, e.g. "npm test" or "tsc --noEmit"'),
@@ -24,7 +25,16 @@ export const runVerifyTool = defineTool({
     inputSchema: InputSchema,
     execute: async (input, ctx) => {
         return safe(async () => {
-            const cwd = input.cwd ?? ctx.cwd;
+            // Contain the model-supplied cwd to the workspace (mirrors shell_exec):
+            // without this the verify command could run in /etc, ~/.ssh, or any
+            // other directory outside the sandbox roots.
+            let cwd;
+            try {
+                cwd = resolveWithinCwd(ctx.cwd, input.cwd ?? '.').resolved;
+            }
+            catch {
+                throw Object.assign(new Error('run_verify cwd escapes workspace (POLICY_DENIED)'), { code: TOOL_ERROR_CODES.PATH_ESCAPE });
+            }
             const timeoutMs = input.timeoutMs ?? DEFAULT_TIMEOUT_MS;
             // S2: verify commands run with filtered env; servers needing keys must use explicit config.
             const env = filteredVerifyEnv();

package/dist/tui/app.d.ts

@@ -37,4 +37,9 @@ export interface AppProps {
     version?: string;
     isFullscreen?: boolean;
 }
+declare const MAX_TRANSCRIPT_ITEMS = 500;
+export { MAX_TRANSCRIPT_ITEMS as TRANSCRIPT_ITEM_CAP };
+export declare function capTranscript<T extends {
+    kind: string;
+}>(prev: T[]): T[];
 export declare function App(props: AppProps): React.JSX.Element;

package/dist/tui/app.js

@@ -10,6 +10,7 @@ import { execFileSync } from 'node:child_process';
 import { readFileSync } from 'node:fs';
 import * as path from 'node:path';
 import { TuiApprovalBridge, ApprovalModal } from './approval.js';
+import { approvalChoiceForKey } from '../policy/approval.js';
 import { parse as parseSlash, suggestCommands } from '../cli/slash/parser.js';
 import { loadCustomCommands, listCompletableFiles } from '../cli/slash/custom.js';
 import { loadMcpServers } from '../mcp/config.js';
@@ -136,10 +137,10 @@ function InputWithCursor({ input, cursor }) {
     if (cursor === null) {
         return _jsxs(Text, { wrap: "wrap", children: [safe, "|"] });
     }
-    const pos = Math.max(0, Math.min(cursor, safe.length));
-    const before = safe.slice(0, pos);
-    const ch = safe.slice(pos, pos + 1) || ' ';
-    const after = safe.slice(pos + 1);
+    const pos = Math.max(0, Math.min(cursor, gLength(safe)));
+    const before = gSlice(safe, 0, pos);
+    const ch = gSlice(safe, pos, pos + 1) || ' ';
+    const after = gSlice(safe, pos + 1);
     return (_jsxs(Text, { wrap: "wrap", children: [before, _jsx(Text, { inverse: true, children: ch }), after] }));
 }
 // design.md §23/§24 — terminal Markdown via tui/markdown.ts: headings,
@@ -181,6 +182,53 @@ function MarkdownText({ text, dim, width }) {
 // Position is an Anchor ({itemId, lineInItem}), never a raw row index (I4),
 // resolved per frame against measured *display lines* (I3, see measure.ts).
 // While anchored to 'bottom', new output follows; scrolling up pins to an
+// Display-state bound: the transcript array never grows without limit.
+// Beyond MAX_TRANSCRIPT_ITEMS the oldest non-user items go first (tool
+// rows, thinking, policy), then oldest-first. Pinned scroll anchors
+// survive via PRUNE re-stick (scroll-model); persistence is unaffected.
+const MAX_TRANSCRIPT_ITEMS = 500;
+export { MAX_TRANSCRIPT_ITEMS as TRANSCRIPT_ITEM_CAP };
+export function capTranscript(prev) {
+    const over = prev.length - MAX_TRANSCRIPT_ITEMS;
+    if (over <= 0)
+        return prev;
+    const isUser = (x) => x.kind === 'text' && x.role === 'user';
+    // Shed the oldest non-user items wherever they sit (a contiguous splice
+    // from the first drop point would also eat the user rows between them).
+    let toDrop = over;
+    const next = prev.filter((x) => {
+        if (toDrop > 0 && !isUser(x)) {
+            toDrop--;
+            return false;
+        }
+        return true;
+    });
+    // All-user transcript: oldest-first.
+    return next.length > MAX_TRANSCRIPT_ITEMS ? next.slice(next.length - MAX_TRANSCRIPT_ITEMS) : next;
+}
+// Grapheme-cluster cursor math: vimCursor/input positions are GRAPHEME
+// indices, never UTF-16 offsets — slicing a surrogate pair or ZWJ cluster
+// renders lone surrogates and corrupts emoji/CJK on h/l/x. Intl.Segmenter
+// with an Array.from fallback (splits pairs correctly, not clusters).
+let segmenterCache;
+function graphemes(s) {
+    try {
+        if (segmenterCache === undefined) {
+            const Seg = Intl.Segmenter;
+            segmenterCache = Seg ? new Seg(undefined, { granularity: 'grapheme' }) : null;
+        }
+        if (segmenterCache)
+            return [...segmenterCache.segment(s)].map((x) => x.segment);
+    }
+    catch { /* fall through to code points */ }
+    return Array.from(s);
+}
+function gLength(s) {
+    return graphemes(s).length;
+}
+function gSlice(s, start, end) {
+    return graphemes(s).slice(start, end).join('');
+}
 // item and freezes, accumulating newSinceUnstick lines for the `↓ N new` pill.
 //
 // Deviation from §7.1: Ink cannot overlay rows, so the badge renders as a
@@ -201,6 +249,8 @@ function useChatScroll(opts) {
     ctxRef.current = ctx;
     // Auto-follow wiring (§6): measured total deltas → CONTENT_GREW;
     // width change → REFLOW (§12). Initial anchor is 'bottom' → follow-tail.
+    // A pinned anchor whose item vanished (transcript pruning) re-sticks via
+    // PRUNE with a zeroed badge counter instead of inheriting stale counts.
     const prevTotalRef = useRef(index.total);
     const prevWidthRef = useRef(width);
     useEffect(() => {
@@ -208,6 +258,11 @@ function useChatScroll(opts) {
         const prevWidth = prevWidthRef.current;
         prevTotalRef.current = index.total;
         prevWidthRef.current = width;
+        const st = stateRef.current;
+        if (st.anchor.mode === 'pinned' && !keys.includes(st.anchor.itemId)) {
+            setState((s) => scrollReducer(s, { type: 'PRUNE' }, ctxRef.current));
+            return;
+        }
         if (width !== prevWidth) {
             setState((s) => scrollReducer(s, { type: 'REFLOW' }, ctxRef.current));
             return;
@@ -330,16 +385,17 @@ export function App(props) {
     const vimCursorRef = useRef(null);
     useEffect(() => { inputRef.current = input; }, [input]);
     useEffect(() => { vimCursorRef.current = vimCursor; }, [vimCursor]);
-    const clampCursor = (v, c) => c === null ? v.length : Math.max(0, Math.min(c, v.length));
+    const clampCursor = (v, c) => c === null ? gLength(v) : Math.max(0, Math.min(c, gLength(v)));
     const insertAtCursor = useCallback((text) => {
         const t = text.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
         if (!t)
             return;
         const v = inputRef.current;
         const pos = clampCursor(v, vimCursorRef.current);
-        const nv = v.slice(0, pos) + t + v.slice(pos);
+        const nv = gSlice(v, 0, pos) + t + gSlice(v, pos);
         setInput(nv);
-        setVimCursor(pos + t.length >= nv.length ? null : pos + t.length);
+        const npos = pos + gLength(t);
+        setVimCursor(npos >= gLength(nv) ? null : npos);
         setHistIdx(null);
     }, []);
     const deleteBeforeCursor = useCallback(() => {
@@ -347,9 +403,9 @@ export function App(props) {
         const pos = clampCursor(v, vimCursorRef.current);
         if (pos === 0)
             return;
-        const nv = v.slice(0, pos - 1) + v.slice(pos);
+        const nv = gSlice(v, 0, pos - 1) + gSlice(v, pos);
         setInput(nv);
-        setVimCursor(pos - 1 >= nv.length ? null : pos - 1);
+        setVimCursor(pos - 1 >= gLength(nv) ? null : pos - 1);
         setHistIdx(null);
     }, []);
     // Shift+Enter intent: explicit shift+return, kitty/CSI-u sequence, legacy
@@ -603,7 +659,7 @@ export function App(props) {
         if (queuedInputs.length > 0 && status.status !== 'running' && !awaitingApproval) {
             const toSend = queuedInputs[0];
             setQueuedInputs((prev) => prev.slice(1));
-            setTranscript((prev) => [...prev, { id: nextId('user'), kind: 'text', text: toSend, role: 'user' }]);
+            setTranscript((prev) => [...capTranscript(prev), { id: nextId('user'), kind: 'text', text: toSend, role: 'user' }]);
             resetStream();
             const cmd = parseSlash(toSend.trim());
             if (cmd.kind === 'prompt')
@@ -619,7 +675,7 @@ export function App(props) {
             flushStream();
             resetStream();
         }
-        setTranscript((prev) => [...prev, item]);
+        setTranscript((prev) => [...capTranscript(prev), item]);
     }, [flushStream, resetStream]);
     const appendDelta = useCallback((text) => {
         if (!text)
@@ -797,7 +853,7 @@ export function App(props) {
             // preserving the message prefix (`look at @ut` → `look at @util.ts`).
             const m = /(?:^|\s)@(\S*)$/.exec(input);
             if (m && m[1] !== undefined) {
-                setInput(input.slice(0, input.length - m[1].length) + top.name.slice(1) + ' ');
+                setInput(gSlice(input, 0, gLength(input) - gLength(m[1])) + top.name.slice(1) + ' ');
             }
             else {
                 setInput(`${top.name} `);
@@ -898,8 +954,26 @@ export function App(props) {
                 return;
             }
         }
-        if (awaitingApproval)
+        // Approval gate: keys must never leak into the input while a prompt is
+        // pending. Decisive keys are routed straight through the bridge instead
+        // of being swallowed: the modal subscribes async, so a fast y/n landing
+        // between ask() and the modal's first render used to vanish and hang
+        // the run on a visibly-pending modal. bridge.resolve() is a no-op when
+        // nothing is pending, and the modal's own handler ignores the duplicate
+        // via the same guard — either order is safe. 'e' is deliberately NOT
+        // routed (it enters the modal's inline edit mode, not a decision).
+        if (awaitingApproval) {
+            if (key.return) {
+                bridge.resolve('deny');
+                return;
+            }
+            const choice = approvalChoiceForKey(inputStr);
+            if ((choice === 'allow' || choice === 'always' || choice === 'always-persist' || choice === 'deny') &&
+                inputStr !== 'e') {
+                bridge.resolve(choice);
+            }
             return;
+        }
         if (key.ctrl && inputStr === 'o') {
             const groups = grouped.filter((x) => typeof x.verb === 'string');
             const last = groups[groups.length - 1];
@@ -932,46 +1006,67 @@ export function App(props) {
                 setVimMode('insert');
                 return;
             }
-            const cur = vimCursor === null ? input.length : Math.max(0, Math.min(vimCursor, input.length));
-            const move = (d) => { setVimCursor(Math.max(0, Math.min(cur + d, input.length))); return true; };
+            // All positions below are grapheme indices (see graphemes()): cursor
+            // math, word motions, and deletions never split a cluster.
+            const gs = graphemes(input);
+            const cur = vimCursor === null ? gs.length : Math.max(0, Math.min(vimCursor, gs.length));
+            const move = (d) => { setVimCursor(Math.max(0, Math.min(cur + d, gs.length))); return true; };
             const isWord = (c) => /[A-Za-z0-9_]/.test(c);
             const wordFwd = (pos, n) => {
                 let p = pos;
-                for (let k = 0; k < n && p < input.length; k++) {
-                    while (p < input.length && isWord(input[p]))
+                for (let k = 0; k < n && p < gs.length; k++) {
+                    while (p < gs.length && isWord(gs[p]))
                         p++;
-                    while (p < input.length && !isWord(input[p]))
+                    while (p < gs.length && !isWord(gs[p]))
                         p++;
                 }
-                return Math.min(p, input.length);
+                return Math.min(p, gs.length);
             };
             const wordBack = (pos, n) => {
                 let p = pos;
                 for (let k = 0; k < n && p > 0; k++) {
-                    while (p > 0 && !isWord(input[p - 1]))
+                    while (p > 0 && !isWord(gs[p - 1]))
                         p--;
-                    while (p > 0 && isWord(input[p - 1]))
+                    while (p > 0 && isWord(gs[p - 1]))
                         p--;
                 }
                 return Math.max(0, p);
             };
+            const lineStart = (pos) => {
+                for (let i = pos - 1; i >= 0; i--) {
+                    if (gs[i] === '\n')
+                        return i + 1;
+                }
+                return 0;
+            };
+            const endOfNthLine = (from, n, keepNewline) => {
+                let seen = 0;
+                for (let i = from; i < gs.length; i++) {
+                    if (gs[i] === '\n') {
+                        seen++;
+                        if (seen === n)
+                            return keepNewline ? i : i + 1;
+                    }
+                }
+                return gs.length;
+            };
             const takeCount = () => {
                 const n = vimCountRef.current <= 1 ? 1 : vimCountRef.current;
                 vimCountRef.current = 0;
                 return n;
             };
             if (!key.ctrl && !key.meta && !key.return && !key.tab && !key.upArrow && !key.downArrow && !key.leftArrow && !key.rightArrow) {
-                // Pending `d` operator: second `d` deletes the current line.
+                // Pending `d` operator: second `d` deletes whole lines (count-aware).
                 if (vimPendingOp.current === 'd') {
                     vimPendingOp.current = null;
                     if (inputStr === 'd') {
-                        const start = input.lastIndexOf('\n', cur - 1) + 1;
-                        const nl = input.indexOf('\n', cur);
-                        const end = nl === -1 ? input.length : nl + 1;
-                        setInput(input.slice(0, start) + input.slice(end));
-                        setVimCursor(Math.min(start, Math.max(0, input.slice(0, start).length)));
+                        const n = takeCount();
+                        const start = lineStart(cur);
+                        const end = endOfNthLine(start, n, false);
+                        const nv = gs.slice(0, start).join('') + gs.slice(end).join('');
+                        setInput(nv);
+                        setVimCursor(Math.min(start, gLength(nv)) >= gLength(nv) ? null : Math.min(start, gLength(nv)));
                         setHistIdx(null);
-                        vimCountRef.current = 0;
                         return;
                     }
                     // Only dd is supported — anything else cancels the operator.
@@ -984,7 +1079,7 @@ export function App(props) {
                     return;
                 }
                 if (inputStr === 'a') {
-                    setVimCursor(Math.min(cur + 1, input.length));
+                    setVimCursor(Math.min(cur + 1, gs.length));
                     setVimMode('insert');
                     vimCountRef.current = 0;
                     return;
@@ -1003,24 +1098,24 @@ export function App(props) {
                     move(n);
                     return;
                 }
-                if (inputStr === '0' && vimCountRef.current === 0) {
-                    setVimCursor(0);
-                    return;
-                }
+                // `0` alone goes to line start; after digits it extends the count
+                // (`10` + `0` = 100, matching vim — the old code moved left by N).
                 if (inputStr === '0') {
-                    const n = takeCount();
-                    move(-n);
+                    if (vimCountRef.current === 0)
+                        setVimCursor(lineStart(cur));
+                    else
+                        vimCountRef.current = vimCountRef.current * 10;
                     return;
                 }
                 if (inputStr === '$') {
                     takeCount();
-                    setVimCursor(input.length);
+                    setVimCursor(gs.length);
                     return;
                 }
                 if (inputStr === 'x') {
                     const n = takeCount();
-                    if (cur < input.length)
-                        setInput(input.slice(0, cur) + input.slice(cur + n));
+                    if (cur < gs.length)
+                        setInput(gSlice(input, 0, cur) + gSlice(input, cur + n));
                     setHistIdx(null);
                     return;
                 }
@@ -1040,24 +1135,25 @@ export function App(props) {
                     return;
                 }
                 if (inputStr === 'D') {
-                    // Delete to end of current line (keep the newline).
-                    const nl = input.indexOf('\n', cur);
-                    const end = nl === -1 ? input.length : nl;
-                    setInput(input.slice(0, cur) + input.slice(end));
+                    // Delete to end of line, count-aware (2D spans two lines).
+                    const n = takeCount();
+                    const end = endOfNthLine(cur, n, true);
+                    setInput(gSlice(input, 0, cur) + gSlice(input, end));
                     setHistIdx(null);
-                    vimCountRef.current = 0;
                     return;
                 }
                 if (inputStr === 'j') {
+                    const n = takeCount();
                     if (isFullscreen && maxTop > 0)
-                        commands.lineDown();
-                    vimCountRef.current = 0;
+                        for (let i = 0; i < n; i++)
+                            commands.lineDown();
                     return;
                 }
                 if (inputStr === 'k') {
+                    const n = takeCount();
                     if (isFullscreen && maxTop > 0)
-                        commands.lineUp();
-                    vimCountRef.current = 0;
+                        for (let i = 0; i < n; i++)
+                            commands.lineUp();
                     return;
                 }
                 if (key.backspace || key.delete) {
@@ -1114,6 +1210,11 @@ export function App(props) {
                     disarmEsc();
                     return;
                 }
+                // This Esc is a cancel gesture, not half of an ESC+CR newline pair:
+                // disarm the 75ms Esc→Return heuristic so a fast follow-up Return
+                // submits instead of inserting a newline. (The vim-normal-mode
+                // partner below is intentionally untouched — it owns that meaning.)
+                escReturnAt.current = 0;
                 const t = Date.now();
                 if (t - escArmedAt.current < 1500) {
                     disarmEsc();
@@ -1201,7 +1302,7 @@ export function App(props) {
             setVimCursor(null);
             setHistIdx(null);
             pushHistory(v);
-            setTranscript((prev) => [...prev, { id: nextId('user'), kind: 'text', text: v, role: 'user' }]);
+            setTranscript((prev) => [...capTranscript(prev), { id: nextId('user'), kind: 'text', text: v, role: 'user' }]);
             resetStream();
             setSubmitKey((k) => k + 1);
             const cmd = parseSlash(v);
@@ -1221,15 +1322,19 @@ export function App(props) {
         // Idle Esc enters vim normal mode (vimLive parity for keyboard-only users).
         if (key.escape && vimMode === 'insert') {
             setVimMode('normal');
-            setVimCursor(inputRef.current.length);
+            setVimCursor(gLength(inputRef.current));
             return;
         }
     });
     // Single source of truth: package.json via version.ts — never hardcoded.
     const ver = props.version ?? readVersion();
     // Single cost/context source: model-aware registry rates + window.
-    const cost = estimateCost(status.model, status.usageInput, status.usageOutput);
-    const totalTokens = status.usageInput + status.usageOutput;
+    // Cache counters included: Anthropic bills them and they consume context.
+    const cost = estimateCost(status.model, status.usageInput, status.usageOutput, {
+        read: status.usageCacheRead,
+        write: status.usageCacheWrite,
+    });
+    const totalTokens = status.usageInput + status.usageOutput + (status.usageCacheRead ?? 0) + (status.usageCacheWrite ?? 0);
     const ctxWindow = getModelInfo(status.model).contextWindow;
     const ctxPct = totalTokens > 0 ? Math.round((totalTokens / ctxWindow) * 100) : 0;
     // Narrow terminals: compact hints so the status bar never wraps mid-word.

package/dist/tui/app.test.js

@@ -676,6 +676,27 @@ describe('App', () => {
         stdin.write('d');
         await waitForMatch(lastFrame, /Message Klyro/);
     });
+    it('vim motions never split emoji graphemes', async () => {
+        let hooks = null;
+        const { stdin, lastFrame } = render(_jsx(App, { initialModel: "m", maxSteps: 10, cwd: "/test", onPrompt: async () => { }, onSlash: async () => { }, isFullscreen: false, onMounted: (h) => {
+                hooks = { setVimMode: h.setVimMode };
+            } }));
+        await new Promise((r) => setTimeout(r, 50));
+        stdin.write('a🎉b');
+        await waitForMatch(lastFrame, /a🎉b/);
+        hooks.setVimMode('normal');
+        await waitForMatch(lastFrame, /--NORMAL--/);
+        // h/l move whole graphemes; x deletes the whole emoji, never a half.
+        stdin.write('0');
+        await new Promise((r) => setTimeout(r, 30));
+        stdin.write('l');
+        await new Promise((r) => setTimeout(r, 30));
+        stdin.write('x');
+        await waitForMatch(lastFrame, /ab/);
+        const frame = lastFrame() ?? '';
+        expect(frame).not.toMatch(/🎉/);
+        expect(frame).not.toMatch(/\uFFFD/); // no replacement char from split surrogates
+    });
     it('vim normal mode swallows typing, shows mode, i returns to insert', async () => {
         let hooks = null;
         const { stdin, lastFrame } = render(_jsx(App, { initialModel: "m", maxSteps: 10, cwd: "/test", onPrompt: async () => { }, onSlash: async () => { }, isFullscreen: false, onMounted: (h) => {