klyro 0.1.16 → 0.1.18

package/dist/agent/runtime.d.ts

@@ -76,6 +76,7 @@ export interface RunOptions {
         command?: string;
         maxRepairAttempts?: number;
         timeoutMs?: number;
+        requireVerify?: boolean;
     };
     /**
      * Level 9 — persistence. When a SessionStore is provided, every message

package/dist/agent/runtime.js

@@ -17,8 +17,12 @@
 import { text, toolUse, toolResult as mkToolResult } from './message.js';
 import { redact } from '../policy/secret-redactor.js';
 import { RuntimeTelemetry, emptyTelemetryBlock, summarizeToolCall } from '../context/level7.js';
+import * as path from 'node:path';
 import { verify, diagnosticForModel } from '../verification/engine.js';
 import { detectVerifyCommand } from '../verification/auto.js';
+import { ensureBaseline, getBaseline } from '../verification/baseline.js';
+import { classifyFailure, rerunOnce, gatherRepairContext, guardRepair } from '../verification/classify.js';
+import { findRelatedTests, buildScopedCommand, runScopedVerify, syntaxCheck, checkImports } from '../verification/scoped.js';
 import { globalBus } from '../events/bus.js';
 import { TraceWriter } from '../trace/writer.js';
 const DEFAULT_MAX_STEPS = 30;
@@ -92,6 +96,20 @@ export async function run(opts, deps) {
     };
     const store = opts.persist?.store;
     const sessionId = opts.persist?.sessionId;
+    // 6.1 baseline cache per HEAD — capture before first edit
+    let baselinePrimed = false;
+    async function primeBaseline() {
+        if (baselinePrimed)
+            return;
+        baselinePrimed = true;
+        const cmd = opts.verify?.command ?? detectVerifyCommand(opts.cwd);
+        if (!cmd)
+            return;
+        try {
+            await ensureBaseline(opts.cwd, cmd);
+        }
+        catch { /* ignore */ }
+    }
     async function checkpoint(msg, obs) {
         if (!store || !sessionId)
             return;
@@ -271,13 +289,53 @@ export async function run(opts, deps) {
             if (verifyEnabled && hasEdits && verifyCmd && verificationAttempts < maxRepairs) {
                 emit?.({ kind: 'verification_started', command: verifyCmd });
                 let vResult;
+                // 6.3 — scoped run if edited files known
+                const edited = [...fileEditCounts.keys()];
+                const related = findRelatedTests(opts.cwd, edited);
+                const scopedCmd = buildScopedCommand(opts.cwd, verifyCmd, related);
+                const cmdToRun = scopedCmd ?? verifyCmd;
+                const isScoped = !!scopedCmd;
+                if (isScoped)
+                    emit?.({ kind: 'verification_started', command: cmdToRun });
                 try {
-                    vResult = await verify({ cwd: opts.cwd, command: verifyCmd, timeoutMs: opts.verify?.timeoutMs });
+                    if (isScoped) {
+                        const sr = await runScopedVerify(opts.cwd, cmdToRun, opts.verify?.timeoutMs);
+                        const det = sr.ok ? undefined : (await import('../verification/detect.js')).detect(sr.stdout, sr.stderr, sr.exitCode);
+                        vResult = { ok: sr.ok, exitCode: sr.exitCode, stdout: sr.stdout, stderr: sr.stderr, ...(det ? { failure: det } : {}) };
+                    }
+                    else {
+                        vResult = await verify({ cwd: opts.cwd, command: cmdToRun, timeoutMs: opts.verify?.timeoutMs });
+                    }
                 }
                 catch (e) {
                     const msg = e instanceof Error ? e.message : String(e);
                     vResult = { ok: false, exitCode: -1, stdout: '', stderr: msg, failure: { type: 'unknown', files: [], raw: msg, exitCode: -1 } };
                 }
+                // 6.3 — sanity checks before full verify
+                if (vResult.ok) {
+                    // quick syntax/import guard for last edited files
+                    for (const f of edited.slice(-3)) {
+                        const sc = await syntaxCheck(opts.cwd, f);
+                        if (!sc.ok) {
+                            vResult = { ok: false, exitCode: 1, stdout: '', stderr: sc.error ?? `syntax error ${f}`, failure: { type: 'build', files: [{ path: f, message: sc.error ?? 'syntax error' }], raw: sc.error ?? '', exitCode: 1 } };
+                            break;
+                        }
+                        const ic = checkImports(opts.cwd, f);
+                        if (!ic.ok) {
+                            vResult = { ok: false, exitCode: 1, stdout: '', stderr: `missing imports in ${f}: ${ic.missing.join(', ')}`, failure: { type: 'build', files: ic.missing.map((m) => ({ path: f, message: `missing import ${m}` })), raw: `missing imports ${ic.missing.join(', ')}`, exitCode: 1 } };
+                            break;
+                        }
+                    }
+                }
+                // If scoped passed but full may still fail, run full before declaring success
+                if (vResult.ok && isScoped) {
+                    try {
+                        const full = await verify({ cwd: opts.cwd, command: verifyCmd, timeoutMs: opts.verify?.timeoutMs });
+                        if (!full.ok)
+                            vResult = full;
+                    }
+                    catch { /* scoped success is enough */ }
+                }
                 if (vResult.ok) {
                     emit?.({ kind: 'verification_succeeded', command: verifyCmd });
                     emit?.({ kind: 'final_text', text: finalText });
@@ -291,16 +349,90 @@ export async function run(opts, deps) {
                     await closeTracer();
                     return { status: 'complete', steps, toolCalls: toolCallCount, finalText, transcript, usage, repairs, verification: { ok: true, command: verifyCmd, attempts: verificationAttempts } };
                 }
-                // Failure → repair loop
+                // 6.4 — classify
+                const baseline = await getBaseline(opts.cwd, verifyCmd);
+                const isFlaky = await rerunOnce(opts.cwd, cmdToRun, 30_000);
+                const cls = classifyFailure({ failure: vResult.failure, stdout: vResult.stdout, stderr: vResult.stderr }, baseline, isFlaky);
+                if (cls === 'flaky') {
+                    // rerun succeeded on second try — treat as flaky, don't count as repair
+                    emit?.({ kind: 'verification_succeeded', command: verifyCmd });
+                    emit?.({ kind: 'final_text', text: finalText });
+                    emit?.({ kind: 'step_end', step: steps });
+                    if (store && sessionId) {
+                        try {
+                            await store.setStatus(sessionId, 'complete', finalText);
+                        }
+                        catch { /* ignore */ }
+                    }
+                    await closeTracer();
+                    return { status: 'complete', steps, toolCalls: toolCallCount, finalText, transcript, usage, repairs, verification: { ok: true, command: verifyCmd, attempts: verificationAttempts } };
+                }
+                if (cls === 'env') {
+                    // don't try to repair env failures with code edits
+                    const envMsg = { role: 'user', content: [text(`Verification failed due to environment issue (not code):\n\n${diagnosticForModel(vResult)}\n\nPlease suggest how to fix the environment (install deps, set env vars) rather than editing code. If this is a missing binary, ask the user.`)] };
+                    transcript.push(envMsg);
+                    await checkpoint(envMsg);
+                    verificationAttempts++;
+                    emit?.({ kind: 'verification_failed', step: String(steps), reason: `env: ${diagnosticForModel(vResult).slice(0, 600)}` });
+                    if (verificationAttempts >= maxRepairs) {
+                        await closeTracer();
+                        return { status: 'verify_failed', steps, toolCalls: toolCallCount, finalText, transcript, usage, repairs, verification: { ok: false, command: verifyCmd, attempts: verificationAttempts, failureType: 'env' } };
+                    }
+                    emit?.({ kind: 'step_end', step: steps });
+                    continue;
+                }
+                if (cls === 'pre_existing') {
+                    // pre-existing — don't penalize, but still surface
+                    const preMsg = { role: 'user', content: [text(`Note: verification failure appears pre-existing (present in baseline at HEAD). Current failure:\n\n${diagnosticForModel(vResult)}\n\nIf this failure is unrelated to your changes, you may proceed, but try to avoid making it worse.`)] };
+                    transcript.push(preMsg);
+                    await checkpoint(preMsg);
+                    // still count as needing repair if introduced files overlap, else allow completion
+                    // For now, treat pre-existing as non-blocking after one warning if no introduced files in failure
+                    const introducedPaths = new Set(edited);
+                    const failurePaths = new Set(vResult.failure?.files.map((f) => f.path).filter(Boolean) ?? []);
+                    const overlaps = [...failurePaths].some((p) => introducedPaths.has(p) || introducedPaths.has(path.basename(p)));
+                    if (!overlaps) {
+                        emit?.({ kind: 'verification_succeeded', command: verifyCmd });
+                        emit?.({ kind: 'final_text', text: finalText });
+                        emit?.({ kind: 'step_end', step: steps });
+                        if (store && sessionId) {
+                            try {
+                                await store.setStatus(sessionId, 'complete', finalText);
+                            }
+                            catch { /* ignore */ }
+                        }
+                        await closeTracer();
+                        return { status: 'complete', steps, toolCalls: toolCallCount, finalText, transcript, usage, repairs, verification: { ok: true, command: verifyCmd, attempts: verificationAttempts } };
+                    }
+                }
+                // Failure → repair loop (introduced)
                 verificationAttempts++;
                 const diagnostic = diagnosticForModel(vResult);
                 const failureType = vResult.failure?.type ?? 'unknown';
+                // 6.4 — gather context
+                const ctx = await gatherRepairContext(opts.cwd, vResult.failure);
+                const ctxBlock = [
+                    ctx.hunks ? `Changed hunks:\n${ctx.hunks.slice(0, 1500)}` : '',
+                    ctx.failingTests.length > 0 ? `Failing test excerpt:\n${ctx.failingTests[0]?.content.slice(0, 1500)}` : '',
+                    ctx.blame ? `Blame:\n${ctx.blame.slice(0, 800)}` : '',
+                ].filter(Boolean).join('\n\n');
                 emit?.({ kind: 'verification_failed', step: String(steps), reason: diagnostic.slice(0, 800) });
                 emit?.({ kind: 'repair_started', attempt: verificationAttempts, maxAttempts: maxRepairs, reason: diagnostic.slice(0, 400) });
                 telemetry.recordError(`verify_${failureType}`);
+                // 6.4 guard — check if last diff touches assertions/skips (would need approval)
+                try {
+                    const diffText = await (await import('node:fs/promises')).readFile(path.join(opts.cwd, '.klyro', 'checkpoints', 'last.diff'), 'utf-8').catch(() => ctx.hunks);
+                    const g = guardRepair(diffText ?? ctx.hunks, edited);
+                    if (g.blocked) {
+                        const guardMsg = { role: 'user', content: [text(`Repair guard blocked: ${g.reason}\n\nIf you must edit test assertions or add skips, first ask the user for explicit approval via ask_user.`)] };
+                        transcript.push(guardMsg);
+                        await checkpoint(guardMsg);
+                    }
+                }
+                catch { /* ignore guard */ }
                 const repairMsg = {
                     role: 'user',
-                    content: [text(`Verification failed (attempt ${verificationAttempts}/${maxRepairs}) running \`${verifyCmd}\`:\n\n${diagnostic}\n\nPlease analyze the failure, re-read the failing files, and repair the code. Focus on the error above.`)],
+                    content: [text(`Verification failed (attempt ${verificationAttempts}/${maxRepairs}, class=${cls}) running \`${verifyCmd}\`:\n\n${diagnostic}\n\n${ctxBlock ? `\nContext:\n${ctxBlock}\n` : ''}\nPlease analyze the failure, re-read the failing files, and repair the code. Focus on the error above. Do not edit test assertions unless the test itself is wrong — fix the source.`)],
                 };
                 transcript.push(repairMsg);
                 await checkpoint(repairMsg);
@@ -398,8 +530,11 @@ export async function run(opts, deps) {
             await checkpoint(toolMsg, { toolCallId: call.id, toolName: call.name, input: call.input, output, isError: !obs.ok });
             if (obs.ok) {
                 telemetry.recordToolCall(call, latencyMs, false);
-                if (call.name === 'write_file' || call.name === 'edit_file')
+                if (call.name === 'write_file' || call.name === 'edit_file' || call.name === 'multi_edit' || call.name === 'apply_patch')
                     hasEdits = true;
+                // 6.1 — prime baseline on first edit
+                if (hasEdits && !baselinePrimed)
+                    void primeBaseline();
             }
             else {
                 const code = String(obs.error?.code ?? 'tool_error');

package/dist/cli/eval.js

@@ -61,6 +61,21 @@ export async function runEval(opts) {
             for (const e of entries) {
                 if (opts.filter && !e.includes(opts.filter))
                     continue;
+                // 6.5 — suite filter: smoke = type smoke, l6 = prefix l6-introduce
+                if (opts.suite && opts.suite !== 'smoke') {
+                    if (!e.startsWith(opts.suite) && !e.includes(opts.suite))
+                        continue;
+                }
+                else if (opts.suite === 'smoke') {
+                    // smoke = only type smoke (exclude l6 introduce fixtures)
+                    try {
+                        const metaRaw = await fs.readFile(path.join(fixturesDir, e, 'meta.json'), 'utf-8');
+                        const meta = JSON.parse(metaRaw);
+                        if (meta.suite === 'l6' || meta.type === 'l6-introduce')
+                            continue;
+                    }
+                    catch { /* no meta → include */ }
+                }
                 const taskPath = path.join(fixturesDir, e, 'task.md');
                 try {
                     const task = await fs.readFile(taskPath, 'utf-8');

package/dist/cli/repl.js

@@ -84,6 +84,14 @@ export async function startRepl(opts = {}) {
         else
             pendingQueue.push({ kind: 'append', item });
     }
+    function queuedDelta(text) {
+        if (!text)
+            return;
+        if (isMounted && directHooks)
+            directHooks.appendDelta(text);
+        else
+            pendingQueue.push({ kind: 'delta', text });
+    }
     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)
@@ -125,6 +133,8 @@ export async function startRepl(opts = {}) {
                     hooks.updateStatus(ev.patch);
                 else if (ev.kind === 'plan')
                     hooks.updatePlan(ev.plan);
+                else if (ev.kind === 'delta')
+                    hooks.appendDelta(ev.text);
                 else
                     hooks.append(ev.item);
             }
@@ -166,8 +176,6 @@ export async function startRepl(opts = {}) {
             }
         }
         queuedStatus({ status: 'running', step: 0, model });
-        let textBuf = '';
-        let pendingTextId = null;
         let activeCallId = null;
         let activeCallName = null;
         let activeCallArgs = '';
@@ -183,36 +191,11 @@ export async function startRepl(opts = {}) {
                 persist: sessionId ? { store: tuiStore, sessionId } : undefined,
                 onEvent: (ev) => {
                     if (ev.kind === 'step_start') {
-                        // Flush coalesced text before new step
-                        pendingTextId = null;
                         queuedStatus({ step: ev.step });
                     }
                     else if (ev.kind === 'text_delta') {
-                        textBuf += ev.text;
-                        // 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) {
-                                last.item.text += ev.text;
-                                return;
-                            }
-                        }
-                        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' });
+                        // single appendDelta path — App merges into one assistant item (Q→A order, no duplication)
+                        queuedDelta(ev.text);
                     }
                     else if (ev.kind === 'verification_started') {
                         queuedAppend({ id: `vrfy-${Date.now()}`, kind: 'text', text: `[verify] running \`${ev.command}\``, role: 'assistant' });
@@ -272,16 +255,7 @@ export async function startRepl(opts = {}) {
                         });
                     }
                     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?.();
-                        }
+                        // streamingId is closed by status change; no extra handling needed
                     }
                     else if (ev.kind === 'usage') {
                         queuedStatus({ usageInput: ev.input, usageOutput: ev.output });
@@ -506,6 +480,29 @@ export async function startRepl(opts = {}) {
                 }
                 return;
             }
+            case 'verify': {
+                const { detectVerifiers, primaryVerifyCommand } = await import('../verification/registry.js');
+                const { verify } = await import('../verification/engine.js');
+                const verifiers = detectVerifiers(cwd);
+                if (verifiers.length === 0) {
+                    queuedAppend({ id: `vrfy-${Date.now()}`, kind: 'text', text: 'No verifiers detected (no test/typecheck/lint/build). Try `npm test` manually.', role: 'assistant' });
+                    return;
+                }
+                const list = verifiers.map((v) => `  ${v.id}: ${v.command}`).join('\n');
+                queuedAppend({ id: `vrfy-list-${Date.now()}`, kind: 'text', text: `Verifiers:\n${list}`, role: 'assistant' });
+                const cmd = primaryVerifyCommand(cwd);
+                if (!cmd)
+                    return;
+                queuedAppend({ id: `vrfy-run-${Date.now()}`, kind: 'text', text: `[verify] running \`${cmd}\`...`, role: 'assistant' });
+                try {
+                    const res = await verify({ cwd, command: cmd });
+                    queuedAppend({ id: `vrfy-res-${Date.now()}`, kind: 'text', text: res.ok ? `[verify] passed (${cmd})` : `[verify] failed (${cmd}): ${res.stderr.slice(0, 500)}`, role: 'assistant' });
+                }
+                catch (err) {
+                    queuedAppend({ id: `vrfy-err-${Date.now()}`, kind: 'error', message: `verify failed: ${err instanceof Error ? err.message : String(err)}` });
+                }
+                return;
+            }
             case 'compact':
                 queuedAppend({
                     id: `stub-${Date.now()}`,

package/dist/cli/run.d.ts

@@ -59,6 +59,7 @@ export interface RunCliOptions {
     verifyCommand?: string;
     maxRepairAttempts?: number;
     verifyTimeoutMs?: number;
+    requireVerify?: boolean;
     /** Level 9 — persistence */
     persist?: boolean;
     sessionId?: string;

package/dist/cli/run.js

@@ -110,6 +110,7 @@ export async function runOnce(opts) {
             command: opts.verifyCommand,
             maxRepairAttempts: opts.maxRepairAttempts ?? 3,
             timeoutMs: opts.verifyTimeoutMs,
+            requireVerify: opts.requireVerify,
         };
     const result = await run({
         task: opts.task,
@@ -212,6 +213,22 @@ export async function runOnce(opts) {
             stderr.write(`klyro: verification failed after ${result.verification?.attempts ?? 3} repairs — see output above\n`);
         return 5;
     }
+    // 6.5 — --require-verify: if edits were made but verification never passed, exit 8
+    if (opts.requireVerify && result.verification && !result.verification.ok) {
+        if (output === 'json')
+            stdout.write(JSON.stringify({ kind: 'final', status: 'require_verify_failed' }) + '\n');
+        else
+            stderr.write('klyro: --require-verify: verification required but not passed\n');
+        return 8;
+    }
+    if (opts.requireVerify && !result.verification) {
+        // hasEdits but no verification command found
+        if (output === 'json')
+            stdout.write(JSON.stringify({ kind: 'final', status: 'require_verify_missing' }) + '\n');
+        else
+            stderr.write('klyro: --require-verify: no verification command found and edits were made\n');
+        return 8;
+    }
     if (output === 'json')
         stdout.write(JSON.stringify({ kind: 'final', status: 'ok', text: result.finalText }) + '\n');
     return 0;

package/dist/cli/slash/parser.d.ts

@@ -49,6 +49,8 @@ export type SlashCommand = {
     kind: 'memory';
 } | {
     kind: 'jobs';
+} | {
+    kind: 'verify';
 } | {
     kind: 'prompt';
     text: string;

package/dist/cli/slash/parser.js

@@ -14,7 +14,7 @@
  * Anything not starting with "/" is a regular prompt and yields
  * { kind: 'prompt', text }.
  */
-const KNOWN = ['clear', 'compact', 'model', 'diff', 'undo', 'rewind', 'plan', 'status', 'quit', 'help', 'config', 'doctor', 'version', 'cost', 'thinking', 'memory', 'jobs', 'exit', 'clear'];
+const KNOWN = ['clear', 'compact', 'model', 'diff', 'undo', 'rewind', 'plan', 'status', 'quit', 'help', 'config', 'doctor', 'version', 'cost', 'thinking', 'memory', 'jobs', 'verify', 'exit', 'clear'];
 export function parse(input) {
     const trimmed = input.trim();
     if (!trimmed.startsWith('/')) {
@@ -35,6 +35,7 @@ export function parse(input) {
         case 'thinking': return { kind: 'thinking' };
         case 'memory': return { kind: 'memory' };
         case 'jobs': return { kind: 'jobs' };
+        case 'verify': return { kind: 'verify' };
         case 'quit':
         case 'exit':
         case 'q': return { kind: 'quit' };

package/dist/index.js

@@ -296,6 +296,7 @@ async function main() {
         .option('--verify-command <cmd>', 'Custom verification command (default: auto-detected)')
         .option('--max-repairs <n>', 'Max autonomous repair attempts (default 3)', (v) => parsePositiveInt('--max-repairs', v))
         .option('--persist', 'Enable session persistence (Level 9, default: enabled)')
+        .option('--require-verify', 'Fail with exit 8 if no verification passed after edits (6.5)')
         .action(async (prompt, opts) => {
         const model = opts.model ?? process.env.KLYRO_MODEL;
         if (!model) {
@@ -328,6 +329,7 @@ async function main() {
                 verifyCommand: opts.verifyCommand,
                 maxRepairAttempts: opts.maxRepairs,
                 persist: opts.persist,
+                requireVerify: !!opts.requireVerify,
             });
             process.exit(code);
         }

package/dist/tui/app.d.ts

@@ -1,10 +1,11 @@
 /**
- * Klyro Full-Screen TUI — TUI_DESIGN.md §2, §24, §38 (Phase 1-4)
- * Full viewport, conversation, input, status bar — professional, dense, terminal-native
+ * Klyro TUI — opencode-style linear transcript
+ * Header (top) → Conversation (scrollable, Q→A→Q→A) → Input (bottom) → StatusBar (bottom)
+ * Single streamingId merges text_delta into one assistant item — no duplication, no liveText ghost.
  */
 import React from 'react';
-import { type StatusSnapshot } from './status.js';
-import { type TranscriptItem } from './transcript.js';
+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 {
@@ -18,6 +19,7 @@ export interface AppProps {
     approvalBridge?: TuiApprovalBridge;
     onMounted?: (hooks: {
         append: (i: TranscriptItem) => void;
+        appendDelta: (text: string) => void;
         updateStatus: (s: Partial<StatusSnapshot>) => void;
         updatePlan: (p: PlanStep[]) => void;
     }) => void;

package/dist/tui/app.js

@@ -1,11 +1,11 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 /**
- * Klyro Full-Screen TUI — TUI_DESIGN.md §2, §24, §38 (Phase 1-4)
- * Full viewport, conversation, input, status bar — professional, dense, terminal-native
+ * Klyro TUI — opencode-style linear transcript
+ * Header (top) → Conversation (scrollable, Q→A→Q→A) → Input (bottom) → StatusBar (bottom)
+ * Single streamingId merges text_delta into one assistant item — no duplication, no liveText ghost.
  */
 import { useState, useEffect, useRef, useCallback } from 'react';
 import { Box, Text, useInput, useStdout } from 'ink';
-import { Transcript } from './transcript.js';
 import { TuiApprovalBridge } from './approval.js';
 import { PlanView } from './plan.js';
 import { parse as parseSlash } from '../cli/slash/parser.js';
@@ -31,41 +31,17 @@ 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]);
+    // streaming: one assistant text item that text_delta merges into
+    const streamingIdRef = useRef(null);
     useEffect(() => bridge.subscribe((p) => setAwaitingApproval(p !== null)), [bridge]);
-    // 2.4 — send queued when idle
+    // queued: send when idle (2.4)
     useEffect(() => {
         if (queued && status.status !== 'running' && !awaitingApproval) {
             const toSend = queued;
             setQueued(null);
-            const item = { id: nextId('text'), kind: 'text', text: toSend, role: 'user' };
+            const item = { id: nextId('user'), kind: 'text', text: toSend, role: 'user' };
             setTranscript((prev) => [...prev, item]);
+            streamingIdRef.current = null;
             const cmd = parseSlash(toSend.trim());
             if (cmd.kind === 'prompt')
                 void props.onPrompt(cmd.text);
@@ -81,34 +57,56 @@ export function App(props) {
         return () => clearInterval(t);
     }, [status.status, elapsed]);
     const append = useCallback((item) => {
-        setTranscript((prev) => {
-            const last = prev[prev.length - 1];
-            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];
-        });
+        // any non-streaming append closes the current streaming block
+        if (item.kind !== 'text' || item.role !== 'assistant')
+            streamingIdRef.current = null;
+        setTranscript((prev) => [...prev, item]);
+    }, []);
+    const appendDelta = useCallback((text) => {
+        if (!text)
+            return;
+        const sid = streamingIdRef.current;
+        if (sid) {
+            setTranscript((prev) => {
+                const idx = prev.findIndex((x) => x.id === sid);
+                if (idx === -1)
+                    return [...prev, { id: sid, kind: 'text', text, role: 'assistant' }];
+                const cur = prev[idx];
+                const next = { ...cur, text: cur.text + text };
+                const copy = [...prev];
+                copy[idx] = next;
+                return copy;
+            });
+        }
+        else {
+            const id = nextId('stream');
+            streamingIdRef.current = id;
+            setTranscript((prev) => [...prev, { id, kind: 'text', text, role: 'assistant' }]);
+        }
     }, []);
+    // close streaming block when status leaves running (so next text_delta starts new item)
+    useEffect(() => {
+        if (status.status !== 'running')
+            streamingIdRef.current = null;
+    }, [status.status]);
     const updateStatus = useCallback((s) => setStatus((p) => ({ ...p, ...s })), []);
     const updatePlan = useCallback((p) => setPlan(p), []);
     const onMountedRef = useRef(props.onMounted);
     useEffect(() => { onMountedRef.current = props.onMounted; }, [props.onMounted]);
     useEffect(() => {
-        onMountedRef.current?.({ append, updateStatus, updatePlan });
+        onMountedRef.current?.({ append, appendDelta, updateStatus, updatePlan });
+        // global hooks for repl bridge (instance-local queue drains here)
         globalThis.__klyroAppAppend = append;
+        globalThis.__klyroAppendDelta = appendDelta;
         globalThis.__klyroAppStatus = updateStatus;
         globalThis.__klyroAppPlan = updatePlan;
-        globalThis.__klyroAppendDelta = appendDeltaBatched;
-        globalThis.__klyroCommitLive = commitLive;
         return () => {
             delete globalThis.__klyroAppAppend;
+            delete globalThis.__klyroAppendDelta;
             delete globalThis.__klyroAppStatus;
             delete globalThis.__klyroAppPlan;
-            delete globalThis.__klyroAppendDelta;
-            delete globalThis.__klyroCommitLive;
         };
-    }, [append, updateStatus, updatePlan, appendDeltaBatched, commitLive]);
-    // Single useInput owner — handles queued when running (2.4)
+    }, [append, appendDelta, updateStatus, updatePlan]);
     useInput((inputStr, key) => {
         if (awaitingApproval)
             return;
@@ -123,7 +121,8 @@ export function App(props) {
                     return;
                 setQueued(v);
                 setInput('');
-                setTranscript((prev) => [...prev, { id: nextId('text'), kind: 'text', text: `queued: ${v.slice(0, 80)}`, role: 'assistant' }]);
+                // queued indicator as muted text, not a full user bubble (opencode style)
+                setTranscript((prev) => [...prev, { id: nextId('queued'), kind: 'text', text: `queued: ${v.slice(0, 80)}`, role: 'assistant' }]);
                 return;
             }
             if (key.backspace || key.delete) {
@@ -141,8 +140,9 @@ export function App(props) {
             if (!v)
                 return;
             setInput('');
-            const item = { id: nextId('text'), kind: 'text', text: v, role: 'user' };
+            const item = { id: nextId('user'), kind: 'text', text: v, role: 'user' };
             setTranscript((prev) => [...prev, item]);
+            streamingIdRef.current = null;
             const cmd = parseSlash(v);
             if (cmd.kind === 'prompt')
                 void props.onPrompt(cmd.text);
@@ -160,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.15" }), _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' })] })] }));
+    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.16" }), _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(Text, { color: tokens.ansi.muted, children: "No conversation yet. Try \"hi\" or /help" })) : (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, 300) }) : 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)))] })) : item.kind === 'error' ? (_jsxs(Text, { color: tokens.ansi.error, children: ["[error] ", item.message] })) : item.kind === 'policy' ? (_jsxs(Text, { color: tokens.ansi.muted, children: ["[policy] ", item.action, " ", item.name, item.reason ? ` — ${item.reason}` : ''] })) : item.kind === 'file_changed' ? (_jsxs(Text, { color: tokens.ansi.muted, children: ["[", item.op, "] ", item.path] })) : null }, item.id)))), status.status === 'running' && !streamingIdRef.current ? (_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' })] })] }));
 }