klyro 0.1.3 → 0.1.4

package/dist/cli/repl.d.ts

@@ -11,5 +11,7 @@ export interface ReplOptions {
     maxSteps?: number;
     model?: string;
     nonInteractive?: boolean;
+    /** Force TUI even when stdin is not a TTY (e.g. for testing or explicit flag). */
+    forceTty?: boolean;
 }
 export declare function startRepl(opts?: ReplOptions): Promise<number>;

package/dist/cli/repl.js

@@ -9,6 +9,7 @@ import React from 'react';
 import { render } from 'ink';
 import { App } from '../tui/app.js';
 import { httpChatAdapter } from '../agent/provider-adapter.js';
+import { anthropicAdapter } from '../agent/anthropic-adapter.js';
 import { run } from '../agent/runtime.js';
 import { builtinRegistry } from '../tools/registry.js';
 import { builtinRules, DEFAULT_POLICY_CONFIG, PolicyEngine } from '../policy/engine.js';
@@ -16,22 +17,39 @@ import { buildLevel6Context } from '../context/level6.js';
 import { DenyAllApprovalPrompt, StdinApprovalPrompt } from '../policy/approval.js';
 import { TuiApprovalBridge } from '../tui/approval.js';
 import { parseUnifiedDiff } from '../tui/diff-parser.js';
