klyro 1.0.16 → 1.0.17

package/dist/agent/anthropic-adapter.js

@@ -17,6 +17,8 @@
  */
 import { assertSafeBaseURL } from '../chat.js';
 import { parseRetryAfterMs } from './provider-adapter.js';
+import { estimateTokens } from '../context/tokenizer.js';
+import { proxiedFetch } from '../shared/proxy.js';
 const DEFAULT_VERSION = '2023-06-01';
 const DEFAULT_TIMEOUT_MS = 120_000;
 export const PROMPT_CACHING_BETA = 'prompt-caching-2024-07-31';
@@ -40,7 +42,7 @@ export function anthropicAdapter(opts) {
     const betas = [...(opts.betas ?? [])];
     if (promptCache && !betas.includes(PROMPT_CACHING_BETA))
         betas.push(PROMPT_CACHING_BETA);
-    const fetchImpl = opts.fetchImpl ?? globalThis.fetch;
+    const fetchImpl = opts.fetchImpl ?? proxiedFetch;
     if (!fetchImpl) {
         throw new Error('anthropicAdapter: no fetch available — pass opts.fetchImpl or run on Node 18+');
     }
@@ -52,6 +54,29 @@ export function anthropicAdapter(opts) {
                 fetchImpl, version, authHeader, betas, promptCache,
             });
         },
+        // 2.1 — capability discovery via the Anthropic Models API.
+        // Returns [] when unavailable (callers fall back to configured ids).
+        async listModels() {
+            try {
+                const headers = { 'anthropic-version': version };
+                if (authHeader === 'x-api-key')
+                    headers['x-api-key'] = opts.apiKey;
+                else
+                    headers['Authorization'] = `Bearer ${opts.apiKey}`;
+                const res = await fetchImpl(`${baseURL}/v1/models`, { headers });
+                if (!res.ok)
+                    return [];
+                const json = (await res.json());
+                const ids = Array.isArray(json.data) ? json.data.map((m) => m.id).filter((id) => typeof id === 'string' && id.length > 0) : [];
+                return [...new Set(ids)];
+            }
+            catch {
+                return [];
+            }
+        },
+        countTokens(text) {
+            return estimateTokens(text);
+        },
     };
 }
 /**

package/dist/agent/provider-adapter.d.ts

@@ -68,11 +68,17 @@ export interface CallRequest {
     tools: ToolDefinition[];
     maxTokens?: number;
     temperature?: number;
+    /** Reasoning effort for reasoning models ( OpenAI `reasoning_effort` ); adapters that lack the concept ignore it. */
+    reasoningEffort?: 'low' | 'medium' | 'high';
     signal?: AbortSignal;
 }
 export interface ProviderAdapter {
     readonly id: string;
     stream(req: CallRequest): AsyncIterable<StreamEvent>;
+    /** Optional capability discovery: model ids (2.1). Absent = unknown, use configured ids. */
+    listModels?(): Promise<string[]>;
+    /** Optional local token estimate (2.1). Absent = caller estimates. */
+    countTokens?(text: string): number | Promise<number>;
 }
 export interface HttpAdapterOptions {
     baseURL: string;
@@ -110,6 +116,7 @@ interface ChatCompletionsRequest {
     }>;
     max_tokens?: number;
     temperature?: number;
+    reasoning_effort?: 'low' | 'medium' | 'high';
     stream: true;
 }
 /**

package/dist/agent/provider-adapter.js

@@ -11,6 +11,8 @@
  * runtime loop sees one shape regardless of provider quirks.
  */
 import { redact } from '../policy/secret-redactor.js';
