klyro 0.1.41 → 0.1.43

package/dist/agent/runtime.d.ts

@@ -191,6 +191,11 @@ export interface RunResult {
 }
 /** Convert a registry of tools into ToolDefinitions for the provider. */
 export declare function toolDefinitions(registry: ToolRegistry): ToolDefinition[];
+/** Estimate USD cost of a usage block given the model name. */
+export declare function estimateCost(model: string, usage: {
+    input: number;
+    output: number;
+}): number;
 /** Run the autonomous loop. */
 export declare function run(opts: RunOptions, deps: RuntimeDeps): Promise<RunResult>;
 export declare function defaultSystemPrompt(ctx: {

package/dist/agent/runtime.js

@@ -35,6 +35,36 @@ export function toolDefinitions(registry) {
         inputSchema: t.function.parameters,
     }));
 }
+// BUG-005: Model-aware cost estimation with sensible defaults.
+// Rates are per-1K tokens (input / output). Local models are $0.
+const MODEL_RATES = [
+    { test: (m) => /gpt-4/i.test(m), input: 0.003, output: 0.015 },
+    { test: (m) => /gpt-3\.5/i.test(m), input: 0.0005, output: 0.0015 },
+    { test: (m) => /claude|anthropic/i.test(m), input: 0.003, output: 0.015 },
+    { test: (m) => /gemini/i.test(m), input: 0.00075, output: 0.003 },
+    { test: (m) => /o1/i.test(m), input: 0.015, output: 0.06 },
+];
+/** Estimate USD cost of a usage block given the model name. */
+export function estimateCost(model, usage) {
+    const match = MODEL_RATES.find((r) => r.test(model));
+    const { input: inRate, output: outRate } = match ?? { input: 0.003, output: 0.015 };
+    return (usage.input / 1000) * inRate + (usage.output / 1000) * outRate;
+}
+// PERF-002: Memoized token counting cache.
+let tokenCache = {
+    lastRef: null,
+    lastSystem: undefined,
+    lastCount: 0,
+};
+/** Memoized totalTokens � only recomputes when transcript ref or system changes. */
+function cachedTotalTokens(system, messages) {
+    if (tokenCache.lastRef === messages && tokenCache.lastSystem === system) {
+        return tokenCache.lastCount;
+    }
+    const count = totalTokens(system, messages);
+    tokenCache = { lastRef: messages, lastSystem: system, lastCount: count };
+    return count;
+}
 /** Run the autonomous loop. */
 export async function run(opts, deps) {
     const maxSteps = opts.maxTurns ?? opts.maxSteps ?? DEFAULT_MAX_STEPS;
@@ -143,12 +173,10 @@ export async function run(opts, deps) {
     // 5.2 — stuck detection state
     const callHistory = [];
     const fileEditCounts = new Map();
-    let stuckCount = 0;
-    let lastSignal;
     outer: while (steps < maxSteps) {
         // 5.1 limits: max-cost, max-time
         if (maxCost !== undefined) {
-            const cost = (usage.input / 1000) * 0.003 + (usage.output / 1000) * 0.015;
+            const cost = estimateCost(opts.model, usage);
             if (cost >= maxCost) {
                 setPhase('limit');
                 await closeTracer();
@@ -189,10 +217,11 @@ export async function run(opts, deps) {
         const BUDGET = { total: 120_000, reservedOutput: 4000 };
         let reqMessages = transcript;
         let reqSystem = systemPrompt;
-        if (totalTokens(systemPrompt, transcript) > BUDGET.total) {
+        if (cachedTotalTokens(systemPrompt, transcript) > BUDGET.total) {
             const c = compressTranscript(systemPrompt, transcript, BUDGET);
             reqSystem = c.system;
             reqMessages = c.messages;
+            tokenCache = { lastRef: null, lastSystem: undefined, lastCount: 0 };
             if (c.dropped > 0)
                 emitKlyro({ type: 'context.compacted', ts: Date.now(), sessionId: sessionId ?? 'ephemeral', dropped: c.dropped });
         }
@@ -279,6 +308,8 @@ export async function run(opts, deps) {
         const assistantMsg = { role: 'assistant', content: assistantContent };
         transcript.push(assistantMsg);
         await checkpoint(assistantMsg);
+        // Invalidate token cache since transcript changed
+        tokenCache = { lastRef: null, lastSystem: undefined, lastCount: 0 };
         // No tool calls → potential completion (Level 8 verify gate)
         if (opts.signal?.aborted) {
             finalText = textBuf;
@@ -363,7 +394,7 @@ export async function run(opts, deps) {
                 }
                 // 6.4 — classify
                 const baseline = await getBaseline(opts.cwd, verifyCmd);
-                const isFlaky = await rerunOnce(opts.cwd, cmdToRun, 30_000);
+                const isFlaky = await rerunOnce(opts.cwd, cmdToRun, opts.verify?.timeoutMs ?? 45_000);
                 const cls = classifyFailure({ failure: vResult.failure, stdout: vResult.stdout, stderr: vResult.stderr }, baseline, isFlaky);
                 if (cls === 'flaky') {
                     // rerun succeeded on second try — treat as flaky, don't count as repair
@@ -596,16 +627,15 @@ export async function run(opts, deps) {
             }
         };
         // 3.5 — parallel if all concurrencySafe, sequential otherwise
-        // For parallel, execute concurrently but commit transcript in original call order to preserve determinism
+        // BUG-002: preserve call order — run sequentially even when allSafe to avoid out-of-order transcript
+        // Parallel execution previously pushed tool_results out of order via Promise.all
         if (allSafe) {
-            toolCallCount += finalizedCalls.length;
-            // runOne internally pushes to transcript — we need ordered commits, so we serialize the push phase
-            // Collect via a temporary queue: run all, but gather transcript deltas and replay in order
-            const pending = [];
-            // Wrap runOne to capture its pushes without interleaving: we monkey-patch transcript push via staging
-            // Simpler: just run sequentially when deterministic order matters — parallel benefit is limited for <4 tools
-            // So we run Promise.all for execution but checkpoint writes are already serialized via store mutex
-            await Promise.all(finalizedCalls.map((c) => runOne(c)));
+            for (const call of finalizedCalls) {
+                toolCallCount++;
+                await runOne(call);
+                if (opts.signal?.aborted)
+                    break;
+            }
         }
         else {
             for (const call of finalizedCalls) {

package/dist/cli/repl.js

@@ -50,9 +50,15 @@ export async function startRepl(opts = {}) {
     if (providerKind === 'anthropic' && !apiKey) {
         process.stderr.write('klyro: anthropic provider detected but KLYRO_API_KEY is empty — falling back to OpenAI-compatible adapter\n');
     }
-    const adapter = effectiveProvider === 'anthropic'
-        ? anthropicAdapter({ baseURL: baseUrl, apiKey, timeoutMs: 60_000 })
-        : httpChatAdapter({ baseURL: baseUrl, apiKey, timeoutMs: 60_000 });
+    let currentProvider = effectiveProvider;
+    let currentBaseUrl = baseUrl;
+    let currentApiKey = apiKey;
+    let currentMaxSteps = opts.maxSteps ?? 30;
+    let effortLevel = 'medium';
+    const buildAdapter = (prov, url, key) => prov === 'anthropic'
+        ? anthropicAdapter({ baseURL: url, apiKey: key, timeoutMs: 60_000 })
+        : httpChatAdapter({ baseURL: url, apiKey: key, timeoutMs: 60_000 });
+    let adapter = buildAdapter(currentProvider, currentBaseUrl, currentApiKey);
     const ctxBlock = await buildLevel6Context({ cwd });
     const ctxPrefix = ctxBlock.formatted ? `\n\n<context>\n${ctxBlock.formatted}\n</context>` : '';
     // 4.4 KLYRO.md hierarchy
@@ -133,9 +139,18 @@ export async function startRepl(opts = {}) {
     let tuiSessionId;
     if (isAltScreen)
         enterAlt();
+    const EFFORT_STEPS = { low: 10, medium: 30, high: 50, max: 100 };
+    function queuedClear() {
+        if (isMounted && directHooks)
+            directHooks.clearTranscript();
+        else
+            pendingQueue.length = 0;
+        if (isMounted && directHooks)
+            directHooks.clearTranscript();
+    }
     app = render(React.createElement(App, {
         initialModel: model,
-        maxSteps: opts.maxSteps ?? 30,
+        maxSteps: currentMaxSteps,
         cwd,
         initialStatus: { status: 'idle' },
         approvalBridge: tuiBridge,
@@ -190,7 +205,7 @@ export async function startRepl(opts = {}) {
         let sessionId;
         if (!isSimpleChat) {
             try {
-                const rec = await tuiStore.create({ cwd, task: taskText, config: { model, maxSteps: opts.maxSteps ?? 30 } });
+                const rec = await tuiStore.create({ cwd, task: taskText, config: { model, maxSteps: currentMaxSteps } });
                 sessionId = rec.id;
                 tuiSessionId = rec.id;
                 // Session info goes to status bar, not transcript (clean like Claude Code)
@@ -238,7 +253,7 @@ export async function startRepl(opts = {}) {
                 task: taskText,
                 cwd,
                 model,
-                maxSteps: opts.maxSteps ?? 30,
+                maxSteps: currentMaxSteps,
                 signal: ac.signal,
                 nonInteractive: opts.nonInteractive ?? false,
                 verify: { enabled: true, maxRepairAttempts: 3 },
@@ -387,21 +402,34 @@ export async function startRepl(opts = {}) {
                 // Listener cleanup is handled by the waitUntilExit resolver below
                 return;
             case 'clear':
+                queuedClear();
                 queuedAppend({ id: `sep-${Date.now()}`, kind: 'text', text: '--- cleared ---', role: 'assistant' });
                 return;
             case 'help': {
                 const helpText = [
                     'commands:',
-                    '  /clear          — clear transcript marker',
-                    '  /diff           — show git diff',
-                    '  /status         — show session status',
-                    '  /compact        — (stub) context compaction',
-                    '  /model <id>     — switch model mid-session',
-                    '  /config         — show config path',
-                    '  /doctor         — run diagnostics',
-                    '  /version        — show version',
-                    '  /quit (/exit)   — exit',
-                    `provider: ${effectiveProvider}  model: ${model}  cwd: ${cwd}`,
+                    '  /clear            — clear transcript',
+                    '  /compact [focus]  — compact context (clears transcript, keeps marker)',
+                    '  /model [id]       — show or switch model mid-session',
+                    '  /provider [name]  — show or switch provider (openai|anthropic)',
+                    '  /effort [level]   — show or set effort (low|medium|high|max → steps)',
+                    '  /diff             — show git diff',
+                    '  /status           — show session status',
+                    '  /plan             — show current plan/todos',
+                    '  /verify           — detect + run verifiers',
+                    '  /project          — project scan',
+                    '  /context          — context breakdown',
+                    '  /cost             — token cost',
+                    '  /jobs             — background jobs',
+                    '  /memory           — session notes',
+                    '  /undo /rewind     — checkpoints',
+                    '  /login /logout    — credentials',
+                    '  /init             — create KLYRO.md',
+                    '  /config           — show config path',
+                    '  /doctor           — run diagnostics',
+                    '  /version          — show version',
+                    '  /quit (/exit)     — exit',
+                    `provider: ${currentProvider}  model: ${model}  effort: ${effortLevel} (${currentMaxSteps} steps)  cwd: ${cwd}`,
                 ].join('\n');
                 queuedAppend({ id: `help-${Date.now()}`, kind: 'text', text: helpText, role: 'assistant' });
                 return;
@@ -476,7 +504,7 @@ export async function startRepl(opts = {}) {
                     });
                 }
                 else {
-                    queuedAppend({ id: `stat2-${Date.now()}`, kind: 'text', text: `model: ${model}  provider: ${effectiveProvider}  cwd: ${cwd}`, role: 'assistant' });
+                    queuedAppend({ id: `stat2-${Date.now()}`, kind: 'text', text: `model: ${model}  provider: ${currentProvider}  effort: ${effortLevel} (${currentMaxSteps} steps)  cwd: ${cwd}`, role: 'assistant' });
                 }
                 return;
             }
@@ -577,14 +605,23 @@ export async function startRepl(opts = {}) {
                 return;
             }
             case 'compact': {
-                queuedAppend({ id: `compact-${Date.now()}`, kind: 'text', text: 'Compacting context…', role: 'assistant' });
-                queuedStatus({ status: 'running' });
+                const focus = cmd.focus?.trim();
+                queuedClear();
+                queuedAppend({
+                    id: `compact-${Date.now()}`,
+                    kind: 'text',
+                    text: focus ? `Context compacted — transcript cleared (focus: ${focus}). Continuing fresh.` : 'Context compacted — transcript cleared. Continuing fresh.',
+                    role: 'assistant',
+                });
+                queuedStatus({ status: 'done' });
                 return;
             }
             case 'model': {
                 const next = cmd.model?.trim();
                 if (!next) {
-                    queuedAppend({ id: `mdl-${Date.now()}`, kind: 'text', text: `current model: ${model}`, role: 'assistant' });
+                    const { MODEL_REGISTRY } = await import('../providers/model-info.js');
+                    const known = Object.keys(MODEL_REGISTRY).join(', ');
+                    queuedAppend({ id: `mdl-${Date.now()}`, kind: 'text', text: `current model: ${model}\nknown: ${known}\nusage: /model <id>`, role: 'assistant' });
                 }
                 else {
                     queuedStatus({ model: next });
@@ -593,6 +630,98 @@ export async function startRepl(opts = {}) {
                 }
                 return;
             }
+            case 'provider': {
+                const next = cmd.provider?.trim().toLowerCase();
+                if (!next) {
+                    queuedAppend({ id: `prov-${Date.now()}`, kind: 'text', text: `current provider: ${currentProvider}\nbaseURL: ${currentBaseUrl}\nusage: /provider <openai|anthropic>`, role: 'assistant' });
+                }
+                else if (next !== 'openai' && next !== 'anthropic') {
+                    queuedAppend({ id: `prov-err-${Date.now()}`, kind: 'error', message: `unknown provider: ${next} (expected openai|anthropic)` });
+                }
+                else {
+                    if (next === 'anthropic' && !currentApiKey) {
+                        queuedAppend({ id: `prov-warn-${Date.now()}`, kind: 'text', text: 'warning: no API key set — anthropic adapter may 401. Set KLYRO_API_KEY or use /login.', role: 'assistant' });
+                    }
+                    currentProvider = next;
+                    adapter = buildAdapter(currentProvider, currentBaseUrl, currentApiKey);
+                    queuedAppend({ id: `prov2-${Date.now()}`, kind: 'text', text: `provider switched to ${next} (takes effect on next prompt)`, role: 'assistant' });
+                }
+                return;
+            }
+            case 'effort': {
+                const level = cmd.level?.trim().toLowerCase();
+                if (!level) {
+                    queuedAppend({ id: `eff-${Date.now()}`, kind: 'text', text: `current effort: ${effortLevel} (${currentMaxSteps} steps)\nlevels: low (10) | medium (30) | high (50) | max (100)\nusage: /effort <level>`, role: 'assistant' });
+                }
+                else if (!EFFORT_STEPS[level]) {
+                    queuedAppend({ id: `eff-err-${Date.now()}`, kind: 'error', message: `unknown effort: ${level} (expected low|medium|high|max)` });
+                }
+                else {
+                    effortLevel = level;
+                    currentMaxSteps = EFFORT_STEPS[level];
+                    queuedStatus({ maxSteps: currentMaxSteps });
+                    queuedAppend({ id: `eff2-${Date.now()}`, kind: 'text', text: `effort set to ${level} (${currentMaxSteps} max steps)`, role: 'assistant' });
+                }
+                return;
+            }
+            case 'login': {
+                const { runLogin } = await import('./auth.js');
+                const code = await runLogin();
+                queuedAppend({ id: `login-${Date.now()}`, kind: 'text', text: code === 0 ? 'login saved (0600)' : 'login failed', role: 'assistant' });
+                return;
+            }
+            case 'logout': {
+                const { runLogout } = await import('./auth.js');
+                const code = await runLogout();
+                queuedAppend({ id: `logout-${Date.now()}`, kind: 'text', text: code === 0 ? 'logged out' : 'logout failed', role: 'assistant' });
+                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' });
+                }
+                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)}` });
+                    }
+                }
+                return;
+            }
+            case 'plan': {
+                try {
+                    const { readFileSync, existsSync } = await import('node:fs');
+                    const { join } = await import('node:path');
+                    const todosPath = join(cwd, '.klyro', 'plans', 'todos.json');
+                    if (!existsSync(todosPath)) {
+                        queuedAppend({ id: `plan-${Date.now()}`, kind: 'text', text: 'No active plan (no .klyro/plans/todos.json). The agent creates one via todo_write when planning.', role: 'assistant' });
+                    }
+                    else {
+                        const raw = readFileSync(todosPath, 'utf-8').slice(0, 2000);
+                        queuedAppend({ id: `plan2-${Date.now()}`, kind: 'text', text: `Plan (todos.json):\n${raw}`, role: 'assistant' });
+                    }
+                }
+                catch (err) {
+                    queuedAppend({ id: `plan-err-${Date.now()}`, kind: 'error', message: `plan failed: ${err instanceof Error ? err.message : String(err)}` });
+                }
+                return;
+            }
+            case 'prompt': {
+                // Regular prompts never reach onSlash — no-op for exhaustiveness.
+                return;
+            }
             case 'unknown':
                 queuedAppend({
                     id: `unk-${Date.now()}`,

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

@@ -18,9 +18,16 @@ export type SlashCommand = {
     kind: 'clear';
 } | {
     kind: 'compact';
+    focus?: string;
 } | {
     kind: 'model';
     model: string;
+} | {
+    kind: 'provider';
+    provider: string;
+} | {
+    kind: 'effort';
+    level: string;
 } | {
     kind: 'diff';
 } | {
@@ -56,8 +63,11 @@ export type SlashCommand = {
 } | {
     kind: 'context';
 } | {
-    kind: 'compact';
-    focus?: string;
+    kind: 'login';
+} | {
+    kind: 'logout';
+} | {
+    kind: 'init';
 } | {
     kind: 'prompt';
     text: string;

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 = ['clear', 'compact', 'model', 'diff', 'undo', 'rewind', 'plan', 'status', 'quit', 'help', 'config', 'doctor', 'version', 'cost', 'thinking', 'memory', 'jobs', 'verify', 'project', 'context', 'compact', 'exit', 'clear'];
+const KNOWN = ['clear', 'compact', 'model', 'm', 'provider', 'effort', 'diff', 'undo', 'rewind', 'plan', 'status', 'quit', 'exit', 'q', 'help', 'config', 'doctor', 'version', 'cost', 'thinking', 'memory', 'jobs', 'verify', 'project', 'context', 'login', 'logout', 'init'];
 export function parse(input) {
     const trimmed = input.trim();
     if (!trimmed.startsWith('/')) {
@@ -25,7 +25,7 @@ export function parse(input) {
     const rest = space === -1 ? '' : trimmed.slice(space + 1).trim();
     switch (name) {
         case 'clear': return { kind: 'clear' };
-        case 'compact': return { kind: 'compact' };
+        case 'compact': return { kind: 'compact', focus: rest || undefined };
         case 'diff': return { kind: 'diff' };
         case 'undo': return { kind: 'undo' };
         case 'rewind': return { kind: 'rewind' };
@@ -38,7 +38,9 @@ export function parse(input) {
         case 'verify': return { kind: 'verify' };
         case 'project': return { kind: 'project' };
         case 'context': return { kind: 'context' };
-        case 'compact': return { kind: 'compact', focus: rest || undefined };
+        case 'login': return { kind: 'login' };
+        case 'logout': return { kind: 'logout' };
+        case 'init': return { kind: 'init' };
         case 'quit':
         case 'exit':
         case 'q': return { kind: 'quit' };
@@ -47,10 +49,16 @@ export function parse(input) {
         case 'config': return { kind: 'config' };
         case 'doctor': return { kind: 'doctor' };
         case 'version': return { kind: 'version' };
+        case 'provider':
+        case 'p': {
+            return { kind: 'provider', provider: rest };
+        }
+        case 'effort':
+        case 'e': {
+            return { kind: 'effort', level: rest };
+        }
         case 'model':
         case 'm': {
-            if (!rest)
-                return { kind: 'unknown', raw: trimmed };
             return { kind: 'model', model: rest };
         }
         default: return { kind: 'unknown', raw: trimmed };

package/dist/tools/fs/apply-patch.js

@@ -6,7 +6,8 @@ import * as path from 'node:path';
 import { z } from 'zod';
 import { defineTool } from '../types.js';
 import { resolveAndFollowSymlinks } from '../../policy/path-guard.js';
-import { safe } from '../normalize.js';
+import { safe, TOOL_ERROR_CODES } from '../normalize.js';
+import { wasRead } from './read-history.js';
 const InputSchema = z.object({
     patch: z.string().min(1).describe('Unified diff patch text'),
 });
@@ -29,6 +30,18 @@ export const applyPatchTool = defineTool({
                     // Flush previous
                     if (currentFile && fileContent !== null) {
                         const { resolved } = await resolveAndFollowSymlinks(ctx.cwd, currentFile);
+                        if (fileContent === null)
+                            throw Object.assign(new Error('fileContent is null — cannot write'), { code: TOOL_ERROR_CODES.INTERNAL });
+                        try {
+                            const existing = await fs.readFile(resolved, 'utf-8');
+                            if (!wasRead(currentFile) && existing.length > 200) {
+                                throw Object.assign(new Error('File was not read this session and is >200 bytes — re-read before writing (POLICY_DENIED)'), { code: 'POLICY_DENIED' });
+                            }
+                        }
+                        catch (e) {
+                            if (e && typeof e === 'object' && e.code === 'POLICY_DENIED')
+                                throw e;
+                        }
                         await fs.mkdir(path.dirname(resolved), { recursive: true });
                         await fs.writeFile(resolved, fileContent, 'utf-8');
                         patchedFiles.push(currentFile);
@@ -48,6 +61,18 @@ export const applyPatchTool = defineTool({
                 if (line.startsWith('*** Add File:')) {
                     if (currentFile && fileContent !== null) {
                         const { resolved } = await resolveAndFollowSymlinks(ctx.cwd, currentFile);
+                        if (fileContent === null)
+                            throw Object.assign(new Error('fileContent is null — cannot write'), { code: TOOL_ERROR_CODES.INTERNAL });
+                        try {
+                            const existing = await fs.readFile(resolved, 'utf-8');
+                            if (!wasRead(currentFile) && existing.length > 200) {
+                                throw Object.assign(new Error('File was not read this session and is >200 bytes — re-read before writing (POLICY_DENIED)'), { code: 'POLICY_DENIED' });
+                            }
+                        }
+                        catch (e) {
+                            if (e && typeof e === 'object' && e.code === 'POLICY_DENIED')
+                                throw e;
+                        }
                         await fs.mkdir(path.dirname(resolved), { recursive: true });
                         await fs.writeFile(resolved, fileContent, 'utf-8');
                         patchedFiles.push(currentFile);
@@ -67,6 +92,18 @@ export const applyPatchTool = defineTool({
             }
             if (currentFile && fileContent !== null) {
                 const { resolved } = await resolveAndFollowSymlinks(ctx.cwd, currentFile);
+                if (fileContent === null)
+                    throw Object.assign(new Error('fileContent is null — cannot write'), { code: TOOL_ERROR_CODES.INTERNAL });
+                try {
+                    const existing = await fs.readFile(resolved, 'utf-8');
+                    if (!wasRead(currentFile) && existing.length > 200) {
+                        throw Object.assign(new Error('File was not read this session and is >200 bytes — re-read before writing (POLICY_DENIED)'), { code: 'POLICY_DENIED' });
+                    }
+                }
+                catch (e) {
+                    if (e && typeof e === 'object' && e.code === 'POLICY_DENIED')
+                        throw e;
+                }
                 await fs.mkdir(path.dirname(resolved), { recursive: true });
                 await fs.writeFile(resolved, fileContent, 'utf-8');
                 patchedFiles.push(currentFile);

package/dist/tools/shell/shell-exec.js

@@ -48,10 +48,21 @@ function filteredEnv(extra) {
             out[k] = v;
         }
     }
-    // Always allow basic
+    // Merge user extra AFTER filtering — but only allowed prefixes, block injection vectors
+    if (extra) {
+        for (const [k, v] of Object.entries(extra)) {
+            if (k === 'NODE_OPTIONS' || k === 'LD_PRELOAD' || k === 'LD_LIBRARY_PATH')
+                continue;
+            if (k.includes('SECRET') || k.includes('TOKEN') || k === 'ANTHROPIC_API_KEY' || k === 'OPENAI_API_KEY')
+                continue;
+            if (ALLOWED_ENV_PREFIXES.some((p) => k.startsWith(p)) || k === 'PATH' || k === 'PWD' || k === 'TMPDIR' || k === 'TEMP') {
+                out[k] = v;
+            }
+        }
+    }
     out.PATH = process.env.PATH;
-    if (extra)
-        Object.assign(out, extra);
+    if (out.NODE_OPTIONS)
+        delete out.NODE_OPTIONS;
     return out;
 }
 // Interactive command detection (3.3)

package/dist/tui/app.d.ts

@@ -1,6 +1,6 @@
 /**
- * Klyro TUI — opencode-clean — no clumsy words, correct wrap, markdown, scroll
- * Header 3 rows, guide │ at col2, ● Klyro accent, prose wrapped at word boundaries
+ * Klyro TUI - opencode-clean - no clumsy words, correct wrap, markdown, scroll
+ * Header 3 rows, guide │ at col2, ● Klyro accent, prose wrapped at word boundaries
  */
 import React from 'react';
 import type { StatusSnapshot } from './status.js';
@@ -21,6 +21,7 @@ export interface AppProps {
         appendDelta: (text: string) => void;
         updateStatus: (s: Partial<StatusSnapshot>) => void;
         updatePlan: (p: PlanStep[]) => void;
+        clearTranscript: () => void;
     }) => void;
     version?: string;
     isFullscreen?: boolean;

package/dist/tui/app.js

@@ -1,7 +1,7 @@
 import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
 /**
- * Klyro TUI — opencode-clean — no clumsy words, correct wrap, markdown, scroll
- * Header 3 rows, guide │ at col2, ● Klyro accent, prose wrapped at word boundaries
+ * Klyro TUI - opencode-clean - no clumsy words, correct wrap, markdown, scroll
+ * Header 3 rows, guide │ at col2, ● Klyro accent, prose wrapped at word boundaries
  */
 import { useState, useEffect, useRef, useCallback, useMemo } from 'react';
 import { Box, Text, useInput, useStdout } from 'ink';
@@ -19,7 +19,7 @@ function Header({ cwd, model, version, width }) {
         return '';
     } })();
     const showLinks = width >= 120;
-    return (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsxs(Box, { justifyContent: "space-between", children: [_jsxs(Text, { bold: true, color: tokens.colors.accent, children: ["KLYRO  v", version] }), showLinks ? _jsx(Text, { color: tokens.colors.dim, children: "\u00E2\u201D\u201A  /help   /config   /clear   /exit" }) : null] }), _jsxs(Text, { color: tokens.colors.dim, children: [model, "[200k]  \u00C2\u00B7  API Usage Billing"] }), _jsxs(Text, { color: tokens.colors.dim, children: [cwd, branch ? `  ·  ${branch}` : ''] })] }));
+    return (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsxs(Box, { justifyContent: "space-between", children: [_jsxs(Text, { bold: true, color: tokens.colors.accent, children: ["KLYRO  v", version] }), showLinks ? _jsx(Text, { color: tokens.colors.dim, children: "\u2502  /help   /config   /clear   /exit" }) : null] }), _jsxs(Text, { color: tokens.colors.dim, children: [model, "[200k]  \u00B7  API Usage Billing"] }), _jsxs(Text, { color: tokens.colors.dim, children: [cwd, branch ? `  ·  ${branch}` : ''] })] }));
 }
 function verbForTool(name) {
     if (name === 'read_file')
@@ -71,7 +71,7 @@ function groupTools(items) {
     flush();
     return out;
 }
-// Simple markdown: **bold** → bold, keep lists/tables, wrap at word boundaries
+// Simple markdown: **bold** †’ bold, keep lists/tables, wrap at word boundaries
 function MarkdownText({ text, dim, width }) {
     // Split by **bold** segments
     const parts = [];
@@ -89,7 +89,7 @@ function MarkdownText({ text, dim, width }) {
         parts.push(_jsx(Text, { color: dim ? tokens.colors.dim : undefined, wrap: "wrap", children: text.slice(last) }, `t-${idx++}`));
     if (parts.length === 0)
         return _jsx(Text, { color: dim ? tokens.colors.dim : undefined, wrap: "wrap", children: text });
-    // Render as single line with bold segments — Ink will wrap the parent Box
+    // Render as single line with bold segments — Ink will wrap the parent Box
     return _jsx(Text, { wrap: "wrap", children: parts });
 }
 // Chat scroll state: scrollOffset, pinned (user scrolled away from bottom),
@@ -233,9 +233,10 @@ export function App(props) {
         streamingIdRef.current = null; }, [status.status]);
     const updateStatus = useCallback((s) => setStatus((p) => ({ ...p, ...s })), []);
     const updatePlan = useCallback((p) => setPlan(p), []);
+    const clearTranscript = useCallback(() => { streamingIdRef.current = null; setTranscript([]); setPlan([]); }, []);
     const onMountedRef = useRef(props.onMounted);
     useEffect(() => { onMountedRef.current = props.onMounted; }, [props.onMounted]);
-    useEffect(() => { onMountedRef.current?.({ append, appendDelta, updateStatus, updatePlan }); globalThis.__klyroAppAppend = append; globalThis.__klyroAppendDelta = appendDelta; globalThis.__klyroAppStatus = updateStatus; globalThis.__klyroAppPlan = updatePlan; return () => { delete globalThis.__klyroAppAppend; delete globalThis.__klyroAppendDelta; delete globalThis.__klyroAppStatus; delete globalThis.__klyroAppPlan; }; }, [append, appendDelta, updateStatus, updatePlan]);
+    useEffect(() => { onMountedRef.current?.({ append, appendDelta, updateStatus, updatePlan, clearTranscript }); globalThis.__klyroAppAppend = append; globalThis.__klyroAppendDelta = appendDelta; globalThis.__klyroAppStatus = updateStatus; globalThis.__klyroAppPlan = updatePlan; return () => { delete globalThis.__klyroAppAppend; delete globalThis.__klyroAppendDelta; delete globalThis.__klyroAppStatus; delete globalThis.__klyroAppPlan; }; }, [append, appendDelta, updateStatus, updatePlan, clearTranscript]);
     const toggleGroup = (id) => setExpandedGroups((prev) => { const n = new Set(prev); if (n.has(id))
         n.delete(id);
     else
@@ -330,9 +331,9 @@ export function App(props) {
     const cost = (status.usageInput / 1000 * 0.003 + status.usageOutput / 1000 * 0.015);
     const totalTokens = status.usageInput + status.usageOutput;
     const ctxPct = totalTokens > 0 ? Math.round((totalTokens / 120_000) * 100) : 0;
-    const baseHints = status.status === 'running' ? 'ctrl+c to stop  ·  enter to queue  ·  ctrl+o expand' : transcript.length === 0 ? 'shift+tab to cycle  ·  ↑↓ for history  ·  / for commands' : 'enter to send  ·  shift+enter newline  ·  @ to attach';
-    const hints = maxOffset > 0 && isFullscreen ? `${baseHints}  ·  PgUp/Dn scroll` : baseHints;
-    return (_jsxs(Box, { flexDirection: "column", width: width, height: isFullscreen ? height - 1 : undefined, children: [_jsx(Header, { cwd: props.cwd, model: status.model, version: ver, width: width }), _jsxs(Box, { flexDirection: "row", flexGrow: isFullscreen ? 1 : 0, overflow: isFullscreen ? 'hidden' : undefined, children: [_jsxs(Box, { flexDirection: "column", flexGrow: 1, overflow: isFullscreen ? 'hidden' : undefined, paddingX: 0, children: [grouped.length === 0 ? (_jsx(Text, { color: tokens.colors.dim, children: "Message Klyro\u00E2\u20AC\u00A6" })) : visibleGrouped.map((item) => {
+    const baseHints = status.status === 'running' ? 'ctrl+c to stop  ·  enter to queue  ·  ctrl+o expand' : transcript.length === 0 ? 'shift+tab to cycle  ·  †‘†“ for history  ·  / for commands' : 'enter to send  ·  shift+enter newline  ·  @ to attach';
+    const hints = maxOffset > 0 && isFullscreen ? `${baseHints}  ·  PgUp/Dn scroll` : baseHints;
+    return (_jsxs(Box, { flexDirection: "column", width: width, height: isFullscreen ? height - 1 : undefined, children: [_jsx(Header, { cwd: props.cwd, model: status.model, version: ver, width: width }), _jsxs(Box, { flexDirection: "row", flexGrow: isFullscreen ? 1 : 0, overflow: isFullscreen ? 'hidden' : undefined, children: [_jsxs(Box, { flexDirection: "column", flexGrow: 1, overflow: isFullscreen ? 'hidden' : undefined, paddingX: 0, children: [grouped.length === 0 ? (_jsx(Text, { color: tokens.colors.dim, children: "Message Klyro..." })) : visibleGrouped.map((item) => {
                                 if (item.verb) {
                                     const gr = item;
                                     const isExpanded = expandedGroups.has(gr.id);
@@ -365,8 +366,8 @@ export function App(props) {
                                             return `Edited ${gr.items.length} files`;
                                         return `${gr.verb} ${gr.items.length} items`;
                                     })();
-                                    const right = gr.status === 'running' ? `${(elapsed / 1000).toFixed(1)}s` : gr.status === 'error' ? '✗' : `${gr.totalMs}ms`;
-                                    const marker = isExpanded ? '▼' : '✓';
+                                    const right = gr.status === 'running' ? `${(elapsed / 1000).toFixed(1)}s` : gr.status === 'error' ? 'œ—' : `${gr.totalMs}ms`;
+                                    const marker = isExpanded ? '–¼' : 'œ“';
                                     const markerColor = gr.status === 'error' ? tokens.colors.err : gr.status === 'running' ? tokens.colors.warn : tokens.colors.ok;
                                     return (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsxs(Box, { children: [_jsxs(Text, { color: tokens.colors.guide, children: ["  ", g('guide'), "   "] }), _jsxs(Text, { color: markerColor, children: [marker, " ", verbLine] }), _jsxs(Text, { color: tokens.colors.dim, children: ["  ", right] })] }), isExpanded ? gr.items.map((it) => {
                                                 let friendly = '';
@@ -394,11 +395,11 @@ export function App(props) {
                                     return _jsxs(Box, { marginBottom: 1, children: [_jsxs(Text, { color: tokens.colors.accent, bold: true, children: [g('prompt'), " "] }), _jsx(Text, { wrap: "wrap", children: it.text })] }, it.id);
                                 }
                                 if (it.kind === 'text') {
-                                    // prose — render markdown, not raw **, with proper wrap and guide
+                                    // prose — render markdown, not raw **, with proper wrap and guide
                                     return (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsxs(Box, { children: [_jsxs(Text, { color: tokens.colors.guide, children: ["  ", g('guide'), "   "] }), _jsxs(Text, { color: tokens.colors.accent, children: [g('agentBullet'), " Klyro"] })] }), _jsx(Box, { paddingLeft: 2, flexDirection: "column", children: _jsxs(Box, { children: [_jsxs(Text, { color: tokens.colors.dim, children: ["  ", g('guide'), "   "] }), _jsx(Box, { flexGrow: 1, children: _jsx(MarkdownText, { text: it.text }) })] }) })] }, it.id));
                                 }
                                 if (it.kind === 'error')
-                                    return _jsx(Box, { paddingLeft: 2, marginBottom: 1, children: _jsxs(Text, { color: tokens.colors.err, children: ["  ", g('guide'), "   \u00E2\u0153\u2014 ", it.message] }) }, it.id);
+                                    return _jsx(Box, { paddingLeft: 2, marginBottom: 1, children: _jsxs(Text, { color: tokens.colors.err, children: ["  ", g('guide'), "   \u0153\u2014 ", it.message] }) }, it.id);
                                 if (it.kind === 'policy')
                                     return null;
                                 if (it.kind === 'file_changed')
@@ -406,5 +407,5 @@ export function App(props) {
                                 if (it.kind === 'diff')
                                     return (_jsxs(Box, { flexDirection: "column", paddingLeft: 2, marginBottom: 1, children: [_jsx(Text, { bold: true, color: tokens.colors.soft, children: it.summary ?? 'Diff' }), it.hunks.map((h, i) => (_jsxs(Box, { flexDirection: "column", marginTop: 0, children: [_jsx(Text, { color: tokens.colors.soft, children: h.path }), h.lines.map((l, j) => (_jsxs(Text, { wrap: "wrap", color: l.kind === 'add' ? tokens.colors.ok : l.kind === 'remove' ? tokens.colors.err : tokens.colors.dim, children: [l.kind === 'add' ? '+ ' : l.kind === 'remove' ? '- ' : '  ', l.text] }, j)))] }, i)))] }, it.id));
                                 return null;
-                            }), status.status === 'running' && !streamingIdRef.current ? (_jsxs(Box, { paddingLeft: 2, marginBottom: 1, children: [_jsxs(Text, { color: tokens.colors.guide, children: ["  ", g('guide'), "   "] }), _jsx(Text, { color: tokens.colors.dim, children: "Thinking..." }), _jsxs(Text, { color: tokens.colors.dim, children: ["  ", (elapsed / 1000).toFixed(1), "s"] })] })) : null, plan.length > 0 ? (_jsxs(Box, { flexDirection: "column", paddingLeft: 2, marginTop: 0, marginBottom: 1, children: [_jsxs(Box, { children: [_jsxs(Text, { color: tokens.colors.guide, children: ["  ", g('guide'), "   "] }), _jsxs(Text, { bold: true, children: [g('todoPlan'), " Plan  ", plan.filter((p) => p.status === 'done').length, "/", plan.length] })] }), plan.slice(0, 8).map((p) => (_jsxs(Box, { children: [_jsxs(Text, { color: tokens.colors.guide, children: ["  ", g('guide'), "   "] }), _jsxs(Text, { color: p.status === 'done' ? tokens.colors.ok : p.status === 'in_progress' ? tokens.colors.accent : tokens.colors.dim, children: [p.status === 'done' ? g('todoDone') : p.status === 'in_progress' ? g('todoActive') : g('todoPending'), " ", p.title] })] }, p.id)))] })) : null, queuedInputs.length > 0 ? (_jsx(Box, { flexDirection: "column", paddingLeft: 2, marginBottom: 1, children: queuedInputs.map((q, i) => (_jsxs(Text, { color: tokens.colors.dim, children: ["queued: ", q.slice(0, 60), i === 0 ? '  esc to drop' : ''] }, i))) })) : null] }), isFullscreen ? (_jsx(Box, { flexDirection: "column", width: 1, marginLeft: 1, children: Array.from({ length: trackH }).map((_, i) => (_jsx(Text, { color: i === thumbPos ? tokens.colors.accent : tokens.colors.guide, children: i === thumbPos ? '●' : '│' }, i))) })) : null] }), pinned && pendingNew > 0 ? (_jsx(Box, { justifyContent: "flex-end", paddingX: 1, marginTop: -1, children: _jsxs(Text, { backgroundColor: tokens.colors.accentSoft, color: tokens.colors.accent, bold: true, children: [' ↓ ', pendingNew, ' new ', pendingNew === 1 ? 'message' : 'messages', ' '] }) })) : null, _jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: tokens.colors.guide, children: g('rule').repeat(Math.max(10, width - 2)) }), _jsxs(Box, { children: [_jsxs(Text, { color: tokens.colors.accent, bold: true, children: [g('prompt'), " "] }), _jsxs(Text, { wrap: "wrap", children: [input || _jsx(Text, { color: tokens.colors.dim, children: "Message Klyro\u00E2\u20AC\u00A6" }), "\u00E2\u2013\u008F"] })] }), _jsx(Text, { color: tokens.colors.guide, children: g('rule').repeat(Math.max(10, width - 2)) })] }), _jsxs(Box, { justifyContent: "space-between", children: [_jsxs(Text, { color: tokens.colors.dim, children: [baseHints, maxOffset > 0 && isFullscreen ? '  ·  PgUp/Dn scroll' : ''] }), _jsxs(Text, { color: tokens.colors.dim, children: [cost > 0 ? `$${cost.toFixed(2)} · ` : '', ctxPct > 0 ? `${ctxPct}% ctx · ` : '', status.status === 'running' ? 'auto mode on ●' : ''] })] })] }));
+                            }), status.status === 'running' && !streamingIdRef.current ? (_jsxs(Box, { paddingLeft: 2, marginBottom: 1, children: [_jsxs(Text, { color: tokens.colors.guide, children: ["  ", g('guide'), "   "] }), _jsx(Text, { color: tokens.colors.dim, children: "Thinking..." }), _jsxs(Text, { color: tokens.colors.dim, children: ["  ", (elapsed / 1000).toFixed(1), "s"] })] })) : null, plan.length > 0 ? (_jsxs(Box, { flexDirection: "column", paddingLeft: 2, marginTop: 0, marginBottom: 1, children: [_jsxs(Box, { children: [_jsxs(Text, { color: tokens.colors.guide, children: ["  ", g('guide'), "   "] }), _jsxs(Text, { bold: true, children: [g('todoPlan'), " Plan  ", plan.filter((p) => p.status === 'done').length, "/", plan.length] })] }), plan.slice(0, 8).map((p) => (_jsxs(Box, { children: [_jsxs(Text, { color: tokens.colors.guide, children: ["  ", g('guide'), "   "] }), _jsxs(Text, { color: p.status === 'done' ? tokens.colors.ok : p.status === 'in_progress' ? tokens.colors.accent : tokens.colors.dim, children: [p.status === 'done' ? g('todoDone') : p.status === 'in_progress' ? g('todoActive') : g('todoPending'), " ", p.title] })] }, p.id)))] })) : null, queuedInputs.length > 0 ? (_jsx(Box, { flexDirection: "column", paddingLeft: 2, marginBottom: 1, children: queuedInputs.map((q, i) => (_jsxs(Text, { color: tokens.colors.dim, children: ["queued: ", q.slice(0, 60), i === 0 ? '  esc to drop' : ''] }, i))) })) : null] }), isFullscreen ? (_jsx(Box, { flexDirection: "column", width: 1, marginLeft: 1, children: Array.from({ length: trackH }).map((_, i) => (_jsx(Text, { color: i === thumbPos ? tokens.colors.accent : tokens.colors.guide, children: i === thumbPos ? '●' : '│' }, i))) })) : null] }), pinned && pendingNew > 0 ? (_jsx(Box, { justifyContent: "flex-end", paddingX: 1, marginTop: -1, children: _jsxs(Text, { backgroundColor: tokens.colors.accentSoft, color: tokens.colors.accent, bold: true, children: [' ↓ ', pendingNew, ' new ', pendingNew === 1 ? 'message' : 'messages', ' '] }) })) : null, _jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: tokens.colors.guide, children: g('rule').repeat(Math.max(10, width - 2)) }), _jsxs(Box, { children: [_jsxs(Text, { color: tokens.colors.accent, bold: true, children: [g('prompt'), " "] }), _jsxs(Text, { wrap: "wrap", children: [input || _jsx(Text, { color: tokens.colors.dim, children: "Message Klyro..." }), "|"] })] }), _jsx(Text, { color: tokens.colors.guide, children: g('rule').repeat(Math.max(10, width - 2)) })] }), _jsxs(Box, { justifyContent: "space-between", children: [_jsxs(Text, { color: tokens.colors.dim, children: [baseHints, maxOffset > 0 && isFullscreen ? '  ·  PgUp/Dn scroll' : ''] }), _jsxs(Text, { color: tokens.colors.dim, children: [cost > 0 ? `$${cost.toFixed(2)} · ` : '', ctxPct > 0 ? `${ctxPct}% ctx · ` : '', status.status === 'running' ? 'auto mode on ●' : ''] })] })] }));
 }

package/dist/verification/baseline.js

@@ -66,17 +66,11 @@ export async function runBaseline(cwd, command, timeoutMs = 90_000) {
     return baseline;
 }
 const MAX_BASELINE_BYTES = 256 * 1024;
-function cap(cur, chunk) {
-    if (cur.length >= MAX_BASELINE_BYTES)
-        return cur;
-    const n = cur + chunk;
-    return n.length > MAX_BASELINE_BYTES ? n.slice(0, MAX_BASELINE_BYTES) + '\n... [truncated]' : n;
-}
 function runCmd(cwd, command, timeoutMs) {
     return new Promise((resolve) => {
         const child = spawn(command, { cwd, shell: true, env: process.env });
-        let stdout = '';
-        let stderr = '';
+        const outChunks = [];
+        const errChunks = [];
         let done = false;
         const timer = setTimeout(() => {
             if (done)
@@ -86,24 +80,31 @@ function runCmd(cwd, command, timeoutMs) {
                 child.kill();
             }
             catch { /* ignore */ }
-            resolve({ ok: false, exitCode: -1, stdout, stderr: stderr + '\n[baseline timeout]' });
+            const so = Buffer.concat(outChunks).toString('utf-8').slice(0, MAX_BASELINE_BYTES);
+            const se = Buffer.concat(errChunks).toString('utf-8').slice(0, MAX_BASELINE_BYTES);
+            resolve({ ok: false, exitCode: -1, stdout: so, stderr: se + '\n[baseline timeout]' });
         }, timeoutMs);
-        child.stdout.on('data', (b) => { stdout = cap(stdout, b.toString()); });
-        child.stderr.on('data', (b) => { stderr = cap(stderr, b.toString()); });
+        child.stdout.on('data', (b) => { if (Buffer.concat(outChunks).length < MAX_BASELINE_BYTES)
+            outChunks.push(b); });
+        child.stderr.on('data', (b) => { if (Buffer.concat(errChunks).length < MAX_BASELINE_BYTES)
+            errChunks.push(b); });
         child.on('close', (code) => {
             if (done)
                 return;
             done = true;
             clearTimeout(timer);
             const exit = typeof code === 'number' ? code : -1;
-            resolve({ ok: exit === 0, exitCode: exit, stdout, stderr });
+            const so = Buffer.concat(outChunks).toString('utf-8').slice(0, MAX_BASELINE_BYTES);
+            const se = Buffer.concat(errChunks).toString('utf-8').slice(0, MAX_BASELINE_BYTES);
+            resolve({ ok: exit === 0, exitCode: exit, stdout: so, stderr: se });
         });
         child.on('error', (err) => {
             if (done)
                 return;
             done = true;
             clearTimeout(timer);
-            resolve({ ok: false, exitCode: -1, stdout, stderr: String(err) });
+            const so = Buffer.concat(outChunks).toString('utf-8').slice(0, MAX_BASELINE_BYTES);
+            resolve({ ok: false, exitCode: -1, stdout: so, stderr: String(err) });
         });
     });
 }

package/dist/verification/classify.js

@@ -7,7 +7,7 @@ import { spawn } from 'node:child_process';
 export function classifyFailure(current, baseline, flakyRerunOk) {
     const combined = (current.stderr + '\n' + current.stdout).toLowerCase();
     // env: missing binary, network, permission, no such file, EACCES etc
-    if (/enoent|command not found|no such file|network|econn|etimedout|eacces|permission denied|env/.test(combined) && /error/i.test(combined)) {
+    if (/enoent|command not found|no such file|network|econn|etimedout|eacces|permission denied|environment variable/.test(combined) && /error/i.test(combined)) {
         // only if not a real test failure but env
         if (!current.failure || current.failure.type === 'unknown')
             return 'env';
@@ -42,7 +42,7 @@ export async function rerunOnce(cwd, command, timeoutMs = 45_000) {
         const t = setTimeout(() => { if (!done) {
             done = true;
             try {
-                child.kill();
+                child.kill('SIGKILL');
             }
             catch { }
             resolve(false);
@@ -72,19 +72,30 @@ export async function gatherRepairContext(cwd, failure) {
         }
     }
     // hunks: git diff --stat + --unified=2 for changed files
-    const hunks = await execCapture(cwd, 'git diff --stat && echo "---" && git diff -U2 2>&1 | head -n 300');
-    const blame = failure?.files[0]?.path
-        ? await execCapture(cwd, `git blame "${failure.files[0].path}" 2>&1 | head -n 20`)
+    const hunks = await execCapturePipe(cwd, 'git diff --stat && echo "---" && git diff -U2 2>&1 | head -n 300');
+    const blamePath = failure?.files[0]?.path;
+    const blame = blamePath && /^[\w./-]+$/.test(blamePath) && !blamePath.includes('..')
+        ? await execCaptureArgv(cwd, blamePath, ['--no-pager', 'blame', '--'])
         : '';
     return { failingTests, hunks, blame };
 }
-function execCapture(cwd, cmd) {
+function execCapturePipe(cwd, cmd) {
     return new Promise((resolve) => {
         const child = spawn(cmd, { cwd, shell: true, env: process.env });
-        let out = '';
-        child.stdout.on('data', (b) => { out += b.toString(); });
-        child.stderr.on('data', (b) => { out += b.toString(); });
-        child.on('close', () => resolve(out.slice(0, 4000)));
+        const chunks = [];
+        child.stdout.on('data', (b) => { chunks.push(b); });
+        child.stderr.on('data', (b) => { chunks.push(b); });
+        child.on('close', () => resolve(Buffer.concat(chunks).toString().slice(0, 4000)));
+        child.on('error', () => resolve(''));
+    });
+}
+function execCaptureArgv(cwd, file, args) {
+    return new Promise((resolve) => {
+        const child = spawn('git', [...args, file], { cwd, shell: false, env: process.env });
+        const chunks = [];
+        child.stdout.on('data', (b) => { chunks.push(b); });
+        child.stderr.on('data', (b) => { chunks.push(b); });
+        child.on('close', () => resolve(Buffer.concat(chunks).toString().split('\n').slice(0, 20).join('\n')));
         child.on('error', () => resolve(''));
     });
 }

package/dist/verification/engine.js

@@ -17,41 +17,88 @@ function appendCapped(current, chunk) {
     const next = current + chunk;
     return next.length > MAX_VERIFY_BYTES ? next.slice(0, MAX_VERIFY_BYTES) + '\n... [truncated]' : next;
 }
+// SEC-004: denylist for dangerous patterns in verify commands.
+// Reuses the same patterns as shell-exec.ts DANGEROUS_PATTERNS.
+const DANGEROUS_VERIFY_PATTERNS = [
+    { pattern: /rm\s+-rf?\s+\//, reason: 'recursive delete at filesystem root' },
+    { pattern: /rm\s+-rf?\s+\/\/+/, reason: 'recursive delete at filesystem root (//)' },
+    { pattern: /rm\s+-rf?\s+\/\*/, reason: 'recursive delete at filesystem root (/*)' },
+    { pattern: /rm\s+-rf?\s+\.\s*($|[;&|])/, reason: 'recursive delete current directory' },
+    { pattern: /rm\s+-rf?\s+\*\s*($|[;&|])/, reason: 'recursive delete all files via *' },
+    { pattern: /rm\s+-rf?\s+\.\/\*\s*($|[;&|])/, reason: 'recursive delete all files' },
+    { pattern: /rm\s+-rf?\s+~(\/|$)/, reason: 'recursive delete home directory via ~' },
+    { pattern: /rm\s+-rf?\s+\$HOME\b/, reason: 'recursive delete home via $HOME' },
+    { pattern: /rm\s+-rf?\s+\$PWD\b/, reason: 'recursive delete via $PWD' },
+    { pattern: /del\s+\/s\s+\/q\s+[a-z]:\\/i, reason: 'recursive delete on Windows drive root' },
+    { pattern: /:\(\)\s*\{\s*:\s*\|\s*:\s*&\s*\}\s*;\s*:/, reason: 'fork bomb' },
+    { pattern: /bomb\(\)\s*\{\s*bomb\|bomb/, reason: 'fork bomb variant' },
+    { pattern: />\s*\/dev\/sd[a-z]/, reason: 'overwrite raw block device' },
+    { pattern: /mkfs(\.|\s)/, reason: 'format filesystem' },
+    { pattern: /dd\s+.*of=\/dev\//, reason: 'dd write to device' },
+    { pattern: /chmod\s+-R\s+777\s+\//, reason: 'chmod 777 on root' },
+    { pattern: /curl.*\|\s*(sh|bash|zsh|python|python3|perl|ruby|php)/i, reason: 'curl|sh to unknown host' },
+    { pattern: /wget.*\|\s*(sh|bash|python|perl|ruby)/i, reason: 'wget|sh pipe' },
+    { pattern: /rm\s+-rf\s+--no-preserve-root\s+\//, reason: 'recursive delete --no-preserve-root' },
+    { pattern: /\$\(/, reason: 'command substitution $()' },
+    { pattern: /`[^`]*`/, reason: 'command substitution via backticks' },
+    { pattern: /\|\s*bash\b|\|\s*sh\b/, reason: 'pipe to shell' },
+    { pattern: /;\s*rm\s+-rf/, reason: 'chained rm -rf' },
+    { pattern: /&&\s*rm\s+-rf/, reason: 'chained rm -rf' },
+    { pattern: /\|\|\s*rm\s+-rf/, reason: 'chained rm -rf' },
+];
 export async function verify(opts) {
+    // SEC-004: reject dangerous patterns before spawning
+    for (const { pattern, reason } of DANGEROUS_VERIFY_PATTERNS) {
+        if (pattern.test(opts.command)) {
+            return {
+                ok: false,
+                exitCode: -1,
+                stdout: '',
+                stderr: `Command blocked: ${reason}`,
+                failure: { type: 'runtime', files: [], raw: `Command blocked: ${reason}`, exitCode: -1 },
+            };
+        }
+    }
     const timeout = opts.timeoutMs ?? 5 * 60 * 1000;
     return new Promise((resolve) => {
         const child = spawn(opts.command, { cwd: opts.cwd, shell: true, env: process.env });
-        let stdout = '';
-        let stderr = '';
+        const outChunks = [];
+        const errChunks = [];
         let done = false;
         const timer = setTimeout(() => {
             if (done)
                 return;
             child.kill();
             done = true;
-            const raw = stderr + '\n' + stdout;
+            const so = Buffer.concat(outChunks).toString('utf-8').slice(0, MAX_VERIFY_BYTES);
+            const se = Buffer.concat(errChunks).toString('utf-8').slice(0, MAX_VERIFY_BYTES);
+            const raw = se + '\n' + so;
             resolve({
                 ok: false,
                 exitCode: -1,
-                stdout,
-                stderr: stderr + '\n[verify timeout]',
+                stdout: so,
+                stderr: se + '\n[verify timeout]',
                 failure: { type: 'runtime', files: [], raw, exitCode: -1 },
             });
         }, timeout);
-        child.stdout.on('data', (b) => { stdout = appendCapped(stdout, b.toString()); });
-        child.stderr.on('data', (b) => { stderr = appendCapped(stderr, b.toString()); });
+        child.stdout.on('data', (b) => { if (Buffer.concat(outChunks).length < MAX_VERIFY_BYTES)
+            outChunks.push(b); });
+        child.stderr.on('data', (b) => { if (Buffer.concat(errChunks).length < MAX_VERIFY_BYTES)
+            errChunks.push(b); });
         child.on('close', (code) => {
             if (done)
                 return;
             done = true;
             clearTimeout(timer);
+            const so = Buffer.concat(outChunks).toString('utf-8').slice(0, MAX_VERIFY_BYTES);
+            const se = Buffer.concat(errChunks).toString('utf-8').slice(0, MAX_VERIFY_BYTES);
             const exit = typeof code === 'number' ? code : -1;
             if (exit === 0) {
-                resolve({ ok: true, exitCode: 0, stdout, stderr });
+                resolve({ ok: true, exitCode: 0, stdout: so, stderr: se });
                 return;
             }
-            const failure = detect(stdout, stderr, exit);
-            resolve({ ok: false, exitCode: exit, stdout, stderr, failure });
+            const failure = detect(so, se, exit);
+            resolve({ ok: false, exitCode: exit, stdout: so, stderr: se, failure });
         });
     });
 }

package/dist/verification/scoped.js

@@ -71,17 +71,11 @@ export function buildScopedCommand(cwd, baseCommand, relatedTests) {
     return null;
 }
 const MAX_SCOPED_BYTES = 256 * 1024;
-function appendCappedScoped(cur, chunk) {
-    if (cur.length >= MAX_SCOPED_BYTES)
-        return cur;
-    const n = cur + chunk;
-    return n.length > MAX_SCOPED_BYTES ? n.slice(0, MAX_SCOPED_BYTES) + '\n... [truncated]' : n;
-}
 export async function runScopedVerify(cwd, command, timeoutMs = 45_000) {
     return new Promise((resolve) => {
         const child = spawn(command, { cwd, shell: true, env: process.env });
-        let stdout = '';
-        let stderr = '';
+        const outChunks = [];
+        const errChunks = [];
         let done = false;
         const timer = setTimeout(() => {
             if (done)
@@ -91,24 +85,31 @@ export async function runScopedVerify(cwd, command, timeoutMs = 45_000) {
                 child.kill();
             }
             catch { /* ignore */ }
-            resolve({ ok: false, exitCode: -1, stdout, stderr: stderr + '\n[scoped timeout]' });
+            const so = Buffer.concat(outChunks).toString('utf-8').slice(0, MAX_SCOPED_BYTES);
+            const se = Buffer.concat(errChunks).toString('utf-8').slice(0, MAX_SCOPED_BYTES);
+            resolve({ ok: false, exitCode: -1, stdout: so, stderr: se + '\n[scoped timeout]' });
         }, timeoutMs);
-        child.stdout.on('data', (b) => { stdout = appendCappedScoped(stdout, b.toString()); });
-        child.stderr.on('data', (b) => { stderr = appendCappedScoped(stderr, b.toString()); });
+        child.stdout.on('data', (b) => { if (Buffer.concat(outChunks).length < MAX_SCOPED_BYTES)
+            outChunks.push(b); });
+        child.stderr.on('data', (b) => { if (Buffer.concat(errChunks).length < MAX_SCOPED_BYTES)
+            errChunks.push(b); });
         child.on('close', (code) => {
             if (done)
                 return;
             done = true;
             clearTimeout(timer);
             const exit = typeof code === 'number' ? code : -1;
-            resolve({ ok: exit === 0, exitCode: exit, stdout, stderr });
+            const so = Buffer.concat(outChunks).toString('utf-8').slice(0, MAX_SCOPED_BYTES);
+            const se = Buffer.concat(errChunks).toString('utf-8').slice(0, MAX_SCOPED_BYTES);
+            resolve({ ok: exit === 0, exitCode: exit, stdout: so, stderr: se });
         });
         child.on('error', (err) => {
             if (done)
                 return;
             done = true;
             clearTimeout(timer);
-            resolve({ ok: false, exitCode: -1, stdout, stderr: String(err) });
+            const so = Buffer.concat(outChunks).toString('utf-8').slice(0, MAX_SCOPED_BYTES);
+            resolve({ ok: false, exitCode: -1, stdout: so, stderr: String(err) });
         });
     });
 }

package/package.json

@@ -1,60 +1,60 @@
-{
-  "name": "klyro",
-  "version": "0.1.41",
-  "description": "Klyro — autonomous coding harness CLI that streams from any OpenAI-compatible or Anthropic LLM endpoint.",
-  "type": "module",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "bin": {
-    "klyro": "dist/index.js",
-    "ky": "dist/index.js"
-  },
-  "files": [
-    "dist",
-    "README.md",
-    "READ.md",
-    "LICENSE"
-  ],
-  "engines": {
-    "node": ">=20"
-  },
-  "scripts": {
-    "build": "tsc",
-    "start": "node dist/index.js",
-    "dev": "tsx src/index.ts",
-    "dev:watch": "tsx watch src/index.ts",
-    "typecheck": "tsc --noEmit",
-    "test": "vitest run",
-    "test:watch": "vitest",
-    "prepublishOnly": "npm run typecheck && npm test && npm run build",
-    "pack:dry": "npm pack --dry-run",
-    "publish:public": "npm publish --access public"
-  },
-  "keywords": [
-    "llm",
-    "ai",
-    "cli",
-    "openai",
-    "anthropic",
-    "harness",
-    "agent",
-    "streaming",
-    "klyro"
-  ],
-  "license": "MIT",
-  "dependencies": {
-    "commander": "^12.1.0",
-    "ink": "^7.1.1",
-    "ink-spinner": "^5.0.0",
-    "react": "^19.2.0",
-    "zod": "^4.5.4"
-  },
-  "devDependencies": {
-    "@types/node": "^22.9.0",
-    "@types/react": "^19.2.18",
-    "ink-testing-library": "^4.0.0",
-    "tsx": "^4.23.13",
-    "typescript": "^5.5.4",
-    "vitest": "^4.1.11"
-  }
-}
+{
+  "name": "klyro",
+  "version": "0.1.43",
+  "description": "Klyro \u2014 autonomous coding harness CLI that streams from any OpenAI-compatible or Anthropic LLM endpoint.",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "klyro": "dist/index.js",
+    "ky": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "READ.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "dev": "tsx src/index.ts",
+    "dev:watch": "tsx watch src/index.ts",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "prepublishOnly": "npm run typecheck && npm test && npm run build",
+    "pack:dry": "npm pack --dry-run",
+    "publish:public": "npm publish --access public"
+  },
+  "keywords": [
+    "llm",
+    "ai",
+    "cli",
+    "openai",
+    "anthropic",
+    "harness",
+    "agent",
+    "streaming",
+    "klyro"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "commander": "^12.1.0",
+    "ink": "^7.1.1",
+    "ink-spinner": "^5.0.0",
+    "react": "^19.2.0",
+    "zod": "^4.5.4"
+  },
+  "devDependencies": {
+    "@types/node": "^22.9.0",
+    "@types/react": "^19.2.18",
+    "ink-testing-library": "^4.0.0",
+    "tsx": "^4.23.13",
+    "typescript": "^5.5.4",
+    "vitest": "^4.1.11"
+  }
+}