klyro 0.1.53 → 0.1.55

package/dist/tools/fs/write-file.js

@@ -34,7 +34,7 @@ export const writeFileTool = defineTool({
             let needsApproval = false;
             try {
                 existing = await fs.readFile(resolved, 'utf-8');
-                if (!wasRead(input.path) && existing.length > 200) {
+                if (!wasRead(input.path, ctx.cwd) && existing.length > 200) {
                     needsApproval = true;
                 }
             }

package/dist/tools/normalize.js

@@ -40,8 +40,18 @@ export function toToolError(err, fallbackCode = TOOL_ERROR_CODES.INTERNAL) {
     }
     return { code: fallbackCode, message: String(err) };
 }
+const CUSTOM_TOOL_CODES = new Set([
+    'MATCH_NOT_FOUND',
+    'MATCH_AMBIGUOUS',
+    'UNKNOWN_TOOL',
+    'INVALID_INPUT',
+    'INVALID_PATCH',
+    'HUNK_MISMATCH',
+    'POLICY_DENIED',
+    'STALE',
+]);
 function isToolErrorCode(code) {
-    return Object.values(TOOL_ERROR_CODES).includes(code) || code === 'MATCH_NOT_FOUND' || code === 'MATCH_AMBIGUOUS' || code === 'UNKNOWN_TOOL' || code === 'INVALID_INPUT';
+    return Object.values(TOOL_ERROR_CODES).includes(code) || CUSTOM_TOOL_CODES.has(code);
 }
 function mapNodeErrorCode(code) {
     switch (code) {

package/dist/tools/shell/background.d.ts

@@ -2,6 +2,11 @@
  * 4.3 — Background shell: shell(run_in_background), bash_output, kill_shell, /jobs
  */
 export declare function startBackground(command: string, cwd: string): string;
+/**
+ * argv variant (shell:false) — no shell interpolation possible. Used for
+ * constructed commands (e.g. opening an editor on a user-supplied path).
+ */
+export declare function startBackgroundArgv(argv: string[], cwd: string): string;
 export declare function getOutput(id: string, filter?: string): string;
 export declare function killJob(id: string): void;
 export declare function listJobs(): Array<{

package/dist/tools/shell/background.js

@@ -2,6 +2,7 @@
  * 4.3 — Background shell: shell(run_in_background), bash_output, kill_shell, /jobs
  */
 import { spawn } from 'node:child_process';
+import { findBlockedReason } from './shell-exec.js';
 const jobs = new Map();
 let counter = 0;
 const MAX_JOBS = 5;
@@ -26,6 +27,10 @@ export function startBackground(command, cwd) {
     pruneJobs();
     if (jobs.size >= MAX_JOBS)
         throw new Error(`Too many background jobs (max ${MAX_JOBS}) — kill one with /jobs`);
+    // Same destructive-pattern gate as shell_exec (spawn is shell:true here too).
+    const blocked = findBlockedReason(command);
+    if (blocked)
+        throw new Error(`Command blocked: ${blocked}`);
     const id = `job-${++counter}-${Date.now().toString(36)}`;
     const proc = spawn(command, { cwd, shell: true, windowsHide: true });
     const job = { id, command, cwd, proc, output: '', start: Date.now() };
@@ -40,6 +45,30 @@ export function startBackground(command, cwd) {
     });
     return id;
 }
+/**
+ * argv variant (shell:false) — no shell interpolation possible. Used for
+ * constructed commands (e.g. opening an editor on a user-supplied path).
+ */
+export function startBackgroundArgv(argv, cwd) {
+    pruneJobs();
+    if (jobs.size >= MAX_JOBS)
+        throw new Error(`Too many background jobs (max ${MAX_JOBS}) — kill one with /jobs`);
+    if (argv.length === 0)
+        throw new Error('startBackgroundArgv requires argv');
+    const id = `job-${++counter}-${Date.now().toString(36)}`;
+    const proc = spawn(argv[0], argv.slice(1), { cwd, shell: false, windowsHide: true });
+    const job = { id, command: argv.join(' '), 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);
+    });
+    return id;
+}
 export function getOutput(id, filter) {
     const job = jobs.get(id);
     if (!job)

package/dist/tools/shell/shell-exec.d.ts

@@ -15,6 +15,15 @@ declare const InputSchema: z.ZodObject<{
     timeoutMs: z.ZodOptional<z.ZodNumber>;
     env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
 }, z.core.$strip>;
+/** Reset the sticky cwd (e.g. after /cd changes the session directory). */
+export declare function resetPersistentCwd(): void;
+/**
+ * Shared dangerous-command check (also used by background shells).
+ * Returns the block reason, or null when the command is not hard-blocked.
+ * NOTE: this covers destructive patterns only — it is NOT an allowlist.
+ * Interactive/user-typed commands intentionally bypass it.
+ */
+export declare function findBlockedReason(command: string): string | null;
 export interface ShellOutput {
     command: string;
     exitCode: number | null;

package/dist/tools/shell/shell-exec.js

@@ -35,6 +35,10 @@ const FULL_OUTPUT_DIR = (() => {
 })();
 // Persistent cwd across calls (3.3)
 let persistentCwd = null;
+/** Reset the sticky cwd (e.g. after /cd changes the session directory). */
+export function resetPersistentCwd() {
+    persistentCwd = null;
+}
 // Filtered env — only safe vars, secrets stripped
 const ALLOWED_ENV_PREFIXES = ['PATH', 'HOME', 'USER', 'SHELL', 'TERM', 'LANG', 'NODE_', 'NPM_', 'PNPM_', 'YARN_'];
 function filteredEnv(extra) {
@@ -96,6 +100,19 @@ const DANGEROUS_PATTERNS = [
     { pattern: /&&\s*rm\s+-rf/, reason: 'chained rm -rf' },
     { pattern: /\|\|\s*rm\s+-rf/, reason: 'chained rm -rf' },
 ];
+/**
+ * Shared dangerous-command check (also used by background shells).
+ * Returns the block reason, or null when the command is not hard-blocked.
+ * NOTE: this covers destructive patterns only — it is NOT an allowlist.
+ * Interactive/user-typed commands intentionally bypass it.
+ */
+export function findBlockedReason(command) {
+    for (const { pattern, reason } of DANGEROUS_PATTERNS) {
+        if (pattern.test(command))
+            return reason;
+    }
+    return null;
+}
 export const shellExecTool = defineTool({
     name: 'shell_exec',
     description: 'Execute a shell command. Default timeout 120s (max 600s). Output head+tail 30k chars, full to ~/.klyro/tool-output/<id>.txt. Persistent cwd, filtered env, tree-kill on timeout.',
@@ -112,10 +129,9 @@ export const shellExecTool = defineTool({
                     throw Object.assign(new Error(`Interactive command blocked: ${input.command.split(' ')[0]} — hint: use non-interactive mode or run in background`), { code: TOOL_ERROR_CODES.COMMAND_DENIED });
                 }
             }
-            for (const { pattern, reason } of DANGEROUS_PATTERNS) {
-                if (pattern.test(input.command)) {
-                    throw Object.assign(new Error(`Command blocked: ${reason}`), { code: TOOL_ERROR_CODES.COMMAND_DENIED });
-                }
+            const blocked = findBlockedReason(input.command);
+            if (blocked) {
+                throw Object.assign(new Error(`Command blocked: ${blocked}`), { code: TOOL_ERROR_CODES.COMMAND_DENIED });
             }
             // Persistent cwd
             let cwd = persistentCwd ?? ctx.cwd;
@@ -137,6 +153,8 @@ export const shellExecTool = defineTool({
             const timeoutMs = Math.min(input.timeoutMs ?? DEFAULT_TIMEOUT_MS, MAX_TIMEOUT_MS);
             const env = filteredEnv(input.env);
             const start = Date.now();
+            // Detached on POSIX so timeout kills the whole process GROUP
+            // (child.kill alone orphans grandchildren holding the pipes).
             const child = spawn(input.command, {
                 cwd,
                 env: env,
@@ -144,6 +162,7 @@ export const shellExecTool = defineTool({
                 stdio: ['ignore', 'pipe', 'pipe'],
                 windowsHide: true,
                 signal: ctx.signal,
+                detached: process.platform !== 'win32',
             });
             const stdoutChunks = [];
             const stderrChunks = [];
@@ -151,9 +170,20 @@ export const shellExecTool = defineTool({
             const fullStderr = [];
             let totalOut = 0;
             let totalErr = 0;
+            // Full-output caps: an infinite emitter (e.g. `yes`) must not OOM the
+            // process or fill the disk. Past the cap we keep counting but drop bytes.
+            let fullOutBytes = 0;
+            let fullErrBytes = 0;
+            const MAX_FULL_BYTES = 512 * 1024;
             let truncated = false;
             child.stdout?.on('data', (chunk) => {
-                fullStdout.push(chunk);
+                if (fullOutBytes + chunk.length <= MAX_FULL_BYTES) {
+                    fullStdout.push(chunk);
+                    fullOutBytes += chunk.length;
+                }
+                else {
+                    truncated = true;
+                }
                 if (totalOut + chunk.length > MAX_OUTPUT_CHARS) {
                     truncated = true;
                     // Keep head+tail: drop middle, keep first half and last half later
@@ -165,7 +195,13 @@ export const shellExecTool = defineTool({
                 totalOut += chunk.length;
             });
             child.stderr?.on('data', (chunk) => {
-                fullStderr.push(chunk);
+                if (fullErrBytes + chunk.length <= MAX_FULL_BYTES) {
+                    fullStderr.push(chunk);
+                    fullErrBytes += chunk.length;
+                }
+                else {
+                    truncated = true;
+                }
                 if (totalErr + chunk.length > MAX_OUTPUT_CHARS) {
                     truncated = true;
                     if (stderrChunks.length < 10)
@@ -200,10 +236,20 @@ export const shellExecTool = defineTool({
                         catch { /* already gone */ }
                     }
                     else {
+                        // Kill the whole process group (spawned detached); fall back to
+                        // the direct child if the group signal fails.
                         try {
-                            child.kill('SIGKILL');
+                            if (child.pid !== undefined)
+                                process.kill(-child.pid, 'SIGKILL');
+                            else
+                                child.kill('SIGKILL');
+                        }
+                        catch {
+                            try {
+                                child.kill('SIGKILL');
+                            }
+                            catch { /* already dead */ }
                         }
-                        catch { /* already dead */ }
                     }
                     finish({ code: null, signal: 'SIGKILL', timedOut: true });
                 }, timeoutMs);

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

@@ -6,7 +6,7 @@
  * engine) can pick a more permissive policy for the verify command: it can
  * run `npm test`, which shell_exec might want approval for in some configs.
  */
-import { spawn } from 'node:child_process';
+import { spawn, spawnSync } from 'node:child_process';
 import { z } from 'zod';
 import { defineTool } from '../types.js';
 import { safe, TOOL_ERROR_CODES } from '../normalize.js';
@@ -71,7 +71,7 @@ export const runVerifyTool = defineTool({
                     // Windows grandchild cleanup — see shell-exec.ts for why.
                     if (process.platform === 'win32') {
                         try {
-                            require('node:child_process').spawnSync('taskkill', ['/F', '/T', '/PID', String(child.pid)], { windowsHide: true });
+                            spawnSync('taskkill', ['/F', '/T', '/PID', String(child.pid)], { windowsHide: true });
                         }
                         catch { /* already gone */ }
                     }

package/dist/tui/app.js

@@ -5,14 +5,16 @@ import { jsxs as _jsxs, jsx as _jsx, Fragment as _Fragment } from "react/jsx-run
  */
 import React, { useState, useEffect, useRef, useCallback, useMemo } from 'react';
 import { Box, Text, useInput, useStdout } from 'ink';
+import Spinner from 'ink-spinner';
 import { execFileSync } from 'node:child_process';
-import { TuiApprovalBridge } from './approval.js';
+import { TuiApprovalBridge, ApprovalModal } from './approval.js';
 import { parse as parseSlash, suggestCommands } from '../cli/slash/parser.js';
 import { tokens, g } from './tokens.js';
 import { initialScroll, scrollReducer, resolveTopRow, maxTopFor, } from './scroll-model.js';
 import { buildIndex, itemAtRow, MeasureCache } from './measure.js';
 import { renderMarkdownLines } from './markdown.js';
 import { getTranscriptCommand, } from './transcript-commands.js';
+import { estimateCost, getModelInfo } from '../providers/model-info.js';
 let _id = 0;
 function nextId(p) { _id++; return `${p}-${_id}`; }
 function Header({ cwd, model, version, width }) {
@@ -633,9 +635,11 @@ export function App(props) {
     });
     const ver = props.version ?? '0.1.27';
     const rule = g('rule').repeat(Math.max(10, width - 2));
-    const cost = (status.usageInput / 1000 * 0.003 + status.usageOutput / 1000 * 0.015);
+    // Single cost/context source: model-aware registry rates + window.
+    const cost = estimateCost(status.model, status.usageInput, status.usageOutput);
     const totalTokens = status.usageInput + status.usageOutput;
-    const ctxPct = totalTokens > 0 ? Math.round((totalTokens / 120_000) * 100) : 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.
     const baseHints = width < 90
         ? status.status === 'running' ? 'ctrl+c stop · enter queue' : 'enter send · / commands'
@@ -680,7 +684,8 @@ export function App(props) {
                                     const right = gr.status === 'running' ? `${(elapsed / 1000).toFixed(1)}s` : gr.status === 'error' ? g('failure') : `${gr.totalMs}ms`;
                                     const marker = isExpanded ? g('expanded') : g('collapsed');
                                     const markerColor = gr.status === 'error' ? tokens.colors.err : gr.status === 'running' ? tokens.colors.warn : tokens.colors.ok;
-                                    return (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsxs(Box, { children: [_jsxs(Text, { color: tokens.colors.guide, children: ["  ", g('guide'), "   "] }), _jsxs(Text, { color: markerColor, children: [marker, " ", verbLine] }), _jsxs(Text, { color: tokens.colors.dim, children: ["  ", right] })] }), isExpanded ? (_jsxs(_Fragment, { children: [gr.items.slice(0, 12).map((it) => {
+                                    const running = gr.status === 'running';
+                                    return (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsxs(Box, { children: [_jsxs(Text, { color: tokens.colors.guide, children: ["  ", g('guide'), "   "] }), running ? _jsxs(Text, { color: markerColor, children: [_jsx(Spinner, { type: "dots" }), " "] }) : null, _jsxs(Text, { color: markerColor, children: [marker, " ", verbLine] }), _jsxs(Text, { color: tokens.colors.dim, children: ["  ", right] })] }), isExpanded ? (_jsxs(_Fragment, { children: [gr.items.slice(0, 12).map((it) => {
                                                         let friendly = '';
                                                         try {
                                                             const a = JSON.parse(it.args);
@@ -718,5 +723,5 @@ export function App(props) {
                                 if (it.kind === 'diff')
                                     return (_jsxs(Box, { flexDirection: "column", paddingLeft: 2, marginBottom: 1, children: [_jsx(Text, { bold: true, color: tokens.colors.soft, children: it.summary ?? 'Diff' }), it.hunks.map((h, i) => (_jsxs(Box, { flexDirection: "column", marginTop: 0, children: [_jsx(Text, { color: tokens.colors.soft, children: h.path }), h.lines.map((l, j) => (_jsxs(Text, { wrap: "wrap", color: l.kind === 'add' ? tokens.colors.ok : l.kind === 'remove' ? tokens.colors.err : tokens.colors.dim, children: [l.kind === 'add' ? '+ ' : l.kind === 'remove' ? '- ' : '  ', l.text] }, j)))] }, i)))] }, it.id));
                                 return null;
-                            }) : null, showThinking && status.status === 'running' && !streamingIdRef.current ? (_jsxs(Box, { paddingLeft: 2, marginBottom: 1, children: [_jsxs(Text, { color: tokens.colors.guide, children: ["  ", g('guide'), "   "] }), _jsx(Text, { color: tokens.colors.dim, children: "Thinking... (esc to cancel)" }), _jsxs(Text, { color: tokens.colors.dim, children: ["  ", (elapsed / 1000).toFixed(1), "s"] })] })) : null, showPlan && plan.length > 0 ? (_jsxs(Box, { flexDirection: "column", paddingLeft: 2, marginTop: 0, marginBottom: 1, children: [_jsxs(Box, { children: [_jsxs(Text, { color: tokens.colors.guide, children: ["  ", g('guide'), "   "] }), _jsxs(Text, { bold: true, children: [g('todoPlan'), " Plan  ", plan.filter((p) => p.status === 'done').length, "/", plan.length] })] }), plan.slice(0, 8).map((p, i) => (_jsxs(Box, { children: [_jsxs(Text, { color: tokens.colors.guide, children: ["  ", g('guide'), "   "] }), _jsxs(Text, { color: p.status === 'done' ? tokens.colors.ok : p.status === 'in_progress' ? tokens.colors.accent : tokens.colors.dim, children: [p.status === 'done' ? g('todoDone') : p.status === 'in_progress' ? g('todoActive') : g('todoPending'), " ", i + 1, ". ", p.title] })] }, p.id)))] })) : null, showQueued && queuedInputs.length > 0 ? (_jsx(Box, { flexDirection: "column", paddingLeft: 2, marginBottom: 1, children: queuedInputs.map((q, i) => (_jsxs(Text, { color: tokens.colors.dim, children: ["queued: ", q.slice(0, 60), i === 0 ? '  esc to drop' : ''] }, i))) })) : null] }), isFullscreen ? (_jsx(Box, { flexDirection: "column", width: 1, marginLeft: 1, children: Array.from({ length: trackH }).map((_, i) => (_jsx(Text, { color: i === thumbPos ? tokens.colors.accent : tokens.colors.guide, children: i === thumbPos ? '●' : '│' }, i))) })) : null] }), pinned && pendingNew > 0 ? (_jsx(Box, { justifyContent: "flex-end", paddingX: 1, marginTop: -1, children: _jsxs(Text, { backgroundColor: tokens.colors.accentSoft, color: tokens.colors.accent, bold: true, children: [' ↓ ', pendingNew >= 1000 ? '999+ new' : `${pendingNew} new`, ' '] }) })) : null, slashSuggest.length > 0 ? (_jsxs(Box, { flexDirection: "column", paddingLeft: 2, children: [slashSuggest.map((s, i) => (_jsxs(Text, { color: i === 0 ? tokens.colors.accent : tokens.colors.dim, children: [i === 0 ? '▸' : ' ', " /", s.name, "  \u2014 ", s.hint] }, s.name))), _jsx(Text, { color: tokens.colors.dim, children: "  tab to complete" })] })) : null, _jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: tokens.colors.guide, children: g('rule').repeat(Math.max(10, width - 2)) }), _jsxs(Box, { children: [_jsxs(Text, { color: tokens.colors.accent, bold: true, children: [g('prompt'), " "] }), _jsxs(Text, { wrap: "wrap", children: [input || _jsx(Text, { color: tokens.colors.dim, children: "Message Klyro..." }), "|"] })] }), _jsx(Text, { color: tokens.colors.guide, children: g('rule').repeat(Math.max(10, width - 2)) })] }), _jsxs(Box, { justifyContent: "space-between", children: [_jsxs(Text, { color: tokens.colors.dim, children: [baseHints, maxTop > 0 && isFullscreen ? '  ·  PgUp/Dn scroll' : ''] }), _jsxs(Text, { color: tokens.colors.dim, children: [cost > 0 ? `$${cost.toFixed(2)} · ` : '', ctxPct, "% ctx \u00B7 ", status.model, status.status === 'running' ? ' ●' : ''] })] })] }));
+                            }) : null, showThinking && status.status === 'running' && !streamingIdRef.current ? (_jsxs(Box, { paddingLeft: 2, marginBottom: 1, children: [_jsxs(Text, { color: tokens.colors.guide, children: ["  ", g('guide'), "   "] }), _jsxs(Text, { color: tokens.colors.accent, children: [_jsx(Spinner, { type: "dots" }), " "] }), _jsx(Text, { color: tokens.colors.dim, children: "Thinking... (esc to cancel)" }), _jsxs(Text, { color: tokens.colors.dim, children: ["  ", (elapsed / 1000).toFixed(1), "s"] })] })) : null, showPlan && plan.length > 0 ? (_jsxs(Box, { flexDirection: "column", paddingLeft: 2, marginTop: 0, marginBottom: 1, children: [_jsxs(Box, { children: [_jsxs(Text, { color: tokens.colors.guide, children: ["  ", g('guide'), "   "] }), _jsxs(Text, { bold: true, children: [g('todoPlan'), " Plan  ", plan.filter((p) => p.status === 'done').length, "/", plan.length] })] }), plan.slice(0, 8).map((p, i) => (_jsxs(Box, { children: [_jsxs(Text, { color: tokens.colors.guide, children: ["  ", g('guide'), "   "] }), _jsxs(Text, { color: p.status === 'done' ? tokens.colors.ok : p.status === 'in_progress' ? tokens.colors.accent : tokens.colors.dim, children: [p.status === 'done' ? g('todoDone') : p.status === 'in_progress' ? g('todoActive') : g('todoPending'), " ", i + 1, ". ", p.title] })] }, p.id)))] })) : null, showQueued && queuedInputs.length > 0 ? (_jsx(Box, { flexDirection: "column", paddingLeft: 2, marginBottom: 1, children: queuedInputs.map((q, i) => (_jsxs(Text, { color: tokens.colors.dim, children: ["queued: ", q.slice(0, 60), i === 0 ? '  esc to drop' : ''] }, i))) })) : null] }), isFullscreen ? (_jsx(Box, { flexDirection: "column", width: 1, marginLeft: 1, children: Array.from({ length: trackH }).map((_, i) => (_jsx(Text, { color: i === thumbPos ? tokens.colors.accent : tokens.colors.guide, children: i === thumbPos ? '●' : '│' }, i))) })) : null] }), pinned && pendingNew > 0 ? (_jsx(Box, { justifyContent: "flex-end", paddingX: 1, marginTop: -1, children: _jsxs(Text, { backgroundColor: tokens.colors.accentSoft, color: tokens.colors.accent, bold: true, children: [' ↓ ', pendingNew >= 1000 ? '999+ new' : `${pendingNew} new`, ' '] }) })) : null, slashSuggest.length > 0 ? (_jsxs(Box, { flexDirection: "column", paddingLeft: 2, children: [slashSuggest.map((s, i) => (_jsxs(Text, { color: i === 0 ? tokens.colors.accent : tokens.colors.dim, children: [i === 0 ? '▸' : ' ', " /", s.name, "  \u2014 ", s.hint] }, s.name))), _jsx(Text, { color: tokens.colors.dim, children: "  tab to complete" })] })) : null, _jsx(ApprovalModal, { bridge: bridge }), _jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: tokens.colors.guide, children: g('rule').repeat(Math.max(10, width - 2)) }), _jsxs(Box, { children: [_jsxs(Text, { color: tokens.colors.accent, bold: true, children: [g('prompt'), " "] }), _jsxs(Text, { wrap: "wrap", children: [input || _jsx(Text, { color: tokens.colors.dim, children: "Message Klyro..." }), "|"] })] }), _jsx(Text, { color: tokens.colors.guide, children: g('rule').repeat(Math.max(10, width - 2)) })] }), _jsxs(Box, { justifyContent: "space-between", children: [_jsxs(Text, { color: tokens.colors.dim, children: [status.status === 'running' ? (_jsxs(Text, { color: tokens.colors.accent, children: [_jsx(Spinner, { type: "dots" }), " working  \u00B7  "] })) : null, baseHints, maxTop > 0 && isFullscreen ? '  ·  PgUp/Dn scroll' : ''] }), _jsxs(Text, { color: tokens.colors.dim, children: [cost > 0 ? `$${cost.toFixed(2)} · ` : '', ctxPct, "% ctx \u00B7 ", status.model, status.status === 'running' ? ' ●' : ''] })] })] }));
 }

package/dist/tui/app.test.js

@@ -394,6 +394,48 @@ describe('App', () => {
         expect(frame).toContain('Answer 29');
         expect(frame).not.toContain('user message number 0');
     });
+    it('renders the approval modal when a prompt is pending (no deadlock)', async () => {
+        const { TuiApprovalBridge } = await import('./approval.js');
+        const bridge = new TuiApprovalBridge();
+        const { lastFrame } = render(_jsx(App, { initialModel: "m", maxSteps: 10, cwd: "/test", onPrompt: async () => { }, onSlash: async () => { }, approvalBridge: bridge }));
+        await new Promise((r) => setTimeout(r, 50));
+        let choice;
+        const pending = bridge
+            .ask({ toolName: 'shell_exec', reason: 'not in allowlist', summary: 'echo hi' })
+            .then((c) => {
+            choice = c;
+        });
+        await new Promise((r) => setTimeout(r, 80));
+        // The modal must actually render — previously it never mounted, so every
+        // policy 'ask' hung the runtime forever.
+        expect(lastFrame() ?? '').toMatch(/approval needed/i);
+        expect(bridge.resolve('deny')).toBe(true);
+        await pending;
+        expect(choice).toBe('deny');
+    });
+    it('shows a working spinner while running (Thinking + status)', async () => {
+        const { lastFrame } = render(_jsx(App, { initialModel: "m", maxSteps: 10, cwd: "/test", onPrompt: async () => { }, onSlash: async () => { }, initialStatus: { status: 'running' } }));
+        await new Promise((r) => setTimeout(r, 120));
+        const frame = lastFrame() ?? '';
+        // Animated dots spinner (any braille frame) or its labels must show.
+        expect(frame).toMatch(/⠋|⠙|⠹|⠸|⠼|⠴|⠦|⠧|⠇|⠏|Thinking|working/);
+        expect(frame).toContain('Thinking');
+        expect(frame).toContain('working');
+    });
+    it('running tool group shows a spinner, resolved group shows latency', async () => {
+        let hooks = null;
+        const { lastFrame } = render(_jsx(App, { initialModel: "m", maxSteps: 10, cwd: "/test", onPrompt: async () => { }, onSlash: async () => { }, isFullscreen: true, initialStatus: { status: 'running' }, onMounted: (h) => {
+                hooks = { append: h.append, updateTool: h.updateTool };
+            } }));
+        await new Promise((r) => setTimeout(r, 50));
+        hooks.append({ id: 't1', kind: 'tool', name: 'read_file', id_call: 'c1', args: '{"path":"a.ts"}', status: 'running' });
+        await new Promise((r) => setTimeout(r, 120));
+        // Running group: spinner next to the verb (braille frame or fallback text).
+        expect(lastFrame() ?? '').toMatch(/⠋|⠙|⠹|⠸|⠼|⠴|⠦|⠧|⠇|⠏|Read/);
+        hooks.updateTool('c1', { result: 'ok', isError: false, latencyMs: 42, status: 'done' });
+        await new Promise((r) => setTimeout(r, 50));
+        expect(lastFrame() ?? '').toMatch(/42ms/);
+    });
     it('Shift+Up / Shift+Down scroll by one line', async () => {
         const { stdin, lastFrame } = render(_jsx(App, { initialModel: "m", maxSteps: 10, cwd: "/test", onPrompt: async () => { }, onSlash: async () => { }, isFullscreen: true, initialTranscript: makeInitialTranscript(25) }));
         await new Promise((r) => setTimeout(r, 50));

package/dist/tui/approval.d.ts

@@ -27,7 +27,7 @@ interface PendingPrompt {
 }
 declare class TuiApprovalBridge implements ApprovalPrompt {
     private pending;
-    private listener;
+    private listeners;
     ask(req: ApprovalRequest): Promise<ApprovalChoice>;
     /** Called by the App's useInput to consume the pending prompt. */
     resolve(choice: ApprovalChoice): boolean;

package/dist/tui/approval.js

@@ -23,11 +23,19 @@ import { useEffect, useState } from 'react';
 import { Box, Text, useInput } from 'ink';
 class TuiApprovalBridge {
     pending = null;
-    listener = null;
+    // Fan-out set: BOTH the App (awaitingApproval gate) and the ApprovalModal
+    // subscribe. The old single slot meant the last subscriber silently
+    // unsubscribed the other — the modal never rendered and approvals hung.
+    listeners = new Set();
     ask(req) {
         return new Promise((resolve) => {
             this.pending = { req, resolve };
-            this.listener?.(this.pending);
+            for (const l of this.listeners) {
+                try {
+                    l(this.pending);
+                }
+                catch { /* ignore listener errors */ }
+            }
         });
     }
     /** Called by the App's useInput to consume the pending prompt. */
@@ -36,7 +44,12 @@ class TuiApprovalBridge {
             return false;
         const p = this.pending;
         this.pending = null;
-        this.listener?.(null);
+        for (const l of this.listeners) {
+            try {
+                l(null);
+            }
+            catch { /* ignore listener errors */ }
+        }
         p.resolve(choice);
         return true;
     }
@@ -45,8 +58,10 @@ class TuiApprovalBridge {
     }
     /** Used by useSyncExternalStore-ish wiring in <ApprovalModal/>. */
     subscribe(listener) {
-        this.listener = listener;
-        return () => { this.listener = null; };
+        this.listeners.add(listener);
+        return () => {
+            this.listeners.delete(listener);
+        };
     }
 }
 export { TuiApprovalBridge };

package/dist/tui/diff.d.ts

@@ -1,19 +1,11 @@
 /**
- * DiffView — a scrollable unified diff display.
+ * Diff data model shared by the transcript renderer (app.tsx) and the
+ * unified-diff parser (diff-parser.ts).
  *
- * Data model: a list of `DiffHunk` (one per file). Each hunk has a path
- * and a list of `DiffLine` with kind (add/remove/context/header).
- *
- *   src/auth/service.ts
- *   -  const old = 1;
- *   +  const old = 2;
- *     const same = true;
- *   +  // new line
- *
- * Lines are truncated to 200 chars and color-coded. The view returns
- * null when there's no diff to show.
+ * NOTE: the old DiffView component was removed: App renders diff hunks
+ * inline, and the standalone component's tests gave false coverage for UI
+ * nobody sees. Only the types remain.
  */
-import React from 'react';
 export type DiffLineKind = 'add' | 'remove' | 'context' | 'header';
 export interface DiffLine {
     kind: DiffLineKind;
@@ -23,9 +15,3 @@ export interface DiffHunk {
     path: string;
     lines: DiffLine[];
 }
-export interface DiffViewProps {
-    hunks: DiffHunk[];
-    /** Optional: total file count summary. */
-    summary?: string;
-}
-export declare function DiffView({ hunks, summary }: DiffViewProps): React.JSX.Element | null;

package/dist/tui/diff.js

@@ -1,25 +1,9 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { Box, Text } from 'ink';
-const LINE_COLORS = {
-    add: 'green',
-    remove: 'red',
-    context: 'gray',
-    header: 'cyan',
-};
-const GLYPHS = {
-    add: '+',
-    remove: '-',
-    context: ' ',
-    header: '@',
-};
-function truncate(s, max) {
-    if (s.length <= max)
-        return s;
-    return s.slice(0, max) + '…';
-}
-export function DiffView({ hunks, summary }) {
-    if (hunks.length === 0) {
-        return (_jsx(Box, { borderStyle: "single", borderColor: "gray", paddingX: 1, marginY: 1, children: _jsx(Text, { color: "gray", children: "(no working-tree changes)" }) }));
-    }
-    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 1, marginY: 1, children: [summary ? (_jsxs(Box, { children: [_jsx(Text, { color: "cyan", bold: true, children: "\uD83D\uDCDD Diff " }), _jsxs(Text, { color: "gray", children: ["  ", summary] })] })) : null, hunks.map((h, i) => (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsxs(Text, { color: "cyan", bold: true, children: ["\u2500\u2500 ", h.path, " "] }), _jsxs(Text, { color: "gray", children: ["(", h.lines.filter((l) => l.kind === 'add').length, "+ /", ' ', h.lines.filter((l) => l.kind === 'remove').length, "-)"] })] }), h.lines.map((l, j) => (_jsxs(Box, { children: [_jsxs(Text, { color: LINE_COLORS[l.kind], children: [GLYPHS[l.kind], " "] }), _jsx(Text, { color: LINE_COLORS[l.kind], children: truncate(l.text, 200) })] }, j)))] }, `${h.path}-${i}`)))] }));
-}
+/**
+ * Diff data model shared by the transcript renderer (app.tsx) and the
+ * unified-diff parser (diff-parser.ts).
+ *
+ * NOTE: the old DiffView component was removed: App renders diff hunks
+ * inline, and the standalone component's tests gave false coverage for UI
+ * nobody sees. Only the types remain.
+ */
+export {};