+import { estimateTokens } from '../context/tokenizer.js';
+import { proxiedFetch } from '../shared/proxy.js';
 const DEFAULT_TIMEOUT_MS = 120_000;
 /**
  * Parse a `Retry-After` response header value into milliseconds.
@@ -157,6 +159,8 @@ export function buildChatCompletionsBody(req) {
         body.max_tokens = req.maxTokens;
     if (typeof req.temperature === 'number')
         body.temperature = req.temperature;
+    if (req.reasoningEffort)
+        body.reasoning_effort = req.reasoningEffort;
     if (req.tools.length) {
         body.tools = req.tools.map((t) => ({
             type: 'function',
@@ -166,13 +170,34 @@ export function buildChatCompletionsBody(req) {
     return body;
 }
 export function httpChatAdapter(opts) {
-    const fetchImpl = opts.fetchImpl ?? fetch;
+    const fetchImpl = opts.fetchImpl ?? proxiedFetch;
     const url = `${opts.baseURL.replace(/\/+$/, '')}/chat/completions`;
     return {
         id: 'http-chat',
         stream(req) {
             return streamChatCompletions(url, opts, req, fetchImpl);
         },
+        // 2.1 — capability discovery: list model ids via OpenAI /models.
+        // Returns [] when the endpoint doesn't serve a model list (not an
+        // error: callers fall back to configured ids).
+        async listModels() {
+            try {
+                const res = await fetchImpl(`${opts.baseURL.replace(/\/+$/, '')}/models`, {
+                    headers: opts.apiKey ? { Authorization: `Bearer ${opts.apiKey}` } : {},
+                });
+                if (!res.ok)
+                    return [];
+                const json = (await res.json());
+                const ids = Array.isArray(json.data) ? json.data.map((m) => m.id).filter((id) => typeof id === 'string' && id.length > 0) : [];
+                return [...new Set(ids)];
+            }
+            catch {
+                return [];
+            }
+        },
+        countTokens(text) {
+            return estimateTokens(text);
+        },
     };
 }
 async function* streamChatCompletions(url, opts, req, fetchImpl) {

package/dist/agent/runtime.d.ts

@@ -83,6 +83,7 @@ export interface RunOptions {
     maxTimeMs?: number;
     maxTokens?: number;
     temperature?: number;
+    reasoningEffort?: 'low' | 'medium' | 'high';
     signal?: AbortSignal;
     nonInteractive: boolean;
     /**
@@ -157,6 +158,12 @@ export interface RunOptions {
         allowedPaths?: readonly string[];
         model?: string;
     };
+    /**
+     * Root sandbox extensions (--add-dir): extra resolvable roots for file
+     * tools, merged with cwd. Child scopes (parentContext.allowedPaths) still
+     * narrow further when present.
+     */
+    allowedPaths?: readonly string[];
     /**
      * Delegation bridge (P0). Present on the root run so the model can call
      * spawn_agent / task_list / task_get. The tool layer reads it from the

package/dist/agent/runtime.js

@@ -223,18 +223,6 @@ export async function run(opts, deps) {
     const sessionId = opts.persist?.sessionId;
     // 6.1 baseline cache per HEAD — capture before first edit
     let baselinePrimed = false;
-    async function primeBaseline() {
-        if (baselinePrimed)
-            return;
-        baselinePrimed = true;
-        const cmd = opts.verify?.command ?? detectVerifyCommand(opts.cwd);
-        if (!cmd)
-            return;
-        try {
-            await ensureBaseline(opts.cwd, cmd);
-        }
-        catch { /* ignore */ }
-    }
     async function checkpoint(msg, obs) {
         if (!store || !sessionId)
             return;
@@ -319,6 +307,11 @@ export async function run(opts, deps) {
             // Abort cascade (fix: background shells must not outlive the run).
             const killed = killAllJobs();
             emitKlyro({ type: 'abort', ts: Date.now(), sessionId: sessionId ?? 'ephemeral', reason: killed.length > 0 ? `aborted by operator (${killed.length} background job(s) killed)` : 'aborted by operator' });
+            // 2.4 — explicit interrupted marker: partial output stays labeled in
+            // the transcript so resume/replay never mistakes it for final text.
+            const interruptedNote = { role: 'user', content: [text('[system note] Interrupted by user — output above is partial and preserved.')] };
+            transcript.push(interruptedNote);
+            await checkpoint(interruptedNote);
             if (store && sessionId) {
                 try {
                     await store.setStatus(sessionId, 'aborted', finalText);
@@ -399,23 +392,22 @@ export async function run(opts, deps) {
             tools: toolDefinitions(deps.registry),
             ...(opts.maxTokens ? { maxTokens: opts.maxTokens } : {}),
             ...(typeof opts.temperature === 'number' ? { temperature: opts.temperature } : {}),
+            ...(opts.reasoningEffort ? { reasoningEffort: opts.reasoningEffort } : {}),
             ...(opts.signal ? { signal: opts.signal } : {}),
         };
         const events = activeAdapter.stream(req);
         let textBuf = '';
         // Thinking is ephemeral: streamed to the UI live, never stored in the
         // transcript, and cleared when the turn's answer completes.
-        let thinkingBuf = '';
         const pendingToolCalls = new Map();
-        let lastFinishReason;
         // Set when this step's request must be re-issued after overflow recovery.
         let overflowRetryPending = false;
         // Set when a terminal provider error consumed a failover adapter — the
         // step is re-issued against the next adapter without consuming budget.
         let failoverPending = false;
-        let failoverFrom = '';
-        let failoverTo = '';
-        let failoverReason = '';
+        let failoverFrom;
+        let failoverTo;
+        let failoverReason;
         for await (const ev of events) {
             if (opts.signal?.aborted)
                 break outer;
@@ -424,7 +416,6 @@ export async function run(opts, deps) {
                 emit?.({ kind: 'text_delta', text: ev.text });
             }
             else if (ev.kind === 'thinking_delta') {
-                thinkingBuf += ev.text;
                 emit?.({ kind: 'thinking_delta', text: ev.text });
             }
             else if (ev.kind === 'tool_call_start') {
@@ -441,7 +432,6 @@ export async function run(opts, deps) {
                 // tool_calls are accumulated; finalization happens after stream.
             }
             else if (ev.kind === 'message_end') {
-                lastFinishReason = ev.finishReason;
                 if (ev.usage) {
                     usage.input += ev.usage.input;
                     usage.output += ev.usage.output;
@@ -553,9 +543,7 @@ export async function run(opts, deps) {
         if (failoverPending) {
             failoverPending = false;
             textBuf = '';
-            thinkingBuf = '';
             pendingToolCalls.clear();
-            lastFinishReason = undefined;
             steps--;
             emit?.({ kind: 'step_end', step: steps + 1 });
             continue outer;
@@ -613,6 +601,10 @@ export async function run(opts, deps) {
             emit?.({ kind: 'aborted' });
             const killed = killAllJobs();
             emitKlyro({ type: 'abort', ts: Date.now(), sessionId: sessionId ?? 'ephemeral', reason: killed.length > 0 ? `aborted by operator (${killed.length} background job(s) killed)` : 'aborted by operator' });
+            // 2.4 — explicit interrupted marker (see loop-top abort).
+            const interruptedNote = { role: 'user', content: [text('[system note] Interrupted by user — output above is partial and preserved.')] };
+            transcript.push(interruptedNote);
+            await checkpoint(interruptedNote);
             if (store && sessionId) {
                 try {
                     await store.setStatus(sessionId, 'aborted', finalText);
@@ -907,6 +899,7 @@ export async function run(opts, deps) {
                 : {}),
             agentDepth: opts.parentContext?.depth ?? 0,
             agentMaxDepth: opts.parentContext?.maxDepth ?? 1,
+            ...(opts.allowedPaths ? { agentAllowedPaths: opts.allowedPaths } : {}),
             ...(opts.parentContext?.allowedTools ? { agentAllowedTools: opts.parentContext.allowedTools } : {}),
             ...(opts.parentContext?.allowedPaths ? { agentAllowedPaths: opts.parentContext.allowedPaths } : {}),
             ...(opts.parentContext?.model ?? opts.model ? { agentModel: opts.parentContext?.model ?? opts.model } : {}),
@@ -1308,6 +1301,10 @@ export async function run(opts, deps) {
     }
     if (opts.signal?.aborted) {
         emit?.({ kind: 'aborted' });
+        // 2.4 — explicit interrupted marker (see loop-top abort).
+        const interruptedNote = { role: 'user', content: [text('[system note] Interrupted by user — output above is partial and preserved.')] };
+        transcript.push(interruptedNote);
+        await checkpoint(interruptedNote);
         if (store && sessionId) {
             try {
                 await store.setStatus(sessionId, 'aborted', finalText);

package/dist/chat.js

@@ -20,6 +20,16 @@
  */
 /** Default request timeout: 60s. */
 const DEFAULT_TIMEOUT_MS = 60_000;
+/**
+ * Legacy output flows through the shared terminal renderer (3.1): all
+ * human output leaves via the renderer module, which also sanitizes
+ * control sequences out of model text.
+ */
+import { TerminalRenderer, writeStdoutDrained } from './renderers/terminal.js';
+const renderer = new TerminalRenderer();
+function frame(text) {
+    renderer.handle({ type: 'stream.delta', ts: Date.now(), sessionId: 'legacy-chat', text });
+}
 /** Max bytes of an error response body we will print. */
 const MAX_ERROR_BODY_BYTES = 4_000;
 /** Strip a trailing slash so we can append /chat/completions cleanly. */
@@ -187,7 +197,7 @@ export async function streamToStdout(body, signal) {
     const reader = body.getReader();
     const decoder = new TextDecoder('utf-8');
     let buf = '';
-    process.stdout.write('\n');
+    frame('\n');
     try {
         while (true) {
             if (signal.aborted)
@@ -209,7 +219,7 @@ export async function streamToStdout(body, signal) {
                         continue;
                     const data = line.slice(5).trim();
                     if (data === '[DONE]') {
-                        process.stdout.write('\n');
+                        frame('\n');
                         return;
                     }
                     // Handle case where data was split across chunks and reassembled as event
@@ -224,7 +234,7 @@ export async function streamToStdout(body, signal) {
                     }
                     const text = parsed.choices?.[0]?.delta?.content;
                     if (text) {
-                        if (!await writeWithBackpressure(text, signal)) {
+                        if (!await writeStdoutDrained(text, signal)) {
                             try {
                                 await reader.cancel();
                             }
@@ -246,7 +256,7 @@ export async function streamToStdout(body, signal) {
                         continue;
                     const data = line.slice(5).trim();
                     if (data === '[DONE]') {
-                        process.stdout.write('\n');
+                        frame('\n');
                         return;
                     }
                     if (data === '')
@@ -255,7 +265,7 @@ export async function streamToStdout(body, signal) {
                         const parsed = JSON.parse(data);
                         const text = parsed.choices?.[0]?.delta?.content;
                         if (text) {
-                            if (!await writeWithBackpressure(text, signal)) {
+                            if (!await writeStdoutDrained(text, signal)) {
                                 try {
                                     await reader.cancel();
                                 }
@@ -270,7 +280,7 @@ export async function streamToStdout(body, signal) {
                 }
             }
         }
-        process.stdout.write('\n');
+        frame('\n');
     }
     finally {
         try {
@@ -281,56 +291,6 @@ export async function streamToStdout(body, signal) {
         }
     }
 }
-/**
- * Write to stdout and wait for the drain event if the buffer is full.
- * Returns false if stdout has been closed (e.g. piped to `head`).
- * Respects abort signal — resolves false if aborted while waiting.
- */
-function writeWithBackpressure(chunk, signal) {
-    return new Promise((resolve) => {
-        if (signal?.aborted) {
-            resolve(false);
-            return;
-        }
-        if (!process.stdout.write(chunk)) {
-            let settled = false;
-            const cleanup = () => {
-                process.stdout.off('drain', onDrain);
-                process.stdout.off('error', onError);
-                if (signal)
-                    signal.removeEventListener('abort', onAbort);
-            };
-            const onDrain = () => {
-                if (settled)
-                    return;
-                settled = true;
-                cleanup();
-                resolve(true);
-            };
-            const onError = () => {
-                if (settled)
-                    return;
-                settled = true;
-                cleanup();
-                resolve(false);
-            };
-            const onAbort = () => {
-                if (settled)
-                    return;
-                settled = true;
-                cleanup();
-                resolve(false);
-            };
-            process.stdout.once('drain', onDrain);
-            process.stdout.once('error', onError);
-            if (signal)
-                signal.addEventListener('abort', onAbort, { once: true });
-        }
-        else {
-            resolve(true);
-        }
-    });
-}
 /**
  * Read up to `max` bytes from a response body. Used for error responses where
  * we want to surface the cause without risking OOM on a misbehaving server.

package/dist/cli/completion.js

@@ -19,9 +19,6 @@ const COMMAND_FLAGS = {
     completion: ['bash', 'zsh', 'fish', 'powershell'],
     resume: ['-m', '--model', '--max-steps'],
 };
-function flagsFor(cmd) {
-    return [...GLOBAL_FLAGS, ...(COMMAND_FLAGS[cmd] ?? [])];
-}
 function bashScript() {
     const cmdCases = Object.entries(COMMAND_FLAGS)
         .map(([c, fs]) => `      ${c}) opts="${fs.join(' ')}" ;;`)

package/dist/cli/doctor.d.ts

@@ -3,6 +3,19 @@
  * Runs quick diagnostics: node version, config, provider reachability,
  * persistence dir, git, tools.
  */
+/**
+ * Pure byte interpreter for `doctor --keys` (unit-tested): names what a
+ * terminal delivered so broken arrow/paste/scroll input becomes provable
+ * fact instead of guesswork. Covers arrows, paging/home/end, Ctrl codes,
+ * bracketed-paste markers, and SGR/X10 mouse sequences.
+ */
+export declare function describeKeyBytes(chunk: Buffer): string;
+/**
+ * Interactive key probe: raw-mode stdin echo of every chunk with its
+ * meaning. Proves what THIS terminal delivers for arrows, Ctrl+P/N,
+ * paste, and wheel — run it when TUI input misbehaves.
+ */
+export declare function runKeysProbe(): Promise<number>;
 export declare function runDoctor(opts?: {
     json?: boolean;
     cwd?: string;

package/dist/cli/doctor.js

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

package/dist/cli/errors.js

@@ -5,7 +5,7 @@ import { KlyroError } from '../shared/errors.js';
 export function handleFatal(err) {
     const isDebug = !!process.env.KLYRO_LOG_LEVEL || !!process.env.DEBUG || process.argv.includes('--debug');
     let code = 1;
-    let message = err instanceof Error ? err.message : String(err);
+    const message = err instanceof Error ? err.message : String(err);
     let hint;
     if (err instanceof KlyroError) {
         code = err.exitCode;

package/dist/cli/eval.js

@@ -65,13 +65,11 @@ export async function runEval(opts) {
     }
     // 5.4 — suite mode: load from evals/fixtures
     if (opts.suite) {
-        const { runHarness, loadFileFixture } = await import('../eval/harness.js');
         const fs = await import('node:fs/promises');
         const path = await import('node:path');
-        const suiteDir = path.join(process.cwd(), 'evals', 'fixtures', opts.suite === 'smoke' ? '' : opts.suite);
         // For smoke, use the 10 fixtures directly
         const fixturesDir = path.join(process.cwd(), 'evals', 'fixtures');
-        let tasks = [];
+        const tasks = [];
         try {
             const entries = await fs.readdir(fixturesDir);
             for (const e of entries) {

package/dist/cli/markdown.js

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