klyro 0.1.1

package/dist/tools/types.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Tool surface — the contract between the agent and the outside world.
+ *
+ * Every action the agent can take on a repo is a Tool. Tools:
+ *   1. Validate input via Zod
+ *   2. Produce a JSON Schema for the model
+ *   3. Execute deterministically (modulo shell)
+ *   4. Normalize errors into { code, message, details? }
+ */
+import type { z } from 'zod';
+/** Standard tool result — either a typed value or a structured error. */
+export type ToolResult<T> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error: {
+        code: string;
+        message: string;
+        details?: unknown;
+    };
+};
+/**
+ * Context handed to every tool execution. Tools MUST treat this as immutable
+ * for the duration of execution.
+ */
+export interface ToolContext {
+    /** Working directory. All relative paths resolve here. */
+    cwd: string;
+    /** Environment variables (read-only snapshot). */
+    env: Readonly<Record<string, string | undefined>>;
+    /** Optional abort signal — tools must check periodically for long ops. */
+    signal?: AbortSignal;
+    /** True when running headless (CI, pipe). Tools should avoid prompts. */
+    nonInteractive?: boolean;
+}
+/**
+ * A typed tool definition. TInput is the validated input shape; TOutput is
+ * what the tool returns on success.
+ */
+export interface Tool<TInput, TOutput> {
+    /** Stable, machine-readable name. Lowercase + underscores. */
+    name: string;
+    /** Human-readable description — shown to the model. */
+    description: string;
+    /** Zod schema for runtime validation. */
+    inputSchema: z.ZodType<TInput>;
+    /** Execute the tool. Must never throw — return a ToolResult instead. */
+    execute(input: TInput, ctx: ToolContext): Promise<ToolResult<TOutput>>;
+}
+/**
+ * Helper to construct a Tool without restating generics.
+ */
+export declare function defineTool<TInput, TOutput>(tool: Tool<TInput, TOutput>): Tool<TInput, TOutput>;

package/dist/tools/types.js

@@ -0,0 +1,15 @@
+/**
+ * Tool surface — the contract between the agent and the outside world.
+ *
+ * Every action the agent can take on a repo is a Tool. Tools:
+ *   1. Validate input via Zod
+ *   2. Produce a JSON Schema for the model
+ *   3. Execute deterministically (modulo shell)
+ *   4. Normalize errors into { code, message, details? }
+ */
+/**
+ * Helper to construct a Tool without restating generics.
+ */
+export function defineTool(tool) {
+    return tool;
+}

package/dist/tools/verify/run-verify.d.ts

