klyro 0.1.2 → 0.1.4

package/dist/agent/runtime.d.ts

@@ -61,6 +61,14 @@ export interface RunOptions {
      */
     onEvent?: (ev: RuntimeEvent) => void;
 }
+/** A single plan step emitted by the agent. */
+export interface PlanStep {
+    id: string;
+    title: string;
+    status: 'pending' | 'in_progress' | 'done' | 'failed' | 'skipped';
+    /** Optional files the step will touch (for L6 diff). */
+    files?: string[];
+}
 /** High-level event stream the runtime emits. Safe for UI consumption. */
 export type RuntimeEvent = {
     kind: 'step_start';
@@ -106,6 +114,17 @@ export type RuntimeEvent = {
     text: string;
 } | {
     kind: 'aborted';
+} | {
+    kind: 'plan_update';
+    plan: PlanStep[];
+} | {
+    kind: 'file_changed';
+    path: string;
+    op: 'created' | 'modified' | 'deleted';
+} | {
+    kind: 'verification_failed';
+    step: string;
+    reason: string;
 };
 export interface RunResult {
     status: 'complete' | 'max_steps' | 'aborted' | 'no_final';

package/dist/agent/runtime.js

@@ -190,6 +190,11 @@ export async function run(opts, deps) {
                 telemetry.recordError(`${code}: ${call.name}`);
             }
             emit?.({ kind: 'tool_result', id: call.id, name: call.name, output, isError: !obs.ok, latencyMs });
+            if (obs.ok) {
+                const fileChanged = inferFileChanged(call.name, call.input, obs.value);
+                if (fileChanged)
+                    emit?.({ kind: 'file_changed', path: fileChanged.path, op: fileChanged.op });
+            }
         }
         emit?.({ kind: 'step_end', step: steps });
     }
@@ -207,6 +212,28 @@ function redactOutput(v) {
         return v; // structured outputs are not redacted wholesale
     return v;
 }
