klyro 0.1.4 → 0.1.6

package/dist/cli/doctor.js

@@ -0,0 +1,136 @@
+/**
+ * LEVEL 1 — klyro doctor
+ * Runs quick diagnostics: node version, config, provider reachability,
+ * persistence dir, git, tools.
+ */
+import * as fs from 'node:fs/promises';
+import * as fsSync from 'node:fs';
+import * as path from 'node:path';
+import { spawn } from 'node:child_process';
+import { getConfigPath, loadConfig } from './config.js';
+import { resolveProvider, providerHelp } from '../providers.js';
+import { getDefaultSessionsDir } from '../persistence/session.js';
+import { builtinRegistry } from '../tools/registry.js';
+function checkNode() {
+    const v = process.versions.node;
+    const major = Number(v.split('.')[0] ?? 0);
+    const ok = major >= 20;
+    return {
+        name: 'Node.js',
+        ok,
+        detail: `${v} ${ok ? '✓' : '✗ requires >=20'} (${process.execPath})`,
+    };
+}
+async function checkConfig() {
+    const p = getConfigPath();
+    try {
+        await loadConfig();
+        const exists = fsSync.existsSync(p);
+        return { name: 'Config', ok: true, detail: exists ? `${p} ✓` : `${p} (not yet created) ✓` };
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return { name: 'Config', ok: false, detail: `${p} ✗ ${msg}` };
+    }
+}
+async function checkProvider() {
+    try {
+        const prov = await resolveProvider();
+        if (!prov) {
+            return { name: 'Provider', ok: false, detail: `none ${providerHelp(null)}` };
+        }
+        const src = prov.source === 'local-probe' ? 'local-probe' : prov.source === 'env' ? 'env' : 'manual';
+        const auth = prov.apiKey ? 'key set' : 'no key (local)';
+        return { name: 'Provider', ok: true, detail: `${prov.baseURL} model=${prov.model} (${src}, ${auth}) ✓` };
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return { name: 'Provider', ok: false, detail: `error: ${msg}` };
+    }
+}
+async function checkSessions() {
+    const dir = getDefaultSessionsDir();
+    try {
+        await fs.mkdir(dir, { recursive: true });
+        const test = path.join(dir, `.doctor-${Date.now()}.tmp`);
+        await fs.writeFile(test, 'ok', 'utf-8');
+        await fs.unlink(test);
+        return { name: 'Sessions dir', ok: true, detail: `${dir} writable ✓` };
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return { name: 'Sessions dir', ok: false, detail: `${dir} ✗ ${msg}` };
+    }
+}
+function checkGit() {
+    return new Promise((resolve) => {
+        const child = spawn('git', ['--version'], { shell: false, windowsHide: true });
+        let out = '';
+        let done = false;
+        const timer = setTimeout(() => {
+            if (done)
+                return;
+            done = true;
+            child.kill();
+            resolve({ name: 'git', ok: false, detail: 'timeout' });
+        }, 3000);
+        child.stdout.on('data', (b) => { out += b.toString(); });
+        child.on('error', () => {
+            if (done)
+                return;
+            done = true;
+            clearTimeout(timer);
+            resolve({ name: 'git', ok: false, detail: 'not found (install git)' });
+        });
+        child.on('close', (code) => {
+            if (done)
+                return;
+            done = true;
+            clearTimeout(timer);
+            if (code === 0)
+                resolve({ name: 'git', ok: true, detail: out.trim() + ' ✓' });
+            else
+                resolve({ name: 'git', ok: false, detail: `exit ${code}` });
+        });
+    });
+}
+function checkTools() {
+    const reg = builtinRegistry();
+    return { name: 'Tools', ok: true, detail: `${reg.list().length} tools: ${reg.list().map((t) => t.name).join(', ')}` };
+}
+function checkPlatform() {
+    const ok = ['win32', 'linux', 'darwin'].includes(process.platform);
+    return { name: 'Platform', ok, detail: `${process.platform} ${process.arch} ${ok ? '✓' : '✗ unsupported'}` };
+}
+export async function runDoctor(opts = {}) {
+    const checks = [];
+    checks.push(checkNode());
+    checks.push(await checkConfig());
+    checks.push(await checkProvider());
+    checks.push(await checkSessions());
+    checks.push(await checkGit());
+    checks.push(checkTools());
+    checks.push(checkPlatform());
+    const allOk = checks.every((c) => c.ok);
+    if (opts.json) {
+        process.stdout.write(JSON.stringify({ ok: allOk, checks }, null, 2) + '\n');
+        return allOk ? 0 : 1;
+    }
+    process.stdout.write('\nklyro doctor\n');
+    process.stdout.write('─'.repeat(40) + '\n');
+    for (const c of checks) {
+        const glyph = c.ok ? '✓' : '✗';
+        const color = c.ok ? '' : '';
+        process.stdout.write(`${glyph} ${c.name.padEnd(14)} ${c.detail}\n`);
+    }
+    process.stdout.write('─'.repeat(40) + '\n');
+    if (allOk) {
+        process.stdout.write('All checks passed.\n');
+    }
+    else {
+        process.stdout.write('Some checks failed — see ✗ above. Fix env/config and re-run.\n');
+        process.stdout.write(`Config path: ${getConfigPath()}\n`);
+        process.stdout.write(`Sessions : ${getDefaultSessionsDir()}\n`);
+    }
+    return allOk ? 0 : 1;
+}