@@ -0,0 +1,60 @@
+/**
+ * run_verify — the verification engine's tool. Runs a user-supplied command
+ * (e.g. `npm test`, `tsc --noEmit`) and returns the structured result.
+ *
+ * Differentiated from `shell_exec` so that downstream code (the verification
+ * 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 { z } from 'zod';
+declare const InputSchema: z.ZodObject<{
+    command: z.ZodString;
+    cwd: z.ZodOptional<z.ZodString>;
+    timeoutMs: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export interface VerifyOutput {
+    command: string;
+    exitCode: number | null;
+    signal: NodeJS.Signals | null;
+    stdout: string;
+    stderr: string;
+    durationMs: number;
+    timedOut: boolean;
+    ok: boolean;
+    truncated: boolean;
+}
+export declare const runVerifyTool: import("../types.js").Tool<{
+    command: string;
+    cwd?: string | undefined;
+    timeoutMs?: number | undefined;
+}, {
+    readonly ok: false;
+    readonly error: {
+        readonly code: "TIMEOUT";
+        readonly message: `verify command timed out after ${number}ms`;
+        readonly details: {
+            readonly command: string;
+        };
+    };
+    command?: undefined;
+    exitCode?: undefined;
+    signal?: undefined;
+    stdout?: undefined;
+    stderr?: undefined;
+    durationMs?: undefined;
+    timedOut?: undefined;
+    truncated?: undefined;
+} | {
+    command: string;
+    exitCode: number | null;
+    signal: NodeJS.Signals | null;
+    stdout: string;
+    stderr: string;
+    durationMs: number;
+    timedOut: false;
+    ok: boolean;
+    truncated: false;
+    readonly error?: undefined;
+}>;
+export type RunVerifyInput = z.infer<typeof InputSchema>;
+export {};

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

@@ -0,0 +1,115 @@
+/**
+ * run_verify — the verification engine's tool. Runs a user-supplied command
+ * (e.g. `npm test`, `tsc --noEmit`) and returns the structured result.
+ *
+ * Differentiated from `shell_exec` so that downstream code (the verification
+ * 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 { z } from 'zod';
+import { defineTool } from '../types.js';
+import { safe, TOOL_ERROR_CODES } from '../normalize.js';
+const InputSchema = z.object({
+    command: z.string().min(1).describe('Verification command, e.g. "npm test" or "tsc --noEmit"'),
+    cwd: z.string().optional(),
+    timeoutMs: z.number().int().min(1).max(600_000).optional().describe('Default 300000 (5 min)'),
+});
+const DEFAULT_TIMEOUT_MS = 300_000;
+const MAX_OUTPUT_BYTES = 256 * 1024;
+export const runVerifyTool = defineTool({
+    name: 'run_verify',
+    description: 'Run a verification command (e.g. tests, typecheck) and return exit code, stdout, stderr. Default timeout 5 minutes. Output is truncated at 256 KiB. Returns ok=true iff exit code is 0.',
+    inputSchema: InputSchema,
+    execute: async (input, ctx) => {
+        return safe(async () => {
+            const cwd = input.cwd ?? ctx.cwd;
+            const timeoutMs = input.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+            const env = process.env;
+            const start = Date.now();
+            const child = spawn(input.command, {
+                cwd,
+                env,
+                shell: true,
+                stdio: ['ignore', 'pipe', 'pipe'],
+                windowsHide: true,
+                signal: ctx.signal,
+            });
+            const stdout = [];
+            const stderr = [];
+            let totalOut = 0;
+            let totalErr = 0;
+            let truncated = false;
+            child.stdout?.on('data', (b) => {
+                if (totalOut + b.length > MAX_OUTPUT_BYTES) {
+                    truncated = true;
+                    return;
+                }
+                stdout.push(b);
+                totalOut += b.length;
+            });
+            child.stderr?.on('data', (b) => {
+                if (totalErr + b.length > MAX_OUTPUT_BYTES) {
+                    truncated = true;
+                    return;
+                }
+                stderr.push(b);
+                totalErr += b.length;
+            });
+            // Resolve on the FIRST of exit/timer/error — see shell-exec.ts for why
+            // awaiting `close` alone deadlocks on Windows with a pipe-holding grandchild.
+            const outcome = await new Promise((resolve) => {
+                let done = false;
+                const finish = (o) => {
+                    if (done)
+                        return;
+                    done = true;
+                    clearTimeout(timer);
+                    resolve(o);
+                };
+                const timer = setTimeout(() => {
+                    // 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 });
+                        }
+                        catch { /* already gone */ }
+                    }
+                    else {
+                        try {
+                            child.kill('SIGKILL');
+                        }
+                        catch { /* noop */ }
+                    }
+                    finish({ code: null, signal: 'SIGKILL', timedOut: true });
+                }, timeoutMs);
+                child.on('exit', (code, signal) => finish({ code, signal, timedOut: false }));
+                child.on('error', () => finish({ code: null, signal: null, timedOut: false }));
+            });
+            const { code: exitCode, signal, timedOut } = outcome;
+            const ok = exitCode === 0 && !timedOut;
+            if (!ok) {
+                // Tool still succeeds — non-zero exit is a verify failure, not a tool
+                // failure. The verification engine consumes this output. We *do*
+                // escalate timeout to TIMEOUT, since that's a hard error mode.
+                if (timedOut) {
+                    return {
+                        ok: false,
+                        error: { code: TOOL_ERROR_CODES.TIMEOUT, message: `verify command timed out after ${timeoutMs}ms`, details: { command: input.command } },
+                    };
+                }
+            }
+            return {
+                command: input.command,
+                exitCode,
+                signal,
+                stdout: Buffer.concat(stdout).toString('utf-8'),
+                stderr: Buffer.concat(stderr).toString('utf-8'),
+                durationMs: Date.now() - start,
+                timedOut,
+                ok,
+                truncated,
+            };
+        });
+    },
+});

