klyro 1.0.16 → 1.0.18

package/dist/cli/doctor.js

@@ -6,7 +6,7 @@
 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 { spawn, execFileSync } from 'node:child_process';
 import { getConfigPath, loadConfig } from './config.js';
 import { resolveProvider, providerHelp } from '../providers.js';
 import { getDefaultSessionsDir } from '../persistence/session.js';
@@ -120,6 +120,45 @@ async function checkSandbox() {
         return { name: 'Sandbox', ok: true, detail: 'none — policy+path guards only' };
     }
 }
+function checkPackageManager() {
+    try {
+        const npm = execFileSync('npm', ['--version'], { encoding: 'utf-8', timeout: 5000 }).trim();
+        return { name: 'npm', ok: true, detail: `npm ${npm} ✓` };
+    }
+    catch {
+        return { name: 'npm', ok: false, detail: 'npm not on PATH — install Node ≥20' };
+    }
+}
+function checkPath() {
+    const pathVar = process.env.PATH ?? process.env.Path ?? '';
+    const nodeDir = process.execPath.includes('\\') || process.execPath.includes('/')
+        ? process.execPath.slice(0, Math.max(process.execPath.lastIndexOf('\\'), process.execPath.lastIndexOf('/')))
+        : '';
+    const onPath = !!pathVar && !!nodeDir && pathVar.toLowerCase().split(path.delimiter).some((p) => p.toLowerCase() === nodeDir.toLowerCase());
+    return { name: 'PATH', ok: true, detail: onPath ? `node dir on PATH ✓` : `node dir not on PATH (${nodeDir || 'unknown'}) — child shells may miss node` };
+}
+function checkRipgrep() {
+    try {
+        const v = execFileSync('rg', ['--version'], { encoding: 'utf-8', timeout: 5000 }).trim().split('\n')[0] ?? '';
+        return { name: 'ripgrep', ok: true, detail: `${v} ✓` };
+    }
+    catch {
+        return { name: 'ripgrep', ok: true, detail: 'not found — built-in grep tool is used instead' };
+    }
+}
+function checkTerminal() {
+    const isTTY = !!process.stdout.isTTY;
+    const term = process.env.TERM ?? '(unset)';
+    const cols = process.stdout.columns ?? 0;
+    return { name: 'Terminal', ok: true, detail: `${isTTY ? 'TTY' : 'non-TTY (headless/pipe mode)'}, TERM=${term}, cols=${cols}` };
+}
+function checkProxy() {
+    const vars = ['HTTP_PROXY', 'HTTPS_PROXY', 'NO_PROXY', 'http_proxy', 'https_proxy', 'no_proxy']
+        .filter((k) => process.env[k] && process.env[k].length > 0);
+    if (vars.length === 0)
+        return { name: 'Proxy', ok: true, detail: 'no proxy env — direct connections' };
+    return { name: 'Proxy', ok: true, detail: `${vars.join(', ')} set — honored for provider/web/update fetches` };
+}
 async function checkMcp(cwd) {
     try {
         const { loadMcpServers } = await import('../mcp/config.js');
@@ -169,14 +208,107 @@ async function checkTrust() {
         return { name: 'Trust stores', ok: true, detail: 'none' };
     }
 }
+/**
+ * Pure byte interpreter for `doctor --keys` (unit-tested): names what a
+ * terminal delivered so broken arrow/paste/scroll input becomes provable
+ * fact instead of guesswork. Covers arrows, paging/home/end, Ctrl codes,
+ * bracketed-paste markers, and SGR/X10 mouse sequences.
+ */
+export function describeKeyBytes(chunk) {
+    const s = chunk.toString('latin1');
+    switch (s) {
+        case '\x1b[A': return 'Up arrow (history prev)';
+        case '\x1b[B': return 'Down arrow (history next)';
+        case '\x1b[C': return 'Right arrow';
+        case '\x1b[D': return 'Left arrow';
+        case '\x1b[5~': return 'PageUp (scroll half-page up)';
+        case '\x1b[6~': return 'PageDown (scroll half-page down)';
+        case '\x1b[H':
+        case '\x1b[1~': return 'Home (jump top)';
+        case '\x1b[F':
+        case '\x1b[4~': return 'End (jump bottom)';
+        case '\x1b[Z': return 'Shift+Tab';
+        case '\r':
+        case '\n': return 'Enter';
+        case '\x7f': return 'Backspace';
+        case '\x1b': return 'Escape (lone — arrow/paste sequences arrive joined; lone ESC means the terminal split them or you pressed Esc)';
+        case '\x1b[200~': return 'Bracketed-paste START (terminal supports bulk paste)';
+        case '\x1b[201~': return 'Bracketed-paste END';
+        case '\x03': return 'Ctrl+C';
+        case '\x10': return 'Ctrl+P (history prev, escape-free)';
+        case '\x0e': return 'Ctrl+N (history next, escape-free)';
+        case '\x15': return 'Ctrl+U (scroll half-page up)';
+        case '\x04': return 'Ctrl+D (scroll half-page down)';
+        case '\x09': return 'Tab';
+    }
+    // eslint-disable-next-line no-control-regex -- intentional: parsing SGR mouse sequences requires ESC matching
+    if (/^\x1b\[<\d+;\d+;\d+[Mm]$/.test(s)) {
+        const cb = Number(s.slice(3).split(';')[0]);
+        return (cb & 64) !== 0
+            ? `Mouse wheel ${(cb & 1) === 0 ? 'up' : 'down'} (reporting active)`
+            : 'Mouse click/drag (reporting active — plain selection needs Shift+drag)';
+    }
+    // eslint-disable-next-line no-control-regex -- intentional: parsing X10 mouse sequences requires ESC matching
+    if (/^\x1b\[M...$/.test(s))
+        return 'Mouse event, X10 encoding (reporting active)';
+    if (/^[\x20-\x7e]+$/.test(s))
+        return `Printable text (${s.length} chars — typing/paste-as-typing works)`;
+    return 'Unrecognized sequence (terminal-specific — paste the bytes line into a bug report)';
+}
+/**
+ * Interactive key probe: raw-mode stdin echo of every chunk with its
+ * meaning. Proves what THIS terminal delivers for arrows, Ctrl+P/N,
+ * paste, and wheel — run it when TUI input misbehaves.
+ */
+export async function runKeysProbe() {
+    const stdin = process.stdin;
+    const stdout = process.stdout;
+    if (!stdin.isTTY || typeof stdin.setRawMode !== 'function') {
+        process.stderr.write('klyro: doctor --keys needs an interactive terminal (stdin is not a TTY)\n');
+        return 2;
+    }
+    stdout.write('klyro doctor --keys — press keys, see exactly what your terminal sends.\n');
+    stdout.write('Try: ↑ ↓ PgUp PgDn Home End Ctrl+P Ctrl+N, then paste text, then scroll the wheel. Ctrl+C quits.\n');
+    stdin.setRawMode(true);
+    stdin.resume();
+    try {
+        await new Promise((resolve) => {
+            const onData = (chunk) => {
+                const bytes = [...chunk].map((b) => b.toString(16).padStart(2, '0')).join(' ');
+                stdout.write(`bytes: ${bytes}  →  ${describeKeyBytes(chunk)}\n`);
+                if (chunk.length === 1 && chunk[0] === 0x03) {
+                    stdin.off('data', onData);
+                    resolve();
+                }
+            };
+            stdin.on('data', onData);
+        });
+    }
+    finally {
+        try {
+            stdin.setRawMode(false);
+        }
+        catch { /* ignore */ }
+        try {
+            stdin.pause();
+        }
+        catch { /* ignore */ }
+    }
+    return 0;
+}
 export async function runDoctor(opts = {}) {
     const cwd = opts.cwd ?? process.cwd();
     const checks = [];
     checks.push(checkNode());
+    checks.push(checkPackageManager());
+    checks.push(checkPath());
     checks.push(await checkConfig());
     checks.push(await checkProvider());
     checks.push(await checkSessions());
     checks.push(await checkGit());
+    checks.push(checkRipgrep());
+    checks.push(checkTerminal());
+    checks.push(checkProxy());
     checks.push(await checkTools());
     checks.push(checkPlatform());
     checks.push(await checkSandbox());

package/dist/cli/errors.js

@@ -5,7 +5,7 @@ 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);
+    const message = err instanceof Error ? err.message : String(err);
     let hint;
     if (err instanceof KlyroError) {
         code = err.exitCode;

package/dist/cli/eval.d.ts

@@ -81,6 +81,22 @@ export interface EvalResult {
     };
     /** Isolated workdir the scenario ran in (tmp unless --cwd). Debugging aid. */
     workDir?: string;
+    /** 5.4a — provider token usage for the scenario run. */
+    tokens?: {
+        input: number;
+        output: number;
+    };
+    /** 5.4a — estimated USD cost (runtime pricing helper, same rates as budgets). */
+    costUsd?: number;
+    /** 5.4a — distinct file paths referenced by tool-call inputs (best-effort). */
+    filesTouched?: string[];
+    /** 5.4a — verification outcome passthrough. */
+    verification?: {
+        ok: boolean;
+        attempts: number;
+    };
+    /** 5.4a — repair count passthrough. */
+    repairs?: number;
 }
 export interface RunEvalOptions {
     inputPath: string;
@@ -98,10 +114,26 @@ export interface RunEvalOptions {
      * touch the caller's directory. Pass explicitly to inspect artifacts.
      */
     cwd?: string;
+    /**
+     * 5.3 — `--auto-answer <text>`: sets `KLYRO_AUTO_ANSWER` before the run
+     * starts so headless `ask_user` calls resolve without prompting.
+     */
+    autoAnswer?: string;
 }
+/**
+ * 5.5a — curated stable subset of `evals/fixtures` for `--suite core`.
+ * Every entry has task.md + check.sh (verified 2026-09-24).
+ */
+export declare const CORE_SUITE_FIXTURES: string[];
+/**
+ * Filter directory names down to the core suite (in curated order).
+ * Exported for tests.
+ */
+export declare function selectCoreFixtures(entries: string[]): string[];
 export declare function runEval(opts: RunEvalOptions): Promise<number>;
 export declare function scriptedAdapterFromSpec(spec: Array<Array<unknown[]>> | undefined): ProviderAdapter;
 export declare function runScenario(sc: EvalScenario, judgeOpts?: {
     adapter: ProviderAdapter;
     model: string;
 }, workDir?: string): Promise<EvalResult>;
+export declare function collectFilesTouched(transcript: RunResult['transcript']): string[];

package/dist/cli/eval.js

@@ -45,11 +45,26 @@ import * as os from 'node:os';
 import * as path from 'node:path';
 import * as readline from 'node:readline/promises';
 import { stdin as input, stdout, stderr } from 'node:process';
-import { run } from '../agent/runtime.js';
+import { run, estimateCost } from '../agent/runtime.js';
+import { applyAutoAnswer } from './args.js';
 import { builtinRegistry } from '../tools/registry.js';
 import { builtinRules, DEFAULT_POLICY_CONFIG, PolicyEngine } from '../policy/engine.js';
 import { DenyAllApprovalPrompt } from '../policy/approval.js';
+/**
+ * 5.5a — curated stable subset of `evals/fixtures` for `--suite core`.
+ * Every entry has task.md + check.sh (verified 2026-09-24).
+ */
+export const CORE_SUITE_FIXTURES = ['read-answer', 'add-fn-test', 'fix-failing-test', 'rename', 'cli-flag'];
+/**
+ * Filter directory names down to the core suite (in curated order).
+ * Exported for tests.
+ */
+export function selectCoreFixtures(entries) {
+    return CORE_SUITE_FIXTURES.filter((id) => entries.includes(id));
+}
 export async function runEval(opts) {
+    // 5.3 — --auto-answer sets KLYRO_AUTO_ANSWER before anything runs.
+    applyAutoAnswer(opts.autoAnswer);
     // Live judge adapter (shared by suite + JSONL paths) for `judge.rubric`.
     let judgeAdapter;
     if (opts.judgeModel) {
@@ -65,20 +80,24 @@ export async function runEval(opts) {
     }
     // 5.4 — suite mode: load from evals/fixtures
     if (opts.suite) {
-        const { runHarness, loadFileFixture } = await import('../eval/harness.js');
+        const suiteStart = Date.now();
         const fs = await import('node:fs/promises');
         const path = await import('node:path');
-        const suiteDir = path.join(process.cwd(), 'evals', 'fixtures', opts.suite === 'smoke' ? '' : opts.suite);
         // For smoke, use the 10 fixtures directly
         const fixturesDir = path.join(process.cwd(), 'evals', 'fixtures');
-        let tasks = [];
+        const tasks = [];
         try {
             const entries = await fs.readdir(fixturesDir);
             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') {
+                // 5.5a — core = curated stable subset (see CORE_SUITE_FIXTURES).
+                if (opts.suite === 'core') {
+                    if (!CORE_SUITE_FIXTURES.includes(e))
+                        continue;
+                    // 6.5 — suite filter: smoke = type smoke, l6 = prefix l6-introduce
+                }
+                else if (opts.suite && opts.suite !== 'smoke') {
                     if (!e.startsWith(opts.suite) && !e.includes(opts.suite))
                         continue;
                 }
@@ -143,6 +162,16 @@ export async function runEval(opts) {
             await fs.mkdir(outDir, { recursive: true });
             const ts = new Date().toISOString().replace(/[:.]/g, '-');
             await fs.writeFile(path.join(outDir, `${ts}.json`), JSON.stringify({ suite: opts.suite, results }, null, 2));
+            // 5.5b — refresh the tracked baseline with environment metadata.
+            const { collectBaselineMetadata, buildEvalBaseline, writeEvalBaseline } = await import('../eval/baseline.js');
+            const meta = collectBaselineMetadata({ model: opts.model });
+            await writeEvalBaseline(outDir, buildEvalBaseline(meta, {
+                suite: opts.suite ?? '',
+                total: results.length,
+                passed,
+                failed: results.length - passed,
+                durationMs: Date.now() - suiteStart,
+            }));
         }
         catch { /* ignore */ }
         return passed === results.length ? 0 : 1;
@@ -167,6 +196,18 @@ export async function runEval(opts) {
             stdout.write(`[${tag}] ${r.name} (${r.durationMs}ms, ${r.steps} steps, ${r.toolCalls} tools)\n`);
             for (const f of r.failures)
                 stdout.write(`         - ${f}\n`);
+            // 5.4a — rich record extras (tokens/cost/files/verification).
+            const extras = [];
+            if (r.tokens)
+                extras.push(`${r.tokens.input} in/${r.tokens.output} out`);
+            if (r.costUsd !== undefined)
+                extras.push(`$${r.costUsd.toFixed(4)}`);
+            if (r.filesTouched && r.filesTouched.length > 0)
+                extras.push(`${r.filesTouched.length} files`);
+            if (r.verification)
+                extras.push(`verify:${r.verification.ok ? 'ok' : 'fail'}`);
+            if (extras.length > 0)
+                stdout.write(`         · ${extras.join(' · ')}\n`);
         }
     }
     const passed = results.filter((r) => r.passed).length;
@@ -334,5 +375,41 @@ export async function runScenario(sc, judgeOpts, workDir) {
         durationMs: 0,
         workDir: cwd,
         ...(judge ? { judge } : {}),
+        // 5.4a — rich records mapped from RunResult (cost reuses the runtime
+        // pricing helper, the same rates the budget code uses).
+        tokens: { input: result.usage.input, output: result.usage.output },
+        costUsd: estimateCost(model, result.usage),
+        filesTouched: collectFilesTouched(result.transcript),
+        ...(result.verification
+            ? { verification: { ok: result.verification.ok, attempts: result.verification.attempts } }
+            : {}),
+        ...(result.repairs !== undefined ? { repairs: result.repairs } : {}),
     };
 }
+/**
+ * 5.4a — best-effort distinct file paths from tool-call inputs in a run
+ * transcript. Looks for common path-ish keys on `tool_use` blocks.
+ * Exported for tests.
+ */
+const FILE_PATH_KEYS = ['path', 'file', 'filePath', 'filename', 'target'];
+export function collectFilesTouched(transcript) {
+    const seen = new Set();
+    for (const m of transcript) {
+        for (const b of m.content) {
+            if (b.kind !== 'tool_use')
+                continue;
+            const input = b.input;
+            for (const k of FILE_PATH_KEYS) {
+                const v = input[k];
+                if (typeof v === 'string' && v.length > 0)
+                    seen.add(v);
+                else if (Array.isArray(v)) {
+                    for (const e of v)
+                        if (typeof e === 'string' && e.length > 0)
+                            seen.add(e);
+                }
+            }
+        }
+    }
+    return [...seen].sort();
+}

package/dist/cli/markdown.js

@@ -38,7 +38,7 @@ export function renderMarkdown(md, opts = {}) {
     const lines = md.split('\n');
     let inCodeBlock = false;
     let fenceLang = '';
-    for (let line of lines) {
+    for (const line of lines) {
         if (line.startsWith('```')) {
             if (!inCodeBlock)
                 fenceLang = line.replace(/^```/, '').trim().toLowerCase();

package/dist/cli/repl.js

@@ -103,6 +103,7 @@ export async function startRepl(opts = {}) {
     // sanitizeForPrompt in sibling-owned policy/approval.ts — intentionally
     // not imported; kept local to avoid coupling the REPL to that module).
     function sanitizeForPrompt(s) {
+        // eslint-disable-next-line no-control-regex -- intentional: stripping C0 controls + CSI sequences
         return s.replace(/[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]|\x1b\[[0-9;]*[A-Za-z]/g, '').slice(0, 120);
     }
     async function loadMcpTools() {
@@ -190,7 +191,7 @@ export async function startRepl(opts = {}) {
     // become fallback adapters for agent runs in this session. Live
     // /provider switches rebuild a single adapter (buildAdapter) and bypass
     // the chain — documented, not a bug.
-    let replFailoverAdapters = [];
+    const replFailoverAdapters = [];
     try {
         const { resolveProviderChain } = await import('./config.js');
         const chain = await resolveProviderChain(cwd);
@@ -372,11 +373,12 @@ export async function startRepl(opts = {}) {
     // ── Full-screen takeover like OpenCode — always when klyro in TTY (user explicitly wants it)
     // Scroll now works correctly via internal viewport, not native terminal scroll
     const isAltScreen = useTui && !!process.stdout.isTTY && process.env.KLYRO_NO_ALT !== '1';
-    // Mouse reporting is opt-in (KLYRO_MOUSE=1): when on, the terminal sends
-    // clicks/wheel to the app (wheel scrolls ±3 lines) but native text
-    // selection and right-click paste stop working. Default off so select to
-    // copy and right-click paste work out of the box; bracketed paste
-    // (keyboard paste) is unaffected and always enabled below.
+    // Mouse reporting is ON by default (opencode parity): the wheel scrolls
+    // the chat, clicks are swallowed by the app. That means plain mouse
+    // selection/right-click go to the app, not the terminal — use Shift+drag
+    // to select and Shift+right-click to paste, or set KLYRO_MOUSE=0 for fully
+    // native selection (then scroll with PgUp/PgDn, Ctrl+U/D, Shift+↑/↓,
+    // Home/End, Space). Bracketed (keyboard) paste is unaffected and always on.
     const mouseReporting = isAltScreen && isMouseReportingEnabled();
     const enterAlt = () => {
         if (!isAltScreen)
@@ -501,8 +503,9 @@ export async function startRepl(opts = {}) {
             if (consoleRing.length > 200)
                 consoleRing.splice(0, consoleRing.length - 200);
             try {
+                // KLYRO_LOG_DIR relocates the debug log (1.5); default is ~/.klyro.
                 const home = process.env.HOME ?? process.env.USERPROFILE ?? cwd;
-                const dir = nodePath.join(home, '.klyro');
+                const dir = process.env.KLYRO_LOG_DIR ?? nodePath.join(home, '.klyro');
                 fsSync.mkdirSync(dir, { recursive: true });
                 const logFile = nodePath.join(dir, 'debug.log');
                 // Rotation: never let the debug log grow without bound (2 MiB cap).
@@ -724,6 +727,7 @@ export async function startRepl(opts = {}) {
         }
         catch { /* silent */ }
     })();
+    // eslint-disable-next-line prefer-const -- single assignment, but `let` is required: declaration precedes this for TDZ-safe handler wiring.
     app = render(React.createElement(App, {
         initialModel: model,
         maxSteps: currentMaxSteps,
@@ -778,6 +782,7 @@ export async function startRepl(opts = {}) {
     }), { patchConsole: false });
     // Install SIGINT handler only after app exists (avoids TDZ) and use once
     // On Ctrl+C in alt-screen, leave alt before exit so shell is restored
+    // eslint-disable-next-line prefer-const -- see above: declaration order is load-bearing.
     sigintHandler = () => {
         ac.abort();
         queuedStatus({ status: 'aborted' });
@@ -861,9 +866,6 @@ export async function startRepl(opts = {}) {
                 return;
             }
         }
-        let activeCallId = null;
-        let activeCallName = null;
-        let activeCallArgs = '';
         let runEndStatus = 'error';
         try {
             const result = await run({
@@ -902,14 +904,6 @@ export async function startRepl(opts = {}) {
                     else if (ev.kind === 'checkpoint_saved') {
                         queuedStatus({ status: 'running' });
                     }
-                    else if (ev.kind === 'tool_call_start') {
-                        activeCallId = ev.id;
-                        activeCallName = ev.name;
-                        activeCallArgs = '';
-                    }
-                    else if (ev.kind === 'tool_call_delta') {
-                        activeCallArgs += ev.argsJson;
-                    }
                     else if (ev.kind === 'tool_call_end') {
                         pendingToolIds.add(ev.id);
                         queuedAppend({
@@ -920,9 +914,6 @@ export async function startRepl(opts = {}) {
                             args: JSON.stringify(ev.input, null, 2),
                             status: 'running',
                         });
-                        activeCallId = null;
-                        activeCallName = null;
-                        activeCallArgs = '';
                     }
                     else if (ev.kind === 'policy_decision') {
                         queuedAppend({
@@ -1354,8 +1345,6 @@ export async function startRepl(opts = {}) {
             }
             case 'context': {
                 const { renderContextBreakdown } = await import('./context.js');
-                // use last transcript via closure? approximate with empty
-                const { accounting } = await import('../context/accounting.js');
                 const sys = ''; // system prompt approx
                 const breakdown = renderContextBreakdown(sys, []);
                 queuedAppend({ id: `ctx-${Date.now()}`, kind: 'text', text: breakdown, role: 'assistant' });
@@ -2689,7 +2678,7 @@ export async function startRepl(opts = {}) {
                         '  Enter send · Shift+Enter newline · Tab complete slash · Esc drop queued / Esc×2 cancel run',
                         '  Ctrl+C cancel (1st) / quit (2nd) · Ctrl+O expand last tool group · Ctrl+G jump bottom',
                         '  PgUp/PgDn or Ctrl+U/Ctrl+D half-page · Ctrl+Home/End top/bottom · Home/End jump · Space jump to unread',
-                        '  Ctrl+B/F page · Shift/Ctrl+↑/↓ line · ↑/↓ and Ctrl+P/N browse input history only · PgUp/Dn or Ctrl+U/D scroll · wheel scrolls with KLYRO_MOUSE=1',
+                        '  Ctrl+B/F page · Shift/Ctrl+↑/↓ line · ↑/↓ and Ctrl+P/N browse input history only · wheel scrolls · PgUp/Dn or Ctrl+U/D scroll · KLYRO_MOUSE=0 for native selection',
                         '  Text selection/copy and right-click paste work natively · Shift+Enter newline · /vim toggles vim input mode · /keymap <note> saves a display note',
                     ].join('\n'),
                 });

package/dist/cli/run.d.ts

@@ -15,9 +15,25 @@ export interface RunCliOptions {
     cwd: string;
     model: string;
     maxSteps?: number;
+    /** Alias for maxSteps (3.5) — when both are set, the smaller wins. */
+    maxTurns?: number;
     maxTokens?: number;
     temperature?: number;
+    /** Reasoning effort for reasoning models (OpenAI `reasoning_effort`). */
+    reasoningEffort?: 'low' | 'medium' | 'high';
     systemPrompt?: SystemPromptFn;
+    /** Replace the assembled system prompt wholesale (2.3). */
+    systemPromptText?: string;
+    /** Extra instructions appended after the assembled system prompt (2.3). */
+    appendSystemPrompt?: string;
+    /** Permission mode override (3.4): default|accept-edits|plan|auto. */
+    permissionMode?: import('../policy/engine.js').PermissionMode;
+    /** Tool names pre-approved for this run (added to allow rules). */
+    allowedTools?: string[] | string;
+    /** Tool names denied for this run (deny always wins). */
+    disallowedTools?: string[] | string;
+    /** Extra sandbox directories, as with /add-dir. */
+    addDir?: string[] | string;
     baseUrl?: string;
     apiKey?: string;
     timeoutMs?: number;
@@ -75,7 +91,28 @@ export interface RunCliOptions {
     /** P1.4 — run the task under a named child-capable orchestrator context. */
     agent?: string;
     maxDepth?: number;
+    /**
+     * 5.3 — `--auto-answer <text>`: answer `ask_user` prompts headlessly.
+     * Applied to `process.env.KLYRO_AUTO_ANSWER` at the top of `runOnce`.
+     */
+    autoAnswer?: string;
 }
+/**
+ * Split a comma-separated tool/dir list (string or string[]) into names.
+ * Exported for tests.
+ */
+export declare function splitToolList(v: string[] | string | undefined): string[];
+/** Smaller of two optional caps (--max-turns aliases --max-steps). Exported for tests. */
+export declare function minDefined(a: number | undefined, b: number | undefined): number | undefined;
+/**
+ * Layer --system-prompt/--append-system-prompt over the assembled prompt
+ * (2.3): replace wins wholesale, append rides after the assembled system
+ * (preserving any suffix the base carries). Exported for tests.
+ */
+export declare function withSystemPromptOverrides(base: SystemPromptFn, opts: {
+    replace?: string;
+    append?: string;
+}): SystemPromptFn;
 /**
  * Double-Ctrl+C detector (pure, exported for tests): the second SIGINT
  * within 1500ms of the first forces `process.exit(130)`. The live handler