package/dist/cli/errors.d.ts

@@ -0,0 +1,5 @@
+/**
+ * 1.5 — handleFatal: ✖ message / hint: / "run with --debug", mapped exit codes
+ */
+export declare function handleFatal(err: unknown): never;
+export declare function setupGlobalHandlers(): void;

package/dist/cli/errors.js

@@ -0,0 +1,37 @@
+/**
+ * 1.5 — handleFatal: ✖ message / hint: / "run with --debug", mapped exit codes
+ */
+import { KlyroError } from '../shared/errors.js';
+export function handleFatal(err) {
+    const isDebug = !!process.env.KLYRO_LOG_LEVEL || !!process.env.DEBUG || process.argv.includes('--debug');
+    let code = 1;
+    let message = err instanceof Error ? err.message : String(err);
+    let hint;
+    if (err instanceof KlyroError) {
+        code = err.exitCode;
+        hint = err.hint;
+    }
+    else if (err instanceof Error && err.code === 'ENOENT') {
+        code = 2;
+        hint = 'Check the file path exists';
+    }
+    // Never print stack without --debug
+    if (!isDebug) {
+        // Strip stack, only print message
+        process.stderr.write(`✖ ${message}\n`);
+    }
+    else {
+        process.stderr.write(`✖ ${message}\n`);
+        if (err instanceof Error && err.stack)
+            process.stderr.write(err.stack + '\n');
+    }
+    if (hint)
+        process.stderr.write(`  hint: ${hint}\n`);
+    if (!isDebug)
+        process.stderr.write('  run with --debug for stack trace\n');
+    process.exit(code);
+}
+export function setupGlobalHandlers() {
+    process.on('uncaughtException', (err) => handleFatal(err));
+    process.on('unhandledRejection', (reason) => handleFatal(reason));
+}

package/dist/cli/markdown.d.ts

@@ -0,0 +1,9 @@
+/**
+ * 1.5 — incremental markdown renderer (headers, code w/ highlight, lists, tables)
+ * Minimal: handles headers, code blocks, lists, tables, width-aware wrap, plain-text for non-TTY.
+ */
+export declare function renderMarkdown(md: string, opts?: {
+    width?: number;
+    isTTY?: boolean;
+}): string;
+export declare function renderIncremental(prev: string, nextChunk: string): string;

package/dist/cli/markdown.js