package/dist/tui/app.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Ink app root — status line + scrollable transcript + input box.
+ *
+ * Owns the session state machine:
+ *   - transcript: array of TranscriptItem (rendered by <Transcript/>)
+ *   - status: snapshot for the <StatusLine/>
+ *   - input: the current input-box buffer
+ *
+ * The actual agent loop runs externally; the app just listens for
+ * RuntimeEvents via the onEvent callback wired by cli/repl.ts and
+ * translates them into transcript/status updates.
+ */
+import React from 'react';
+import { type StatusSnapshot } from './status.js';
+import { type TranscriptItem } from './transcript.js';
+export interface AppProps {
+    initialModel: string;
+    maxSteps: number;
+    /** Called when the user submits a non-slash prompt. */
+    onPrompt: (text: string) => void | Promise<void>;
+    /** Called when the user types a slash command. */
+    onSlash: (cmd: import('../cli/slash/parser.js').SlashCommand) => void | Promise<void>;
+    /** Initial state (e.g. when resuming a session). */
+    initialTranscript?: TranscriptItem[];
+    initialStatus?: Partial<StatusSnapshot>;
+}
+export declare function App(props: AppProps): React.JSX.Element;

package/dist/tui/app.js

@@ -0,0 +1,79 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * Ink app root — status line + scrollable transcript + input box.
+ *
+ * Owns the session state machine:
+ *   - transcript: array of TranscriptItem (rendered by <Transcript/>)
+ *   - status: snapshot for the <StatusLine/>
+ *   - input: the current input-box buffer
+ *
+ * The actual agent loop runs externally; the app just listens for
+ * RuntimeEvents via the onEvent callback wired by cli/repl.ts and
+ * translates them into transcript/status updates.
+ */
+import { useState, useCallback, useEffect } from 'react';
+import { Box, Text, useInput } from 'ink';
+import { StatusLine } from './status.js';
+import { Transcript } from './transcript.js';
+import { parse as parseSlash } from '../cli/slash/parser.js';
+let _itemCounter = 0;
+function nextId(prefix) {
+    _itemCounter += 1;
+    return `${prefix}-${_itemCounter}`;
+}
+export function App(props) {
+    const [transcript, setTranscript] = useState(props.initialTranscript ?? []);
+    const [input, setInput] = useState('');
+    const [status, setStatus] = useState({
+        model: props.initialModel,
+        step: 0,
+        maxSteps: props.maxSteps,
+        usageInput: 0,
+        usageOutput: 0,
+        repairs: 0,
+        status: 'idle',
+        ...props.initialStatus,
+    });
+    const append = useCallback((item) => {
+        setTranscript((prev) => [...prev, item]);
+    }, []);
+    useEffect(() => {
+        globalThis.__klyroAppAppend = append;
+        globalThis.__klyroAppStatus = (s) => setStatus((prev) => ({ ...prev, ...s }));
+        return () => {
+            delete globalThis.__klyroAppAppend;
+            delete globalThis.__klyroAppStatus;
+        };
+    }, [append]);
+    useInput((inputStr, key) => {
+        if (status.status === 'running')
+            return;
+        if (key.return) {
+            const value = input.trim();
+            setInput('');
+            if (!value)
+                return;
+            append({ id: nextId('text'), kind: 'text', text: value, role: 'user' });
+            const cmd = parseSlash(value);
+            if (cmd.kind === 'prompt') {
+                void props.onPrompt(cmd.text);
+            }
+            else {
+                void props.onSlash(cmd);
+            }
+            return;
+        }
+        if (key.backspace || key.delete) {
+            setInput((v) => v.slice(0, -1));
+            return;
+        }
+        if (key.ctrl && inputStr === 'c') {
+            void props.onSlash({ kind: 'quit' });
+            return;
+        }
+        if (!key.ctrl && !key.meta) {
+            setInput((v) => v + inputStr);
+        }
+    });
+    return (_jsxs(Box, { flexDirection: "column", width: "100%", height: "100%", children: [_jsx(StatusLine, { snapshot: status }), _jsx(Transcript, { items: transcript }), _jsxs(Box, { borderStyle: "single", borderColor: "gray", paddingX: 1, children: [_jsx(Text, { color: "gray", children: '> ' }), _jsx(Text, { children: input }), status.status === 'running' ? _jsx(Text, { color: "cyan", children: " \u258D" }) : _jsx(Text, { children: "\u258D" })] })] }));
+}

package/dist/tui/app.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tui/app.test.js