package/dist/tui/status.d.ts

@@ -1,11 +1,10 @@
 /**
- * Status line — model name, step counter, usage, repair counter.
+ * Status snapshot — session state pushed from app.tsx via hooks.
  *
- * Pure presentation: takes a snapshot of session state, renders a single
- * Ink <Box> with the relevant fields. State changes are pushed from
- * app.tsx via React props.
+ * NOTE: the old StatusLine component was removed: App renders its own
+ * status row inline, and the standalone component's tests gave false
+ * coverage for UI nobody sees.
  */
-import React from 'react';
 export interface StatusSnapshot {
     model: string;
     step: number;
@@ -16,6 +15,3 @@ export interface StatusSnapshot {
     status: 'idle' | 'running' | 'done' | 'error' | 'aborted';
     errorMessage?: string;
 }
-export declare function StatusLine({ snapshot }: {
-    snapshot: StatusSnapshot;
-}): React.JSX.Element;

package/dist/tui/status.js

@@ -1,17 +1,8 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { Text, Box } from 'ink';
-import { estimateCost } from '../providers/model-info.js';
-export function StatusLine({ snapshot }) {
-    const { model, step, maxSteps, usageInput, usageOutput, repairs, status } = snapshot;
-    const statusColor = status === 'running' ? 'cyan' :
-        status === 'done' ? 'green' :
-            status === 'error' ? 'red' :
-                status === 'aborted' ? 'yellow' :
-                    'gray';
-    const usageKbIn = (usageInput / 1024).toFixed(1);
-    const usageKbOut = (usageOutput / 1024).toFixed(1);
-    const cost = estimateCost(model, usageInput, usageOutput);
-    const costStr = cost > 0 ? `$${cost.toFixed(3)}` : `$0.000`;
-    const ctxPct = Math.min(99, Math.round(((usageInput + usageOutput) / 128000) * 100));
-    return (_jsxs(Box, { borderStyle: "round", borderColor: "gray", paddingX: 1, justifyContent: "space-between", children: [_jsxs(Text, { children: [_jsx(Text, { color: "gray", children: "model " }), _jsx(Text, { bold: true, children: model }), _jsx(Text, { color: "gray", children: "  step " }), _jsx(Text, { bold: true, children: step }), _jsxs(Text, { color: "gray", children: ["/", maxSteps] }), _jsx(Text, { color: "gray", children: "  repairs " }), _jsx(Text, { bold: true, children: repairs })] }), _jsxs(Text, { children: [_jsx(Text, { color: "gray", children: "tokens " }), _jsxs(Text, { color: "cyan", children: [usageKbIn, "K"] }), _jsx(Text, { color: "gray", children: " in / " }), _jsxs(Text, { color: "cyan", children: [usageKbOut, "K"] }), _jsx(Text, { color: "gray", children: " \u00B7 " }), _jsx(Text, { color: "green", children: costStr }), _jsxs(Text, { color: "gray", children: [" \u00B7 ", ctxPct, "% ctx"] })] }), _jsx(Text, { children: _jsxs(Text, { color: statusColor, children: ["\u25CF ", status] }) })] }));
-}
+/**
+ * Status snapshot — session state pushed from app.tsx via hooks.
+ *
+ * NOTE: the old StatusLine component was removed: App renders its own
+ * status row inline, and the standalone component's tests gave false
+ * coverage for UI nobody sees.
+ */
+export {};

package/dist/tui/transcript.d.ts

@@ -1,23 +1,12 @@
 /**
- * Transcript — a scrollable list of transcript entries.
+ * Transcript item types — the scrollable entry list owned by App.
  *
- * Each entry is a typed TranscriptItem (text delta, tool call block,
- * tool result, policy decision, error, file changed). The component
- * takes a flat list and renders it. Tool blocks use a card layout
- * (┌─ name ─┐) and show a spinner while running.
- *
- * State management: parent owns the list, passes a fresh array on every
- * update. This component is pure presentational.
+ * NOTE: the old Transcript/TranscriptRow/ToolCard presentational components
+ * were removed: App renders entries inline (grouped tool activity), and the
+ * standalone components' tests gave false coverage for UI nobody sees.
+ * Only the item types remain.
  */
-import React from 'react';
-import { type DiffHunk } from './diff.js';
-/** Patch applied to a running tool item when its result arrives. */
-export interface ToolResultPatch {
-    result: string;
-    isError: boolean;
-    latencyMs: number;
-    status: 'done' | 'error';
-}
+import type { DiffHunk } from './diff.js';
 export type TranscriptItem = {
     id: string;
     kind: 'text';
@@ -55,6 +44,10 @@ export type TranscriptItem = {
     hunks: DiffHunk[];
     summary?: string;
 };
-export declare function Transcript({ items }: {
-    items: TranscriptItem[];
-}): React.JSX.Element;
+/** Patch applied to a running tool item when its result arrives. */
+export interface ToolResultPatch {
+    result: string;
+    isError: boolean;
+    latencyMs: number;
+    status: 'done' | 'error';
+}