klyro 1.0.5 → 1.0.6

package/dist/cli/repl.js

@@ -293,6 +293,8 @@ export async function startRepl(opts = {}) {
     let isMounted = false;
     // Live vim input mode for the TUI (toggled by /vim, persisted to config).
     let vimLive = 'insert';
+    // Custom-command recursion guard (a command body may invoke /commands).
+    const customDepthRef = { current: 0 };
     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.
@@ -844,6 +846,7 @@ export async function startRepl(opts = {}) {
         let activeCallId = null;
         let activeCallName = null;
         let activeCallArgs = '';
+        let runEndStatus = 'error';
         try {
             const result = await run({
                 task: taskText,
@@ -976,6 +979,7 @@ export async function startRepl(opts = {}) {
             });
             if (result.finalText)
                 lastAssistantText = result.finalText;
+            runEndStatus = result.status;
             if (result.verification) {
                 const v = result.verification;
                 queuedAppend({
@@ -1015,6 +1019,12 @@ export async function startRepl(opts = {}) {
             queuedAppend({ id: `err-${Date.now()}`, kind: 'error', message });
             queuedStatus({ status: 'error', errorMessage: message });
         }
+        // sessionEnd hooks: best-effort end-of-run side effects. Never throws.
+        try {
+            const { runSessionEndHooks } = await import('./hooks.js');
+            await runSessionEndHooks(cwd, sessionId, runEndStatus);
+        }
+        catch { /* ignore */ }
     }
     async function handleSlash(cmd) {
         switch (cmd.kind) {
@@ -1095,6 +1105,22 @@ export async function startRepl(opts = {}) {
                 });
                 return;
             }
+            case 'memory-append': {
+                // Human write path: same redaction + atomicity as memory_write.
+                if (!cmd.text) {
+                    queuedAppend({ id: `mem-${Date.now()}`, kind: 'text', text: 'usage: /memory append <text>', role: 'assistant' });
+                    return;
+                }
+                try {
+                    const { memoryWrite } = await import('../context/memory.js');
+                    const p = await memoryWrite(cwd, cmd.text);
+                    queuedAppend({ id: `mem-${Date.now()}`, kind: 'text', text: `Noted → ${p}`, role: 'assistant' });
+                }
+                catch (err) {
+                    queuedAppend({ id: `mem-err-${Date.now()}`, kind: 'error', message: `memory append failed: ${err instanceof Error ? err.message : String(err)}` });
+                }
+                return;
+            }
             case 'jobs': {
                 const { listJobs } = await import('../tools/shell/background.js');
                 const jobs = listJobs();
@@ -1151,8 +1177,8 @@ export async function startRepl(opts = {}) {
             case 'undo': {
                 try {
                     const { undo } = await import('../checkpoints/store.js');
-                    await undo(cwd);
-                    queuedAppend({ id: `undo-${Date.now()}`, kind: 'text', text: 'Undone last checkpoint', role: 'assistant' });
+                    await undo(cwd, cmd.n ?? 1);
+                    queuedAppend({ id: `undo-${Date.now()}`, kind: 'text', text: `Undone ${cmd.n ?? 1} checkpoint(s)`, role: 'assistant' });
                 }
                 catch (err) {
                     const msg = err instanceof Error ? err.message : String(err);
@@ -1161,10 +1187,47 @@ export async function startRepl(opts = {}) {
                 return;
             }
             case 'rewind': {
+                // Numbered rewind menu: bare /rewind lists snapshots (1 = latest),
+                // /rewind <n> restores, /rewind <n> summary also reports reverted files.
+                const { listCheckpointInfo, undo } = await import('../checkpoints/store.js');
+                const infos = await listCheckpointInfo(cwd);
+                if (infos.length === 0) {
+                    queuedAppend({ id: `rewind-${Date.now()}`, kind: 'text', text: 'No checkpoints yet — snapshots are taken after each file mutation.', role: 'assistant' });
+                    return;
+                }
+                const n = cmd.n ?? 1;
+                if (cmd.n === undefined && !cmd.summary) {
+                    const rows = infos.slice(0, 10).map((c) => {
+                        const age = c.ts > 0 ? ` (${Math.max(1, Math.round((Date.now() - c.ts) / 60000))}m ago)` : '';
+                        return `  ${c.index}. ${c.id.slice(0, 12)} · ${c.files} file(s)${age}`;
+                    });
+                    queuedAppend({ id: `rewind-${Date.now()}`, kind: 'text', text: `Checkpoints (1 = latest):\n${rows.join('\n')}\nrun /rewind <n> to restore, /rewind <n> summary for a revert report`, role: 'assistant' });
+                    return;
+                }
+                if (n < 1 || n > infos.length) {
+                    queuedAppend({ id: `rewind-err-${Date.now()}`, kind: 'error', message: `rewind failed: only ${infos.length} checkpoint(s), got n=${n}` });
+                    return;
+                }
                 try {
-                    const { rewind } = await import('../checkpoints/store.js');
-                    await rewind(cwd);
-                    queuedAppend({ id: `rewind-${Date.now()}`, kind: 'text', text: 'Rewound to last checkpoint', role: 'assistant' });
+                    // Capture the pre-restore dirty state so `summary` can report it.
+                    let before = '';
+                    if (cmd.summary) {
+                        try {
+                            const { execFileSync } = await import('node:child_process');
+                            before = execFileSync('git', ['status', '--porcelain'], { cwd, encoding: 'utf-8', timeout: 5000 });
+                        }
+                        catch {
+                            before = '';
+                        }
+                    }
+                    await undo(cwd, n);
+                    const target = infos[n - 1];
+                    let text = `Rewound to checkpoint ${n} (${target.id.slice(0, 12)}, ${target.files} file(s))`;
+                    if (cmd.summary) {
+                        const files = before.split('\n').map((l) => l.trim()).filter(Boolean).slice(0, 20);
+                        text += files.length > 0 ? `\nReverted working-tree changes:\n${files.map((f) => `  ${f}`).join('\n')}` : '\nWorking tree was clean before restore.';
+                    }
+                    queuedAppend({ id: `rewind-${Date.now()}`, kind: 'text', text, role: 'assistant' });
                 }
                 catch (err) {
                     const msg = err instanceof Error ? err.message : String(err);
@@ -1172,6 +1235,27 @@ export async function startRepl(opts = {}) {
                 }
                 return;
             }
+            case 'checkpoints': {
+                try {
+                    const { listCheckpointInfo } = await import('../checkpoints/store.js');
+                    const infos = await listCheckpointInfo(cwd);
+                    if (infos.length === 0) {
+                        queuedAppend({ id: `ckpt-${Date.now()}`, kind: 'text', text: 'No checkpoints yet.', role: 'assistant' });
+                    }
+                    else {
+                        const rows = infos.slice(0, 15).map((c) => {
+                            const age = c.ts > 0 ? ` (${Math.max(1, Math.round((Date.now() - c.ts) / 60000))}m ago)` : '';
+                            return `  ${c.index}. ${c.id.slice(0, 12)} · ${c.files} file(s)${age}`;
+                        });
+                        queuedAppend({ id: `ckpt-${Date.now()}`, kind: 'text', text: `Checkpoints (1 = latest):\n${rows.join('\n')}`, role: 'assistant' });
+                    }
+                }
+                catch (err) {
+                    const msg = err instanceof Error ? err.message : String(err);
+                    queuedAppend({ id: `ckpt-err-${Date.now()}`, kind: 'error', message: `checkpoints failed: ${msg}` });
+                }
+                return;
+            }
             case 'verify': {
                 const { detectVerifiers, primaryVerifyCommand } = await import('../verification/registry.js');
                 const { verify } = await import('../verification/engine.js');
@@ -1339,26 +1423,18 @@ export async function startRepl(opts = {}) {
                 return;
             }
             case 'init': {
-                const { writeFileSync, existsSync } = await import('node:fs');
-                const { join } = await import('node:path');
-                const target = join(cwd, 'KLYRO.md');
-                if (existsSync(target)) {
-                    queuedAppend({ id: `init-${Date.now()}`, kind: 'text', text: `KLYRO.md already exists at ${target}`, role: 'assistant' });
+                try {
+                    const { initProject, nextStepsText } = await import('./init.js');
+                    const { created, skipped } = await initProject(cwd);
+                    const lines = [
+                        ...created.map((f) => `created ${f}`),
+                        ...skipped.map((f) => `kept ${f}`),
+                        nextStepsText(),
+                    ];
+                    queuedAppend({ id: `init-${Date.now()}`, kind: 'text', text: lines.join('\n'), role: 'assistant' });
                 }
-                else {
-                    try {
-                        const { runScan } = await import('./scan.js');
-                        let out = '';
-                        const orig = process.stdout.write.bind(process.stdout);
-                        process.stdout.write = ((c) => { out += String(c); return true; });
-                        await runScan({ cwd, json: false });
-                        process.stdout.write = orig;
-                        writeFileSync(target, `# KLYRO.md\n\nProject: ${cwd}\n\n## Stack\n\n${out.slice(0, 2000)}\n\n## Conventions\n\n- Prefer smallest change that solves the task.\n- Run verification after edits.\n`);
-                        queuedAppend({ id: `init2-${Date.now()}`, kind: 'text', text: `created ${target}`, role: 'assistant' });
-                    }
-                    catch (err) {
-                        queuedAppend({ id: `init-err-${Date.now()}`, kind: 'error', message: `init failed: ${err instanceof Error ? err.message : String(err)}` });
-                    }
+                catch (err) {
+                    queuedAppend({ id: `init-err-${Date.now()}`, kind: 'error', message: `init failed: ${err instanceof Error ? err.message : String(err)}` });
                 }
                 return;
             }
@@ -2573,7 +2649,7 @@ export async function startRepl(opts = {}) {
                 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' });
+                queuedAppend({ id: `vim-${Date.now()}`, kind: 'text', text: `vim mode: ${next}${next === 'normal' ? ' (h/l/0/$ move · 3h counts · w/b words · x/D/dd delete · i/a insert · j/k scroll)' : ''}`, role: 'assistant' });
                 return;
             }
             case 'theme':
@@ -2817,6 +2893,51 @@ export async function startRepl(opts = {}) {
                     await handleSlash(parse(target + extra));
                     return;
                 }
+                // Custom command files: .klyro/commands/*.md (project wins).
+                // Body expands $1..$9/$@ and runs as a prompt (recursion-guarded).
+                if (m) {
+                    const { loadCustomCommands, expandArgs } = await import('./slash/custom.js');
+                    const custom = loadCustomCommands(cwd).find((c) => c.name === m[1].toLowerCase());
+                    if (custom) {
+                        const depth = (customDepthRef.current ?? 0) + 1;
+                        if (depth > 3) {
+                            queuedAppend({ id: `cust-${Date.now()}`, kind: 'error', message: `custom command recursion limit: /${custom.name}` });
+                            return;
+                        }
+                        const argList = m[2] ? m[2].split(/\s+/) : [];
+                        const expanded = expandArgs(custom.body, argList);
+                        customDepthRef.current = depth;
+                        try {
+                            if (expanded.trimStart().startsWith('/'))
+                                await handleSlash(parse(expanded));
+                            else
+                                await runWithBridge(expanded);
+                        }
+                        finally {
+                            customDepthRef.current = depth - 1;
+                        }
+                        return;
+                    }
+                }
+                // MCP prompt-commands: /mcp__<server>__<prompt> [args...]
+                if (m) {
+                    const pm = /^mcp__([A-Za-z0-9_-]{1,20})__([A-Za-z0-9_-]+)$/.exec(m[1].toLowerCase());
+                    if (pm) {
+                        const { runMcpPrompt } = await import('../mcp/registry.js');
+                        const argList = m[2] ? m[2].split(/\s+/) : [];
+                        const args = {};
+                        argList.forEach((a, i) => { args[`arg${i + 1}`] = a; });
+                        args['input'] = m[2] ?? '';
+                        try {
+                            const text = await runMcpPrompt(cwd, pm[1], pm[2], args);
+                            await runWithBridge(text);
+                        }
+                        catch (err) {
+                            queuedAppend({ id: `mcp-p-${Date.now()}`, kind: 'error', message: `mcp prompt failed: ${err instanceof Error ? err.message : String(err)}` });
+                        }
+                        return;
+                    }
+                }
                 queuedAppend({
                     id: `unk-${Date.now()}`,
                     kind: 'error',

package/dist/cli/run.d.ts

@@ -66,6 +66,12 @@ export interface RunCliOptions {
     persist?: boolean;
     sessionId?: string;
     sessionsDir?: string;
+    /**
+     * Bare mode (`--bare`): skip MCP servers, all hooks, memory/KLYRO.md/L6
+     * context, and session persistence for fast deterministic runs. The model
+     * gets the base system prompt + tools only.
+     */
+    bare?: boolean;
     /** P1.4 — run the task under a named child-capable orchestrator context. */
     agent?: string;
     maxDepth?: number;
@@ -78,5 +84,5 @@ export interface RunCliOptions {
 export declare function shouldForceExit(lastSigintAt: number | undefined, now: number): boolean;
 export declare function runOnce(opts: RunCliOptions): Promise<number>;
 /** Wrap a system-prompt fn to inject Level-6 context (project map etc.) + KLYRO.md (4.4). */
-export declare function makeRunSystemPrompt(cwd: string, base: SystemPromptFn): Promise<SystemPromptFn>;
+export declare function makeRunSystemPrompt(cwd: string, base: SystemPromptFn, bare?: boolean): Promise<SystemPromptFn>;
 export declare function loadTranscript(path: string): Message[];

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
@@ -406,52 +427,70 @@ export async function runOnce(opts) {
     // 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)' : ''}`;
+    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: 'cost', cost_usd: cost, usage: result.usage }) + '\n');
-        }
-        else {
-            stderr.write(`klyro: cost ${costLine}\n`);
+            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) {
@@ -459,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
@@ -467,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 —
@@ -509,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[];