@@ -0,0 +1,77 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { describe, it, expect, vi } from 'vitest';
+import { render } from 'ink-testing-library';
+import { App } from './app.js';
+describe('App', () => {
+    it('shows the empty-state hint and the status line', () => {
+        const { lastFrame } = render(_jsx(App, { initialModel: "mock", maxSteps: 10, onPrompt: async () => { }, onSlash: async () => { } }));
+        const out = lastFrame();
+        expect(out).toContain('mock');
+        expect(out).toMatch(/Type a prompt/);
+    });
+    it('renders initial transcript items', () => {
+        const items = [
+            { id: '1', kind: 'text', text: 'seed', role: 'user' },
+        ];
+        const { lastFrame } = render(_jsx(App, { initialModel: "m", maxSteps: 10, onPrompt: async () => { }, onSlash: async () => { }, initialTranscript: items }));
+        expect(lastFrame()).toContain('> seed');
+    });
+    it('honors initialStatus overrides', () => {
+        const overrides = { step: 5, repairs: 3, status: 'running' };
+        const { lastFrame } = render(_jsx(App, { initialModel: "m", maxSteps: 10, onPrompt: async () => { }, onSlash: async () => { }, initialStatus: overrides }));
+        const out = lastFrame();
+        expect(out).toContain('5');
+        expect(out).toContain('10');
+        expect(out).toContain('3');
+        expect(out).toContain('running');
+    });
+    it('installs and tears down the global bridge hooks', () => {
+        const g = globalThis;
+        const { unmount } = render(_jsx(App, { initialModel: "m", maxSteps: 10, onPrompt: async () => { }, onSlash: async () => { } }));
+        expect(g.__klyroAppAppend).toBeTypeOf('function');
+        expect(g.__klyroAppStatus).toBeTypeOf('function');
+        unmount();
+        expect(g.__klyroAppAppend).toBeUndefined();
+        expect(g.__klyroAppStatus).toBeUndefined();
+    });
+    it('submits a non-slash prompt via onPrompt', async () => {
+        const onPrompt = vi.fn(async () => { });
+        const { stdin } = render(_jsx(App, { initialModel: "m", maxSteps: 10, onPrompt: onPrompt, onSlash: async () => { } }));
+        stdin.write('hello world');
+        await new Promise((r) => setTimeout(r, 20));
+        stdin.write('\x0d');
+        await new Promise((r) => setTimeout(r, 50));
+        expect(onPrompt).toHaveBeenCalledWith('hello world');
+    });
+    it('routes a slash command to onSlash', async () => {
+        const onSlash = vi.fn(async () => { });
+        const { stdin } = render(_jsx(App, { initialModel: "m", maxSteps: 10, onPrompt: async () => { }, onSlash: onSlash }));
+        stdin.write('/help');
+        await new Promise((r) => setTimeout(r, 20));
+        stdin.write('\x0d');
+        await new Promise((r) => setTimeout(r, 50));
+        expect(onSlash).toHaveBeenCalled();
+        const call = onSlash.mock.calls[0]?.[0];
+        expect(call?.kind).toBe('help');
+    });
+    it('ignores Enter while status is running', async () => {
+        const onPrompt = vi.fn(async () => { });
+        const { stdin } = render(_jsx(App, { initialModel: "m", maxSteps: 10, onPrompt: onPrompt, onSlash: async () => { }, initialStatus: { status: 'running' } }));
+        stdin.write('hello');
+        await new Promise((r) => setTimeout(r, 20));
+        stdin.write('\x0d');
+        await new Promise((r) => setTimeout(r, 50));
+        expect(onPrompt).not.toHaveBeenCalled();
+    });
+    it('routes /quit to onSlash as a quit command', async () => {
+        const onSlash = vi.fn(async () => { });
+        const { stdin } = render(_jsx(App, { initialModel: "m", maxSteps: 10, onPrompt: async () => { }, onSlash: onSlash }));
+        stdin.write('/quit');
+        await new Promise((r) => setTimeout(r, 20));
+        stdin.write('\x0d');
+        await new Promise((r) => setTimeout(r, 50));
+        expect(onSlash).toHaveBeenCalled();
+        const call = onSlash.mock.calls[0]?.[0];
+        expect(call?.kind).toBe('quit');
+    });
+});

package/dist/tui/status.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Status line — model name, step counter, usage, repair counter.
+ *
+ * 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.
+ */
+import React from 'react';
+export interface StatusSnapshot {
+    model: string;
+    step: number;
+    maxSteps: number;
+    usageInput: number;
+    usageOutput: number;
+    repairs: number;
+    status: 'idle' | 'running' | 'done' | 'error' | 'aborted';
+    errorMessage?: string;
+}
+export declare function StatusLine({ snapshot }: {
+    snapshot: StatusSnapshot;
+}): React.JSX.Element;