+/**
+ * Best-effort inference of "this tool call changed a file" for the
+ * file_changed event. Returns null when we don't have a clear answer.
+ *
+ * Today: write_file, edit_file, write_file (truncate via empty content).
+ * Tomorrow: shell_exec that ran `rm` or `git mv` would need to grep
+ * the output, but that's out of scope.
+ */
+function inferFileChanged(toolName, input, output) {
+    const inPath = typeof input.path === 'string' ? input.path : null;
+    if (!inPath)
+        return null;
+    if (toolName === 'write_file' || toolName === 'edit_file') {
+        // Distinguish create vs modify by the output shape: write_file returns
+        // { path, bytesWritten }; edit_file returns { path, replacements, diff }.
+        // Both are "modified" semantically; we don't have the pre-state easily
+        // from inside the runtime. A more precise implementation would stat the
+        // file before/after the call. For now: treat both as 'modified'.
+        return { path: inPath, op: 'modified' };
+    }
+    return null;
+}
 export function defaultSystemPrompt(ctx) {
     const base = [
         'You are Klyro, an autonomous coding harness. You solve the user\'s task by',

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,28 +9,47 @@ 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';
 import { buildLevel6Context } from '../context/level6.js';
 import { DenyAllApprovalPrompt, StdinApprovalPrompt } from '../policy/approval.js';
-function readEnv(name, fallback) {
-    const v = process.env[name];
-    return v && v.length > 0 ? v : fallback;
-}
+import { TuiApprovalBridge } from '../tui/approval.js';
+import { parseUnifiedDiff } from '../tui/diff-parser.js';
+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 approval = opts.nonInteractive ? new DenyAllApprovalPrompt() : new StdinApprovalPrompt();
+    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) => {
@@ -39,14 +58,47 @@ 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()
+        : (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,
         initialStatus: { status: 'idle' },
+        approvalBridge: tuiBridge,
         onPrompt: async (text) => {
             inflight = runWithBridge(text);
             await inflight;
@@ -55,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 = '';
@@ -70,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;
@@ -91,20 +187,20 @@ 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,
                             id_call: ev.id,
                             args: JSON.stringify(ev.input, null, 2),
-                            collapsed: true,
+                            status: 'running',
                         });
                         activeCallId = null;
                         activeCallName = null;
                         activeCallArgs = '';
                     }
                     else if (ev.kind === 'policy_decision') {
-                        appG.__klyroAppAppend?.({
+                        queuedAppend({
                             id: `pol-${ev.id}-${Date.now()}`,
                             kind: 'policy',
                             name: ev.name,
@@ -113,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,
@@ -122,65 +218,125 @@ export async function startRepl(opts = {}) {
                             result: typeof ev.output === 'string' ? ev.output : JSON.stringify(ev.output, null, 2),
                             isError: ev.isError,
                             latencyMs: ev.latencyMs,
-                            collapsed: true,
+                            status: ev.isError ? 'error' : 'done',
                         });
                     }
                     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') {
+                        queuedPlan(ev.plan);
+                    }
+                    else if (ev.kind === 'file_changed') {
+                        queuedAppend({
+                            id: `fc-${ev.path}-${Date.now()}`,
+                            kind: 'file_changed',
+                            path: ev.path,
+                            op: ev.op,
+                        });
+                    }
+                    else if (ev.kind === 'verification_failed') {
+                        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) {
+                    queuedAppend({
+                        id: `diff-err-${Date.now()}`,
+                        kind: 'error',
+                        message: `git_diff failed: ${r.error.message ?? r.error.code}`,
+                    });
+                    return;
+                }
+                const out = r.value;
+                const hunks = parseUnifiedDiff(out.diff);
+                queuedAppend({
+                    id: `diff-${Date.now()}`,
+                    kind: 'diff',
+                    hunks,
+                    summary: `${out.patchedFiles.length} file(s) changed${out.stat ? ' — ' + out.stat.split('\n').pop() : ''}`,
+                });
                 return;
             }
             case 'compact':
-            case 'diff':
-            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)`,
@@ -188,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/cli/slash/parser.d.ts

@@ -6,6 +6,7 @@
  *   /compact           — ask the agent to compact its own context
  *   /model <id>        — switch the active model mid-session
  *   /diff              — show working-tree diff (git diff)
+ *   /plan              — toggle the plan view (if a plan is loaded)
  *   /status            — show session status (model, steps, usage)
  *   /quit              — exit the REPL
  *   /help              — list available commands
@@ -22,6 +23,8 @@ export type SlashCommand = {
     model: string;
 } | {
     kind: 'diff';
+} | {
+    kind: 'plan';
 } | {
     kind: 'status';
 } | {

package/dist/cli/slash/parser.js

@@ -6,6 +6,7 @@
  *   /compact           — ask the agent to compact its own context
  *   /model <id>        — switch the active model mid-session
  *   /diff              — show working-tree diff (git diff)
+ *   /plan              — toggle the plan view (if a plan is loaded)
  *   /status            — show session status (model, steps, usage)
  *   /quit              — exit the REPL
  *   /help              — list available commands
@@ -13,7 +14,7 @@
  * Anything not starting with "/" is a regular prompt and yields
  * { kind: 'prompt', text }.
  */
-const KNOWN = ['clear', 'compact', 'model', 'diff', 'status', 'quit', 'help'];
+const KNOWN = ['clear', 'compact', 'model', 'diff', 'plan', 'status', 'quit', 'help'];
 export function parse(input) {
     const trimmed = input.trim();
     if (!trimmed.startsWith('/')) {
@@ -26,6 +27,7 @@ export function parse(input) {
         case 'clear': return { kind: 'clear' };
         case 'compact': return { kind: 'compact' };
         case 'diff': return { kind: 'diff' };
+        case 'plan': return { kind: 'plan' };
         case 'status': return { kind: 'status' };
         case 'quit':
         case 'exit':
@@ -38,8 +40,7 @@ export function parse(input) {
                 return { kind: 'unknown', raw: trimmed };
             return { kind: 'model', model: rest };
         }
-        default:
-            return { kind: 'unknown', raw: trimmed };
+        default: return { kind: 'unknown', raw: trimmed };
     }
 }
 export function listCommands() {

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

@@ -13,9 +13,13 @@
 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;
+    /** Working directory to display in the header. */
+    cwd: string;
     /** Called when the user submits a non-slash prompt. */
     onPrompt: (text: string) => void | Promise<void>;
     /** Called when the user types a slash command. */
@@ -23,5 +27,13 @@ export interface AppProps {
     /** Initial state (e.g. when resuming a session). */
     initialTranscript?: TranscriptItem[];
     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;