@@ -0,0 +1,77 @@
+/**
+ * 1.5 — incremental markdown renderer (headers, code w/ highlight, lists, tables)
+ * Minimal: handles headers, code blocks, lists, tables, width-aware wrap, plain-text for non-TTY.
+ */
+export function renderMarkdown(md, opts = {}) {
+    const width = opts.width ?? (process.stdout.columns || 80);
+    const isTTY = opts.isTTY ?? !!process.stdout.isTTY;
+    if (!isTTY || process.env.KLYRO_JSON === '1' || process.env.NO_COLOR === '1') {
+        // Plain text: strip markdown decorations
+        return stripMarkdown(md);
+    }
+    let out = '';
+    const lines = md.split('\n');
+    let inCodeBlock = false;
+    for (let line of lines) {
+        if (line.startsWith('```')) {
+            inCodeBlock = !inCodeBlock;
+            out += (inCodeBlock ? '┌ code ──\n' : '└──────\n');
+            continue;
+        }
+        if (inCodeBlock) {
+            out += '│ ' + line + '\n';
+            continue;
+        }
+        if (line.startsWith('# ')) {
+            out += '\n' + line.replace(/^#\s+/, '').toUpperCase() + '\n' + '─'.repeat(Math.min(width, 40)) + '\n';
+            continue;
+        }
+        if (line.startsWith('## ')) {
+            out += '\n' + line.replace(/^##\s+/, '') + '\n';
+            continue;
+        }
+        if (line.startsWith('- ') || line.startsWith('* ')) {
+            out += '• ' + line.slice(2) + '\n';
+            continue;
+        }
+        if (line.startsWith('|') && line.endsWith('|')) {
+            // Table row: replace | with │ and trim
+            const cells = line.split('|').filter(Boolean).map((c) => c.trim());
+            out += '│ ' + cells.join(' │ ') + ' │\n';
+            continue;
+        }
+        // Wrap long lines
+        if (line.length > width) {
+            const words = line.split(' ');
+            let cur = '';
+            for (const w of words) {
+                if ((cur + ' ' + w).length > width) {
+                    out += cur.trimEnd() + '\n';
+                    cur = w + ' ';
+                }
+                else {
+                    cur += w + ' ';
+                }
+            }
+            if (cur.trim())
+                out += cur.trimEnd() + '\n';
+        }
+        else {
+            out += line + '\n';
+        }
+    }
+    return out;
+}
+function stripMarkdown(md) {
+    return md
+        .replace(/^#+\s+/gm, '')
+        .replace(/```[\s\S]*?```/g, (m) => m.replace(/```/g, '').trim())
+        .replace(/\*\*(.+?)\*\*/g, '$1')
+        .replace(/\*(.+?)\*/g, '$1')
+        .replace(/`(.+?)`/g, '$1')
+        .replace(/\[([^\]]+)\]\([^)]+\)/g, '$1');
+}
+export function renderIncremental(prev, nextChunk) {
+    // For streaming, just append and re-render last chunk
+    return renderMarkdown(prev + nextChunk);
+}

package/dist/cli/repl.js

@@ -19,6 +19,9 @@ 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';
+import { getDefaultSessionStore } from '../persistence/session.js';
+import { buildSystemPrompt, parseImageInput } from '../context/system-prompt.js';
+import { estimateCost } from '../providers/model-info.js';
 export async function startRepl(opts = {}) {
     // Reuse the same provider resolution as legacy repl.ts — probes local
     // Ollama / LM Studio / vLLM when env is not fully set, so bare `klyro`
@@ -52,10 +55,11 @@ export async function startRepl(opts = {}) {
         : httpChatAdapter({ baseURL: baseUrl, apiKey, timeoutMs: 60_000 });
     const ctxBlock = await buildLevel6Context({ cwd });
     const ctxPrefix = ctxBlock.formatted ? `\n\n<context>\n${ctxBlock.formatted}\n</context>` : '';
+    // 2.3 layered system prompt
     const systemPromptFn = (_ctx) => {
-        const base = opts.systemPrompt ?? 'You are Klyro, an autonomous coding harness. Solve the user\'s task using the available tools.';
+        const base = buildSystemPrompt({ cwd, model, extraSystem: opts.systemPrompt, appendSystem: ctxPrefix });
         const t = _ctx.telemetry ? '\n\n' + _ctx.telemetry : '';
-        return base + ctxPrefix + t;
+        return base + t;
     };
     const ac = new AbortController();
     // When the TUI is mounted, use the inline Ink prompt. Otherwise
@@ -93,6 +97,9 @@ export async function startRepl(opts = {}) {
     // Declare app before handler to avoid TDZ; handler added after render
     let app;
     let sigintHandler;
+    // Level 9 — session store for TUI (one store per REPL)
+    const tuiStore = getDefaultSessionStore();
+    let tuiSessionId;
     app = render(React.createElement(App, {
         initialModel: model,
         maxSteps: opts.maxSteps ?? 30,
@@ -137,6 +144,20 @@ export async function startRepl(opts = {}) {
             queuedStatus({ status: 'error', errorMessage: 'no model configured' });
             return;
         }
+        // 2.3 image handling: extract @img refs
+        const { text: cleanText, images } = parseImageInput(text);
+        const taskText = images.length > 0 ? `${cleanText}\n\n[images: ${images.join(', ')}]` : cleanText;
+        // Level 9 — create session for this prompt if not already (one session per prompt)
+        let sessionId;
+        try {
+            const rec = await tuiStore.create({ cwd, task: taskText, config: { model, maxSteps: opts.maxSteps ?? 30 } });
+            sessionId = rec.id;
+            tuiSessionId = rec.id;
+            queuedAppend({ id: `sess-${Date.now()}`, kind: 'text', text: `session ${rec.id.slice(0, 8)} started`, role: 'assistant' });
+        }
+        catch {
+            // best-effort
+        }
         queuedStatus({ status: 'running', step: 0, model });
         let textBuf = '';
         let pendingTextId = null;
@@ -145,12 +166,14 @@ export async function startRepl(opts = {}) {
         let activeCallArgs = '';
         try {
             const result = await run({
-                task: text,
+                task: taskText,
                 cwd,
                 model,
                 maxSteps: opts.maxSteps ?? 30,
                 signal: ac.signal,
                 nonInteractive: opts.nonInteractive ?? false,
+                verify: { enabled: true, maxRepairAttempts: 3 },
+                persist: sessionId ? { store: tuiStore, sessionId } : undefined,
                 onEvent: (ev) => {
                     if (ev.kind === 'step_start') {
                         // Flush coalesced text before new step
@@ -178,6 +201,20 @@ export async function startRepl(opts = {}) {
                         pendingTextId = id;
                         queuedAppend({ id, kind: 'text', text: ev.text, role: 'assistant' });
                     }
+                    else if (ev.kind === 'verification_started') {
+                        queuedAppend({ id: `vrfy-${Date.now()}`, kind: 'text', text: `[verify] running \`${ev.command}\``, role: 'assistant' });
+                        queuedStatus({ status: 'running' });
+                    }
+                    else if (ev.kind === 'verification_succeeded') {
+                        queuedAppend({ id: `vrfy-ok-${Date.now()}`, kind: 'text', text: `[verify] passed (${ev.command})`, role: 'assistant' });
+                    }
+                    else if (ev.kind === 'repair_started') {
+                        queuedAppend({ id: `repair-${Date.now()}`, kind: 'text', text: `[repair] attempt ${ev.attempt}/${ev.maxAttempts}: ${ev.reason.slice(0, 200)}`, role: 'assistant' });
+                        queuedStatus({ status: 'running', errorMessage: undefined });
+                    }
+                    else if (ev.kind === 'checkpoint_saved') {
+                        queuedStatus({ status: 'running' });
+                    }
                     else if (ev.kind === 'tool_call_start') {
                         activeCallId = ev.id;
                         activeCallName = ev.name;
@@ -247,7 +284,28 @@ export async function startRepl(opts = {}) {
                     }
                 },
             }, { adapter, registry, policy, approval, systemPrompt: systemPromptFn });
-            queuedStatus({ status: 'complete' === result.status ? 'done' : 'error', repairs: result.repairs ?? 0 });
+            if (result.verification) {
+                const v = result.verification;
+                queuedAppend({
+                    id: `vfin-${Date.now()}`,
+                    kind: 'text',
+                    text: `[verify] ${v.ok ? 'passed' : `failed (${v.failureType ?? 'unknown'})`} after ${v.attempts} attempt(s)${v.command ? ` — ${v.command}` : ''}`,
+                    role: 'assistant',
+                });
+                if (!v.ok) {
+                    queuedStatus({ status: 'error', errorMessage: `verification failed: ${v.failureType ?? 'unknown'}` });
+                }
+            }
+            if (result.status === 'verify_failed') {
+                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 {
+                queuedStatus({ status: 'complete' === result.status ? 'done' : 'error', repairs: result.repairs ?? 0 });
+            }
+            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' });
+            }
         }
         catch (err) {
             const message = err instanceof Error ? err.message : String(err);
@@ -275,12 +333,62 @@ export async function startRepl(opts = {}) {
                     '  /status         — show session status',
                     '  /compact        — (stub) context compaction',
                     '  /model <id>     — switch model mid-session',
-                    '  /quit           — exit',
+                    '  /config         — show config path',
+                    '  /doctor         — run diagnostics',
+                    '  /version        — show version',
+                    '  /quit (/exit)   — exit',
                     `provider: ${effectiveProvider}  model: ${model}  cwd: ${cwd}`,
                 ].join('\n');
                 queuedAppend({ id: `help-${Date.now()}`, kind: 'text', text: helpText, role: 'assistant' });
                 return;
             }