package/dist/tui/status.js

@@ -0,0 +1,13 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Text, Box } from 'ink';
+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);
+    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: " out" })] }), _jsx(Text, { children: _jsxs(Text, { color: statusColor, children: ["\u25CF ", status] }) })] }));
+}

package/dist/tui/status.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tui/status.test.js

@@ -0,0 +1,39 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { describe, it, expect } from 'vitest';
+import { render } from 'ink-testing-library';
+import { StatusLine } from './status.js';
+describe('StatusLine', () => {
+    it('renders model, step, repairs, and token usage', () => {
+        const snapshot = {
+            model: 'gpt-4o-mini',
+            step: 3,
+            maxSteps: 30,
+            usageInput: 4096,
+            usageOutput: 1024,
+            repairs: 1,
+            status: 'running',
+        };
+        const { lastFrame } = render(_jsx(StatusLine, { snapshot: snapshot }));
+        const out = lastFrame();
+        expect(out).toContain('gpt-4o-mini');
+        expect(out).toContain('3');
+        expect(out).toContain('30');
+        expect(out).toContain('repairs');
+        expect(out).toContain('running');
+    });
+    it('renders different status colors for done / error / aborted', () => {
+        for (const status of ['done', 'error', 'aborted', 'idle']) {
+            const { lastFrame } = render(_jsx(StatusLine, { snapshot: {
+                    model: 'm', step: 1, maxSteps: 10, usageInput: 0, usageOutput: 0, repairs: 0, status,
+                } }));
+            const out = lastFrame();
+            expect(out).toContain(status);
+        }
+    });
+    it('formats usage in KiB', () => {
+        const { lastFrame } = render(_jsx(StatusLine, { snapshot: {
+                model: 'm', step: 1, maxSteps: 10, usageInput: 2048, usageOutput: 0, repairs: 0, status: 'idle',
+            } }));
+        expect(lastFrame()).toContain('2.0K');
+    });
+});

package/dist/tui/transcript.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Transcript — a scrollable list of transcript entries.
+ *
+ * Each entry is a typed TranscriptItem (text delta, tool call block,
+ * tool result, policy decision, error). The component takes a flat list
+ * and renders it. Tool call blocks are collapsible via a `collapsed` flag.
+ *
+ * State management: parent owns the list, passes a fresh array on every
+ * update. This component is pure presentational.
+ */
+import React from 'react';
+export type TranscriptItem = {
+    id: string;
+    kind: 'text';
+    text: string;
+    role: 'user' | 'assistant';
+} | {
+    id: string;
+    kind: 'tool';
+    name: string;
+    id_call: string;
+    args: string;
+    result?: string;
+    isError?: boolean;
+    latencyMs?: number;
+    collapsed?: boolean;
+} | {
+    id: string;
+    kind: 'policy';
+    name: string;
+    action: 'allow' | 'ask' | 'deny';
+    reason?: string;
+} | {
+    id: string;
+    kind: 'error';
+    message: string;
+};
+export declare function Transcript({ items }: {
+    items: TranscriptItem[];
+}): React.JSX.Element;

package/dist/tui/transcript.js

