klyro 0.1.11 → 0.1.14

package/dist/agent/provider-adapter.js

@@ -211,8 +211,14 @@ async function* streamChatCompletions(url, opts, req, fetchImpl) {
                         pendingUsage = { input: chunk.usage.prompt_tokens, output: chunk.usage.completion_tokens };
                     }
                     for (const choice of chunk.choices) {
-                        if (choice.delta.content) {
-                            yield { kind: 'text_delta', text: choice.delta.content };
+                        // Handle multiple possible content fields for compat (OpenAI, Ollama, OpenRouter gemini, etc.)
+                        const delta = choice.delta;
+                        const text = delta?.content ??
+                            delta?.text ??
+                            choice?.message?.content ??
+                            choice?.delta?.text;
+                        if (typeof text === 'string' && text) {
+                            yield { kind: 'text_delta', text };
                         }
                         for (const tc of choice.delta.tool_calls ?? []) {
                             if (tc.id && tc.function?.name) {

package/dist/agent/registry.js

@@ -47,20 +47,46 @@ function isLoopbackBaseURL(url) {
         return false;
     }
 }
+const PROVIDER_ALIASES = {
+    '9router': 'openai',
+    'openrouter': 'openai',
+    'groq': 'openai',
+    'ollama': 'openai',
+    'vllm': 'openai',
+    'lmstudio': 'openai',
+};
+function normalizeProviderName(name) {
+    if (!name)
+        return undefined;
+    const lower = name.toLowerCase().trim();
+    if (lower === 'openai' || lower === 'anthropic')
+        return lower;
+    return PROVIDER_ALIASES[lower];
+}
 export function buildProvider(opts = {}) {
     const baseURL = opts.baseURL ?? process.env.KLYRO_BASE_URL;
     const apiKey = opts.apiKey ?? process.env.KLYRO_API_KEY;
     const timeoutMs = opts.timeoutMs ?? 60_000;
-    // Resolve provider.
+    // Resolve provider (with aliases like 9router -> openrouter -> openai)
     let provider;
-    if (opts.provider) {
-        provider = opts.provider;
+    const normalizedOpt = normalizeProviderName(opts.provider);
+    if (normalizedOpt) {
+        provider = normalizedOpt;
     }
-    else if (process.env.KLYRO_PROVIDER === 'anthropic' || process.env.KLYRO_PROVIDER === 'openai') {
-        provider = process.env.KLYRO_PROVIDER;
+    else if (opts.provider) {
+        // Fallback: treat any unknown as openai (OpenAI-compatible)
+        provider = 'openai';
     }
     else {
-        provider = inferProviderFromBaseURL(baseURL);
+        const envProvider = normalizeProviderName(process.env.KLYRO_PROVIDER);
+        if (envProvider)
+            provider = envProvider;
+        else if (process.env.KLYRO_PROVIDER) {
+            // Unknown provider string -> treat as openai
+            provider = 'openai';
+        }
+        else
+            provider = inferProviderFromBaseURL(baseURL);
     }
     let inner;
     if (provider === 'anthropic') {
@@ -90,9 +116,13 @@ export function buildProvider(opts = {}) {
  * This is the version called from CLI entry points.
  */
 export function buildProviderFromCli(args) {
-    const provider = args.provider;
-    if (provider && provider !== 'openai' && provider !== 'anthropic') {
-        throw new Error(`klyro: invalid --provider: ${provider} (expected openai|anthropic)`);
+    const raw = args.provider?.toLowerCase().trim();
+    const normalized = raw ? normalizeProviderName(raw) ?? (raw ? 'openai' : undefined) : undefined;
+    const provider = normalized;
+    // No longer throws for unknown — treat as openai (e.g. 9router, groq)
+    if (raw && !normalized && raw !== 'openai' && raw !== 'anthropic') {
+        // Silently treat as openai, but log hint
+        process.stderr.write(`klyro: unknown provider "${raw}" — treating as openai-compatible\n`);
     }
     return buildProvider({
         provider,

package/dist/agent/runtime.d.ts

@@ -35,6 +35,7 @@ export interface RuntimeDeps {
         telemetry?: string;
     }) => string;
 }
+export type Phase = 'understanding' | 'exploring' | 'planning' | 'implementing' | 'verifying' | 'done' | 'blocked' | 'limit';
 export interface RunOptions {
     task: string;
     cwd: string;
@@ -42,6 +43,8 @@ export interface RunOptions {
     maxSteps?: number;
     /** Alias for maxSteps (3.5) */
     maxTurns?: number;
+    maxCost?: number;
+    maxTimeMs?: number;
     maxTokens?: number;
     temperature?: number;
     signal?: AbortSignal;
@@ -164,7 +167,7 @@ export type RuntimeEvent = {
     sessionId: string;
 };
 export interface RunResult {
-    status: 'complete' | 'max_steps' | 'aborted' | 'no_final' | 'verify_failed';
+    status: 'complete' | 'max_steps' | 'aborted' | 'no_final' | 'verify_failed' | 'limit' | 'blocked';
     steps: number;
     toolCalls: number;
     finalText: string;
@@ -182,6 +185,8 @@ export interface RunResult {
         attempts: number;
         failureType?: string;
     };
+    /** 5.1 phase */
+    phase?: Phase;
 }
 /** Convert a registry of tools into ToolDefinitions for the provider. */
 export declare function toolDefinitions(registry: ToolRegistry): ToolDefinition[];

package/dist/agent/runtime.js

@@ -77,7 +77,19 @@ export async function run(opts, deps) {
         }
         catch { /* ignore */ }
     };
-    // Level 9 — persistence helpers
+    // 5.1 — phases and limits
+    const maxCost = opts.maxCost;
+    const maxTimeMs = opts.maxTimeMs;
+    const startTime = Date.now();
+    let phase = 'understanding';
+    const setPhase = (p) => {
+        if (p !== phase) {
+            phase = p;
+            // Emit as any (RuntimeEvent extension) + KlyroEvent
+            emit?.({ kind: 'phase_changed', phase });
+            emitKlyro({ type: 'phase.changed', ts: Date.now(), sessionId: sessionId ?? 'ephemeral', phase });
+        }
+    };
     const store = opts.persist?.store;
     const sessionId = opts.persist?.sessionId;
     async function checkpoint(msg, obs) {
@@ -109,7 +121,26 @@ export async function run(opts, deps) {
         // Fire-and-forget initial checkpoint (don't await to block loop start)
         void checkpoint(transcript[transcript.length - 1]);
     }
+    // 5.2 — stuck detection state
+    const callHistory = [];
+    const fileEditCounts = new Map();
+    let stuckCount = 0;
+    let lastSignal;
     outer: while (steps < maxSteps) {
+        // 5.1 limits: max-cost, max-time
+        if (maxCost !== undefined) {
+            const cost = (usage.input / 1000) * 0.003 + (usage.output / 1000) * 0.015;
+            if (cost >= maxCost) {
+                setPhase('limit');
+                await closeTracer();
+                return { status: 'limit', steps, toolCalls: toolCallCount, finalText: `Stopped: max cost $${maxCost} reached (cost $${cost.toFixed(2)})`, transcript, usage, repairs, phase: 'limit' };
+            }
+        }
+        if (maxTimeMs !== undefined && Date.now() - startTime >= maxTimeMs) {
+            setPhase('limit');
+            await closeTracer();
+            return { status: 'limit', steps, toolCalls: toolCallCount, finalText: `Stopped: max time ${maxTimeMs}ms reached`, transcript, usage, repairs, phase: 'limit' };
+        }
         if (opts.signal?.aborted) {
             emit?.({ kind: 'aborted' });
             if (store && sessionId) {
@@ -119,9 +150,20 @@ export async function run(opts, deps) {
                 catch { /* ignore */ }
             }
             await closeTracer();
-            return { status: 'aborted', steps, toolCalls: toolCallCount, finalText, transcript, usage, repairs, verification: hasEdits ? { ok: false, attempts: verificationAttempts } : undefined };
+            return { status: 'aborted', steps, toolCalls: toolCallCount, finalText, transcript, usage, repairs, verification: hasEdits ? { ok: false, attempts: verificationAttempts } : undefined, phase: 'blocked' };
         }
         steps++;
+        // 5.1 phase transitions (model-narrated)
+        if (steps === 1)
+            setPhase('understanding');
+        else if (steps === 2)
+            setPhase('exploring');
+        else if (steps === 3)
+            setPhase('planning');
+        else if (hasEdits)
+            setPhase('implementing');
+        else if (steps > 3)
+            setPhase('verifying');
         emit?.({ kind: 'step_start', step: steps });
         telemetry.recordStepStart(steps);
         const req = {
@@ -377,8 +419,27 @@ export async function run(opts, deps) {
                         await snapshot(opts.cwd, [fileChanged.path]);
                     }
                     catch { /* ignore */ }
+                    // 5.2 file edit count
+                    const cnt = (fileEditCounts.get(fileChanged.path) ?? 0) + 1;
+                    fileEditCounts.set(fileChanged.path, cnt);
+                    if (cnt > 8) {
+                        emitKlyro({ type: 'error', ts: Date.now(), sessionId: sessionId ?? 'ephemeral', code: 'stuck', message: `same file edited >8×: ${fileChanged.path}` });
+                    }
                 }
             }
+            // 5.2 identical call ×3
+            const sig = `${call.name}:${JSON.stringify(call.input).slice(0, 200)}`;
+            callHistory.push(sig);
+            if (callHistory.length > 10)
+                callHistory.shift();
+            const last3 = callHistory.slice(-3);
+            if (last3.length === 3 && last3[0] === last3[1] && last3[1] === last3[2]) {
+                emitKlyro({ type: 'error', ts: Date.now(), sessionId: sessionId ?? 'ephemeral', code: 'stuck', message: `identical call ×3: ${sig}` });
+                // Inject system note for next turn
+                const note = { role: 'user', content: [text(`[system note] Stuck detected: identical call ×3: ${sig}. Try a different approach.`)] };
+                transcript.push(note);
+                await checkpoint(note);
+            }
         };
         // 3.5 — parallel if all concurrencySafe, sequential otherwise
         if (allSafe) {

package/dist/chat.js

@@ -33,19 +33,28 @@ export function assertSafeBaseURL(url) {
     if (parsed.protocol === 'https:')
         return;
     if (parsed.protocol === 'http:') {
+        // Allow insecure HTTP if explicitly opted in (for remote Ollama etc.)
+        if (process.env.KLYRO_ALLOW_INSECURE === '1')
+            return;
         const host = parsed.hostname.toLowerCase();
-        // Allow loopback equivalents: localhost, 127.0.0.1, ::1, 0.0.0.0, ::, 127.x.x.x is NOT allowed without https
-        // Note: hostnames that resolve to loopback (e.g. nip.io) still require https — we check hostname, not DNS.
+        // Allow loopback and private networks without extra flag
         if (host === 'localhost' || host === '127.0.0.1' || host === '::1' || host === '0.0.0.0' || host === '::' || host === '[::]')
             return;
-        // Also allow 127.0.0.0/8 range via prefix check (e.g. 127.0.0.2)
         if (host.startsWith('127.')) {
             const parts = host.split('.');
             if (parts.length === 4 && parts.every((p) => /^\d+$/.test(p) && Number(p) >= 0 && Number(p) <= 255))
                 return;
         }
+        // Private ranges 10/8, 192.168/16, 172.16-31/12
+        if (/^10\.\d+\.\d+\.\d+$/.test(host))
+            return;
+        if (/^192\.168\.\d+\.\d+$/.test(host))
+            return;
+        if (/^172\.(1[6-9]|2\d|3[0-1])\.\d+\.\d+$/.test(host))
+            return;
         throw new Error(`Refusing to send KLYRO_API_KEY over plaintext HTTP to ${host}. ` +
-            `Use https:// or a localhost URL (localhost, 127.0.0.1, ::1, 0.0.0.0).`);
+            `Use https:// or a localhost/private URL, or set KLYRO_ALLOW_INSECURE=1 to allow insecure HTTP (not recommended). ` +
+            `Example: $Env:KLYRO_ALLOW_INSECURE=\"1\"; klyro`);
     }
     throw new Error(`Unsupported KLYRO_BASE_URL protocol: ${parsed.protocol}`);
 }

package/dist/cli/eval.d.ts

@@ -69,6 +69,11 @@ export interface EvalResult {
 export interface RunEvalOptions {
     inputPath: string;
     output: 'human' | 'json' | 'silent';
+    suite?: string;
+    filter?: string;
+    runs?: number;
+    parallel?: number;
+    model?: string;
 }
 export declare function runEval(opts: RunEvalOptions): Promise<number>;
 export declare function scriptedAdapterFromSpec(spec: Array<Array<unknown[]>> | undefined): ProviderAdapter;

package/dist/cli/eval.js

@@ -47,6 +47,67 @@ import { builtinRegistry } from '../tools/registry.js';
 import { builtinRules, DEFAULT_POLICY_CONFIG, PolicyEngine } from '../policy/engine.js';
 import { DenyAllApprovalPrompt } from '../policy/approval.js';
 export async function runEval(opts) {
+    // 5.4 — suite mode: load from evals/fixtures
+    if (opts.suite) {
+        const { runHarness, loadFileFixture } = await import('../eval/harness.js');
+        const fs = await import('node:fs/promises');
+        const path = await import('node:path');
+        const suiteDir = path.join(process.cwd(), 'evals', 'fixtures', opts.suite === 'smoke' ? '' : opts.suite);
+        // For smoke, use the 10 fixtures directly
+        const fixturesDir = path.join(process.cwd(), 'evals', 'fixtures');
+        let tasks = [];
+        try {
+            const entries = await fs.readdir(fixturesDir);
+            for (const e of entries) {
+                if (opts.filter && !e.includes(opts.filter))
+                    continue;
+                const taskPath = path.join(fixturesDir, e, 'task.md');
+                try {
+                    const task = await fs.readFile(taskPath, 'utf-8');
+                    tasks.push({
+                        id: e,
+                        description: e,
+                        task: task.trim(),
+                        script: [],
+                        expectStatus: 'complete',
+                    });
+                }
+                catch { /* ignore */ }
+            }
+        }
+        catch { /* no fixtures */ }
+        if (tasks.length === 0) {
+            stderr.write(`klyro eval: no fixtures for suite ${opts.suite}\n`);
+            return 2;
+        }
+        // Simple harness for suite: just run check.sh via file fixtures
+        const { runFileFixture, loadFileFixture: loadFF } = await import('../eval/harness.js');
+        const results = [];
+        for (const t of tasks) {
+            const fixture = await loadFF(path.join(fixturesDir, t.id));
+            const r = await runFileFixture(fixture, { runs: opts.runs, parallel: opts.parallel });
+            results.push(r);
+            const tag = r.status === 'pass' ? 'PASS' : 'FAIL';
+            if (opts.output === 'json')
+                stdout.write(JSON.stringify({ kind: 'eval_result', ...r }) + '\n');
+            else
+                stdout.write(`[${tag}] ${r.id}\n`);
+        }
+        const passed = results.filter((r) => r.status === 'pass').length;
+        if (opts.output === 'json')
+            stdout.write(JSON.stringify({ kind: 'eval_summary', total: results.length, passed, failed: results.length - passed }) + '\n');
+        else
+            stdout.write(`\n${passed}/${results.length} passed\n`);
+        // Save results
+        try {
+            const outDir = path.join(process.cwd(), 'evals', 'results');
+            await fs.mkdir(outDir, { recursive: true });
+            const ts = new Date().toISOString().replace(/[:.]/g, '-');
+            await fs.writeFile(path.join(outDir, `${ts}.json`), JSON.stringify({ suite: opts.suite, results }, null, 2));
+        }
+        catch { /* ignore */ }
+        return passed === results.length ? 0 : 1;
+    }
     const scenarios = await readScenarios(opts.inputPath);
     if (scenarios.length === 0) {
         stderr.write('klyro eval: no scenarios in input\n');

package/dist/cli/repl.js

@@ -189,8 +189,16 @@ export async function startRepl(opts = {}) {
                     }
                     else if (ev.kind === 'text_delta') {
                         textBuf += ev.text;
-                        // 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.
+                        // Try full-screen live region first (batched 30fps)
+                        const g = globalThis;
+                        if (isMounted && g.__klyroAppendDelta) {
+                            g.__klyroAppendDelta(ev.text);
+                            // Also keep coalescing for fallback inline mode
+                            if (!pendingTextId)
+                                pendingTextId = `text-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
+                            return;
+                        }
+                        // Fallback inline mode: coalesce via queuedAppend
                         if (pendingTextId) {
                             const last = pendingQueue[pendingQueue.length - 1];
                             if (last?.kind === 'append' && last.item.kind === 'text' && last.item.id === pendingTextId) {
@@ -198,8 +206,6 @@ export async function startRepl(opts = {}) {
                                 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;
@@ -265,6 +271,18 @@ export async function startRepl(opts = {}) {
                             status: ev.isError ? 'error' : 'done',
                         });
                     }
+                    else if (ev.kind === 'final_text') {
+                        // Commit live region for both inline and full-screen TUI
+                        const g2 = globalThis;
+                        g2.__klyroCommitLive?.();
+                        pendingTextId = null;
+                        // For full-screen, also ensure liveText is committed if any remaining
+                        if (ev.text) {
+                            const g3 = globalThis;
+                            // If liveText was batched, ensure it's flushed and committed
+                            g2.__klyroCommitLive?.();
+                        }
+                    }
                     else if (ev.kind === 'usage') {
                         queuedStatus({ usageInput: ev.input, usageOutput: ev.output });
                     }
@@ -307,9 +325,23 @@ export async function startRepl(opts = {}) {
                 queuedAppend({ id: `verr-${Date.now()}`, kind: 'error', message: `Verification failed after ${result.verification?.attempts ?? 3} attempts. Check output above.` });
                 queuedStatus({ status: 'error', errorMessage: 'verification failed' });
             }
-            else if (result.status === 'no_final' && result.finalText) {
-                // Simple chat with text but no tool calls — treat as done (provider finished)
-                queuedStatus({ status: 'done', repairs: result.repairs ?? 0 });
+            else if (result.status === 'no_final') {
+                if (result.finalText) {
+                    queuedStatus({ status: 'done', repairs: result.repairs ?? 0 });
+                }
+                else {
+                    // For simple chat, no_final with empty text is often a provider quirk (e.g. gemini via openai compat)
+                    // Show a helpful message but don't mark as error in header for chat
+                    const isSimpleChat = taskText.trim().split(/\s+/).length <= 6;
+                    if (isSimpleChat) {
+                        queuedStatus({ status: 'done', repairs: result.repairs ?? 0 });
+                        queuedAppend({ id: `no_final-${Date.now()}`, kind: 'text', text: `(no response — try /model ${model} or check provider logs)`, role: 'assistant' });
+                    }
+                    else {
+                        queuedStatus({ status: 'error', errorMessage: 'no final text' });
+                        queuedAppend({ id: `no_final-${Date.now()}`, kind: 'error', message: 'Provider returned no final text — check model/provider (try /model or /doctor)' });
+                    }
+                }
             }
             else {
                 queuedStatus({ status: 'complete' === result.status ? 'done' : 'error', repairs: result.repairs ?? 0 });
@@ -317,9 +349,6 @@ export async function startRepl(opts = {}) {
             if (sessionId) {
                 queuedAppend({ id: `sess-end-${Date.now()}`, kind: 'text', text: `session ${sessionId.slice(0, 8)} ${result.status} — ${result.steps} steps, ${result.toolCalls} tool calls`, role: 'assistant' });
             }
-            else if (result.status === 'no_final' && !result.finalText) {
-                queuedAppend({ id: `no_final-${Date.now()}`, kind: 'error', message: 'Provider returned no final text — check model/provider' });
-            }
         }
         catch (err) {
             const message = err instanceof Error ? err.message : String(err);

package/dist/eval/harness.d.ts

@@ -41,8 +41,23 @@ export interface HarnessSummary {
 export declare function runHarness(tasks: ScriptedTask[]): Promise<HarnessSummary>;
 /** Format a harness summary as a markdown report. */
 export declare function formatReport(summary: HarnessSummary): string;
+/** 5.4 — File-based fixture support: repo|repo.json, task.md, check.sh, meta.json */
+export interface FileFixture {
+    dir: string;
+    task: string;
+    checkSh: string;
+    meta: Record<string, unknown>;
+    repo?: string;
+}
+export declare function loadFileFixture(dir: string): Promise<FileFixture>;
+export declare function runFileFixture(fixture: FileFixture, opts?: {
+    runs?: number;
+    parallel?: number;
+}): Promise<TaskResult>;
 /** Hook the harness up to a session + audit log so task runs are durable. */
 export declare function runHarnessWithPersistence(tasks: ScriptedTask[], opts: {
     storeDir: string;
     auditPath: string;
 }): Promise<HarnessSummary>;
+/** Compare two harness runs */
+export declare function compareReports(a: HarnessSummary, b: HarnessSummary): string;

package/dist/eval/harness.js

@@ -117,6 +117,57 @@ export function formatReport(summary) {
     ];
     return lines.join('\n');
 }
+export async function loadFileFixture(dir) {
+    const task = await fs.readFile(path.join(dir, 'task.md'), 'utf-8').catch(() => 'test task');
+    const checkSh = await fs.readFile(path.join(dir, 'check.sh'), 'utf-8').catch(() => 'exit 0');
+    let meta = {};
+    try {
+        meta = JSON.parse(await fs.readFile(path.join(dir, 'meta.json'), 'utf-8'));
+    }
+    catch { /* ignore */ }
+    let repo;
+    try {
+        repo = await fs.readFile(path.join(dir, 'repo'), 'utf-8');
+    }
+    catch { /* ignore */ }
+    return { dir, task: task.trim(), checkSh, meta, repo };
+}
+export async function runFileFixture(fixture, opts = {}) {
+    const start = Date.now();
+    const tmp = path.join(os.tmpdir(), 'klyro-eval-file-' + Math.random().toString(36).slice(2));
+    await fs.mkdir(tmp, { recursive: true });
+    // Copy repo if exists
+    if (fixture.repo) {
+        const src = path.isAbsolute(fixture.repo) ? fixture.repo : path.join(fixture.dir, fixture.repo);
+        await fs.cp(src, tmp, { recursive: true }).catch(() => undefined);
+    }
+    else {
+        await fs.cp(fixture.dir, tmp, { recursive: true }).catch(() => undefined);
+    }
+    // Run check.sh via shell
+    const { spawn } = await import('node:child_process');
+    const result = await new Promise((resolve) => {
+        const child = spawn('bash', ['-c', fixture.checkSh], { cwd: tmp, shell: false });
+        let out = '';
+        child.stdout?.on('data', (b) => { out += b.toString(); });
+        child.stderr?.on('data', (b) => { out += b.toString(); });
+        child.on('close', (code) => {
+            const pass = code === 0;
+            resolve({
+                id: path.basename(fixture.dir),
+                status: pass ? 'pass' : 'fail',
+                details: out.slice(0, 500),
+                observedStatus: pass ? 'complete' : 'verify_failed',
+                durationMs: Date.now() - start,
+            });
+        });
+        child.on('error', (err) => {
+            resolve({ id: path.basename(fixture.dir), status: 'fail', details: String(err), durationMs: Date.now() - start });
+        });
+    });
+    await fs.rm(tmp, { recursive: true, force: true }).catch(() => undefined);
+    return result;
+}
 /** Hook the harness up to a session + audit log so task runs are durable. */
 export async function runHarnessWithPersistence(tasks, opts) {
     const store = new SessionStore(opts.storeDir);
@@ -134,8 +185,12 @@ export async function runHarnessWithPersistence(tasks, opts) {
             type: r.details,
             ts: Date.now(),
         });
-        // Suppress unused warning.
-        void store;
+        // Persist to session store
+        try {
+            const rec = await store.create({ cwd: process.cwd(), task: t.task, config: { model: 'mock', maxSteps: 12 } });
+            await store.setStatus(rec.id, r.status === 'pass' ? 'complete' : 'verify_failed', r.details);
+        }
+        catch { /* ignore */ }
     }
     const passed = results.filter((r) => r.status === 'pass').length;
     return {
@@ -147,3 +202,19 @@ export async function runHarnessWithPersistence(tasks, opts) {
         durationMs: Date.now() - start,
     };
 }
+/** Compare two harness runs */
+export function compareReports(a, b) {
+    const lines = [
+        `# Compare: ${a.passed}/${a.total} (${(a.passRate * 100).toFixed(1)}%) vs ${b.passed}/${b.total} (${(b.passRate * 100).toFixed(1)}%)`,
+        `Duration: ${(a.durationMs / 1000).toFixed(1)}s vs ${(b.durationMs / 1000).toFixed(1)}s`,
+        `| Task | A | B |`,
+        `|------|---|---|`,
+    ];
+    const allIds = new Set([...a.results.map((r) => r.id), ...b.results.map((r) => r.id)]);
+    for (const id of allIds) {
+        const ra = a.results.find((r) => r.id === id);
+        const rb = b.results.find((r) => r.id === id);
+        lines.push(`| ${id} | ${ra?.status ?? '-'} | ${rb?.status ?? '-'} |`);
+    }
+    return lines.join('\n');
+}

package/dist/index.js

@@ -351,14 +351,39 @@ async function main() {
         }
     });
     program
-        .command('eval <input>')
-        .description('Run scripted scenarios from a JSONL file against the agent runtime. Exits 0 if all pass, 1 otherwise.')
+        .command('eval [input]')
+        .description('Run eval harness: klyro eval --suite smoke | klyro eval <input.jsonl>')
         .option('--output <mode>', 'Output mode: human (default), json (one JSON per line)')
+        .option('--suite <name>', 'Suite name (smoke, core, etc.) — loads from evals/fixtures')
+        .option('--filter <str>', 'Filter fixtures by name substring')
+        .option('--runs <n>', 'Runs per fixture (default 1)', (v) => parsePositiveInt('--runs', v))
+        .option('--parallel <n>', 'Parallelism (default 1)', (v) => parsePositiveInt('--parallel', v))
+        .option('--model <id>', 'Model for eval')
         .action(async (input, opts) => {
         const output = (opts.output ?? 'human');
-        const code = await runEval({ inputPath: input, output });
+        if (opts.suite) {
+            const code = await runEval({ inputPath: input ?? '-', output, suite: opts.suite, filter: opts.filter, runs: opts.runs, parallel: opts.parallel, model: opts.model });
+            process.exit(code);
+        }
+        if (!input) {
+            process.stderr.write('klyro eval: missing input (provide <input> or --suite)\n');
+            process.exit(2);
+        }
+        const code = await runEval({ inputPath: input, output, suite: opts.suite, filter: opts.filter, runs: opts.runs, parallel: opts.parallel, model: opts.model });
         process.exit(code);
     });
+    program
+        .command('eval:compare <a> <b>')
+        .description('Compare two eval results JSON files')
+        .action(async (a, b) => {
+        const { compareReports } = await import('./eval/harness.js');
+        const fs = await import('node:fs/promises');
+        const ra = JSON.parse(await fs.readFile(a, 'utf-8'));
+        const rb = JSON.parse(await fs.readFile(b, 'utf-8'));
+        const out = compareReports(ra, rb);
+        process.stdout.write(out + '\n');
+        process.exit(0);
+    });
     // Level 9 — Session management
     const session = program.command('session').description('Session persistence (Level 9)');
     session

package/dist/tools/plan/ask-user.d.ts

@@ -0,0 +1,12 @@
+export declare const askUserTool: import("../types.js").Tool<{
+    question: string;
+    options?: string[] | undefined;
+}, {
+    readonly answer: string;
+    readonly question?: undefined;
+    readonly options?: undefined;
+} | {
+    readonly question: string;
+    readonly options: string[] | undefined;
+    readonly answer?: undefined;
+}>;

package/dist/tools/plan/ask-user.js

@@ -0,0 +1,28 @@
+import { z } from 'zod';
+import { defineTool } from '../types.js';
+import { safe } from '../normalize.js';
+const InputSchema = z.object({
+    question: z.string().min(1),
+    options: z.array(z.string()).optional(),
+});
+export const askUserTool = defineTool({
+    name: 'ask_user',
+    description: 'Ask the user a question (multiple choice or free text). Headless fails fast unless --auto-answer.',
+    inputSchema: InputSchema,
+    permission: 'read',
+    isConcurrencySafe: true,
+    execute: async (input, ctx) => {
+        return safe(async () => {
+            if (ctx.nonInteractive) {
+                // Check for auto-answer
+                const auto = process.env.KLYRO_AUTO_ANSWER;
+                if (auto)
+                    return { answer: auto };
+                throw Object.assign(new Error(`ask_user requires interaction: ${input.question}`), { code: 'HEADLESS' });
+            }
+            // In TUI, this will be handled via ApprovalModal with ask_user kind
+            // For now, return as requires approval
+            return { question: input.question, options: input.options };
+        });
+    },
+});

package/dist/tools/plan/todo-write.d.ts

@@ -0,0 +1,10 @@
+export declare const todoWriteTool: import("../types.js").Tool<{
+    todos: {
+        id: string;
+        title: string;
+        status: "done" | "pending" | "in_progress" | "failed" | "skipped";
+        files?: string[] | undefined;
+    }[];
+}, {
+    readonly updated: number;
+}>;

package/dist/tools/plan/todo-write.js

@@ -0,0 +1,31 @@
+import { z } from 'zod';
+import { defineTool } from '../types.js';
+import { safe } from '../normalize.js';
+const TodoSchema = z.object({
+    id: z.string(),
+    title: z.string(),
+    status: z.enum(['pending', 'in_progress', 'done', 'failed', 'skipped']),
+    files: z.array(z.string()).optional(),
+});
+const InputSchema = z.object({
+    todos: z.array(TodoSchema),
+});
+export const todoWriteTool = defineTool({
+    name: 'todo_write',
+    description: 'Update the live plan checklist. Persisted and re-injected when stale.',
+    inputSchema: InputSchema,
+    permission: 'read',
+    isConcurrencySafe: true,
+    execute: async (input, ctx) => {
+        return safe(async () => {
+            // Persist to .klyro/plans/todos.json for 5.3
+            const fs = await import('node:fs/promises');
+            const path = await import('node:path');
+            const dir = path.join(ctx.cwd, '.klyro', 'plans');
+            await fs.mkdir(dir, { recursive: true });
+            const file = path.join(dir, 'todos.json');
+            await fs.writeFile(file, JSON.stringify(input.todos, null, 2), 'utf-8');
+            return { updated: input.todos.length };
+        });
+    },
+});

package/dist/tools/registry.js

@@ -17,6 +17,8 @@ import { gitStatusTool } from './git/git-status.js';
 import { gitDiffTool } from './git/git-diff.js';
 import { gitLogTool } from './git/git-log.js';
 import { runVerifyTool } from './verify/run-verify.js';
+import { todoWriteTool } from './plan/todo-write.js';
+import { askUserTool } from './plan/ask-user.js';
 import { zodToJsonSchema } from './schema.js';
 export class ToolRegistry {
     tools = new Map();
@@ -89,5 +91,7 @@ export const builtinRegistry = () => {
     r.register(gitDiffTool);
     r.register(gitLogTool);
     r.register(runVerifyTool);
+    r.register(todoWriteTool);
+    r.register(askUserTool);
     return r;
 };

package/dist/tui/app.js

@@ -31,6 +31,33 @@ export function App(props) {
     });
     const [elapsed, setElapsed] = useState(0);
     const [queued, setQueued] = useState(null);
+    const [liveText, setLiveText] = useState('');
+    const batchRef = useRef('');
+    const batchTimer = useRef(null);
+    const flushBatch = useCallback(() => {
+        if (batchRef.current) {
+            const chunk = batchRef.current;
+            batchRef.current = '';
+            setLiveText((prev) => prev + chunk);
+        }
+        if (batchTimer.current) {
+            clearTimeout(batchTimer.current);
+            batchTimer.current = null;
+        }
+    }, []);
+    const appendDeltaBatched = useCallback((text) => {
+        batchRef.current += text;
+        if (!batchTimer.current)
+            batchTimer.current = setTimeout(flushBatch, 33);
+    }, [flushBatch]);
+    const commitLive = useCallback(() => {
+        flushBatch();
+        if (liveText) {
+            const item = { id: nextId('text'), kind: 'text', text: liveText, role: 'assistant' };
+            setTranscript((prev) => [...prev, item]);
+            setLiveText('');
+        }
+    }, [liveText, flushBatch]);
     useEffect(() => bridge.subscribe((p) => setAwaitingApproval(p !== null)), [bridge]);
     // 2.4 — send queued when idle
     useEffect(() => {
@@ -71,12 +98,16 @@ export function App(props) {
         globalThis.__klyroAppAppend = append;
         globalThis.__klyroAppStatus = updateStatus;
         globalThis.__klyroAppPlan = updatePlan;
+        globalThis.__klyroAppendDelta = appendDeltaBatched;
+        globalThis.__klyroCommitLive = commitLive;
         return () => {
             delete globalThis.__klyroAppAppend;
             delete globalThis.__klyroAppStatus;
             delete globalThis.__klyroAppPlan;
+            delete globalThis.__klyroAppendDelta;
+            delete globalThis.__klyroCommitLive;
         };
-    }, [append, updateStatus, updatePlan]);
+    }, [append, updateStatus, updatePlan, appendDeltaBatched, commitLive]);
     // Single useInput owner — handles queued when running (2.4)
     useInput((inputStr, key) => {
         if (awaitingApproval)
@@ -129,5 +160,5 @@ export function App(props) {
     const width = stdout?.columns ?? 100;
     const height = stdout?.rows ?? 30;
     const isSmall = width < 80;
-    return (_jsxs(Box, { flexDirection: "column", width: width, height: height - 1, children: [_jsxs(Box, { flexDirection: "column", borderStyle: "single", borderColor: tokens.ansi.border, paddingX: 1, children: [_jsx(Text, { bold: true, children: "KLYRO v0.1.11" }), _jsxs(Text, { color: tokens.ansi.muted, children: [status.model, " \u00B7 API Usage Billing \u00B7 step ", status.step, "/", status.maxSteps, " \u00B7 ", status.status, " \u00B7 repairs ", status.repairs] }), _jsx(Text, { color: tokens.ansi.muted, children: props.cwd })] }), _jsxs(Box, { flexDirection: "column", flexGrow: 1, overflow: "hidden", paddingX: 1, paddingY: 1, children: [transcript.length === 0 ? (_jsx(Box, { flexDirection: "column", children: _jsx(Text, { color: tokens.ansi.muted, children: "No conversation yet. Try \"fix the failing login test\"" }) })) : (transcript.map((item) => (_jsx(Box, { flexDirection: "column", marginBottom: 1, children: item.kind === 'text' && item.role === 'user' ? (_jsxs(Text, { children: ["\u203A ", item.text] })) : item.kind === 'text' ? (_jsxs(Text, { children: ["  ", item.text] })) : item.kind === 'tool' ? (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: tokens.ansi.border, paddingX: 1, children: [_jsxs(Text, { children: [item.name, " ", item.isError ? '✗' : '✓', " ", item.latencyMs ?? 0, "ms"] }), item.result ? _jsx(Text, { color: tokens.ansi.muted, children: String(item.result).slice(0, 200) }) : null] })) : item.kind === 'diff' ? (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: tokens.ansi.border, paddingX: 1, children: [_jsx(Text, { bold: true, children: item.summary ?? 'Diff' }), item.hunks.map((h, i) => (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { color: tokens.ansi.info, children: h.path }), h.lines.map((l, j) => (_jsxs(Text, { color: l.kind === 'add' ? tokens.ansi.success : l.kind === 'remove' ? tokens.ansi.error : tokens.ansi.muted, children: [l.kind === 'add' ? '+ ' : l.kind === 'remove' ? '- ' : '  ', l.text] }, j)))] }, i)))] })) : (_jsx(Transcript, { items: [item] })) }, item.id)))), status.status === 'running' ? (_jsxs(Box, { children: [_jsx(Text, { color: tokens.ansi.info, children: "\u2726 Thinking..." }), _jsxs(Text, { color: tokens.ansi.muted, children: [" \u00B7 ", Math.round(elapsed / 1000), "s"] })] })) : null, plan.length > 0 ? _jsx(PlanView, { steps: plan, expanded: false, onToggle: () => { } }) : null] }), _jsxs(Box, { borderStyle: "single", borderColor: tokens.ansi.accent, paddingX: 1, children: [_jsx(Text, { children: "\u203A " }), _jsxs(Text, { children: [input, "\u258F"] })] }), _jsxs(Box, { justifyContent: "space-between", paddingX: 1, borderStyle: "single", borderColor: tokens.ansi.border, children: [_jsxs(Text, { color: tokens.ansi.muted, children: [status.model, " \u00B7 ", status.usageInput + status.usageOutput, " tokens \u00B7 $", (status.usageInput / 1000 * 0.003 + status.usageOutput / 1000 * 0.015).toFixed(2), " \u00B7 ", Math.round(elapsed / 1000), "s"] }), _jsx(Text, { color: tokens.ansi.muted, children: isSmall ? 'Ctrl+C interrupt' : 'Ctrl+C interrupt · Ctrl+O expand · ↑↓ scroll' })] })] }));
+    return (_jsxs(Box, { flexDirection: "column", width: width, height: height - 1, children: [_jsxs(Box, { flexDirection: "column", borderStyle: "single", borderColor: tokens.ansi.border, paddingX: 1, children: [_jsx(Text, { bold: true, children: "KLYRO v0.1.14" }), _jsxs(Text, { color: tokens.ansi.muted, children: [status.model, " \u00B7 API Usage Billing \u00B7 step ", status.step, "/", status.maxSteps, " \u00B7 ", status.status, " \u00B7 repairs ", status.repairs] }), _jsx(Text, { color: tokens.ansi.muted, children: props.cwd })] }), _jsxs(Box, { flexDirection: "column", flexGrow: 1, overflow: "hidden", paddingX: 1, paddingY: 1, children: [transcript.length === 0 ? (_jsx(Box, { flexDirection: "column", children: _jsx(Text, { color: tokens.ansi.muted, children: "No conversation yet. Try \"fix the failing login test\"" }) })) : (transcript.map((item) => (_jsx(Box, { flexDirection: "column", marginBottom: 1, children: item.kind === 'text' && item.role === 'user' ? (_jsxs(Text, { children: ["\u203A ", item.text] })) : item.kind === 'text' ? (_jsxs(Text, { children: ["  ", item.text] })) : item.kind === 'tool' ? (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: tokens.ansi.border, paddingX: 1, children: [_jsxs(Text, { children: [item.name, " ", item.isError ? '✗' : '✓', " ", item.latencyMs ?? 0, "ms"] }), item.result ? _jsx(Text, { color: tokens.ansi.muted, children: String(item.result).slice(0, 200) }) : null] })) : item.kind === 'diff' ? (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: tokens.ansi.border, paddingX: 1, children: [_jsx(Text, { bold: true, children: item.summary ?? 'Diff' }), item.hunks.map((h, i) => (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { color: tokens.ansi.info, children: h.path }), h.lines.map((l, j) => (_jsxs(Text, { color: l.kind === 'add' ? tokens.ansi.success : l.kind === 'remove' ? tokens.ansi.error : tokens.ansi.muted, children: [l.kind === 'add' ? '+ ' : l.kind === 'remove' ? '- ' : '  ', l.text] }, j)))] }, i)))] })) : (_jsx(Transcript, { items: [item] })) }, item.id)))), liveText ? (_jsx(Box, { paddingLeft: 2, marginBottom: 1, children: _jsxs(Text, { children: [liveText, "\u258D"] }) })) : status.status === 'running' ? (_jsxs(Box, { children: [_jsx(Text, { color: tokens.ansi.info, children: "\u2726 Thinking..." }), _jsxs(Text, { color: tokens.ansi.muted, children: [" \u00B7 ", Math.round(elapsed / 1000), "s"] })] })) : null, plan.length > 0 ? _jsx(PlanView, { steps: plan, expanded: false, onToggle: () => { } }) : null] }), _jsxs(Box, { borderStyle: "single", borderColor: tokens.ansi.accent, paddingX: 1, children: [_jsx(Text, { children: "\u203A " }), _jsxs(Text, { children: [input, "\u258F"] })] }), _jsxs(Box, { justifyContent: "space-between", paddingX: 1, borderStyle: "single", borderColor: tokens.ansi.border, children: [_jsxs(Text, { color: tokens.ansi.muted, children: [status.model, " \u00B7 ", status.usageInput + status.usageOutput, " tokens \u00B7 $", (status.usageInput / 1000 * 0.003 + status.usageOutput / 1000 * 0.015).toFixed(2), " \u00B7 ", Math.round(elapsed / 1000), "s"] }), _jsx(Text, { color: tokens.ansi.muted, children: isSmall ? 'Ctrl+C interrupt' : 'Ctrl+C interrupt · Ctrl+O expand · ↑↓ scroll' })] })] }));
 }

package/package.json

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