klyro 1.0.4 → 1.0.6

package/dist/cli/run.js

@@ -19,6 +19,7 @@ import { DenyAllApprovalPrompt } from '../policy/approval.js';
 import { redact } from '../policy/secret-redactor.js';
 import { buildLevel6Context } from '../context/level6.js';
 import { memoryBlock } from '../context/memory.js';
+import { estimateCost } from '../providers/model-info.js';
 import { resolveSessionId } from '../persistence/session.js';
 import * as fs from 'node:fs';
 function readEnv(name, fallback) {
@@ -53,7 +54,8 @@ export async function runOnce(opts) {
     catch { /* ignore */ }
     // P1.4 — validate --agent early so typos fail fast (exit 2) even without API keys.
     if (opts.agent) {
-        const { BUILTIN_AGENTS: _known } = await import('../agent/orchestrator.js');
+        const { listAllAgents } = await import('../agent/orchestrator.js');
+        const _known = listAllAgents(opts.cwd);
         if (!_known.some((a) => a.id === opts.agent)) {
             stderr.write(`klyro: unknown agent: ${opts.agent} (known: ${_known.map((a) => a.id).join(', ')})\n`);
             return 2;
@@ -141,36 +143,39 @@ export async function runOnce(opts) {
     // approve). Project-sourced servers auto-connect ONLY when their exact
     // spec hash is already in the McpTrust store (e.g. approved in a prior
     // REPL session); unknown specs are skipped with a warning.
+    // --bare skips MCP entirely (deterministic, no subprocesses).
     let closeMcp;
-    try {
-        const { loadAndRegisterMcp } = await import('../mcp/registry.js');
-        const { McpTrust, hashSpec } = await import('../mcp/trust.js');
-        const { loadMcpServers } = await import('../mcp/config.js');
-        const mcpTrust = new McpTrust();
-        const mcpSpecs = loadMcpServers(opts.cwd).servers;
-        const mcp = await loadAndRegisterMcp({
-            cwd: opts.cwd,
-            registry,
-            policy,
-            approveProjectServer: async ({ name }) => {
-                const spec = mcpSpecs[name];
-                if (spec && mcpTrust.isTrusted(name, hashSpec(spec)))
-                    return true;
-                stderr.write(`klyro: mcp project server "${name}" not in trust store (skipped — headless cannot prompt)\n`);
-                return false;
-            },
-        });
-        for (const e of mcp.errors)
-            stderr.write(`klyro: mcp ${e.server}: ${e.message}\n`);
-        if (mcp.registered.length > 0 && output === 'human') {
-            stderr.write(`klyro: mcp tools: ${mcp.registered.join(', ')}\n`);
+    if (!opts.bare) {
+        try {
+            const { loadAndRegisterMcp } = await import('../mcp/registry.js');
+            const { McpTrust, hashSpec } = await import('../mcp/trust.js');
+            const { loadMcpServers } = await import('../mcp/config.js');
+            const mcpTrust = new McpTrust();
+            const mcpSpecs = loadMcpServers(opts.cwd).servers;
+            const mcp = await loadAndRegisterMcp({
+                cwd: opts.cwd,
+                registry,
+                policy,
+                approveProjectServer: async ({ name }) => {
+                    const spec = mcpSpecs[name];
+                    if (spec && mcpTrust.isTrusted(name, hashSpec(spec)))
+                        return true;
+                    stderr.write(`klyro: mcp project server "${name}" not in trust store (skipped — headless cannot prompt)\n`);
+                    return false;
+                },
+            });
+            for (const e of mcp.errors)
+                stderr.write(`klyro: mcp ${e.server}: ${e.message}\n`);
+            if (mcp.registered.length > 0 && output === 'human') {
+                stderr.write(`klyro: mcp tools: ${mcp.registered.join(', ')}\n`);
+            }
+            closeMcp = mcp.closeAll;
         }
-        closeMcp = mcp.closeAll;
+        catch { /* ignore — MCP is optional */ }
     }
-    catch { /* ignore — MCP is optional */ }
-    const systemPrompt = await makeRunSystemPrompt(opts.cwd, opts.systemPrompt ?? defaultRunSystemPrompt);
-    // Level 9 — session setup (create or resume)
-    const persistEnabled = opts.persist !== false;
+    const systemPrompt = await makeRunSystemPrompt(opts.cwd, opts.systemPrompt ?? defaultRunSystemPrompt, opts.bare);
+    // Level 9 — session setup (create or resume). --bare skips persistence.
+    const persistEnabled = opts.persist !== false && !opts.bare;
     let store;
     let sessionId;
     let initialTranscript;
@@ -256,17 +261,18 @@ export async function runOnce(opts) {
             ...(opts.verifyMode ? { mode: opts.verifyMode } : {}),
         };
     let result;
+    let endStatus = 'error';
     // P1.4 — if --agent is requested, stand up a parent orchestrator so the
     // model can call spawn_agent / task_list / task_get. The root run keeps
     // depth 0; children are capped at maxDepth (default 1 per r-6-10.fix.md).
     let agentBridge;
     let parentContext;
     if (opts.agent) {
-        const { AgentOrchestrator, BUILTIN_AGENTS } = await import('../agent/orchestrator.js');
-        const def = BUILTIN_AGENTS.find((a) => a.id === opts.agent); // validated above
+        const { AgentOrchestrator, findAgent } = await import('../agent/orchestrator.js');
+        const def = findAgent(opts.agent, opts.cwd); // validated above
         const maxDepth = opts.maxDepth ?? 1;
         const rootDeps = { adapter, registry, policy, approval: new DenyAllApprovalPrompt(), systemPrompt };
-        const orchestrator = new AgentOrchestrator({ sessionId: sessionId ?? 'ephemeral', deps: rootDeps });
+        const orchestrator = new AgentOrchestrator({ sessionId: sessionId ?? 'ephemeral', deps: rootDeps, cwd: opts.cwd });
         const allowedTools = new Set(registry.list().map((t) => t.name));
         parentContext = {
             sessionId: sessionId ?? 'ephemeral',
@@ -304,6 +310,7 @@ export async function runOnce(opts) {
             task: opts.task,
             cwd: opts.cwd,
             model: opts.model,
+            ...(opts.bare ? { bare: true } : {}),
             maxSteps: opts.maxSteps,
             maxTokens: opts.maxTokens,
             temperature: opts.temperature,
@@ -371,6 +378,7 @@ export async function runOnce(opts) {
             adapter, registry, policy, approval: new DenyAllApprovalPrompt(), systemPrompt,
             ...(failoverAdapters ? { failoverAdapters } : {}),
         });
+        endStatus = result.status;
     }
     finally {
         doneSigint();
@@ -378,6 +386,19 @@ export async function runOnce(opts) {
             await closeMcp?.();
         }
         catch { /* ignore */ }
+        // sessionEnd hooks: best-effort end-of-run side effects (logging,
+        // notifications, cleanup). Skipped in --bare. Never affects exit code.
+        if (!opts.bare) {
+            try {
+                const { runSessionEndHooks } = await import('./hooks.js');
+                const outs = await runSessionEndHooks(opts.cwd, sessionId, endStatus);
+                for (const o of outs) {
+                    if (output !== 'silent' && o.output)
+                        stderr.write(`[hook ${o.name}] ${o.output.slice(0, 300)}\n`);
+                }
+            }
+            catch { /* ignore */ }
+        }
     }
     if (store && sessionId) {
         // Finalize session status
@@ -403,41 +424,73 @@ 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 finalCost = estimateCost(opts.model, result.usage.input, result.usage.output);
+    const costLine = `$${finalCost.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: finalCost, usage: result.usage }) + '\n');
+    }
+    else {
+        stderr.write(`klyro: cost ${costLine}\n`);
+    }
+    // Stable result envelope (machine contract): exactly one `kind:result`
+    // line per run in json mode, after all legacy per-status lines. Parsers
+    // should read the LAST line; legacy `kind:final` lines are kept for compat.
+    const emitEnvelope = (exitCode, extra = {}) => {
+        if (output === 'json') {
+            stdout.write(JSON.stringify({
+                kind: 'result',
+                status: result.status,
+                exit_code: exitCode,
+                text: result.finalText,
+                steps: result.steps,
+                toolCalls: result.toolCalls,
+                cost_usd: finalCost,
+                usage: result.usage,
+                ...(result.verification ? { verification: result.verification } : {}),
+                ...(sessionId ? { session_id: sessionId } : {}),
+                ...extra,
+            }) + '\n');
+        }
+        return exitCode;
+    };
     if (result.status === 'max_steps') {
         if (output === 'json')
             stdout.write(JSON.stringify({ kind: 'final', status: result.status, steps: result.steps }) + '\n');
         else
             stderr.write(`klyro: hit max steps (${result.steps}); consider raising --max-steps\n`);
-        return 7;
+        return emitEnvelope(7);
     }
     if (result.status === 'limit') {
         if (output === 'json')
             stdout.write(JSON.stringify({ kind: 'final', status: result.status, steps: result.steps, text: result.finalText }) + '\n');
         else
             stderr.write(`klyro: stopped early: ${result.finalText || result.status} (after ${result.steps} steps)\n`);
-        return 7;
+        return emitEnvelope(7);
     }
     if (result.status === 'stuck') {
         if (output === 'json')
             stdout.write(JSON.stringify({ kind: 'final', status: result.status, steps: result.steps }) + '\n');
         else
             stderr.write(`klyro: stuck — repeated the same action with no progress; aborting after ${result.steps} steps\n`);
-        return 7;
+        return emitEnvelope(7);
     }
     if (result.status === 'aborted') {
-        return 130;
+        return emitEnvelope(130);
     }
     if (result.status === 'no_final') {
         if (output !== 'json')
             stderr.write('klyro: provider error — no final answer\n');
-        return 5;
+        return emitEnvelope(5);
     }
     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 8;
+        return emitEnvelope(8);
     }
     // 6.5 — --require-verify: if edits were made but verification never passed, exit 8
     if (opts.requireVerify && result.verification && !result.verification.ok) {
@@ -445,7 +498,7 @@ export async function runOnce(opts) {
             stdout.write(JSON.stringify({ kind: 'final', status: 'require_verify_failed' }) + '\n');
         else
             stderr.write('klyro: --require-verify: verification required but not passed\n');
-        return 8;
+        return emitEnvelope(8);
     }
     if (opts.requireVerify && !result.verification && result.hasEdits) {
         // Edits were made but no verification command found
@@ -453,11 +506,11 @@ export async function runOnce(opts) {
             stdout.write(JSON.stringify({ kind: 'final', status: 'require_verify_missing' }) + '\n');
         else
             stderr.write('klyro: --require-verify: no verification command found and edits were made\n');
-        return 8;
+        return emitEnvelope(8);
     }
     if (output === 'json')
         stdout.write(JSON.stringify({ kind: 'final', status: 'ok', text: result.finalText }) + '\n');
-    return 0;
+    return emitEnvelope(0);
 }
 async function dryRunReport(opts) {
     // Assemble the REAL prompt (Level-6 context + KLYRO.md), not the bare base —
@@ -495,7 +548,10 @@ function defaultRunSystemPrompt(_ctx) {
     return _ctx.telemetry ? { system: base, suffix: _ctx.telemetry } : { system: base };
 }
 /** Wrap a system-prompt fn to inject Level-6 context (project map etc.) + KLYRO.md (4.4). */
-export async function makeRunSystemPrompt(cwd, base) {
+export async function makeRunSystemPrompt(cwd, base, bare = false) {
+    // --bare: base prompt only — no L6 scan, memory, or KLYRO.md (fast + deterministic).
+    if (bare)
+        return base;
     const ctxBlock = await buildLevel6Context({ cwd });
     const prefix = ctxBlock.formatted ? `\n\n<context>\n${ctxBlock.formatted}\n</context>` : '';
     // Session memory: .klyro/memory/session-notes.md injected so memory_write

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

@@ -0,0 +1,25 @@
+export interface FrontmatterResult {
+    data: Record<string, string>;
+    body: string;
+}
+/** Minimal frontmatter parser: `---` fences + `key: value` lines only. */
+export declare function parseFrontmatter(text: string): FrontmatterResult;
+/** Parse a scalar list: `[a, b]`, `a, b`, or newline/`- ` items. */
+export declare function parseList(value: string | undefined): string[];
+export declare function parseBool(value: string | undefined, fallback: boolean): boolean;
+export declare function parseInt_(value: string | undefined): number | undefined;
+export interface CustomCommand {
+    name: string;
+    description: string;
+    body: string;
+    source: 'project' | 'global';
+}
+/** Expand `$1..$9` and `$@` (all args joined by space). Missing args → ''. */
+export declare function expandArgs(body: string, args: string[]): string;
+/** Load custom commands: global first, project wins on name clash. Never throws. */
+export declare function loadCustomCommands(cwd: string): CustomCommand[];
+/**
+ * Relative file paths for `@`-completion: recursive walk, ignored dirs
+ * skipped, capped (directories sort first via trailing `/`).
+ */
+export declare function listCompletableFiles(cwd: string): string[];

package/dist/cli/slash/custom.js

@@ -0,0 +1,166 @@
+/**
+ * File-based extensibility: `.klyro/commands/*.md` (project) +
+ * `~/.klyro/commands/*.md` (global). Project wins on name clash.
+ *
+ * Format: YAML-ish frontmatter (`---` fences) with `name` (default:
+ * filename), `description`/`hint`, then a body supporting `$1..$9` and
+ * `$@` (all args). A custom command expands to prompt text and runs
+ * through the normal prompt path (with recursion depth guard).
+ */
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+/** Minimal frontmatter parser: `---` fences + `key: value` lines only. */
+export function parseFrontmatter(text) {
+    const data = {};
+    if (!text.startsWith('---'))
+        return { data, body: text };
+    const end = text.indexOf('\n---', 3);
+    if (end === -1)
+        return { data, body: text };
+    const head = text.slice(3, end);
+    for (const line of head.split('\n')) {
+        const m = /^([A-Za-z0-9_-]+)\s*:\s*(.*)$/.exec(line.trimEnd());
+        if (m)
+            data[m[1].toLowerCase()] = (m[2] ?? '').trim();
+    }
+    return { data, body: text.slice(end + 4).replace(/^\r?\n/, '') };
+}
+/** Parse a scalar list: `[a, b]`, `a, b`, or newline/`- ` items. */
+export function parseList(value) {
+    if (!value)
+        return [];
+    let v = value.trim();
+    if (v.startsWith('[') && v.endsWith(']'))
+        v = v.slice(1, -1);
+    const out = [];
+    for (const chunk of v.split(/[\n,]/)) {
+        const t = chunk.trim().replace(/^-+\s*/, '').replace(/^['"]|['"]$/g, '');
+        if (t)
+            out.push(t);
+    }
+    return out;
+}
+export function parseBool(value, fallback) {
+    if (value === undefined || value === '')
+        return fallback;
+    return /^(true|yes|1|on)$/i.test(value.trim());
+}
+export function parseInt_(value) {
+    if (!value)
+        return undefined;
+    const n = Number(value.trim());
+    return Number.isInteger(n) && n > 0 ? n : undefined;
+}
+/** Expand `$1..$9` and `$@` (all args joined by space). Missing args → ''. */
+export function expandArgs(body, args) {
+    const all = args.join(' ');
+    return body
+        .replace(/\$@/g, () => all)
+        .replace(/\$([1-9])/g, (_m, d) => args[Number(d) - 1] ?? '');
+}
+function commandsDir(home) {
+    return [path.join(home, '.klyro', 'commands')];
+}
+function readCommandFile(file, source) {
+    let raw;
+    try {
+        raw = fs.readFileSync(file, 'utf-8');
+    }
+    catch {
+        return null;
+    }
+    const { data, body } = parseFrontmatter(raw);
+    const fallback = path.basename(file, path.extname(file)).toLowerCase();
+    const name = (data['name'] || fallback).toLowerCase();
+    if (!/^[a-z0-9_-]{1,32}$/.test(name))
+        return null;
+    if (!body.trim())
+        return null;
+    return { name, description: data['description'] || data['hint'] || '', body: body.trim(), source };
+}
+function listCommandFiles(dir) {
+    let entries;
+    try {
+        entries = fs.readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    return entries
+        .filter((e) => e.isFile() && e.name.toLowerCase().endsWith('.md'))
+        .map((e) => path.join(dir, e.name))
+        .sort();
+}
+/** Load custom commands: global first, project wins on name clash. Never throws. */
+export function loadCustomCommands(cwd) {
+    const byName = new Map();
+    try {
+        const home = os.homedir() || process.cwd();
+        for (const dir of commandsDir(home)) {
+            for (const f of listCommandFiles(dir)) {
+                const c = readCommandFile(f, 'global');
+                if (c)
+                    byName.set(c.name, c);
+            }
+        }
+        const projectDir = path.join(cwd, '.klyro', 'commands');
+        for (const f of listCommandFiles(projectDir)) {
+            const c = readCommandFile(f, 'project');
+            if (c)
+                byName.set(c.name, c);
+        }
+    }
+    catch {
+        return [...byName.values()];
+    }
+    return [...byName.values()];
+}
+const COMPLETABLE_IGNORED = new Set(['node_modules', '.git', 'dist', 'build', 'coverage', '.klyro', 'out', '.next', 'target', 'vendor']);
+const MAX_COMPLETABLE_FILES = 1000;
+/**
+ * Relative file paths for `@`-completion: recursive walk, ignored dirs
+ * skipped, capped (directories sort first via trailing `/`).
+ */
+export function listCompletableFiles(cwd) {
+    const out = [];
+    const walk = (dir, rel) => {
+        if (out.length >= MAX_COMPLETABLE_FILES)
+            return;
+        let entries;
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        const sorted = entries.sort((a, b) => (a.isDirectory() === b.isDirectory() ? a.name.localeCompare(b.name) : a.isDirectory() ? -1 : 1));
+        for (const e of sorted) {
+            if (out.length >= MAX_COMPLETABLE_FILES)
+                return;
+            if (rel === '' && COMPLETABLE_IGNORED.has(e.name))
+                continue;
+            if (e.name.startsWith('.') && rel === '') {
+                // Top-level dotfiles are completable (e.g. .env.example) but never traversed.
+                if (e.isFile())
+                    out.push(e.name);
+                continue;
+            }
+            const r = rel === '' ? e.name : `${rel}/${e.name}`;
+            if (e.isDirectory()) {
+                out.push(`${r}/`);
+                walk(path.join(dir, e.name), r);
+            }
+            else if (e.isFile()) {
+                out.push(r);
+            }
+        }
+    };
+    try {
+        walk(cwd, '');
+    }
+    catch {
+        return out;
+    }
+    return out;
+}

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

@@ -39,8 +39,13 @@ export type SlashCommand = {
     kind: 'diff';
 } | {
     kind: 'undo';
+    n?: number;
 } | {
     kind: 'rewind';
+    n?: number;
+    summary?: boolean;
+} | {
+    kind: 'checkpoints';
 } | {
     kind: 'plan';
     task?: string;
@@ -68,6 +73,9 @@ export type SlashCommand = {
     kind: 'thinking';
 } | {
     kind: 'memory';
+} | {
+    kind: 'memory-append';
+    text: string;
 } | {
     kind: 'jobs';
 } | {
@@ -316,5 +324,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). */
-export declare function suggestCommands(prefix: string, limit?: number): CommandDef[];
+/**
+ * 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, extra?: CommandDef[]): CommandDef[];

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 = ['help', 'clear', 'new', 'exit', 'quit', 'q', 'compact', 'resume', 'sessions', 'rename', 'fork', 'branch', 'export', 'copy', 'model', 'm', 'models', 'provider', 'p', 'effort', 'e', 'fast', 'init', 'status', 'context', 'diff', 'plan', 'todos', 'memory', 'permissions', 'mode', 'sandbox', 'approve', 'deny', 'login', 'logout', 'auth', 'version', 'update', 'cancel', 'shell', 'mention', 'tools', 'config', 'settings', 'doctor', 'cost', 'thinking', 'jobs', 'verify', 'project', 'undo', 'rewind', 'review', 'code-review', 'security-review', 'simplify', 'test', 'lint', 'build', 'run', 'fix', 'explain', 'format', 'ask', 'redo', 'checkpoint', 'accept', 'reject', 'details', 'verbose', 'raw', 'activity', 'tasks', 'ps', 'stop', 'queue', 'retry', 'kill', 'mcp', 'agents', 'agent', 'subagents', 'subtask', 'background', 'add-dir', 'cd', 'attach', 'drop', 'image', 'paste', 'files', 'ls', 'tree', 'search', 'web', 'read', 'map', 'tokens', 'commit', 'push', 'pull', 'pr', 'issue', 'editor', 'keymap', 'vim', 'theme', 'statusline', 'output-style', 'debug', 'whoami', 'reload', 'reset', 'bug', 'changelog', 'prompt', 'alias', 'commands', 'env', 'deps', 'install'];
+const KNOWN = ['help', 'clear', 'new', 'exit', 'quit', 'q', 'compact', 'resume', 'sessions', 'rename', 'fork', 'branch', 'export', 'copy', 'model', 'm', 'models', 'provider', 'p', 'effort', 'e', 'fast', 'init', 'status', 'context', 'diff', 'plan', 'todos', 'memory', 'permissions', 'mode', 'sandbox', 'approve', 'deny', 'login', 'logout', 'auth', 'version', 'update', 'cancel', 'shell', 'mention', 'tools', 'config', 'settings', 'doctor', 'cost', 'thinking', 'jobs', 'verify', 'project', 'undo', 'rewind', 'checkpoints', 'review', 'code-review', 'security-review', 'simplify', 'test', 'lint', 'build', 'run', 'fix', 'explain', 'format', 'ask', 'redo', 'checkpoint', 'accept', 'reject', 'details', 'verbose', 'raw', 'activity', 'tasks', 'ps', 'stop', 'queue', 'retry', 'kill', 'mcp', 'agents', 'agent', 'subagents', 'subtask', 'background', 'add-dir', 'cd', 'attach', 'drop', 'image', 'paste', 'files', 'ls', 'tree', 'search', 'web', 'read', 'map', 'tokens', 'commit', 'push', 'pull', 'pr', 'issue', 'editor', 'keymap', 'vim', 'theme', 'statusline', 'output-style', 'debug', 'whoami', 'reload', 'reset', 'bug', 'changelog', 'prompt', 'alias', 'commands', 'env', 'deps', 'install'];
 export function parse(input) {
     const trimmed = input.trim();
     // `!cmd` alias for /shell, `@path` alias for /mention (commands.md P1)
@@ -35,14 +35,35 @@ export function parse(input) {
         case 'new': return { kind: 'new' };
         case 'compact': return { kind: 'compact', focus: rest || undefined };
         case 'diff': return { kind: 'diff' };
-        case 'undo': return { kind: 'undo' };
-        case 'rewind': return { kind: 'rewind' };
+        case 'undo': {
+            const un = Number(rest.split(/\s+/).filter(Boolean)[0] ?? '1');
+            return { kind: 'undo', n: Number.isInteger(un) && un > 0 ? un : 1 };
+        }
+        case 'rewind': {
+            // /rewind [n] [summary] — nth-back snapshot (1 = latest), optional
+            // post-restore summary of the reverted changes.
+            const parts = rest.split(/\s+/).filter(Boolean);
+            const n = parts.length > 0 ? Number(parts[0]) : 1;
+            return {
+                kind: 'rewind',
+                n: Number.isInteger(n) && n > 0 ? n : 1,
+                ...(parts.slice(1).join(' ').toLowerCase() === 'summary' ? { summary: true } : {}),
+            };
+        }
+        case 'checkpoints': return { kind: 'checkpoints' };
         case 'plan': return { kind: 'plan', task: rest || undefined };
         case 'todos': return { kind: 'todos' };
         case 'status': return { kind: 'status' };
         case 'cost': return { kind: 'cost' };
         case 'thinking': return { kind: 'thinking' };
-        case 'memory': return { kind: 'memory' };
+        case 'memory': {
+            // /memory shows notes; /memory append <text> writes one (human path,
+            // same redaction + atomicity as the memory_write tool).
+            const mm = /^append\s+([\s\S]+)$/.exec(rest);
+            if (mm)
+                return { kind: 'memory-append', text: mm[1].trim() };
+            return { kind: 'memory' };
+        }
         case 'jobs': return { kind: 'jobs' };
         case 'verify': return { kind: 'verify' };
         case 'project': return { kind: 'project' };
@@ -233,9 +254,9 @@ export const COMMAND_DEFS = [
     { name: 'explain', hint: 'explain code' },
     { name: 'format', hint: 'format code' },
     { name: 'ask', hint: 'read-only Q&A' },
-    { name: 'undo', hint: 'undo change' },
-    { name: 'redo', hint: 'redo change' },
+    { name: 'undo', hint: 'undo change' }, { name: 'redo', hint: 'redo change' },
     { name: 'rewind', hint: 'rewind code' },
+    { name: 'checkpoints', hint: 'list snapshots' },
     { name: 'checkpoint', hint: 'create checkpoint' },
     { name: 'accept', hint: 'accept edits' },
     { name: 'reject', hint: 'reject edits' },
@@ -293,18 +314,46 @@ export const COMMAND_DEFS = [
     { name: 'deps', hint: 'dependencies' },
     { name: 'install', hint: 'install deps' },
 ];
-/** Prefix-match command names for TUI autocomplete — top `limit` (default 6). */
-export function suggestCommands(prefix, limit = 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, extra = []) {
     const p = prefix.toLowerCase().replace(/^\//, '');
+    const pool = extra.length > 0 ? [...extra, ...COMMAND_DEFS] : COMMAND_DEFS;
     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 pool.slice(0, limit);
+    return pool.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>;