@@ -0,0 +1,28 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { Text, Box } from 'ink';
+export function Transcript({ items }) {
+    return (_jsx(Box, { flexDirection: "column", flexGrow: 1, paddingX: 1, children: items.length === 0 ? (_jsx(Text, { color: "gray", dimColor: true, children: "Type a prompt or /help for commands." })) : items.map((item) => (_jsx(TranscriptRow, { item: item }, item.id))) }));
+}
+function TranscriptRow({ item }) {
+    if (item.kind === 'text') {
+        const color = item.role === 'user' ? 'blue' : undefined;
+        return (_jsx(Box, { marginY: 0, children: _jsxs(Text, { color: color, children: [item.role === 'user' ? '> ' : '', item.text] }) }));
+    }
+    if (item.kind === 'tool') {
+        const headerColor = item.isError ? 'red' : 'yellow';
+        return (_jsxs(Box, { flexDirection: "column", marginY: 0, paddingLeft: 2, children: [_jsxs(Text, { children: [_jsxs(Text, { color: headerColor, children: ["[tool] ", item.name] }), item.latencyMs !== undefined ? (_jsxs(Text, { color: "gray", children: ["  (", item.latencyMs, "ms)"] })) : null] }), item.collapsed ? (_jsxs(Text, { color: "gray", dimColor: true, children: ["  (collapsed \u2014 ", item.args.length, " chars of args, ", item.result?.length ?? 0, " chars of result)"] })) : (_jsxs(_Fragment, { children: [_jsxs(Text, { color: "gray", children: ["  args: ", truncate(item.args, 200)] }), item.result !== undefined ? (_jsxs(Text, { color: item.isError ? 'red' : 'gray', children: ["  -> ", truncate(item.result, 400)] })) : null] }))] }));
+    }
+    if (item.kind === 'policy') {
+        const color = item.action === 'allow' ? 'green' : item.action === 'deny' ? 'red' : 'yellow';
+        return (_jsxs(Box, { paddingLeft: 2, children: [_jsx(Text, { color: "gray", children: "[policy] " }), _jsx(Text, { color: color, children: item.action }), _jsxs(Text, { color: "gray", children: [" ", item.name] }), item.reason ? _jsxs(Text, { color: "gray", children: [" \u2014 ", item.reason] }) : null] }));
+    }
+    if (item.kind === 'error') {
+        return (_jsx(Box, { paddingLeft: 2, children: _jsxs(Text, { color: "red", children: ["[error] ", item.message] }) }));
+    }
+    return null;
+}
+function truncate(s, max) {
+    if (s.length <= max)
+        return s;
+    return s.slice(0, max) + '…';
+}

package/dist/tui/transcript.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tui/transcript.test.js

@@ -0,0 +1,71 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { describe, it, expect } from 'vitest';
+import { render } from 'ink-testing-library';
+import { Transcript } from './transcript.js';
+describe('Transcript', () => {
+    it('shows the empty-state hint when no items', () => {
+        const { lastFrame } = render(_jsx(Transcript, { items: [] }));
+        expect(lastFrame()).toMatch(/Type a prompt/);
+    });
+    it('renders user text with the > prefix', () => {
+        const items = [
+            { id: '1', kind: 'text', text: 'hello', role: 'user' },
+        ];
+        const { lastFrame } = render(_jsx(Transcript, { items: items }));
+        expect(lastFrame()).toContain('> hello');
+    });
+    it('renders assistant text without prefix', () => {
+        const items = [
+            { id: '1', kind: 'text', text: 'world', role: 'assistant' },
+        ];
+        const { lastFrame } = render(_jsx(Transcript, { items: items }));
+        expect(lastFrame()).toContain('world');
+        expect(lastFrame()).not.toContain('> world');
+    });
+    it('renders a tool call block with header and result', () => {
+        const items = [
+            {
+                id: 't1', kind: 'tool', name: 'read_file', id_call: 'c1',
+                args: '{"path":"x"}', result: 'content', isError: false, latencyMs: 12,
+            },
+        ];
+        const { lastFrame } = render(_jsx(Transcript, { items: items }));
+        const out = lastFrame();
+        expect(out).toContain('[tool]');
+        expect(out).toContain('read_file');
+        expect(out).toContain('(12ms)');
+        expect(out).toContain('content');
+    });
+    it('collapses long tool args/results when collapsed=true', () => {
+        const items = [
+            {
+                id: 't1', kind: 'tool', name: 'shell_exec', id_call: 'c1',
+                args: 'x'.repeat(500), result: 'y'.repeat(500), isError: false, latencyMs: 5,
+                collapsed: true,
+            },
+        ];
+        const { lastFrame } = render(_jsx(Transcript, { items: items }));
+        const out = lastFrame();
+        expect(out).toContain('collapsed');
+        expect(out).toContain('500');
+        expect(out).not.toContain('x'.repeat(50));
+    });
+    it('renders policy decisions with the right color cue', () => {
+        const items = [
+            { id: 'p1', kind: 'policy', name: 'shell_exec', action: 'deny', reason: 'r' },
+            { id: 'p2', kind: 'policy', name: 'shell_exec', action: 'allow' },
+        ];
+        const { lastFrame } = render(_jsx(Transcript, { items: items }));
+        const out = lastFrame();
+        expect(out).toContain('deny');
+        expect(out).toContain('allow');
+        expect(out).toContain('shell_exec');
+    });
+    it('renders error items', () => {
+        const items = [
+            { id: 'e1', kind: 'error', message: 'oops' },
+        ];
+        const { lastFrame } = render(_jsx(Transcript, { items: items }));
+        expect(lastFrame()).toContain('[error] oops');
+    });
+});