klyro 1.0.0 → 1.0.2

package/dist/context/project-map.js

@@ -383,7 +383,8 @@ function lockfileHash(root) {
 async function getCachedProjectMap(root) {
     const head = await gitHead(root);
     const hash = lockfileHash(root);
-    const p = path.join(root, '.klyro', 'cache', `project-map-${head.slice(0, 8)}-${hash}.json`);
+    const dirty = await dirtyMtime(root);
+    const p = path.join(root, '.klyro', 'cache', `project-map-${head.slice(0, 8)}-${hash}-${dirty.toString(36)}.json`);
     try {
         const raw = await fs.readFile(p, 'utf-8');
         const j = JSON.parse(raw);
@@ -396,13 +397,60 @@ async function getCachedProjectMap(root) {
 async function setCachedProjectMap(root, m) {
     const head = await gitHead(root);
     const hash = lockfileHash(root);
-    const p = path.join(root, '.klyro', 'cache', `project-map-${head.slice(0, 8)}-${hash}.json`);
+    const dirty = await dirtyMtime(root);
+    const p = path.join(root, '.klyro', 'cache', `project-map-${head.slice(0, 8)}-${hash}-${dirty.toString(36)}.json`);
     try {
         await fs.mkdir(path.dirname(p), { recursive: true });
         await fs.writeFile(p, JSON.stringify(m, null, 2), 'utf-8');
     }
     catch { /* ignore */ }
 }
+/**
+ * Dirty-tree fingerprint: max mtimeMs over a bounded walk (≤200 files,
+ * depth ≤4, ignored dirs skipped). Cheap enough to run on every cache
+ * lookup; any edit under the tree changes the key and busts the cache.
+ */
+export async function dirtyMtime(root) {
+    let max = 0;
+    let seen = 0;
+    let stop = false;
+    async function walk(dir, depth) {
+        if (stop || depth > 4)
+            return;
+        let entries;
+        try {
+            entries = await fs.readdir(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const e of entries) {
+            if (stop)
+                return;
+            if (IGNORED_DIRS.has(e.name))
+                continue;
+            const full = path.join(dir, e.name);
+            if (e.isDirectory()) {
+                await walk(full, depth + 1);
+            }
+            else if (e.isFile()) {
+                seen++;
+                try {
+                    const s = await fs.stat(full);
+                    if (s.mtimeMs > max)
+                        max = s.mtimeMs;
+                }
+                catch { /* race */ }
+                if (seen >= 200) {
+                    stop = true;
+                    return;
+                }
+            }
+        }
+    }
+    await walk(root, 0);
+    return Math.floor(max);
+}
 function detectMonorepo(root, rootFiles, rootDirs) {
     if (rootFiles.has('pnpm-workspace.yaml') || rootFiles.has('lerna.json') || rootFiles.has('nx.json'))
         return true;

package/dist/context/repo-map.d.ts

@@ -18,6 +18,8 @@ export interface RepoFile {
     path: string;
     symbols: Symbol[];
 }
+/** Invalidate the repo-map cache (tests + callers that mutate the tree). */
+export declare function clearRepoMapCache(): void;
 /** Heuristic: walk cwd, return at most `maxFiles` files with symbols. */
 export declare function buildRepoMap(opts: {
     cwd: string;

package/dist/context/repo-map.js

@@ -12,11 +12,38 @@ import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
 const SUPPORTED_EXTS = new Set(['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs', '.py', '.go', '.rs']);
 const IGNORED_DIRS = new Set(['node_modules', '.git', 'dist', 'build', '.klyro', 'coverage', 'out']);
+const REPO_MAP_TTL_MS = 60_000;
+let repoMapCache = null;
+/** Invalidate the repo-map cache (tests + callers that mutate the tree). */
+export function clearRepoMapCache() {
+    repoMapCache = null;
+}
+/** Re-stat every file in the cached map; true when all stats still match. */
+async function repoMapStatsMatch(cwd, stats) {
+    for (const [rel, prev] of stats) {
+        try {
+            const s = await fs.stat(path.join(cwd, rel));
+            if (s.mtimeMs !== prev.mtimeMs || s.size !== prev.size)
+                return false;
+        }
+        catch {
+            return false; // deleted (or unreadable) — rebuild
+        }
+    }
+    return true;
+}
 /** Heuristic: walk cwd, return at most `maxFiles` files with symbols. */
 export async function buildRepoMap(opts) {
     const maxFiles = opts.maxFiles ?? 500;
     const maxFileBytes = opts.maxFileBytes ?? 256 * 1024;
+    const cached = repoMapCache;
+    if (cached && cached.cwd === opts.cwd && cached.maxFiles === maxFiles &&
+        cached.maxFileBytes === maxFileBytes && Date.now() - cached.at < REPO_MAP_TTL_MS &&
+        (await repoMapStatsMatch(opts.cwd, cached.stats))) {
+        return cached.files;
+    }
     const out = [];
+    const stats = new Map();
     await walk(opts.cwd, async (file) => {
         if (out.length >= maxFiles)
             return false;
@@ -39,9 +66,12 @@ export async function buildRepoMap(opts) {
         catch {
             return true;
         }
-        out.push({ path: path.relative(opts.cwd, file), symbols: extractSymbols(content, ext) });
+        const rel = path.relative(opts.cwd, file);
+        stats.set(rel, { mtimeMs: stat.mtimeMs, size: stat.size });
+        out.push({ path: rel, symbols: extractSymbols(content, ext) });
         return true;
     });
+    repoMapCache = { cwd: opts.cwd, maxFiles, maxFileBytes, files: out, stats, at: Date.now() };
     return out;
 }
 async function walk(dir, visit) {

package/dist/events/catalog.d.ts

@@ -1,6 +1,15 @@
 /**
  * 3.1 — KlyroEvent catalog (Appendix C)
  * Every observable action in the harness is a typed event.
+ *
+ * Reserved-future members (declared but intentionally unproduced — no
+ * emitter exists yet, so do not treat their absence as a bug):
+ * `subtask.tool_call`, `subtask.tool_result`.
+ * `subtask.progress` IS emitted (throttled: max 1 per child tool call,
+ * in-process children only; process-isolated children don't run the emitter).
+ * The orchestrator otherwise emits started/completed/failed/cancelled/
+ * timed_out/merged only; grep for emitters before assuming one of the
+ * reserved members fires.
  */
 export type KlyroEvent = {
     type: 'session.start';
@@ -167,6 +176,28 @@ export type KlyroEvent = {
         code: string;
         message: string;
     };
+} | {
+    type: 'subtask.cancelled';
+    ts: number;
+    sessionId: string;
+    taskId: string;
+    status: 'cancelled';
+    durationMs: number;
+    error?: {
+        code: string;
+        message: string;
+    };
+} | {
+    type: 'subtask.timed_out';
+    ts: number;
+    sessionId: string;
+    taskId: string;
+    status: 'timed_out';
+    durationMs: number;
+    error?: {
+        code: string;
+        message: string;
+    };
 } | {
     type: 'subtask.tool_call';
     ts: number;
@@ -189,6 +220,7 @@ export type KlyroEvent = {
     sessionId: string;
     taskId: string;
     changedFiles: string[];
+    merged?: boolean;
 } | {
     type: 'provider.retry';
     ts: number;
@@ -203,5 +235,10 @@ export type KlyroEvent = {
     path: string;
     reason: 'unknown' | 'changed';
     trusted: boolean;
+} | {
+    type: 'context.compacted';
+    ts: number;
+    sessionId: string;
+    dropped: number;
 };
 export type KlyroEventType = KlyroEvent['type'];

package/dist/events/catalog.js

@@ -1,5 +1,14 @@
 /**
  * 3.1 — KlyroEvent catalog (Appendix C)
  * Every observable action in the harness is a typed event.
+ *
+ * Reserved-future members (declared but intentionally unproduced — no
+ * emitter exists yet, so do not treat their absence as a bug):
+ * `subtask.tool_call`, `subtask.tool_result`.
+ * `subtask.progress` IS emitted (throttled: max 1 per child tool call,
+ * in-process children only; process-isolated children don't run the emitter).
+ * The orchestrator otherwise emits started/completed/failed/cancelled/
+ * timed_out/merged only; grep for emitters before assuming one of the
+ * reserved members fires.
  */
 export {};

package/dist/index.js

@@ -23,6 +23,7 @@ import { runCompletion } from './cli/completion.js';
 import { runUpdate } from './cli/update.js';
 import { runLogin, runLogout } from './cli/auth.js';
 import { readVersion } from './version.js';
+import { verifyAuditChain } from './persistence/audit.js';
 const VERSION = readVersion();
 function parsePositiveInt(name, v) {
     const n = Number(v);
@@ -61,8 +62,21 @@ async function main() {
         .option('--output-format <fmt>', 'Headless output format: text|json|stream-json (default text)')
         .option('--no-stream', 'Disable streaming (buffer full response)')
         .option('--show-thinking', 'Show thinking blocks');
+    // Unknown commands / unknown options are usage errors (exit 2 per PRD).
+    // Help and version still exit 0; anything else rethrows to the last-resort
+    // handler (exit 1).
+    program.exitOverride((err) => {
+        if (err.code === 'commander.unknownCommand' || err.code === 'commander.unknownOption') {
+            process.stderr.write(`klyro: ${err.message}\n`);
+            process.exit(2);
+        }
+        if (err.code === 'commander.helpDisplayed' || err.code === 'commander.version') {
+            process.exit(0);
+        }
+        throw err;
+    });
     // Handle global flags before any command runs
-    program.hook('preAction', (thisCommand) => {
+    program.hook('preAction', async (thisCommand) => {
         const opts = thisCommand.optsWithGlobals();
         if (opts.cwd) {
             try {
@@ -73,6 +87,13 @@ async function main() {
                 process.exit(2);
             }
         }
+        // Load <cwd>/.env globally (after chdir) so KLYRO_* vars resolve for
+        // every command. Never throws; explicit env wins (no-clobber).
+        try {
+            const { loadDotenv } = await import('./cli/dotenv.js');
+            loadDotenv(process.cwd());
+        }
+        catch { /* ignore */ }
         if (opts.config)
             process.env.KLYRO_CONFIG = opts.config;
         if (opts.debug)
@@ -271,6 +292,7 @@ async function main() {
         .option('--resume-session <id>', 'Resume from a persisted session (Level 9) by id prefix')
         .option('--verify', 'Enable verification after edits (Level 8, default: enabled)')
         .option('--verify-command <cmd>', 'Custom verification command (default: auto-detected)')
+        .option('--verify-mode <mode>', 'Verification mode: strict (default), advisory, off')
         .option('--max-repairs <n>', 'Max autonomous repair attempts (default 3)', (v) => parsePositiveInt('--max-repairs', v))
         .option('--persist', 'Enable session persistence (Level 9, default: enabled)')
         .option('--require-verify', 'Fail with exit 8 if no verification passed after edits (6.5)')
@@ -287,6 +309,11 @@ async function main() {
             process.stderr.write(`klyro: invalid --output: ${output} (expected human|json|silent)\n`);
             process.exit(2);
         }
+        const verifyMode = opts.verifyMode ?? 'strict';
+        if (verifyMode !== 'strict' && verifyMode !== 'advisory' && verifyMode !== 'off') {
+            process.stderr.write(`klyro: invalid --verify-mode: ${opts.verifyMode} (expected strict|advisory|off)\n`);
+            process.exit(2);
+        }
         // Provider validation is handled inside runOnce (single source of truth)
         try {
             const code = await runOnce({
@@ -306,6 +333,7 @@ async function main() {
                 sessionId: opts.resumeSession,
                 verify: opts.verify,
                 verifyCommand: opts.verifyCommand,
+                verifyMode: verifyMode,
                 maxRepairAttempts: opts.maxRepairs,
                 persist: opts.persist,
                 requireVerify: !!opts.requireVerify,
@@ -321,7 +349,7 @@ async function main() {
     });
     program
         .command('chat [prompt]')
-        .description('Legacy streamed chat. Without a prompt, start an interactive REPL.')
+        .description('Legacy streamed chat. Without a prompt, start an interactive REPL. (deprecated: history truncation is approximate; prefer `klyro tui`)')
         .option('-s, --system <text>', 'System message', 'You are a helpful assistant.')
         .option('-m, --model <id>', 'Override the model (default: env KLYRO_MODEL)')
         .option('-t, --timeout <ms>', 'Request timeout in ms (default: env KLYRO_TIMEOUT_MS or 60000)', (v) => parsePositiveInt('-t/--timeout', v))
@@ -570,15 +598,156 @@ async function main() {
     });
     // 10.1 — MCP
     const mcp = program.command('mcp').description('MCP client/server (10.1)');
-    mcp.command('list').description('List MCP servers').action(async () => { process.stdout.write('mcp servers: (stub) github filesystem — use .mcp.json\n'); });
+    mcp.command('list').description('List MCP servers').action(async () => {
+        const { loadMcpServers } = await import('./mcp/config.js');
+        const cfg = loadMcpServers(process.cwd());
+        const names = Object.keys(cfg.servers);
+        if (names.length === 0) {
+            process.stdout.write('mcp servers: none configured (use .mcp.json)\n');
+            return;
+        }
+        for (const name of names) {
+            const spec = cfg.servers[name];
+            const source = cfg.sources[name] ?? 'unknown';
+            process.stdout.write(`${name} source=${source}${spec?.disabled ? ' disabled' : ''}\n`);
+        }
+    });
     mcp.command('add <name> <url>').description('Add MCP server').action(async (name) => { process.stdout.write(`added mcp ${name} (stub)\n`); });
+    mcp.command('probe <name>').description('Connect to an MCP server (15s timeout), list its tools, print count+names').action(async (name) => {
+        const { loadMcpServers } = await import('./mcp/config.js');
+        const cfg = loadMcpServers(process.cwd());
+        const spec = cfg.servers[name];
+        if (!spec) {
+            process.stderr.write(`klyro: mcp server not found: ${name}\n`);
+            process.exit(2);
+        }
+        const { McpClient } = await import('./mcp/client.js');
+        const client = new McpClient(name, spec);
+        // 15s overall probe budget (connect has its own internal timeout too).
+        const timer = setTimeout(() => {
+            process.stderr.write(`klyro: mcp probe ${name} timed out after 15s\n`);
+            process.exit(2);
+        }, 15_000);
+        try {
+            await client.connect();
+            const tools = await client.listTools();
+            const names = tools.map((t) => t.name);
+            process.stdout.write(`${name}: ${tools.length} tool(s)${names.length > 0 ? `: ${names.join(', ')}` : ''}\n`);
+            process.exit(0);
+        }
+        catch (err) {
+            process.stderr.write(`klyro: mcp probe ${name} failed: ${err instanceof Error ? err.message : String(err)}\n`);
+            process.exit(2);
+        }
+        finally {
+            clearTimeout(timer);
+            try {
+                await client.close();
+            }
+            catch { /* ignore */ }
+        }
+    });
     mcp.command('serve').description('Serve as MCP server').action(async () => { process.stdout.write('klyro mcp serve — exposing tools (stub)\n'); });
-    // 10.2 — Hooks / agents
-    program.command('hooks').description('List hooks (10.2)').action(async () => { process.stdout.write('hooks: SessionStart UserPromptSubmit PreToolUse PostToolUse (stub)\n'); });
-    program.command('agents').description('List agents (10.2)').action(async () => { process.stdout.write('agents: explorer implementer tester reviewer (stub)\n'); });
+    // 10.2 — Hooks: list configured preToolUse/postToolUse hooks.
+    program.command('hooks [cmd]').description('Hooks (10.2): `klyro hooks` or `klyro hooks list` prints configured hooks').action(async (cmd) => {
+        if (cmd && cmd !== 'list') {
+            process.stderr.write(`klyro: unknown hooks command: ${cmd} (usage: klyro hooks [list])\n`);
+            process.exit(2);
+        }
+        const { loadHooks } = await import('./cli/hooks.js');
+        const hooks = loadHooks(process.cwd());
+        if (hooks.length === 0) {
+            process.stdout.write('hooks: none configured (.klyro/hooks.json, ~/.klyro/hooks.json)\n');
+            return;
+        }
+        for (const h of hooks)
+            process.stdout.write(`${h.name} ${h.event} ${h.command}\n`);
+    });
+    program.command('agents [name] [extra...]').description('List agents (10.2), show one, or run: agents run <name> <task...>').action(async (name, extra) => {
+        const { BUILTIN_AGENTS } = await import('./agent/orchestrator.js');
+        // `klyro agents run <name> <task...>`: one-shot run under a named agent.
+        if (name === 'run') {
+            const [agentName, ...taskParts] = extra ?? [];
+            if (!agentName || !BUILTIN_AGENTS.some((a) => a.id === agentName)) {
+                process.stderr.write(`klyro: unknown agent: ${agentName ?? '(missing)'} (known: ${BUILTIN_AGENTS.map((a) => a.id).join(', ')})\n`);
+                process.exit(2);
+            }
+            const task = (taskParts ?? []).join(' ').trim();
+            if (!task) {
+                process.stderr.write('klyro: agents run requires a task (usage: klyro agents run <name> <task...>)\n');
+                process.exit(2);
+            }
+            const model = process.env.KLYRO_MODEL;
+            if (!model) {
+                process.stderr.write('klyro: KLYRO_MODEL is not set (or pass --model via klyro run)\n');
+                process.exit(2);
+            }
+            const code = await runOnce({ task, cwd: process.cwd(), model, agent: agentName });
+            process.exit(code);
+        }
+        if (!name) {
+            for (const a of BUILTIN_AGENTS)
+                process.stdout.write(`${a.id} — ${a.description}\n`);
+            return;
+        }
+        const def = BUILTIN_AGENTS.find((a) => a.id === name);
+        if (!def) {
+            process.stderr.write(`klyro: unknown agent: ${name} (known: ${BUILTIN_AGENTS.map((a) => a.id).join(', ')})\n`);
+            process.exit(2);
+        }
+        const tools = def.allowedTools ?? ['<inherited: all parent tools>'];
+        const lines = [
+            `agent: ${def.id}`,
+            `description: ${def.description}`,
+            `tools (${tools.length}): ${tools.join(', ')}`,
+            `readonly: ${def.readonly ?? false}`,
+            `canSpawn: ${def.canSpawn ?? false}`,
+            `model: ${def.model ?? '<session default>'}`,
+            `maxSteps: ${def.maxSteps ?? '<default>'}`,
+            `maxTokens: ${def.maxTokens ?? '<default>'}`,
+        ];
+        process.stdout.write(lines.join('\n') + '\n');
+    });
     // 10.3 — Web / git workflows / SDK
-    program.command('commit').description('Create commit (10.3)').action(async () => { process.stdout.write('commit — conventional message (stub, use /commit)\n'); });
-    program.command('audit').description('Audit log (13.4)').action(async () => { process.stdout.write('audit — hash-chained JSONL (stub)\n'); });
+    program
+        .command('commit')
+        .description('Commit staged changes with a conventional message (verification hooks always run)')
+        .option('--dry-run', 'Print the message + files without committing')
+        .option('--message <msg>', 'Summary for the conventional message (default: update <n> files)')
+        .option('--force-secret', 'Commit even if the staged diff looks like it contains a secret')
+        .action(async (opts) => {
+        const { runCommit } = await import('./cli/commit.js');
+        const globalYes = program.opts().yes ?? process.env.KLYRO_YES === '1';
+        const code = await runCommit({
+            cwd: process.cwd(),
+            yes: !!globalYes,
+            dryRun: !!opts.dryRun,
+            ...(opts.message !== undefined ? { message: opts.message } : {}),
+            forceSecret: !!opts.forceSecret,
+        });
+        process.exit(code);
+    });
+    program.command('audit [session]').description('Verify audit chain (13.4)').action(async (session) => {
+        if (!session) {
+            process.stderr.write('klyro: audit requires a session id (usage: klyro audit <session>)\n');
+            process.exit(2);
+        }
+        try {
+            const { getDefaultSessionsDir } = await import('./persistence/session.js');
+            const res = await verifyAuditChain(getDefaultSessionsDir(), session);
+            if (res.ok) {
+                process.stdout.write(`audit ok: ${res.events} events verified\n`);
+                process.exit(0);
+            }
+            process.stderr.write(`klyro: audit failed: ${res.error ?? 'chain broken'}\n`);
+            process.exit(1);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            process.stderr.write(`klyro: audit failed: ${msg}\n`);
+            process.exit(1);
+        }
+    });
     // 10.4 — Benchmark parity (10.5)
     program.command('benchmark').description('Run benchmark (10.5)').action(async () => {
         const { runHarness } = await import('./eval/harness.js');

package/dist/mcp/client.d.ts

@@ -16,9 +16,9 @@ export interface McpCallResult {
     raw: unknown;
 }
 export interface McpClientLike {
-    listTools(): Promise<McpToolDef[]>;
+    listTools(signal?: AbortSignal): Promise<McpToolDef[]>;
     callTool(name: string, args: unknown, signal?: AbortSignal): Promise<McpCallResult>;
-    listResources(): Promise<McpResource[]>;
+    listResources(signal?: AbortSignal): Promise<McpResource[]>;
     close(): Promise<void>;
 }
 export declare class McpError extends Error {
@@ -39,11 +39,13 @@ export declare class McpClient implements McpClientLike {
     constructor(name: string, spec: McpServerSpec);
     connect(): Promise<void>;
     private connected;
-    listTools(): Promise<McpToolDef[]>;
+    listTools(signal?: AbortSignal): Promise<McpToolDef[]>;
     callTool(name: string, args: unknown, signal?: AbortSignal): Promise<McpCallResult>;
-    listResources(): Promise<McpResource[]>;
+    listResources(signal?: AbortSignal): Promise<McpResource[]>;
     readResource(uri: string, signal?: AbortSignal): Promise<string>;
     close(): Promise<void>;
+    /** Test hook: number of in-flight JSON-RPC requests. */
+    pendingCount(): number;
     private timeout;
     private assertLive;
     private onStdout;

package/dist/mcp/client.js

@@ -7,7 +7,7 @@
  * failures and server errors surface as typed `McpError`s — never throws
  * raw across the boundary.
  */
-import { spawn } from 'node:child_process';
+import { execFileSync, spawn } from 'node:child_process';
 export class McpError extends Error {
     code;
     details;
@@ -21,6 +21,10 @@ export class McpError extends Error {
 const PROTOCOL_VERSION = '2024-11-05';
 const DEFAULT_TIMEOUT_MS = 30_000;
 const MAX_STDERR_BYTES = 8192;
+/** Upper bound on spawn + initialize handshake; partial children are killed. */
+const CONNECT_TIMEOUT_MS = 15_000;
+/** Grace period between SIGTERM and SIGKILL in close(). */
+const CLOSE_SIGKILL_AFTER_MS = 2000;
 export class McpClient {
     name;
     spec;
@@ -54,6 +58,12 @@ export class McpClient {
                 return;
             }
             this.child = child;
+            // Swallow async stream errors (e.g. EPIPE on write-after-exit):
+            // request promises already surface failures via write callbacks and
+            // the exit handler, so these must never become uncaught exceptions.
+            child.stdin?.on('error', () => { });
+            child.stdout?.on('error', () => { });
+            child.stderr?.on('error', () => { });
             child.on('error', (err) => {
                 this.failAll(new McpError(`mcp server "${this.name}" process error: ${err.message}`, 'SPAWN_FAILED'));
                 if (!this.connected)
@@ -73,13 +83,29 @@ export class McpClient {
             resolve();
         });
         try {
-            await this.request('initialize', {
-                protocolVersion: PROTOCOL_VERSION,
-                capabilities: {},
-                clientInfo: { name: 'klyro', version: '1.0.0' },
-            }, timeoutMs);
-            this.notify('notifications/initialized', {});
-            this.connected = true;
+            let connectTimer;
+            try {
+                await Promise.race([
+                    (async () => {
+                        await this.request('initialize', {
+                            protocolVersion: PROTOCOL_VERSION,
+                            capabilities: {},
+                            clientInfo: { name: 'klyro', version: '1.0.2' },
+                        }, timeoutMs);
+                        this.notify('notifications/initialized', {});
+                        this.connected = true;
+                    })(),
+                    new Promise((_resolve, reject) => {
+                        connectTimer = setTimeout(() => {
+                            reject(new McpError(`mcp server "${this.name}" connect timed out after ${CONNECT_TIMEOUT_MS}ms`, 'TIMEOUT'));
+                        }, CONNECT_TIMEOUT_MS);
+                    }),
+                ]);
+            }
+            finally {
+                if (connectTimer)
+                    clearTimeout(connectTimer);
+            }
         }
         catch (err) {
             await this.close();
@@ -87,9 +113,9 @@ export class McpClient {
         }
     }
     connected = false;
-    async listTools() {
+    async listTools(signal) {
         this.assertLive();
-        const res = (await this.request('tools/list', {}, this.timeout()));
+        const res = (await this.request('tools/list', {}, this.timeout(), signal));
         return Array.isArray(res.tools) ? res.tools : [];
     }
     async callTool(name, args, signal) {
@@ -99,9 +125,9 @@ export class McpClient {
         const text = blocks.map((b) => (typeof b.text === 'string' ? b.text : JSON.stringify(b))).join('\n');
         return { text, isError: res.isError === true, raw: res };
     }
-    async listResources() {
+    async listResources(signal) {
         this.assertLive();
-        const res = (await this.request('resources/list', {}, this.timeout()));
+        const res = (await this.request('resources/list', {}, this.timeout(), signal));
         return Array.isArray(res.resources) ? res.resources : [];
     }
     async readResource(uri, signal) {
@@ -111,16 +137,49 @@ export class McpClient {
         return contents.map((c) => (typeof c.text === 'string' ? c.text : JSON.stringify(c))).join('\n');
     }
     async close() {
+        // Idempotent vs the exit handler: closed is set FIRST (the on('exit')
+        // callback checks it before failAll), and a second close() with no child
+        // left is a no-op.
+        if (this.closed && this.child === null)
+            return;
         this.closed = true;
         this.failAll(new McpError(`mcp server "${this.name}" closed`, 'CLOSED'));
         const child = this.child;
         this.child = null;
-        if (child && !child.killed) {
+        if (!child)
+            return;
+        // Already reaped — no escalation timer needed.
+        if (child.exitCode !== null || child.signalCode !== null)
+            return;
+        if (process.platform === 'win32') {
+            try {
+                if (child.pid !== undefined) {
+                    execFileSync('taskkill', ['/pid', String(child.pid), '/T', '/F'], { stdio: 'ignore' });
+                }
+            }
+            catch { /* ignore — fall through to kill() */ }
             try {
                 child.kill();
             }
             catch { /* ignore */ }
+            return;
+        }
+        try {
+            child.kill('SIGTERM');
         }
+        catch { /* already gone */ }
+        const timer = setTimeout(() => {
+            try {
+                child.kill('SIGKILL');
+            }
+            catch { /* already gone */ }
+        }, CLOSE_SIGKILL_AFTER_MS);
+        timer.unref?.();
+        child.once('exit', () => clearTimeout(timer));
+    }
+    /** Test hook: number of in-flight JSON-RPC requests. */
+    pendingCount() {
+        return this.pending.size;
     }
     /* ---------------- internals ---------------- */
     timeout() {
@@ -154,7 +213,8 @@ export class McpClient {
                 continue;
             this.pending.delete(msg.id);
             clearTimeout(pend.timer);
-            pend.signal?.removeEventListener('abort', pend.onAbort);
+            if (pend.signal && pend.onAbort)
+                pend.signal.removeEventListener('abort', pend.onAbort);
             if (msg.error) {
                 pend.reject(new McpError(`mcp server "${this.name}" error: ${msg.error.message ?? 'unknown'}`, 'SERVER_ERROR', msg.error));
             }
@@ -181,6 +241,9 @@ export class McpClient {
             }
             const id = this.nextId++;
             const timer = setTimeout(() => {
+                const p = this.pending.get(id);
+                if (p?.signal && p.onAbort)
+                    p.signal.removeEventListener('abort', p.onAbort);
                 this.pending.delete(id);
                 reject(new McpError(`mcp call "${method}" timed out after ${timeoutMs}ms`, 'TIMEOUT'));
             }, timeoutMs);
@@ -202,6 +265,8 @@ export class McpClient {
                     if (err) {
                         this.pending.delete(id);
                         clearTimeout(timer);
+                        if (signal && pend.onAbort)
+                            signal.removeEventListener('abort', pend.onAbort);
                         reject(new McpError(`mcp call "${method}" write failed: ${err.message}`, 'IO_ERROR'));
                     }
                 });
@@ -209,6 +274,8 @@ export class McpClient {
             catch (err) {
                 this.pending.delete(id);
                 clearTimeout(timer);
+                if (signal && pend.onAbort)
+                    signal.removeEventListener('abort', pend.onAbort);
                 reject(new McpError(`mcp call "${method}" write failed: ${err instanceof Error ? err.message : String(err)}`, 'IO_ERROR'));
             }
         });
@@ -219,6 +286,8 @@ export class McpClient {
         for (const [id, pend] of [...this.pending]) {
             this.pending.delete(id);
             clearTimeout(pend.timer);
+            if (pend.signal && pend.onAbort)
+                pend.signal.removeEventListener('abort', pend.onAbort);
             pend.reject(err);
         }
     }