klyro 0.1.3 → 0.1.5

package/dist/cli/repl.js

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

package/dist/cli/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;