klyro 1.0.4 → 1.0.5

package/README.md

@@ -26,6 +26,35 @@ node dist/index.js chat "Explain TypeScript in 2 sentences"
 node dist/index.js chat
 ```
 
+## Exit codes
+
+| Code | Meaning |
+|---|---|
+| 0 | Success / complete |
+| 1 | Unexpected failure (last-resort handler) |
+| 2 | Usage / config error, policy refusal to commit, unknown command or option |
+| 3 | Config invalid / not found |
+| 4 | Provider error (auth, rate-limit, timeout) |
+| 5 | No final answer from provider |
+| 7 | Stopped: max steps, cost/time limit, or stuck |
+| 8 | Verification failed (or `--require-verify` unsatisfied) |
+| 130 | Aborted (Ctrl+C / Esc×2 / /cancel / SIGINT) |
+
+## Environment
+
+| Variable | Scope |
+|---|---|
+| `KLYRO_BASE_URL`, `KLYRO_API_KEY`, `KLYRO_MODEL`, `KLYRO_PROVIDER` | Provider selection |
+| `KLYRO_CONFIG` / `--config` | Config file override |
+| `KLYRO_YES` / `--yes` | **Commit only** — auto-approves `klyro commit` prompts; nothing else reads it |
+| `KLYRO_NO_UPDATE_CHECK=1` | Disables the 24h update check |
+| `KLYRO_ALLOW_MAIN_PUSH=1` | Per-risk escape for protected-branch push |
+| `KLYRO_CREDENTIALS_INSECURE_OK=1` | Warn (don't refuse) on group-readable credentials |
+| `KLYRO_LSP=0` | Force language tools off |
+| `KLYRO_SYMBOLS=0` | Force `find_symbol` off |
+| `KLYRO_WORKER=0` | Disable subprocess isolation for subagents |
+| `KLYRO_SESSIONS_DIR`, `KLYRO_UPDATE_CACHE`, `KLYRO_CREDENTIALS_FILE` | Relocatable state (tests + power users) |
+
 ## Documentation
 
 | Doc | Purpose |

package/dist/agent/runtime.js

@@ -23,11 +23,13 @@ import { verify, diagnosticForModel } from '../verification/engine.js';
 import { detectVerifyCommand } from '../verification/auto.js';
 import { ensureBaseline, getBaseline } from '../verification/baseline.js';
 import { compressTranscript, totalTokens, calibrateEstimate, transcriptCharLength } from '../context/tokenizer.js';
+import { capForModel } from '../context/accounting.js';
 import { ratesFor, isAnthropicModel } from '../providers/model-info.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';
+import { killAllJobs } from '../tools/shell/background.js';
 import { loadHooks, runHook } from '../cli/hooks.js';
 /** Normalize either systemPrompt shape into {system, suffix}. */
 export function resolveSystemPrompt(fn, ctx) {
@@ -267,6 +269,9 @@ export async function run(opts, deps) {
         }
         if (opts.signal?.aborted) {
             emit?.({ kind: 'aborted' });
+            // Abort cascade (fix: background shells must not outlive the run).
+            const killed = killAllJobs();
+            emitKlyro({ type: 'abort', ts: Date.now(), sessionId: sessionId ?? 'ephemeral', reason: killed.length > 0 ? `aborted by operator (${killed.length} background job(s) killed)` : 'aborted by operator' });
             if (store && sessionId) {
                 try {
                     await store.setStatus(sessionId, 'aborted', finalText);
@@ -297,7 +302,9 @@ export async function run(opts, deps) {
         // Budget accounting sees what the model sees (prefix + suffix); the
         // request itself keeps the halves split for cache-friendly adapters.
         const systemForBudget = telemetrySuffix ? `${stableSystem}\n\n${telemetrySuffix}` : stableSystem;
-        const BUDGET = { total: 120_000, reservedOutput: 4000 };
+        // Window-aware ceiling (was a hardcoded 120k that overflowed 8k local
+        // models): size the input budget to the model's context window.
+        const BUDGET = { total: capForModel(opts.model, 4000), reservedOutput: 4000 };
         let reqMessages = transcript;
         let reqSystem = stableSystem;
         let reqSuffix = telemetrySuffix;
@@ -530,6 +537,8 @@ export async function run(opts, deps) {
         if (opts.signal?.aborted) {
             finalText = textBuf;
             emit?.({ kind: 'aborted' });
+            const killed = killAllJobs();
+            emitKlyro({ type: 'abort', ts: Date.now(), sessionId: sessionId ?? 'ephemeral', reason: killed.length > 0 ? `aborted by operator (${killed.length} background job(s) killed)` : 'aborted by operator' });
             if (store && sessionId) {
                 try {
                     await store.setStatus(sessionId, 'aborted', finalText);
@@ -824,7 +833,7 @@ export async function run(opts, deps) {
         // results immediately — gate runs in call order so these stay ordered.
         // Returns true when the call is approved for execution.
         const gateCall = async (call) => {
-            const decision = await deps.policy.evaluate({ name: call.name, input: call.input }, { cwd: opts.cwd, nonInteractive: opts.nonInteractive });
+            const decision = await deps.policy.evaluate({ name: call.name, input: call.input, permission: deps.registry.get(call.name)?.permission }, { cwd: opts.cwd, nonInteractive: opts.nonInteractive });
             emit?.({ kind: 'policy_decision', id: call.id, name: call.name, action: decision.action, ...(decision.action !== 'allow' ? { reason: decision.reason } : {}) });
             // Mirror to KlyroEvent bus
             if (decision.action === 'allow') {

package/dist/cli/auth.js

@@ -132,13 +132,21 @@ export async function runLogout(provider) {
 }
 export function getStoredKey(provider) {
     try {
-        // Warn (don't refuse) when the credentials file is group/other-readable.
-        // Refusing would lock out existing users with old umasks; warn instead.
+        // Refuse (don't just warn) when the credentials file is
+        // group/other-readable: a key other users can read is compromised by
+        // definition. Repair hint included. KLYRO_CREDENTIALS_INSECURE_OK=1
+        // preserves the old warn-and-continue behavior for exotic setups.
         if (process.platform !== 'win32') {
             try {
                 const st = fsSync.statSync(credPath());
                 if ((st.mode & 0o077) !== 0) {
-                    process.stderr.write(`warning: credentials file ${credPath()} is group/other-readable (mode ${(st.mode & 0o777).toString(8)}) — run chmod 600 on it\n`);
+                    if (process.env.KLYRO_CREDENTIALS_INSECURE_OK === '1') {
+                        process.stderr.write(`warning: credentials file ${credPath()} is group/other-readable (mode ${(st.mode & 0o777).toString(8)}) — run chmod 600 on it\n`);
+                    }
+                    else {
+                        process.stderr.write(`klyro: refusing to use group/other-readable credentials file ${credPath()} (mode ${(st.mode & 0o777).toString(8)}) — run: chmod 600 ${credPath()} (or set KLYRO_CREDENTIALS_INSECURE_OK=1 to override)\n`);
+                        return undefined;
+                    }
                 }
             }
             catch { /* missing file → no warning */ }

package/dist/cli/completion.js

@@ -2,40 +2,93 @@
  * 1.2 — klyro completion
  * Generates shell completion scripts for bash/zsh/fish/powershell.
  */
-const COMMANDS = ['tui', 'run', 'chat', 'config', 'doctor', 'completion', 'update', 'eval', 'session', 'resume', 'help', 'version'];
+const COMMANDS = ['tui', 'run', 'chat', 'config', 'doctor', 'completion', 'update', 'eval', 'session', 'resume', 'help', 'version', 'scan', 'project', 'mcp', 'hooks', 'agents', 'commit', 'audit', 'benchmark', 'sessions', 'login', 'logout'];
+/** Second-level completion: global flags + per-command flags. */
+const GLOBAL_FLAGS = ['--cwd', '--config', '--debug', '--verbose', '--quiet', '--json', '--yes', '--no-color', '--print', '--output-format', '--no-stream', '--show-thinking', '--tui', '--chat', '--continue', '--resume', '--help', '--version'];
+const COMMAND_FLAGS = {
+    run: ['-m', '--model', '--max-steps', '--max-tokens', '--temperature', '--timeout', '--base-url', '--api-key', '--output', '--provider', '--dry-run', '--resume', '--resume-session', '--verify', '--verify-command', '--verify-mode', '--max-repairs', '--persist', '--require-verify', '--agent', '--max-depth'],
+    chat: ['-s', '--system', '-m', '--model', '-t', '--timeout'],
+    eval: ['--output', '--suite', '--filter', '--runs', '--parallel', '--model'],
+    tui: ['-m', '--model', '--max-steps'],
+    doctor: ['--json'],
+    session: ['list', 'show', 'resume', 'fork', 'delete'],
+    sessions: ['export', 'import', 'fork', 'delete'],
+    mcp: ['list', 'add', 'remove', 'probe', 'serve'],
+    config: ['list', 'get', 'set', 'unset', 'path'],
+    commit: ['--dry-run', '--message', '--force-secret'],
+    completion: ['bash', 'zsh', 'fish', 'powershell'],
+    resume: ['-m', '--model', '--max-steps'],
+};
+function flagsFor(cmd) {
+    return [...GLOBAL_FLAGS, ...(COMMAND_FLAGS[cmd] ?? [])];
+}
 function bashScript() {
-    return `# klyro bash completion
+    const cmdCases = Object.entries(COMMAND_FLAGS)
+        .map(([c, fs]) => `      ${c}) opts="${fs.join(' ')}" ;;`)
+        .join('\n');
+    return `# klyro bash completion (commands + flags)
 _klyro_complete() {
   local cur="\${COMP_WORDS[COMP_CWORD]}"
+  local prev="\${COMP_WORDS[COMP_CWORD-1]}"
   local cmds="${COMMANDS.join(' ')}"
-  COMPREPLY=( $(compgen -W "$cmds" -- "$cur") )
+  if [[ $COMP_CWORD -eq 1 ]]; then
+    COMPREPLY=( $(compgen -W "$cmds ${GLOBAL_FLAGS.join(' ')}" -- "$cur") )
+    return
+  fi
+  local first="\${COMP_WORDS[1]}"
+  local opts=""
+  case "$first" in
+${cmdCases}
+    *) opts="${GLOBAL_FLAGS.join(' ')}" ;;
+  esac
+  COMPREPLY=( $(compgen -W "$opts" -- "$cur") )
 }
 complete -F _klyro_complete klyro
 complete -F _klyro_complete ky
 `;
 }
 function zshScript() {
+    const cmdCases = Object.entries(COMMAND_FLAGS)
+        .map(([c, fs]) => `      ${c}) _values 'flags' ${fs.map((f) => `'${f}'`).join(' ')} ;;`)
+        .join('\n');
     return `#compdef klyro ky
 _klyro() {
-  local -a completions
-  completions=(${COMMANDS.map((c) => `'${c}'`).join(' ')})
-  _describe 'klyro commands' completions
+  if (( CURRENT == 2 )); then
+    _describe 'klyro commands' ${COMMANDS.map((c) => `'${c}'`).join(' ')} ${GLOBAL_FLAGS.map((f) => `'${f}'`).join(' ')}
+    return
+  fi
+  case "$words[2]" in
+${cmdCases}
+    *) _values 'flags' ${GLOBAL_FLAGS.map((f) => `'${f}'`).join(' ')} ;;
+  esac
 }
 compdef _klyro klyro ky
 `;
 }
 function fishScript() {
-    return `# klyro fish completion
-${COMMANDS.map((c) => `complete -c klyro -f -a ${c}`).join('\n')}
+    const flagLines = Object.entries(COMMAND_FLAGS)
+        .flatMap(([c, fs]) => fs.map((f) => `complete -c klyro -f -n "__fish_seen_subcommand_from ${c}" -a ${f}`))
+        .join('\n');
+    return `# klyro fish completion (commands + flags)
+${COMMANDS.map((c) => `complete -c klyro -f -n __fish_use_subcommand -a ${c}`).join('\n')}
+${flagLines}
 complete -c ky -f -a "${COMMANDS.join(' ')}"
 `;
 }
 function powershellScript() {
-    return `# klyro powershell completion
+    return `# klyro powershell completion (commands + flags)
 Register-ArgumentCompleter -Native -CommandName klyro,ky -ScriptBlock {
   param($wordToComplete, $commandAst, $cursorPosition)
   $cmds = @(${COMMANDS.map((c) => `'${c}'`).join(', ')})
-  $cmds | Where-Object { $_ -like "$wordToComplete*" } | ForEach-Object {
+  $flags = @(${GLOBAL_FLAGS.map((f) => `'${f}'`).join(', ')})
+  $tokens = $commandAst.ToString() -split '\\s+'
+  if ($tokens.Count -le 2) { $cands = $cmds + $flags } else {
+    switch ($tokens[1]) {
+${Object.entries(COMMAND_FLAGS).map(([c, fs]) => `      '${c}' { $cands = @(${fs.map((f) => `'${f}'`).join(', ')}) }`).join('\n')}
+      default { $cands = $flags }
+    }
+  }
+  $cands | Where-Object { $_ -like "$wordToComplete*" } | ForEach-Object {
     [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterValue', $_)
   }
 }

package/dist/cli/doctor.js

@@ -108,6 +108,18 @@ function checkPlatform() {
     const ok = ['win32', 'linux', 'darwin'].includes(process.platform);
     return { name: 'Platform', ok, detail: `${process.platform} ${process.arch} ${ok ? '✓' : '✗ unsupported'}` };
 }
+async function checkSandbox() {
+    try {
+        const { detectSandbox } = await import('../tools/shell/sandbox.js');
+        const st = detectSandbox();
+        if (st.active)
+            return { name: 'Sandbox', ok: true, detail: `${st.backend} ✓` };
+        return { name: 'Sandbox', ok: true, detail: `none — ${st.reason ?? 'policy+path guards only'}` };
+    }
+    catch {
+        return { name: 'Sandbox', ok: true, detail: 'none — policy+path guards only' };
+    }
+}
 async function checkMcp(cwd) {
     try {
         const { loadMcpServers } = await import('../mcp/config.js');
@@ -167,6 +179,7 @@ export async function runDoctor(opts = {}) {
     checks.push(await checkGit());
     checks.push(await checkTools());
     checks.push(checkPlatform());
+    checks.push(await checkSandbox());
     const mcpCheck = await checkMcp(cwd);
     const trustCheck = await checkTrust();
     checks.push(mcpCheck);

package/dist/cli/repl.js

@@ -25,7 +25,7 @@ import { parseUnifiedDiff } from '../tui/diff-parser.js';
 import { parse } from './slash/parser.js';
 import { resolveProvider, providerHelp, lastProviderError } from '../providers.js';
 import { readVersion } from '../version.js';
-import { MouseFilter, MOUSE_ENABLE, MOUSE_DISABLE, createReadWrapper } from '../tui/mouse.js';
+import { MouseFilter, MOUSE_ENABLE, MOUSE_DISABLE, PASTE_ENABLE, PASTE_DISABLE, PasteFilter, createReadWrapper } from '../tui/mouse.js';
 import { inferProviderFromBaseURL } from '../agent/registry.js';
 import { getDefaultSessionStore } from '../persistence/session.js';
 import { buildSystemPrompt, parseImageInput } from '../context/system-prompt.js';
@@ -291,6 +291,8 @@ export async function startRepl(opts = {}) {
     let lastStatus = null;
     const pendingQueue = [];
     let isMounted = false;
+    // Live vim input mode for the TUI (toggled by /vim, persisted to config).
+    let vimLive = 'insert';
     let directHooks;
     // Plain-text mirror for exit replay (scroll.md §1.2: session survives in
     // native scrollback after the alt screen is torn down). Cap 300 lines.
@@ -393,6 +395,7 @@ export async function startRepl(opts = {}) {
     // IMPORTANT: Ink 7 reads stdin via 'readable' + stdin.read() (paused mode),
     // never 'data' events — so the tap wraps read(), not emit().
     const mouseFilter = new MouseFilter();
+    const pasteFilter = new PasteFilter();
     const origStdinRead = process.stdin.read.bind(process.stdin);
     const origStdinEmit = process.stdin.emit.bind(process.stdin);
     let mouseTapInstalled = false;
@@ -405,18 +408,36 @@ export async function startRepl(opts = {}) {
             catch { /* ignore */ }
         }
     }
+    // Bracketed paste: bulk-insert into the input buffer instead of
+    // char-at-a-time typing (no autocomplete/history churn per char).
+    function dispatchPastes(pastes) {
+        for (const p of pastes) {
+            try {
+                if (isMounted && directHooks)
+                    directHooks.pasteText(p);
+            }
+            catch { /* ignore */ }
+        }
+    }
     function installMouseTap() {
         if (!isAltScreen || mouseTapInstalled)
             return;
         mouseTapInstalled = true;
+        // Bracketed paste on: the terminal wraps pastes in ESC[200~ … ESC[201~.
+        try {
+            process.stdout.write(PASTE_ENABLE);
+        }
+        catch { /* ignore */ }
         const stdinAny = process.stdin;
         // Primary path: Ink's paused-mode read loop.
-        stdinAny.read = createReadWrapper(origStdinRead, mouseFilter, (d) => dispatchWheels([d]));
+        stdinAny.read = createReadWrapper(origStdinRead, mouseFilter, (d) => dispatchWheels([d]), { onPaste: (p) => dispatchPastes([p]), pasteFilter });
         // Fallback path: flowing mode ('data' events), e.g. if any library
         // resumes the stream. Same split, same dispatch.
         stdinAny.emit = (...a) => {
             if (a[0] === 'data' && Buffer.isBuffer(a[1])) {
-                const split = mouseFilter.push(a[1]);
+                const psplit = pasteFilter.push(a[1]);
+                dispatchPastes(psplit.pastes);
+                const split = mouseFilter.push(psplit.kept);
                 dispatchWheels(split.wheels);
                 if (split.kept.length === 0)
                     return false;
@@ -430,6 +451,11 @@ export async function startRepl(opts = {}) {
             return;
         mouseTapInstalled = false;
         mouseFilter.reset();
+        pasteFilter.reset();
+        try {
+            process.stdout.write(PASTE_DISABLE);
+        }
+        catch { /* ignore */ }
         const stdinAny = process.stdin;
         stdinAny.read = origStdinRead;
         stdinAny.emit = origStdinEmit;
@@ -457,7 +483,9 @@ export async function startRepl(opts = {}) {
         if (!isAltScreen)
             return;
         const sink = (...args) => {
-            const line = `[${new Date().toISOString()}] ${args.map((a) => (typeof a === 'string' ? a : JSON.stringify(a))).join(' ')}`;
+            // Scrub secrets before the line reaches the ring buffer or disk —
+            // stray provider/tool logs must never persist credentials.
+            const line = redact(`[${new Date().toISOString()}] ${args.map((a) => (typeof a === 'string' ? a : JSON.stringify(a))).join(' ')}`);
             consoleRing.push(line);
             if (consoleRing.length > 200)
                 consoleRing.splice(0, consoleRing.length - 200);
@@ -700,6 +728,13 @@ export async function startRepl(opts = {}) {
         onMounted: (hooks) => {
             directHooks = hooks;
             isMounted = true;
+            // Apply a live vim mode toggled before mount.
+            if (vimLive !== 'insert') {
+                try {
+                    hooks.setVimMode(vimLive);
+                }
+                catch { /* ignore */ }
+            }
             for (const ev of pendingQueue) {
                 if (ev.kind === 'status')
                     hooks.updateStatus(ev.patch);
@@ -1050,7 +1085,14 @@ export async function startRepl(opts = {}) {
                 return;
             }
             case 'memory': {
-                queuedAppend({ id: `mem-${Date.now()}`, kind: 'text', text: 'Memory: .klyro/memory/session-notes.md (stub) — use /memory to view', role: 'assistant' });
+                const { loadMemory } = await import('../context/memory.js');
+                const notes = (await loadMemory(cwd)).trim();
+                queuedAppend({
+                    id: `mem-${Date.now()}`,
+                    kind: 'text',
+                    text: notes ? `Memory (.klyro/memory/session-notes.md):\n${notes.slice(0, 4000)}` : 'Memory is empty — the agent records durable notes here via memory_write.',
+                    role: 'assistant',
+                });
                 return;
             }
             case 'jobs': {
@@ -1613,8 +1655,13 @@ export async function startRepl(opts = {}) {
             case 'cancel': {
                 ac.abort();
                 ac = new AbortController();
+                // Immediate abort cascade: background shells must not outlive the
+                // cancelled run (the runtime abort path also kills them, but the
+                // controller swap above means we do it here for immediacy).
+                const { killAllJobs } = await import('../tools/shell/background.js');
+                const killed = killAllJobs();
                 queuedStatus({ status: 'aborted' });
-                queuedAppend({ id: `cancel-${Date.now()}`, kind: 'text', text: 'cancelled current operation', role: 'assistant' });
+                queuedAppend({ id: `cancel-${Date.now()}`, kind: 'text', text: killed.length > 0 ? `cancelled current operation (${killed.length} background job(s) killed)` : 'cancelled current operation', role: 'assistant' });
                 return;
             }
             case 'shell': {
@@ -2468,13 +2515,72 @@ export async function startRepl(opts = {}) {
                 }
                 return;
             }
-            case 'keymap':
-            case 'vim':
+            case 'keymap': {
+                // Real binding table (mirrors src/tui/app.tsx useInput + mouse.ts).
+                // A stored `klyro.keymap` override is shown, not applied — the TUI
+                // has one compiled keymap; the value is kept for future remapping.
+                const { runConfig } = await import('./config.js');
+                const capture = async (args) => {
+                    const orig = process.stdout.write.bind(process.stdout);
+                    let out = '';
+                    process.stdout.write = ((c) => { out += String(c); return true; });
+                    try {
+                        await runConfig(args);
+                    }
+                    finally {
+                        process.stdout.write = orig;
+                    }
+                    return out;
+                };
+                const stored = cmd.name?.trim();
+                if (stored) {
+                    await capture(['set', 'klyro.keymap', stored]);
+                    queuedAppend({ id: `keymap2-${Date.now()}`, kind: 'text', text: `keymap note saved: ${stored} (display-only — the TUI uses its compiled keymap below)`, role: 'assistant' });
+                    return;
+                }
+                queuedAppend({
+                    id: `keymap-${Date.now()}`,
+                    kind: 'text',
+                    role: 'assistant',
+                    text: [
+                        'Keymap (TUI compiled bindings):',
+                        '  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 · ↑/↓ history (with text) else scroll · wheel ±3 lines',
+                        '  Shift+drag selects · /vim toggles vim input mode · /keymap <note> saves a display note',
+                    ].join('\n'),
+                });
+                return;
+            }
+            case 'vim': {
+                // Live vim input mode (not a config stub): toggles the TUI between
+                // insert and normal mode via directHooks; persists the choice too.
+                const want = cmd.state?.trim().toLowerCase();
+                const next = want === 'on' || want === 'normal' ? 'normal' : want === 'off' || want === 'insert' ? 'insert' : vimLive === 'insert' ? 'normal' : 'insert';
+                vimLive = next;
+                try {
+                    const { runConfig } = await import('./config.js');
+                    const orig = process.stdout.write.bind(process.stdout);
+                    process.stdout.write = (() => true);
+                    try {
+                        await runConfig(['set', 'klyro.vim', next]);
+                    }
+                    finally {
+                        process.stdout.write = orig;
+                    }
+                }
+                catch { /* persist best-effort */ }
+                if (isMounted && directHooks)
+                    directHooks.setVimMode(next);
+                queuedAppend({ id: `vim-${Date.now()}`, kind: 'text', text: `vim mode: ${next}${next === 'normal' ? ' (h/l move · i/a insert · x delete · 0/$ ends · j/k scroll)' : ''}`, role: 'assistant' });
+                return;
+            }
             case 'theme':
             case 'statusline':
             case 'output-style': {
-                const key = cmd.kind === 'keymap' ? 'klyro.keymap' : cmd.kind === 'vim' ? 'klyro.vim' : cmd.kind === 'theme' ? 'klyro.theme' : cmd.kind === 'statusline' ? 'klyro.statusline' : 'klyro.outputStyle';
-                const val = (cmd.kind === 'keymap' ? cmd.name : cmd.kind === 'vim' ? cmd.state : cmd.kind === 'theme' ? cmd.name : cmd.kind === 'statusline' ? cmd.format : cmd.style)?.trim();
+                const key = cmd.kind === 'theme' ? 'klyro.theme' : cmd.kind === 'statusline' ? 'klyro.statusline' : 'klyro.outputStyle';
+                const val = (cmd.kind === 'theme' ? cmd.name : cmd.kind === 'statusline' ? cmd.format : cmd.style)?.trim();
                 const { runConfig } = await import('./config.js');
                 const capture = async (args) => {
                     const orig = process.stdout.write.bind(process.stdout);

package/dist/cli/run.js

@@ -403,6 +403,20 @@ export async function runOnce(opts) {
     }
     if (output === 'human')
         stdout.write('\n');
+    // Final cost line: headless runs previously surfaced cost only through
+    // [budget] warnings. Human/silent → stderr one-liner; json → additive
+    // cost_usd/usage fields on the final object (purely additive, no shape break).
+    {
+        const { estimateCost } = await import('../providers/model-info.js');
+        const cost = estimateCost(opts.model, result.usage.input, result.usage.output);
+        const costLine = `$${cost.toFixed(4)} · ${result.usage.input} in / ${result.usage.output} out${result.usage.estimated ? ' (estimated)' : ''}`;
+        if (output === 'json') {
+            stdout.write(JSON.stringify({ kind: 'cost', cost_usd: cost, usage: result.usage }) + '\n');
+        }
+        else {
+            stderr.write(`klyro: cost ${costLine}\n`);
+        }
+    }
     if (result.status === 'max_steps') {
         if (output === 'json')
             stdout.write(JSON.stringify({ kind: 'final', status: result.status, steps: result.steps }) + '\n');

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

@@ -316,5 +316,11 @@ export interface CommandDef {
 }
 /** Curated canonical commands with one-line hints — drives /help, /commands and TUI autocomplete. */
 export declare const COMMAND_DEFS: CommandDef[];
-/** Prefix-match command names for TUI autocomplete — top `limit` (default 6). */
+/**
+ * Fuzzy score for TUI autocomplete: subsequence match with bonuses for
+ * prefix (+100), word-boundary (+30), and consecutive (+15) matches, minus
+ * a gap penalty. Returns -Infinity when `query` is not a subsequence.
+ */
+export declare function fuzzyScore(name: string, query: string): number;
+/** Fuzzy-match command names for TUI autocomplete — top `limit` (default 6). */
 export declare function suggestCommands(prefix: string, limit?: number): CommandDef[];

package/dist/cli/slash/parser.js

@@ -293,18 +293,45 @@ export const COMMAND_DEFS = [
     { name: 'deps', hint: 'dependencies' },
     { name: 'install', hint: 'install deps' },
 ];
-/** Prefix-match command names for TUI autocomplete — top `limit` (default 6). */
+/**
+ * Fuzzy score for TUI autocomplete: subsequence match with bonuses for
+ * prefix (+100), word-boundary (+30), and consecutive (+15) matches, minus
+ * a gap penalty. Returns -Infinity when `query` is not a subsequence.
+ */
+export function fuzzyScore(name, query) {
+    const n = name.toLowerCase();
+    const q = query.toLowerCase();
+    if (!q)
+        return 0;
+    let score = 0;
+    let ni = 0;
+    let lastHit = -2;
+    for (let qi = 0; qi < q.length; qi++) {
+        const found = n.indexOf(q[qi], ni);
+        if (found === -1)
+            return -Infinity;
+        if (qi === 0 && found === 0)
+            score += 100; // prefix
+        if (found > 0 && (n[found - 1] === '-' || n[found - 1] === '_'))
+            score += 30; // word boundary
+        if (found === lastHit + 1)
+            score += 15; // consecutive
+        else
+            score -= (found - ni); // gap penalty
+        lastHit = found;
+        ni = found + 1;
+    }
+    score -= (n.length - q.length); // prefer shorter names
+    return score;
+}
+/** Fuzzy-match command names for TUI autocomplete — top `limit` (default 6). */
 export function suggestCommands(prefix, limit = 6) {
     const p = prefix.toLowerCase().replace(/^\//, '');
     if (!p)
         return COMMAND_DEFS.slice(0, limit);
-    const starts = [];
-    const contains = [];
-    for (const d of COMMAND_DEFS) {
-        if (d.name.startsWith(p))
-            starts.push(d);
-        else if (d.name.includes(p))
-            contains.push(d);
-    }
-    return [...starts, ...contains].slice(0, limit);
+    return COMMAND_DEFS.map((d) => ({ d, s: fuzzyScore(d.name, p) + fuzzyScore(d.hint, p) * 0.25 }))
+        .filter((x) => x.s > -Infinity)
+        .sort((a, b) => b.s - a.s)
+        .slice(0, limit)
+        .map((x) => x.d);
 }

package/dist/cli/update.d.ts

@@ -2,10 +2,14 @@
  * klyro update — check registry for newer version, cached 24h.
  * Env KLYRO_NO_UPDATE_CHECK=1 disables.
  *
- * Integrity: before recommending `npm i`, we verify the tarball's SRI hash
- * (sha512) against the registry's recorded `dist.integrity`. An install is
- * only recommended when the download hash matches, so a tampered CDN or
- * MITM registry response can't push a malicious binary to the operator.
+ * Integrity: before recommending `npm i`, we verify the tarball against
+ * BOTH the registry's SRI digest (sha512/sha256) AND the legacy sha1
+ * `dist.shasum` when present — a tampered CDN or MITM registry response
+ * must forge two independent digests to push a malicious binary.
+ * Downgrade protection: a registry `latest` that is not strictly newer
+ * than the running version (semver) is never recommended.
  */
+/** Minimal semver compare for `x.y.z[-prerelease]`; null when unparseable. */
+export declare function compareSemver(a: string, b: string): number | null;
 export declare function checkForUpdate(current: string): Promise<string | null>;
 export declare function runUpdate(): Promise<number>;