+            case 'config': {
+                const { getConfigPath } = await import('./config.js');
+                queuedAppend({ id: `cfg-${Date.now()}`, kind: 'text', text: `config: ${getConfigPath()}`, role: 'assistant' });
+                return;
+            }
+            case 'doctor': {
+                const { runDoctor } = await import('./doctor.js');
+                // Capture doctor output via temporary override
+                const origWrite = process.stdout.write.bind(process.stdout);
+                let out = '';
+                process.stdout.write = ((chunk) => { out += String(chunk); return true; });
+                await runDoctor({});
+                process.stdout.write = origWrite;
+                queuedAppend({ id: `doc-${Date.now()}`, kind: 'text', text: out, role: 'assistant' });
+                return;
+            }
+            case 'version': {
+                const { readFileSync } = await import('node:fs');
+                const { resolve, dirname } = await import('node:path');
+                const { fileURLToPath } = await import('node:url');
+                try {
+                    const here = dirname(fileURLToPath(import.meta.url));
+                    const pkg = JSON.parse(readFileSync(resolve(here, '../../package.json'), 'utf-8'));
+                    queuedAppend({ id: `ver-${Date.now()}`, kind: 'text', text: `klyro ${pkg.version ?? '0.0.0'}`, role: 'assistant' });
+                }
+                catch {
+                    queuedAppend({ id: `ver-${Date.now()}`, kind: 'text', text: 'klyro (version unknown)', role: 'assistant' });
+                }
+                return;
+            }
+            case 'cost': {
+                const cost = lastStatus ? estimateCost(lastStatus.model ?? model, lastStatus.usageInput ?? 0, lastStatus.usageOutput ?? 0) : 0;
+                const input = lastStatus?.usageInput ?? 0;
+                const output = lastStatus?.usageOutput ?? 0;
+                const total = input + output;
+                queuedAppend({
+                    id: `cost-${Date.now()}`,
+                    kind: 'text',
+                    text: `Cost: $${cost.toFixed(4)} · ${input} in / ${output} out · ${total} total · model ${lastStatus?.model ?? model}`,
+                    role: 'assistant',
+                });
+                return;
+            }
+            case 'thinking': {
+                queuedAppend({ id: `think-${Date.now()}`, kind: 'text', text: 'Thinking: collapsed (use --show-thinking to expand)', role: 'assistant' });
+                return;
+            }
             case 'status': {
                 if (lastStatus) {
                     queuedAppend({

package/dist/cli/run.d.ts

@@ -54,6 +54,15 @@ export interface RunCliOptions {
      * turn; if absent, `opts.task` is appended.
      */
     resumePath?: string;
+    /** Level 8 — verification */
+    verify?: boolean;
+    verifyCommand?: string;
+    maxRepairAttempts?: number;
+    verifyTimeoutMs?: number;
+    /** Level 9 — persistence */
+    persist?: boolean;
+    sessionId?: string;
+    sessionsDir?: string;
 }
 export declare function runOnce(opts: RunCliOptions): Promise<number>;
 /** Wrap a system-prompt fn to inject Level-6 context (project map etc.). */

package/dist/cli/run.js

@@ -15,7 +15,7 @@ import { builtinRegistry } from '../tools/registry.js';
 import { builtinRules, DEFAULT_POLICY_CONFIG, PolicyEngine } from '../policy/engine.js';
 import { DenyAllApprovalPrompt } from '../policy/approval.js';
 import { buildLevel6Context } from '../context/level6.js';
-;
+import { resolveSessionId } from '../persistence/session.js';
 import * as fs from 'node:fs';
 function readEnv(name, fallback) {
     const v = process.env[name];
@@ -54,6 +54,48 @@ export async function runOnce(opts) {
     const registry = builtinRegistry();
     const policy = new PolicyEngine(builtinRules(), DEFAULT_POLICY_CONFIG);
     const systemPrompt = await makeRunSystemPrompt(opts.cwd, opts.systemPrompt ?? defaultRunSystemPrompt);
+    // Level 9 — session setup (create or resume)
+    const persistEnabled = opts.persist !== false;
+    let store;
+    let sessionId;
+    let initialTranscript;
+    if (persistEnabled) {
+        const { SessionStore } = await import('../persistence/store.js');
+        const { getDefaultSessionStore } = await import('../persistence/session.js');
+        store = opts.sessionsDir ? new SessionStore(opts.sessionsDir) : getDefaultSessionStore();
+        if (opts.resumePath) {
+            initialTranscript = loadTranscript(opts.resumePath);
+        }
+        else if (opts.sessionId) {
+            const full = await resolveSessionId(store, opts.sessionId);
+            if (!full) {
+                stderr.write(`klyro: session not found: ${opts.sessionId}\n`);
+                return 2;
+            }
+            sessionId = full;
+            const msgs = await store.loadMessages(sessionId);
+            // Convert StoredMessage to Message
+            initialTranscript = msgs.map((m) => ({ role: m.role, content: m.content }));
+            const rec = await store.get(sessionId);
+            if (rec) {
+                stderr.write(`klyro: resuming session ${sessionId.slice(0, 8)} — task: "${rec.task}"\n`);
+            }
+        }
+        else if (opts.resumePath) {
+            // already handled
+        }
+        else {
+            // Create new session
+            const rec = await store.create({ cwd: opts.cwd, task: opts.task, config: { model: opts.model, maxSteps: opts.maxSteps ?? 30 } });
+            sessionId = rec.id;
+            if (output !== 'silent' && output !== 'json') {
+                stderr.write(`klyro: session ${sessionId.slice(0, 8)} created\n`);
+            }
+        }
+    }
+    else if (opts.resumePath) {
+        initialTranscript = loadTranscript(opts.resumePath);
+    }
     const ac = new AbortController();
     if (opts.abortOnSigint !== false) {
         process.on('SIGINT', () => {
@@ -61,6 +103,14 @@ export async function runOnce(opts) {
             ac.abort();
         });
     }
+    const verifyOpts = opts.verify === false
+        ? { enabled: false }
+        : {
+            enabled: true,
+            command: opts.verifyCommand,
+            maxRepairAttempts: opts.maxRepairAttempts ?? 3,
+            timeoutMs: opts.verifyTimeoutMs,
+        };
     const result = await run({
         task: opts.task,
         cwd: opts.cwd,
@@ -70,7 +120,9 @@ export async function runOnce(opts) {
         temperature: opts.temperature,
         signal: ac.signal,
         nonInteractive: true,
-        initialTranscript: opts.resumePath ? loadTranscript(opts.resumePath) : undefined,
+        initialTranscript,
+        verify: verifyOpts,
+        persist: store && sessionId ? { store, sessionId } : undefined,
         onEvent: (ev) => {
             if (output === 'json') {
                 stdout.write(JSON.stringify(ev) + '\n');
@@ -98,8 +150,44 @@ export async function runOnce(opts) {
             else if (ev.kind === 'step_start') {
                 stderr.write(`\n[step ${ev.step}]\n`);
             }
+            else if (ev.kind === 'verification_started') {
+                stderr.write(`\n[verify] running \`${ev.command}\`\n`);
+            }
+            else if (ev.kind === 'verification_succeeded') {
+                stderr.write(`[verify] passed\n`);
+            }
+            else if (ev.kind === 'verification_failed') {
+                stderr.write(`[verify] failed — ${ev.reason.slice(0, 200)}\n`);
+            }
+            else if (ev.kind === 'repair_started') {
+                stderr.write(`[repair] attempt ${ev.attempt}/${ev.maxAttempts}\n`);
+            }
+            else if (ev.kind === 'checkpoint_saved') {
+                if (output === 'human')
+                    stderr.write(`[session ${ev.sessionId.slice(0, 8)} checkpoint]\n`);
+            }
         },
     }, { adapter, registry, policy, approval: new DenyAllApprovalPrompt(), systemPrompt });
+    if (store && sessionId) {
+        // Finalize session status
+        const statusMap = {
+            complete: 'complete',
+            max_steps: 'max_steps',
+            aborted: 'aborted',
+            no_final: 'aborted',
+            verify_failed: 'verify_failed',
+        };
+        try {
+            await store.setStatus(sessionId, statusMap[result.status] ?? 'complete', result.finalText);
+        }
+        catch { /* ignore */ }
+        if (output !== 'json' && output !== 'silent') {
+            stderr.write(`klyro: session ${sessionId.slice(0, 8)} ${result.status}`);
+            if (result.verification)
+                stderr.write(`  verify: ${result.verification.ok ? 'ok' : 'failed'} (${result.verification.attempts} attempts)`);
+            stderr.write('\n');
+        }
+    }
     if (output !== 'json')
         stdout.write('\n');
     if (result.status === 'max_steps') {
@@ -117,6 +205,13 @@ export async function runOnce(opts) {
             stderr.write('klyro: provider error — no final answer\n');
         return 4;
     }
+    if (result.status === 'verify_failed') {
+        if (output === 'json')
+            stdout.write(JSON.stringify({ kind: 'final', status: 'verify_failed', failureType: result.verification?.failureType }) + '\n');
+        else
+            stderr.write(`klyro: verification failed after ${result.verification?.attempts ?? 3} repairs — see output above\n`);
+        return 5;
+    }
     if (output === 'json')
         stdout.write(JSON.stringify({ kind: 'final', status: 'ok', text: result.finalText }) + '\n');
     return 0;

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

@@ -31,6 +31,16 @@ export type SlashCommand = {
     kind: 'quit';
 } | {
     kind: 'help';
+} | {
+    kind: 'config';
+} | {
+    kind: 'doctor';
+} | {
+    kind: 'version';
+} | {
+    kind: 'cost';
+} | {
+    kind: 'thinking';
 } | {
     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', 'plan', 'status', 'quit', 'help'];
+const KNOWN = ['clear', 'compact', 'model', 'diff', 'plan', 'status', 'quit', 'help', 'config', 'doctor', 'version', 'cost', 'thinking', 'exit', 'clear'];
 export function parse(input) {
     const trimmed = input.trim();
     if (!trimmed.startsWith('/')) {
@@ -29,11 +29,16 @@ export function parse(input) {
         case 'diff': return { kind: 'diff' };
         case 'plan': return { kind: 'plan' };
         case 'status': return { kind: 'status' };
+        case 'cost': return { kind: 'cost' };
+        case 'thinking': return { kind: 'thinking' };
         case 'quit':
         case 'exit':
         case 'q': return { kind: 'quit' };
         case 'help':
         case '?': return { kind: 'help' };
+        case 'config': return { kind: 'config' };
+        case 'doctor': return { kind: 'doctor' };
+        case 'version': return { kind: 'version' };
         case 'model':
         case 'm': {
             if (!rest)

package/dist/cli/trace.d.ts

@@ -0,0 +1,7 @@
+/**
+ * 3.1 — klyro trace <session> pretty-print, --stats
+ */
+export declare function runTrace(sessionId: string, opts?: {
+    stats?: boolean;
+    json?: boolean;
+}): Promise<number>;