klyro 0.1.1

package/dist/tools/search/grep.d.ts

@@ -0,0 +1,52 @@
+/**
+ * grep — regex search over file contents. Bounded results.
+ */
+import { z } from 'zod';
+declare const InputSchema: z.ZodObject<{
+    pattern: z.ZodString;
+    cwd: z.ZodOptional<z.ZodString>;
+    include: z.ZodOptional<z.ZodString>;
+    maxResults: z.ZodOptional<z.ZodNumber>;
+    contextLines: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export interface GrepHit {
+    file: string;
+    line: number;
+    text: string;
+    context?: {
+        before: string[];
+        after: string[];
+    };
+}
+export interface GrepOutput {
+    pattern: string;
+    hits: GrepHit[];
+    truncated: boolean;
+    searchedFiles: number;
+}
+export declare const grepTool: import("../types.js").Tool<{
+    pattern: string;
+    cwd?: string | undefined;
+    include?: string | undefined;
+    maxResults?: number | undefined;
+    contextLines?: number | undefined;
+}, {
+    readonly ok: false;
+    readonly error: {
+        readonly code: "INVALID_INPUT";
+        readonly message: `Invalid regex: ${string}`;
+    };
+    pattern?: undefined;
+    hits?: undefined;
+    truncated?: undefined;
+    searchedFiles?: undefined;
+} | {
+    pattern: string;
+    hits: GrepHit[];
+    truncated: false;
+    searchedFiles: number;
+    readonly ok?: undefined;
+    readonly error?: undefined;
+}>;
+export type GrepInput = z.infer<typeof InputSchema>;
+export {};

package/dist/tools/search/grep.js

@@ -0,0 +1,125 @@
+/**
+ * grep — regex search over file contents. Bounded results.
+ */
+import * as path from 'node:path';
+import * as fs from 'node:fs/promises';
+import { z } from 'zod';
+import { defineTool } from '../types.js';
+import { resolveWithinCwd } from '../../policy/path-guard.js';
+import { safe, TOOL_ERROR_CODES } from '../normalize.js';
+const InputSchema = z.object({
+    pattern: z.string().min(1).describe('JavaScript regular expression (not ripgrep syntax)'),
+    cwd: z.string().optional(),
+    include: z.string().optional().describe('Glob filter for included files (e.g. "*.ts")'),
+    maxResults: z.number().int().min(1).max(5_000).optional().describe('Cap hits (default 500)'),
+    contextLines: z.number().int().min(0).max(5).optional().describe('Lines of context around each hit (default 0)'),
+});
+const DEFAULT_MAX = 500;
+const DEFAULT_MAX_FILE_BYTES = 2 * 1024 * 1024;
+const SKIP_DIRS = new Set(['node_modules', '.git', 'dist', 'build', '.next', '.turbo', 'coverage', '.klyro']);
+const SKIP_EXT = new Set(['.png', '.jpg', '.jpeg', '.gif', '.woff', '.woff2', '.ttf', '.otf', '.exe', '.dll', '.bin', '.zip', '.tar', '.gz']);
+export const grepTool = defineTool({
+    name: 'grep',
+    description: 'Search file contents with a JavaScript regex. Skips binary files and common build dirs. Returns hits with optional context lines.',
+    inputSchema: InputSchema,
+    execute: async (input, ctx) => {
+        return safe(async () => {
+            const base = input.cwd ? resolveWithinCwd(ctx.cwd, input.cwd).resolved : ctx.cwd;
+            let re;
+            try {
+                re = new RegExp(input.pattern, 'g');
+            }
+            catch (e) {
+                return {
+                    ok: false,
+                    error: { code: TOOL_ERROR_CODES.INVALID_INPUT, message: `Invalid regex: ${e instanceof Error ? e.message : String(e)}` },
+                };
+            }
+            const incRe = input.include ? globToRegex(input.include) : null;
+            const max = input.maxResults ?? DEFAULT_MAX;
+            const ctxLines = input.contextLines ?? 0;
+            const hits = [];
+            let searched = 0;
+            let truncated = false;
+            await walk(base, async (file) => {
+                if (hits.length >= max) {
+                    truncated = true;
+                    return;
+                }
+                if (incRe && !incRe.test(path.relative(base, file).split(path.sep).join('/')))
+                    return;
+                const ext = path.extname(file).toLowerCase();
+                if (SKIP_EXT.has(ext))
+                    return;
+                const stat = await fs.stat(file).catch(() => null);
+                if (!stat || stat.size > DEFAULT_MAX_FILE_BYTES)
+                    return;
+                searched++;
+                const text = await fs.readFile(file, 'utf-8').catch(() => null);
+                if (text === null)
+                    return;
+                if (text.includes('\0'))
+                    return; // binary
+                const lines = text.split(/\r\n|\r|\n/);
+                for (let i = 0; i < lines.length && hits.length < max; i++) {
+                    const line = lines[i];
+                    if (line === undefined)
+                        continue;
+                    re.lastIndex = 0;
+                    if (re.test(line)) {
+                        const hit = {
+                            file: path.relative(ctx.cwd, file),
+                            line: i + 1,
+                            text: line,
+                        };
+                        if (ctxLines > 0) {
+                            hit.context = {
+                                before: lines.slice(Math.max(0, i - ctxLines), i),
+                                after: lines.slice(i + 1, i + 1 + ctxLines),
+                            };
+                        }
+                        hits.push(hit);
+                    }
+                }
+            });
+            return { pattern: input.pattern, hits, truncated, searchedFiles: searched };
+        });
+    },
+});
+function globToRegex(g) {
+    const escaped = g
+        .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+        .replace(/\*\*/g, '::DS::')
+        .replace(/\*/g, '[^/]*')
+        .replace(/\?/g, '[^/]')
+        .replace(/::DS::/g, '.*');
+    return new RegExp(`^${escaped}$`);
+}
+async function walk(dir, visit) {
+    let names;
+    try {
+        names = await fs.readdir(dir);
+    }
+    catch {
+        return;
+    }
+    for (const name of names) {
+        if (SKIP_DIRS.has(name))
+            continue;
+        const full = path.join(dir, name);
+        let isDir = false;
+        try {
+            const s = await fs.lstat(full);
+            if (s.isSymbolicLink())
+                continue;
+            isDir = s.isDirectory();
+        }
+        catch {
+            continue;
+        }
+        if (isDir)
+            await walk(full, visit);
+        else
+            await visit(full);
+    }
+}

package/dist/tools/search/recent-files.d.ts

@@ -0,0 +1,33 @@
+/**
+ * recent_files — list files modified recently, newest first.
+ *
+ * Answers "what changed lately?" without forcing the model to walk the tree.
+ * Skips the same dirs as glob/grep.
+ */
+import { z } from 'zod';
+declare const InputSchema: z.ZodObject<{
+    cwd: z.ZodOptional<z.ZodString>;
+    sinceHours: z.ZodOptional<z.ZodNumber>;
+    maxResults: z.ZodOptional<z.ZodNumber>;
+    glob: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export interface RecentFile {
+    path: string;
+    mtimeMs: number;
+    ageHours: number;
+}
+export interface RecentFilesOutput {
+    files: RecentFile[];
+    truncated: boolean;
+}
+export declare const recentFilesTool: import("../types.js").Tool<{
+    cwd?: string | undefined;
+    sinceHours?: number | undefined;
+    maxResults?: number | undefined;
+    glob?: string | undefined;
+}, {
+    files: RecentFile[];
+    truncated: boolean;
+}>;
+export type RecentFilesInput = z.infer<typeof InputSchema>;
+export {};

package/dist/tools/search/recent-files.js

@@ -0,0 +1,100 @@
+/**
+ * recent_files — list files modified recently, newest first.
+ *
+ * Answers "what changed lately?" without forcing the model to walk the tree.
+ * Skips the same dirs as glob/grep.
+ */
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import { z } from 'zod';
+import { defineTool } from '../types.js';
+import { resolveWithinCwd } from '../../policy/path-guard.js';
+import { safe } from '../normalize.js';
+const InputSchema = z.object({
+    cwd: z.string().optional(),
+    sinceHours: z.number().int().min(0).max(24 * 365).optional().describe('Only files modified within this many hours (default 24)'),
+    maxResults: z.number().int().min(1).max(500).optional().describe('Cap results (default 50)'),
+    glob: z.string().optional().describe('Glob pattern to constrain (e.g. "src/**")'),
+});
+const DEFAULT_MAX = 50;
+const DEFAULT_SINCE_HOURS = 24;
+const SKIP_DIRS = new Set(['node_modules', '.git', 'dist', 'build', '.next', '.turbo', 'coverage', '.klyro']);
+const SKIP_EXT = new Set(['.png', '.jpg', '.jpeg', '.gif', '.woff', '.woff2', '.ttf', '.otf', '.exe', '.dll', '.bin', '.zip', '.tar', '.gz', '.map']);
+async function globToRegex(pattern) {
+    let p = pattern;
+    const anchor = p.startsWith('**/') ? '^(?:.*/)?' : p === '**' ? '^.*' : '^';
+    if (p.startsWith('**/'))
+        p = p.slice(3);
+    const escaped = p
+        .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+        .replace(/\*\*/g, '::DOUBLESTAR::')
+        .replace(/\*/g, '[^/]*')
+        .replace(/\?/g, '[^/]')
+        .replace(/::DOUBLESTAR::/g, '.*');
+    return new RegExp(`${anchor}${escaped}$`);
+}
+async function walk(root, dir, onFile) {
+    let names;
+    try {
+        names = await fs.readdir(dir);
+    }
+    catch {
+        return;
+    }
+    for (const name of names) {
+        if (SKIP_DIRS.has(name))
+            continue;
+        const full = path.join(dir, name);
+        let isDir = false;
+        try {
+            const s = await fs.lstat(full);
+            if (s.isSymbolicLink())
+                continue;
+            isDir = s.isDirectory();
+        }
+        catch {
+            continue;
+        }
+        if (isDir)
+            await walk(root, full, onFile);
+        else
+            await onFile(full);
+    }
+}
+export const recentFilesTool = defineTool({
+    name: 'recent_files',
+    description: 'List files in the repo modified within the last N hours, newest first. Use to answer "what changed recently?" efficiently.',
+    inputSchema: InputSchema,
+    execute: async (input, ctx) => {
+        return safe(async () => {
+            const base = input.cwd ? resolveWithinCwd(ctx.cwd, input.cwd).resolved : ctx.cwd;
+            const max = input.maxResults ?? DEFAULT_MAX;
+            const sinceHours = input.sinceHours ?? DEFAULT_SINCE_HOURS;
+            const sinceMs = Date.now() - sinceHours * 60 * 60 * 1000;
+            const globRe = input.glob ? await globToRegex(input.glob) : null;
+            const results = [];
+            await walk(base, base, async (full) => {
+                const ext = path.extname(full).toLowerCase();
+                if (SKIP_EXT.has(ext))
+                    return;
+                const rel = path.relative(ctx.cwd, full).split(path.sep).join('/');
+                if (globRe && !globRe.test(rel))
+                    return;
+                let mtimeMs = 0;
+                try {
+                    mtimeMs = (await fs.stat(full)).mtimeMs;
+                }
+                catch {
+                    return;
+                }
+                if (mtimeMs < sinceMs)
+                    return;
+                const ageHours = (Date.now() - mtimeMs) / (1000 * 60 * 60);
+                results.push({ path: rel, mtimeMs, ageHours });
+            });
+            results.sort((a, b) => b.mtimeMs - a.mtimeMs);
+            const truncated = results.length > max;
+            return { files: results.slice(0, max), truncated };
+        });
+    },
+});

package/dist/tools/search/search-files.d.ts

@@ -0,0 +1,39 @@
+/**
+ * search_files — repo-aware file lookup with ranking.
+ *
+ * Returns files that match an optional glob AND/OR a regex against the file
+ * contents, ranked by:
+ *   - path/regex match strength
+ *   - recent modification time (newer = higher)
+ *   - whether the file is a first-party source file (src/ etc.) vs vendored
+ *
+ * The agent uses this to answer "where is X?" without doing a full grep.
+ */
+import { z } from 'zod';
+declare const InputSchema: z.ZodObject<{
+    query: z.ZodOptional<z.ZodString>;
+    glob: z.ZodOptional<z.ZodString>;
+    cwd: z.ZodOptional<z.ZodString>;
+    maxResults: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export interface RankedFile {
+    path: string;
+    score: number;
+    mtimeMs: number;
+    firstParty: boolean;
+}
+export interface SearchFilesOutput {
+    matches: RankedFile[];
+    truncated: boolean;
+}
+export declare const searchFilesTool: import("../types.js").Tool<{
+    query?: string | undefined;
+    glob?: string | undefined;
+    cwd?: string | undefined;
+    maxResults?: number | undefined;
+}, {
+    matches: RankedFile[];
+    truncated: boolean;
+}>;
+export type SearchFilesInput = z.infer<typeof InputSchema>;
+export {};

package/dist/tools/search/search-files.js

@@ -0,0 +1,110 @@
+/**
+ * search_files — repo-aware file lookup with ranking.
+ *
+ * Returns files that match an optional glob AND/OR a regex against the file
+ * contents, ranked by:
+ *   - path/regex match strength
+ *   - recent modification time (newer = higher)
+ *   - whether the file is a first-party source file (src/ etc.) vs vendored
+ *
+ * The agent uses this to answer "where is X?" without doing a full grep.
+ */
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import { z } from 'zod';
+import { defineTool } from '../types.js';
+import { resolveWithinCwd } from '../../policy/path-guard.js';
+import { safe } from '../normalize.js';
+import { globToRegex } from './glob.js';
+const InputSchema = z.object({
+    query: z.string().optional().describe('Substring or regex to match against file paths (case-insensitive)'),
+    glob: z.string().optional().describe('Glob pattern to constrain candidates, e.g. "src/**/*.ts"'),
+    cwd: z.string().optional(),
+    maxResults: z.number().int().min(1).max(500).optional().describe('Cap results (default 50)'),
+});
+const DEFAULT_MAX = 50;
+const SKIP_DIRS = new Set(['node_modules', '.git', 'dist', 'build', '.next', '.turbo', 'coverage', '.klyro']);
+const FIRST_PARTY_HINTS = ['src/', 'lib/', 'app/', 'pkg/'];
+function queryToRegex(query) {
+    const escaped = query.replace(/[.+^${}()|[\]\\]/g, '\\$&');
+    return new RegExp(escaped, 'i');
+}
+async function walk(root, dir, onFile) {
+    let names;
+    try {
+        names = await fs.readdir(dir);
+    }
+    catch {
+        return;
+    }
+    for (const name of names) {
+        if (SKIP_DIRS.has(name))
+            continue;
+        const full = path.join(dir, name);
+        let isDir = false;
+        try {
+            const s = await fs.lstat(full);
+            if (s.isSymbolicLink())
+                continue;
+            isDir = s.isDirectory();
+        }
+        catch {
+            continue;
+        }
+        if (isDir)
+            await walk(root, full, onFile);
+        else
+            await onFile(full);
+    }
+}
+export const searchFilesTool = defineTool({
+    name: 'search_files',
+    description: 'Find files in the repo, ranked by name/path match and recency. Use to answer "where is X?" questions efficiently. Pass `query` (substring) and/or `glob` to constrain candidates.',
+    inputSchema: InputSchema,
+    execute: async (input, ctx) => {
+        return safe(async () => {
+            const base = input.cwd ? resolveWithinCwd(ctx.cwd, input.cwd).resolved : ctx.cwd;
+            const max = input.maxResults ?? DEFAULT_MAX;
+            const matcher = input.query ? queryToRegex(input.query) : null;
+            const globRe = input.glob ? globToRegex(input.glob) : null;
+            const candidates = [];
+            const now = Date.now();
+            await walk(base, base, async (full) => {
+                const rel = path.relative(ctx.cwd, full).split(path.sep).join('/');
+                if (globRe && !globRe.test(rel))
+                    return;
+                if (matcher && !matcher.test(rel))
+                    return;
+                let mtimeMs = 0;
+                try {
+                    const s = await fs.stat(full);
+                    mtimeMs = s.mtimeMs;
+                }
+                catch {
+                    return;
+                }
+                const ageDays = Math.max(0, (now - mtimeMs) / (1000 * 60 * 60 * 24));
+                const firstParty = FIRST_PARTY_HINTS.some((h) => rel.startsWith(h));
+                let score = 0;
+                if (matcher) {
+                    // Substring match weight depends on how much of the path matches.
+                    const nameOnly = rel.split('/').pop() ?? rel;
+                    if (nameOnly.toLowerCase() === input.query.toLowerCase())
+                        score += 200;
+                    else if (nameOnly.toLowerCase().includes(input.query.toLowerCase()))
+                        score += 80;
+                    else if (rel.toLowerCase().includes(input.query.toLowerCase()))
+                        score += 40;
+                }
+                if (firstParty)
+                    score += 20;
+                // Recency: 0..30 points, 0 days = 30, 30+ days = 0
+                score += Math.max(0, 30 - ageDays);
+                candidates.push({ path: rel, score, mtimeMs, firstParty });
+            });
+            candidates.sort((a, b) => b.score - a.score);
+            const truncated = candidates.length > max;
+            return { matches: candidates.slice(0, max), truncated };
+        });
+    },
+});

package/dist/tools/shell/shell-exec.d.ts

@@ -0,0 +1,60 @@
+/**
+ * shell_exec — run a shell command.
+ *
+ * Safety:
+ *   - Hard-coded dangerous patterns are always blocked (fork bomb, rm -rf /, etc.)
+ *   - Per-call timeout (default 30s)
+ *   - stdout/stderr are truncated at 128 KiB so a runaway command can't OOM us
+ *   - Non-zero exit is returned as a successful tool call (with exitCode in
+ *     the output). The agent reads exitCode to decide what to do next.
+ */
+import { z } from 'zod';
+declare const InputSchema: z.ZodObject<{
+    command: z.ZodString;
+    cwd: z.ZodOptional<z.ZodString>;
+    timeoutMs: z.ZodOptional<z.ZodNumber>;
+    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strip>;
+export interface ShellOutput {
+    command: string;
+    exitCode: number | null;
+    signal: NodeJS.Signals | null;
+    stdout: string;
+    stderr: string;
+    durationMs: number;
+    timedOut: boolean;
+    truncated: boolean;
+}
+export declare const shellExecTool: import("../types.js").Tool<{
+    command: string;
+    cwd?: string | undefined;
+    timeoutMs?: number | undefined;
+    env?: Record<string, string> | undefined;
+}, {
+    readonly ok: false;
+    readonly error: {
+        readonly code: "COMMAND_DENIED";
+        readonly message: `Command blocked: ${string}`;
+    };
+    command?: undefined;
+    exitCode?: undefined;
+    signal?: undefined;
+    stdout?: undefined;
+    stderr?: undefined;
+    durationMs?: undefined;
+    timedOut?: undefined;
+    truncated?: undefined;
+} | {
+    command: string;
+    exitCode: number | null;
+    signal: NodeJS.Signals | null;
+    stdout: string;
+    stderr: string;
+    durationMs: number;
+    timedOut: boolean;
+    truncated: false;
+    readonly ok?: undefined;
+    readonly error?: undefined;
+}>;
+export type ShellInput = z.infer<typeof InputSchema>;
+export {};

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

@@ -0,0 +1,133 @@
+/**
+ * shell_exec — run a shell command.
+ *
+ * Safety:
+ *   - Hard-coded dangerous patterns are always blocked (fork bomb, rm -rf /, etc.)
+ *   - Per-call timeout (default 30s)
+ *   - stdout/stderr are truncated at 128 KiB so a runaway command can't OOM us
+ *   - Non-zero exit is returned as a successful tool call (with exitCode in
+ *     the output). The agent reads exitCode to decide what to do next.
+ */
+import { spawn } from 'node:child_process';
+import { z } from 'zod';
+import { defineTool } from '../types.js';
+import { resolveWithinCwd } from '../../policy/path-guard.js';
+import { safe, TOOL_ERROR_CODES } from '../normalize.js';
+const InputSchema = z.object({
+    command: z.string().min(1).describe('Shell command to execute (interpreted by /bin/sh -c on Unix, cmd.exe /c on Windows)'),
+    cwd: z.string().optional().describe('Working directory; defaults to the workspace cwd'),
+    timeoutMs: z.number().int().min(1).max(600_000).optional().describe('Timeout in milliseconds (default 30000, max 600000)'),
+    env: z.record(z.string(), z.string()).optional().describe('Extra env vars merged onto process.env'),
+});
+const DEFAULT_TIMEOUT_MS = 30_000;
+const MAX_OUTPUT_BYTES = 128 * 1024;
+// Hard-coded dangerous patterns. These are non-overridable in MVP.
+const DANGEROUS_PATTERNS = [
+    { pattern: /rm\s+-rf?\s+\//, reason: 'recursive delete at filesystem root' },
+    { 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: />\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' },
+];
+export const shellExecTool = defineTool({
+    name: 'shell_exec',
+    description: 'Execute a shell command. Default timeout 30s. Output is truncated at 128 KiB. Returns exitCode (or null if killed by signal). Non-zero exit code is NOT a tool error — the tool succeeds and the agent sees the exit code in the output.',
+    inputSchema: InputSchema,
+    execute: async (input, ctx) => {
+        return safe(async () => {
+            for (const { pattern, reason } of DANGEROUS_PATTERNS) {
+                if (pattern.test(input.command)) {
+                    return {
+                        ok: false,
+                        error: { code: TOOL_ERROR_CODES.COMMAND_DENIED, message: `Command blocked: ${reason}` },
+                    };
+                }
+            }
+            let cwd = ctx.cwd;
+            if (input.cwd) {
+                cwd = resolveWithinCwd(ctx.cwd, input.cwd).resolved;
+            }
+            const timeoutMs = input.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+            const env = { ...process.env, ...(input.env ?? {}) };
+            const start = Date.now();
+            const child = spawn(input.command, {
+                cwd,
+                env: env,
+                shell: true,
+                stdio: ['ignore', 'pipe', 'pipe'],
+                windowsHide: true,
+                signal: ctx.signal,
+            });
+            const stdoutChunks = [];
+            const stderrChunks = [];
+            let totalOut = 0;
+            let totalErr = 0;
+            let truncated = false;
+            child.stdout?.on('data', (chunk) => {
+                if (totalOut + chunk.length > MAX_OUTPUT_BYTES) {
+                    truncated = true;
+                    return;
+                }
+                stdoutChunks.push(chunk);
+                totalOut += chunk.length;
+            });
+            child.stderr?.on('data', (chunk) => {
+                if (totalErr + chunk.length > MAX_OUTPUT_BYTES) {
+                    truncated = true;
+                    return;
+                }
+                stderrChunks.push(chunk);
+                totalErr += chunk.length;
+            });
+            // Resolve on the FIRST of: process exit, or the timeout timer. Awaiting
+            // `close` alone would deadlock on Windows, where a grandchild (e.g. ping)
+            // inherits the stdio pipes and keeps them open after the shell wrapper
+            // exits. We listen to `exit` for the code and let the timer force-kill.
+            const outcome = await new Promise((resolve) => {
+                let done = false;
+                const finish = (o) => {
+                    if (done)
+                        return;
+                    done = true;
+                    clearTimeout(timer);
+                    resolve(o);
+                };
+                const timer = setTimeout(() => {
+                    // On Windows, `child.kill()` only kills the shell wrapper, leaving
+                    // grandchildren (e.g. ping) holding the stdio pipes open. Use
+                    // `taskkill /F /T` to nuke the entire process tree; on POSIX,
+                    // -SIGKILL signals the group so children go too.
+                    if (process.platform === 'win32') {
+                        try {
+                            require('node:child_process').spawnSync('taskkill', ['/F', '/T', '/PID', String(child.pid)], { windowsHide: true });
+                        }
+                        catch { /* already gone */ }
+                    }
+                    else {
+                        try {
+                            child.kill('SIGKILL');
+                        }
+                        catch { /* already dead */ }
+                    }
+                    finish({ code: null, signal: 'SIGKILL', timedOut: true });
+                }, timeoutMs);
+                child.on('exit', (code, signal) => finish({ code, signal, timedOut: false }));
+                child.on('error', () => finish({ code: null, signal: null, timedOut: false }));
+            });
+            const { code: exitCode, signal, timedOut } = outcome;
+            const stdout = Buffer.concat(stdoutChunks).toString('utf-8');
+            const stderr = Buffer.concat(stderrChunks).toString('utf-8');
+            return {
+                command: input.command,
+                exitCode,
+                signal,
+                stdout,
+                stderr,
+                durationMs: Date.now() - start,
+                timedOut,
+                truncated,
+            };
+        });
+    },
+});