-function readEnv(name, fallback) {
-    const v = process.env[name];
-    return v && v.length > 0 ? v : fallback;
-}
+import { resolveProvider, providerHelp } from '../providers.js';
+import { inferProviderFromBaseURL } from '../agent/registry.js';
 export async function startRepl(opts = {}) {
-    const baseUrl = readEnv('KLYRO_BASE_URL');
-    const apiKey = readEnv('KLYRO_API_KEY');
-    const model = opts.model ?? readEnv('KLYRO_MODEL');
-    if (!baseUrl || !apiKey || !model) {
-        process.stderr.write('klyro: KLYRO_BASE_URL, KLYRO_API_KEY, and KLYRO_MODEL must be set\n');
+    // Reuse the same provider resolution as legacy repl.ts — probes local
+    // Ollama / LM Studio / vLLM when env is not fully set, so bare `klyro`
+    // works with a local model just like `klyro chat` does.
+    const resolved = await resolveProvider();
+    if (!resolved) {
+        process.stderr.write('klyro: no provider available.\n');
+        process.stderr.write(`  ${providerHelp(null)}\n`);
+        process.stderr.write('  Set KLYRO_BASE_URL and KLYRO_API_KEY, or run a local server (Ollama, LM Studio, vLLM).\n');
+        process.stderr.write('  Examples:\n');
+        process.stderr.write('    set KLYRO_BASE_URL=https://api.openai.com/v1\n');
+        process.stderr.write('    set KLYRO_API_KEY=sk-...\n');
+        process.stderr.write('    ollama serve   # then KLYRO_BASE_URL=http://localhost:11434/v1 KLYRO_MODEL=llama3.2\n');
         return 2;
     }
+    const baseUrl = resolved.baseURL;
+    const apiKey = resolved.apiKey;
+    let model = opts.model ?? resolved.model;
     const cwd = opts.cwd ?? process.cwd();
     const registry = builtinRegistry();
     const policy = new PolicyEngine(builtinRules(), DEFAULT_POLICY_CONFIG);
-    const adapter = httpChatAdapter({ baseURL: baseUrl, apiKey, timeoutMs: 60_000 });
+    const providerKind = inferProviderFromBaseURL(baseUrl);
+    // Local Ollama exposes OpenAI-compat but hostname could contain "anthropic"
+    // via proxy — don't try anthropic adapter with empty key (would 401).
+    const effectiveProvider = providerKind === 'anthropic' && !apiKey ? 'openai' : providerKind;
+    if (providerKind === 'anthropic' && !apiKey) {
+        process.stderr.write('klyro: anthropic provider detected but KLYRO_API_KEY is empty — falling back to OpenAI-compatible adapter\n');
+    }
+    const adapter = effectiveProvider === 'anthropic'
+        ? anthropicAdapter({ baseURL: baseUrl, apiKey, timeoutMs: 60_000 })
+        : httpChatAdapter({ baseURL: baseUrl, apiKey, timeoutMs: 60_000 });
     const ctxBlock = await buildLevel6Context({ cwd });
     const ctxPrefix = ctxBlock.formatted ? `\n\n<context>\n${ctxBlock.formatted}\n</context>` : '';
     const systemPromptFn = (_ctx) => {
@@ -40,18 +58,42 @@ export async function startRepl(opts = {}) {
         return base + ctxPrefix + t;
     };
     const ac = new AbortController();
-    process.on('SIGINT', () => ac.abort());
     // When the TUI is mounted, use the inline Ink prompt. Otherwise
     // fall back to stdin readline. The bridge is shared between the
     // App and the runtime so the modal can resolve the runtime's ask().
     const tuiBridge = new TuiApprovalBridge();
+    const useTui = opts.forceTty || process.stdin.isTTY;
     const approval = opts.nonInteractive
         ? new DenyAllApprovalPrompt()
-        : (process.stdin.isTTY ? tuiBridge : new StdinApprovalPrompt());
+        : (useTui ? tuiBridge : new StdinApprovalPrompt());
     let inflight = null;
-    let transcriptRef = [];
     let lastStatus = null;
-    const app = render(React.createElement(App, {
+    const pendingQueue = [];
+    let isMounted = false;
+    let directHooks;
+    function queuedAppend(item) {
+        if (isMounted && directHooks)
+            directHooks.append(item);
+        else
+            pendingQueue.push({ kind: 'append', item });
+    }
+    function queuedStatus(s) {
+        lastStatus = { ...(lastStatus ?? { model: model ?? '', step: 0, maxSteps: opts.maxSteps ?? 30, usageInput: 0, usageOutput: 0, repairs: 0, status: 'idle' }), ...s };
+        if (isMounted && directHooks)
+            directHooks.updateStatus(s);
+        else
+            pendingQueue.push({ kind: 'status', patch: s });
+    }
+    function queuedPlan(p) {
+        if (isMounted && directHooks)
+            directHooks.updatePlan(p);
+        else
+            pendingQueue.push({ kind: 'plan', plan: p });
+    }
+    // Declare app before handler to avoid TDZ; handler added after render
+    let app;
+    let sigintHandler;
+    app = render(React.createElement(App, {
         initialModel: model,
         maxSteps: opts.maxSteps ?? 30,
         cwd,
@@ -65,14 +107,39 @@ export async function startRepl(opts = {}) {
         onSlash: async (cmd) => {
             await handleSlash(cmd);
         },
+        onMounted: (hooks) => {
+            directHooks = hooks;
+            isMounted = true;
+            for (const ev of pendingQueue) {
+                if (ev.kind === 'status')
+                    hooks.updateStatus(ev.patch);
+                else if (ev.kind === 'plan')
+                    hooks.updatePlan(ev.plan);
+                else
+                    hooks.append(ev.item);
+            }
+            pendingQueue.length = 0;
+        },
     }));
-    // Bridge: subscribes to global hooks installed by App.useEffect.
-    // Every time the runtime emits, we translate to a transcript item or
-    // a status update.
-    const appG = globalThis;
+    // Install SIGINT handler only after app exists (avoids TDZ) and use once
+    sigintHandler = () => {
+        ac.abort();
+        queuedStatus({ status: 'aborted' });
+        try {
+            app?.unmount();
+        }
+        catch { /* ignore */ }
+    };
+    process.once('SIGINT', sigintHandler);
     async function runWithBridge(text) {
-        appG.__klyroAppStatus?.({ status: 'running', step: 0 });
+        if (!model) {
+            queuedAppend({ id: `err-${Date.now()}`, kind: 'error', message: 'no model configured' });
+            queuedStatus({ status: 'error', errorMessage: 'no model configured' });
+            return;
+        }
+        queuedStatus({ status: 'running', step: 0, model });
         let textBuf = '';
+        let pendingTextId = null;
         let activeCallId = null;
         let activeCallName = null;
         let activeCallArgs = '';
@@ -80,17 +147,36 @@ export async function startRepl(opts = {}) {
             const result = await run({
                 task: text,
                 cwd,
-                model: model,
+                model,
                 maxSteps: opts.maxSteps ?? 30,
                 signal: ac.signal,
                 nonInteractive: opts.nonInteractive ?? false,
                 onEvent: (ev) => {
                     if (ev.kind === 'step_start') {
-                        appG.__klyroAppStatus?.({ step: ev.step });
+                        // Flush coalesced text before new step
+                        pendingTextId = null;
+                        queuedStatus({ step: ev.step });
                     }
                     else if (ev.kind === 'text_delta') {
                         textBuf += ev.text;
-                        appG.__klyroAppAppend?.({ id: `text-${ev.kind}-${Date.now()}-${Math.random()}`, kind: 'text', text: ev.text, role: 'assistant' });
+                        // Coalesce: reuse pending text item if still queued, otherwise create one.
+                        // App.tsx also coalesces post-mount, so we only need to avoid queue bloat.
+                        if (pendingTextId) {
+                            const last = pendingQueue[pendingQueue.length - 1];
+                            if (last?.kind === 'append' && last.item.kind === 'text' && last.item.id === pendingTextId) {
+                                last.item.text += ev.text;
+                                return;
+                            }
+                        }
+                        // For mounted case, App will merge via its own coalescing (same id)
+                        // so reuse pendingTextId to let App merge
+                        if (pendingTextId && isMounted) {
+                            queuedAppend({ id: pendingTextId, kind: 'text', text: ev.text, role: 'assistant' });
+                            return;
+                        }
+                        const id = `text-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
+                        pendingTextId = id;
+                        queuedAppend({ id, kind: 'text', text: ev.text, role: 'assistant' });
                     }
                     else if (ev.kind === 'tool_call_start') {
                         activeCallId = ev.id;
@@ -101,7 +187,7 @@ export async function startRepl(opts = {}) {
                         activeCallArgs += ev.argsJson;
                     }
                     else if (ev.kind === 'tool_call_end') {
-                        appG.__klyroAppAppend?.({
+                        queuedAppend({
                             id: `tool-${ev.id}-${Date.now()}`,
                             kind: 'tool',
                             name: ev.name,
@@ -114,7 +200,7 @@ export async function startRepl(opts = {}) {
                         activeCallArgs = '';
                     }
                     else if (ev.kind === 'policy_decision') {
-                        appG.__klyroAppAppend?.({
+                        queuedAppend({
                             id: `pol-${ev.id}-${Date.now()}`,
                             kind: 'policy',
                             name: ev.name,
@@ -123,7 +209,7 @@ export async function startRepl(opts = {}) {
                         });
                     }
                     else if (ev.kind === 'tool_result') {
-                        appG.__klyroAppAppend?.({
+                        queuedAppend({
                             id: `tres-${ev.id}-${Date.now()}`,
                             kind: 'tool',
                             name: ev.name,
@@ -136,13 +222,13 @@ export async function startRepl(opts = {}) {
                         });
                     }
                     else if (ev.kind === 'usage') {
-                        appG.__klyroAppStatus?.({ usageInput: ev.input, usageOutput: ev.output });
+                        queuedStatus({ usageInput: ev.input, usageOutput: ev.output });
                     }
                     else if (ev.kind === 'plan_update') {
-                        appG.__klyroAppPlan?.(ev.plan);
+                        queuedPlan(ev.plan);
                     }
                     else if (ev.kind === 'file_changed') {
-                        appG.__klyroAppAppend?.({
+                        queuedAppend({
                             id: `fc-${ev.path}-${Date.now()}`,
                             kind: 'file_changed',
                             path: ev.path,
@@ -150,57 +236,69 @@ export async function startRepl(opts = {}) {
                         });
                     }
                     else if (ev.kind === 'verification_failed') {
-                        appG.__klyroAppAppend?.({
+                        queuedAppend({
                             id: `vf-${ev.step}-${Date.now()}`,
                             kind: 'error',
                             message: `verification failed at ${ev.step}: ${ev.reason}`,
                         });
                     }
                     else if (ev.kind === 'aborted') {
-                        appG.__klyroAppStatus?.({ status: 'aborted' });
+                        queuedStatus({ status: 'aborted' });
                     }
                 },
             }, { adapter, registry, policy, approval, systemPrompt: systemPromptFn });
-            appG.__klyroAppStatus?.({ status: 'complete' === result.status ? 'done' : 'error', repairs: result.repairs ?? 0 });
+            queuedStatus({ status: 'complete' === result.status ? 'done' : 'error', repairs: result.repairs ?? 0 });
         }
         catch (err) {
             const message = err instanceof Error ? err.message : String(err);
-            appG.__klyroAppAppend?.({ id: `err-${Date.now()}`, kind: 'error', message });
-            appG.__klyroAppStatus?.({ status: 'error', errorMessage: message });
+            queuedAppend({ id: `err-${Date.now()}`, kind: 'error', message });
+            queuedStatus({ status: 'error', errorMessage: message });
         }
     }
     async function handleSlash(cmd) {
         switch (cmd.kind) {
             case 'quit':
-                app.unmount();
-                process.exit(0);
+                try {
+                    app?.unmount();
+                }
+                catch { /* ignore */ }
+                // Listener cleanup is handled by the waitUntilExit resolver below
                 return;
             case 'clear':
-                // Bypass via the app's setTranscript by re-rendering is awkward;
-                // for MVP, append a marker and rely on the user to scroll.
-                // A real implementation would expose a clear() method.
-                appG.__klyroAppAppend?.({ id: `sep-${Date.now()}`, kind: 'text', text: '--- cleared ---', role: 'assistant' });
+                queuedAppend({ id: `sep-${Date.now()}`, kind: 'text', text: '--- cleared ---', role: 'assistant' });
                 return;
             case 'help': {
-                const helpText = 'commands: /clear /compact /model <id> /diff /status /quit';
-                appG.__klyroAppAppend?.({ id: `help-${Date.now()}`, kind: 'text', text: helpText, role: 'assistant' });
+                const helpText = [
+                    'commands:',
+                    '  /clear          — clear transcript marker',
+                    '  /diff           — show git diff',
+                    '  /status         — show session status',
+                    '  /compact        — (stub) context compaction',
+                    '  /model <id>     — switch model mid-session',
+                    '  /quit           — exit',
+                    `provider: ${effectiveProvider}  model: ${model}  cwd: ${cwd}`,
+                ].join('\n');
+                queuedAppend({ id: `help-${Date.now()}`, kind: 'text', text: helpText, role: 'assistant' });
                 return;
             }
             case 'status': {
                 if (lastStatus) {
-                    appG.__klyroAppAppend?.({
+                    queuedAppend({
                         id: `stat-${Date.now()}`,
                         kind: 'text',
                         text: JSON.stringify(lastStatus, null, 2),
                         role: 'assistant',
                     });
                 }
+                else {
+                    queuedAppend({ id: `stat2-${Date.now()}`, kind: 'text', text: `model: ${model}  provider: ${effectiveProvider}  cwd: ${cwd}`, role: 'assistant' });
+                }
                 return;
             }
             case 'diff': {
                 const r = await registry.execute('git_diff', {}, { cwd, env: process.env, nonInteractive: true });
                 if (!r.ok) {
-                    appG.__klyroAppAppend?.({
+                    queuedAppend({
                         id: `diff-err-${Date.now()}`,
                         kind: 'error',
                         message: `git_diff failed: ${r.error.message ?? r.error.code}`,
@@ -209,7 +307,7 @@ export async function startRepl(opts = {}) {
                 }
                 const out = r.value;
                 const hunks = parseUnifiedDiff(out.diff);
-                appG.__klyroAppAppend?.({
+                queuedAppend({
                     id: `diff-${Date.now()}`,
                     kind: 'diff',
                     hunks,
@@ -218,16 +316,27 @@ export async function startRepl(opts = {}) {
                 return;
             }
             case 'compact':
-            case 'model':
-                appG.__klyroAppAppend?.({
+                queuedAppend({
                     id: `stub-${Date.now()}`,
                     kind: 'text',
-                    text: `/${cmd.kind} is a stub in this build. (${cmd.kind === 'model' ? `requested: ${cmd.model}` : 'persistence integration pending'})`,
+                    text: `/compact is a stub in this build. (persistence integration pending)`,
                     role: 'assistant',
                 });
                 return;
+            case 'model': {
+                const next = cmd.model?.trim();
+                if (!next) {
+                    queuedAppend({ id: `mdl-${Date.now()}`, kind: 'text', text: `current model: ${model}`, role: 'assistant' });
+                }
+                else {
+                    queuedStatus({ model: next });
+                    queuedAppend({ id: `mdl2-${Date.now()}`, kind: 'text', text: `model switched to ${next} (takes effect on next prompt)`, role: 'assistant' });
+                    model = next;
+                }
+                return;
+            }
             case 'unknown':
-                appG.__klyroAppAppend?.({
+                queuedAppend({
                     id: `unk-${Date.now()}`,
                     kind: 'error',
                     message: `unknown command: ${cmd.raw} (try /help)`,
@@ -235,7 +344,18 @@ export async function startRepl(opts = {}) {
                 return;
         }
     }
+    // Keep process alive until user quits; resolve on unmount or SIGINT.
+    // ac.aborted indicates SIGINT; return 130 (128+SIGINT) like shells do.
     return new Promise((resolve) => {
-        process.on('exit', () => resolve(0));
+        const onExit = () => {
+            if (sigintHandler)
+                process.removeListener('SIGINT', sigintHandler);
+            resolve(ac.signal.aborted ? 130 : 0);
+        };
+        if (!app) {
+            resolve(1);
+            return;
+        }
+        app.waitUntilExit().then(onExit, onExit);
     });
 }

package/dist/index.js

@@ -17,6 +17,7 @@ import { fileURLToPath } from 'node:url';
 import { dirname, resolve } from 'node:path';
 import { chat } from './chat.js';
 import { repl } from './repl.js';
+import { startRepl } from './cli/repl.js';
 import { runOnce } from './cli/run.js';
 import { runEval } from './cli/eval.js';
 // Read version from package.json so `klyro --version` always matches the
@@ -48,10 +49,42 @@ async function main() {
         .version(VERSION, '-V, --version', 'Print the version number')
         .helpOption('-h, --help', 'Print this help message')
         .showHelpAfterError();
-    // Default action: TUI REPL. For now this falls back to the legacy REPL
-    // until the Ink-based TUI lands. The wiring point is cli/repl.ts.
+    // Top-level TUI overrides — single definition; commander auto-creates --no-tui negation
+    // Note: -m/--model and --max-steps are defined only on the `tui` subcommand to avoid
+    // CommanderError "option already exists" (parent options are inherited by subcommands).
+    program
+        .option('--tui', 'Force Ink TUI even when stdin is not a TTY')
+        .option('--chat', 'Alias for --no-tui (force legacy chat REPL)');
+    // Explicit `klyro tui` command — always uses the Ink UI.
+    program
+        .command('tui')
+        .description('Start the Ink TUI REPL (same as bare `klyro` on a TTY)')
+        .option('-m, --model <id>', 'Model id (default: auto-detected)')
+        .option('--max-steps <n>', 'Max agent steps (default 30)', (v) => parsePositiveInt('--max-steps', v))
+        .action(async (opts) => {
+        const code = await startRepl({ model: opts.model, maxSteps: opts.maxSteps, forceTty: true });
+        process.exit(code);
+    });
     program
         .action(async () => {
+        const opts = program.opts();
+        const forceTui = opts.tui === true;
+        const forceLegacy = opts.chat === true || opts.tui === false;
+        if (forceTui) {
+            const code = await startRepl({ forceTty: true });
+            process.exit(code);
+        }
+        if (forceLegacy) {
+            await repl('You are a helpful assistant.');
+            return;
+        }
+        if (process.stdin.isTTY) {
+            const code = await startRepl();
+            process.exit(code);
+        }
+        // Non-TTY without explicit flag: explain UI requires TTY
+        process.stderr.write('klyro: no TTY detected — starting legacy REPL (pipe mode)\n');
+        process.stderr.write('  Tip: run `klyro tui` or `klyro --tui` to force the Ink UI, or `klyro --help` for options.\n');
         await repl('You are a helpful assistant.');
     });
     program

package/dist/tui/app.d.ts

@@ -14,6 +14,7 @@ import React from 'react';
 import { type StatusSnapshot } from './status.js';
 import { type TranscriptItem } from './transcript.js';
 import { TuiApprovalBridge } from './approval.js';
+import type { PlanStep } from '../agent/runtime.js';
 export interface AppProps {
     initialModel: string;
     maxSteps: number;
@@ -28,5 +29,11 @@ export interface AppProps {
     initialStatus?: Partial<StatusSnapshot>;
     /** Optional approval bridge — when set, the modal prompts inline. */
     approvalBridge?: TuiApprovalBridge;
+    /** Called once after mount with direct hooks; also installs global compat hooks. */
+    onMounted?: (hooks: {
+        append: (i: TranscriptItem) => void;
+        updateStatus: (s: Partial<StatusSnapshot>) => void;
+        updatePlan: (p: PlanStep[]) => void;
+    }) => void;
 }
 export declare function App(props: AppProps): React.JSX.Element;

package/dist/tui/app.js

@@ -11,7 +11,7 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
  * RuntimeEvents via the onEvent callback wired by cli/repl.ts and
  * translates them into transcript/status updates.
  */
-import { useState, useCallback, useEffect } from 'react';
+import { useState, useCallback, useEffect, useRef } from 'react';
 import { Box, Text, useInput } from 'ink';
 import { StatusLine } from './status.js';
 import { Transcript } from './transcript.js';
@@ -46,21 +46,42 @@ export function App(props) {
         return bridge.subscribe((p) => setAwaitingApproval(p !== null));
     }, [bridge]);
     const append = useCallback((item) => {
-        setTranscript((prev) => [...prev, item]);
+        setTranscript((prev) => {
+            const last = prev[prev.length - 1];
+            // Only coalesce when IDs match — separate turns have different IDs
+            if (last?.kind === 'text' &&
+                item.kind === 'text' &&
+                last.role === 'assistant' &&
+                item.role === 'assistant' &&
+                last.id === item.id) {
+                return [...prev.slice(0, -1), { ...last, text: last.text + item.text }];
+            }
+            return [...prev, item];
+        });
+    }, []);
+    const updateStatus = useCallback((s) => {
+        setStatus((prev) => ({ ...prev, ...s }));
     }, []);
+    const updatePlan = useCallback((p) => {
+        setPlan(p);
+        setPlanExpanded(true);
+    }, []);
+    // Stabilize onMounted to avoid re-installing hooks on every parent re-render
+    const onMountedRef = useRef(props.onMounted);
+    useEffect(() => { onMountedRef.current = props.onMounted; }, [props.onMounted]);
     useEffect(() => {
+        // Instance-local hooks via callback (preferred)
+        onMountedRef.current?.({ append, updateStatus, updatePlan });
+        // Global compat hooks for tests / legacy callers (single instance at a time)
         globalThis.__klyroAppAppend = append;
-        globalThis.__klyroAppStatus = (s) => setStatus((prev) => ({ ...prev, ...s }));
-        globalThis.__klyroAppPlan = (p) => {
-            setPlan(p);
-            setPlanExpanded(true);
-        };
+        globalThis.__klyroAppStatus = updateStatus;
+        globalThis.__klyroAppPlan = updatePlan;
         return () => {
             delete globalThis.__klyroAppAppend;
             delete globalThis.__klyroAppStatus;
             delete globalThis.__klyroAppPlan;
         };
-    }, [append]);
+    }, [append, updateStatus, updatePlan]);
     useInput((inputStr, key) => {
         if (status.status === 'running' || awaitingApproval)
             return;

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

@@ -0,0 +1,6 @@
+/**
+ * Snapshot tests for the full TUI App — render various states and assert
+ * the exact visible frame. This is the "what does the user actually see"
+ * ground truth.
+ */
+export {};

package/dist/tui/snapshot.test.js

@@ -0,0 +1,87 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * Snapshot tests for the full TUI App — render various states and assert
+ * the exact visible frame. This is the "what does the user actually see"
+ * ground truth.
+ */
+import { describe, it, expect } from 'vitest';
+import { render } from 'ink-testing-library';
+import { App } from './app.js';
+const DEFAULT_PROPS = {
+    cwd: '/projects/demo',
+    onPrompt: async () => { },
+    onSlash: async () => { },
+};
+describe('App visual snapshot', () => {
+    it('renders header + statusline + transcript + input at idle', () => {
+        const { lastFrame } = render(_jsx(App, { ...DEFAULT_PROPS, initialModel: "gpt-4o-mini", maxSteps: 30, initialStatus: { status: 'idle', model: 'gpt-4o-mini', step: 0, maxSteps: 30, usageInput: 0, usageOutput: 0, repairs: 0 } }));
+        const frame = lastFrame();
+        // Header should be visible (uppercase KLYRO as rendered)
+        expect(frame).toContain('KLYRO');
+        expect(frame).toContain('demo'); // cwd basename
+        expect(frame).toContain('gpt-4o-mini');
+        // Status line should show
+        expect(frame).toMatch(/idle/i);
+        // Input prompt should be visible
+        expect(frame).toContain('>');
+    });
+    it('renders a transcript with assistant text', () => {
+        const { lastFrame } = render(_jsx(App, { ...DEFAULT_PROPS, initialModel: "gpt-4o-mini", maxSteps: 30, initialStatus: { status: 'idle', model: 'gpt-4o-mini', step: 0, maxSteps: 30, usageInput: 0, usageOutput: 0, repairs: 0 }, initialTranscript: [
+                { id: 'u1', kind: 'text', text: 'hello', role: 'user' },
+                { id: 'a1', kind: 'text', text: 'hi there', role: 'assistant' },
+            ] }));
+        const frame = lastFrame();
+        expect(frame).toContain('hello');
+        expect(frame).toContain('hi there');
+    });
+    it('does not render plan view when plan is empty', () => {
+        const { lastFrame } = render(_jsx(App, { ...DEFAULT_PROPS, initialModel: "gpt-4o-mini", maxSteps: 30, initialStatus: { status: 'idle', model: 'gpt-4o-mini', step: 0, maxSteps: 30, usageInput: 0, usageOutput: 0, repairs: 0 }, initialTranscript: [] }));
+        const frame = lastFrame();
+        // When plan is empty, no plan section should be visible
+        expect(frame).not.toContain('Plan');
+    });
+    it('renders plan view when plan is populated via mounted hooks', async () => {
+        const { lastFrame } = render(_jsx(App, { ...DEFAULT_PROPS, initialModel: "gpt-4o-mini", maxSteps: 30, initialStatus: { status: 'idle', model: 'gpt-4o-mini', step: 0, maxSteps: 30, usageInput: 0, usageOutput: 0, repairs: 0 } }));
+        const g = globalThis;
+        // Poll for hooks installed by useEffect (avoids flaky fixed timeout)
+        for (let i = 0; i < 10 && !g.__klyroAppPlan; i++)
+            await new Promise((r) => setTimeout(r, 10));
+        g.__klyroAppPlan?.([
+            { id: '1', title: 'Read files', status: 'done' },
+            { id: '2', title: 'Edit code', status: 'in_progress', files: ['src/x.ts'] },
+        ]);
+        await new Promise((r) => setTimeout(r, 20));
+        const frame = lastFrame();
+        expect(frame).toContain('Read files');
+        expect(frame).toContain('Edit code');
+    });
+    it('renders file_changed inline (the colored line)', () => {
+        const { lastFrame } = render(_jsx(App, { ...DEFAULT_PROPS, initialModel: "gpt-4o-mini", maxSteps: 30, initialStatus: { status: 'idle', model: 'gpt-4o-mini', step: 0, maxSteps: 30, usageInput: 0, usageOutput: 0, repairs: 0 }, initialTranscript: [
+                { id: 'fc1', kind: 'file_changed', path: 'src/foo.ts', op: 'modified' },
+            ] }));
+        const frame = lastFrame();
+        expect(frame).toContain('src/foo.ts');
+        expect(frame).toMatch(/modified|\~/);
+    });
+    it('diff transcript item renders the diff box', () => {
+        const { lastFrame } = render(_jsx(App, { ...DEFAULT_PROPS, initialModel: "gpt-4o-mini", maxSteps: 30, initialStatus: { status: 'idle', model: 'gpt-4o-mini', step: 0, maxSteps: 30, usageInput: 0, usageOutput: 0, repairs: 0 }, initialTranscript: [
+                {
+                    id: 'd1',
+                    kind: 'diff',
+                    summary: '1 file(s) changed',
+                    hunks: [{
+                            path: 'src/x.ts',
+                            lines: [
+                                { kind: 'header', text: '@@ -1 +1 @@' },
+                                { kind: 'remove', text: 'const a = 1;' },
+                                { kind: 'add', text: 'const a = 2;' },
+                            ],
+                        }],
+                },
+            ] }));
+        const frame = lastFrame();
+        expect(frame).toContain('src/x.ts');
+        expect(frame).toContain('const a = 2;');
+        expect(frame).toContain('+ ');
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "klyro",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "Klyro — autonomous coding harness CLI that streams from any OpenAI-compatible or Anthropic LLM endpoint.",
   "type": "module",
   "main": "dist/index.js",