agent-sh 0.9.0 → 0.10.1

package/dist/agent/tools/ls.js

@@ -44,21 +44,20 @@ export function createLsTool(getCwd) {
                 const entries = await fs.readdir(absPath, {
                     withFileTypes: true,
                 });
-                const lines = [];
-                for (const e of entries) {
+                const items = await Promise.all(entries.map(async (e) => {
                     const fullPath = path.join(absPath, e.name);
                     try {
                         const stat = await fs.stat(fullPath);
                         const size = e.isDirectory() ? "-" : formatSize(stat.size);
                         const mtime = stat.mtime.toISOString().slice(0, 16).replace("T", " ");
-                        lines.push(`${mtime}  ${size.padStart(8)}  ${e.isDirectory() ? e.name + "/" : e.name}`);
+                        return `${mtime}  ${size.padStart(8)}  ${e.isDirectory() ? e.name + "/" : e.name}`;
                     }
                     catch {
-                        lines.push(`${"?".padStart(16)}  ${"?".padStart(8)}  ${e.isDirectory() ? e.name + "/" : e.name}`);
+                        return `${"?".padStart(16)}  ${"?".padStart(8)}  ${e.isDirectory() ? e.name + "/" : e.name}`;
                     }
-                }
+                }));
                 return {
-                    content: lines.join("\n") || "(empty directory)",
+                    content: items.join("\n") || "(empty directory)",
                     exitCode: 0,
                     isError: false,
                 };

package/dist/agent/types.d.ts

@@ -4,7 +4,6 @@
  * Backends self-wire to bus events in their constructor:
  *   - agent:submit → handle queries
  *   - agent:cancel-request → handle cancellation
- *   - config:cycle → handle mode switching
  *
  * They emit bus events for results:
  *   - agent:response-chunk, agent:tool-started, agent:tool-completed, etc.
@@ -38,7 +37,7 @@ export type ToolResultBody = {
     maxLines?: number;
 };
 export interface ToolDisplayInfo {
-    kind: "read" | "write" | "execute" | "search" | "display";
+    kind: "read" | "write" | "execute" | "search";
     locations?: {
         path: string;
         line?: number | null;

package/dist/context-manager.d.ts

@@ -4,41 +4,38 @@ export declare class ContextManager {
     private exchanges;
     private nextId;
     private currentCwd;
-    private sessionStart;
-    private firstPrompt;
     private agentShellActive;
-    private handlers;
-    constructor(bus: EventBus, handlers?: HandlerRegistry);
+    constructor(bus: EventBus, _handlers?: HandlerRegistry);
     getCwd(): string;
-    /**
-     * Build the <shell_context> block for the agent prompt.
-     * Pipeline: window → truncate → format
-     */
-    getContext(budget?: number): string;
     /**
      * Regex/keyword search across all exchanges. Returns formatted results.
      */
     search(query: string): string;
     /**
-     * Return content for specific exchange IDs.
-     * Optional start/end restrict to a line range (1-indexed).
+     * Return shell events with id > afterId, formatted as an incremental
+     * delta suitable for injection into conversation history. Skips
+     * agent-source commands (already visible in tool results). Returns
+     * null when nothing new exists.
+     *
+     * The motivation: resending the full <shell_context> every turn wastes
+     * tokens — N turns × full history = O(N²) cost for O(N) information.
+     * Instead we inject only new events as regular conversation messages,
+     * so the provider's prefix cache amortizes them to O(N).
      */
-    expand(ids: number[], start?: number, end?: number): string;
+    getEventsSince(afterId: number): {
+        text: string;
+        lastSeq: number;
+    } | null;
+    /** Highest exchange id seen so far (0 if none). */
+    lastSeq(): number;
     /**
      * One-line summaries of last N exchanges.
      */
     getRecentSummary(n?: number): string;
-    /**
-     * Parse and handle shell_recall commands.
-     */
-    handleRecallCommand(command: string): string;
     /**
      * Clear exchange history (used by /clear command).
      */
     clear(): void;
-    private applyWindow;
-    private applyTruncation;
-    private formatContext;
     private addExchange;
     private formatExchangeTruncated;
     private formatExchangeFull;

package/dist/context-manager.js

@@ -1,32 +1,43 @@
 import { getSettings } from "./settings.js";
+import { spillOutput } from "./utils/shell-output-spill.js";
 export class ContextManager {
     exchanges = [];
     nextId = 1;
     currentCwd;
-    sessionStart;
-    firstPrompt = true;
     agentShellActive = false; // true while user_shell command is executing
-    handlers = null;
-    constructor(bus, handlers) {
-        if (handlers) {
-            this.handlers = handlers;
-            // Extensions can advise this to inject extra context (e.g. terminal buffer)
-            handlers.define("context:build-extra", () => "");
-        }
+    constructor(bus, _handlers) {
         this.currentCwd = process.cwd();
-        this.sessionStart = Date.now();
         // ── Subscribe to shell events ──
         bus.on("shell:command-done", (e) => {
             const lines = e.output.split("\n");
+            const s = getSettings();
+            // Spill long outputs to a tempfile so the agent can `read_file` them
+            // on demand instead of carrying the full text in LLM context.
+            let output = e.output;
+            let spillPath;
+            if (lines.length > s.shellTruncateThreshold) {
+                // Reserve the id we're about to assign so the tempfile name matches.
+                const id = this.nextId;
+                try {
+                    spillPath = spillOutput(id, e.output);
+                    output = buildSpillStub(lines, s.shellHeadLines, s.shellTailLines, spillPath);
+                }
+                catch {
+                    // If spill fails (e.g. disk full), fall back to keeping output in memory.
+                    output = e.output;
+                    spillPath = undefined;
+                }
+            }
             this.addExchange({
                 type: "shell_command",
                 command: e.command,
-                output: e.output,
+                output,
                 cwd: e.cwd,
                 exitCode: e.exitCode,
                 outputLines: lines.length,
                 outputBytes: e.output.length,
                 source: this.agentShellActive ? "agent" : "user",
+                spillPath,
             });
         });
         bus.on("shell:cwd-change", (e) => {
@@ -46,16 +57,6 @@ export class ContextManager {
     getCwd() {
         return this.currentCwd;
     }
-    /**
-     * Build the <shell_context> block for the agent prompt.
-     * Pipeline: window → truncate → format
-     */
-    getContext(budget) {
-        budget ??= getSettings().contextBudget;
-        let exchanges = this.applyWindow(this.exchanges);
-        exchanges = this.applyTruncation(exchanges, budget);
-        return this.formatContext(exchanges);
-    }
     /**
      * Regex/keyword search across all exchanges. Returns formatted results.
      */
@@ -107,38 +108,31 @@ export class ContextManager {
         return parts.join("\n");
     }
     /**
-     * Return content for specific exchange IDs.
-     * Optional start/end restrict to a line range (1-indexed).
+     * Return shell events with id > afterId, formatted as an incremental
+     * delta suitable for injection into conversation history. Skips
+     * agent-source commands (already visible in tool results). Returns
+     * null when nothing new exists.
+     *
+     * The motivation: resending the full <shell_context> every turn wastes
+     * tokens — N turns × full history = O(N²) cost for O(N) information.
+     * Instead we inject only new events as regular conversation messages,
+     * so the provider's prefix cache amortizes them to O(N).
      */
-    expand(ids, start, end) {
-        const results = [];
-        for (const id of ids) {
-            const ex = this.exchanges.find((e) => e.id === id);
-            if (!ex) {
-                results.push(`#${id}: not found`);
-                continue;
-            }
-            const text = this.formatExchangeFull(ex);
-            const lines = text.split("\n");
-            const total = lines.length;
-            if (start != null || end != null) {
-                // Line range requested
-                const s = Math.max(0, (start ?? 1) - 1);
-                const e = end ?? total;
-                results.push(lines.slice(s, e).join("\n") +
-                    `\n[showing lines ${s + 1}-${Math.min(e, total)} of ${total}]`);
-            }
-            else if (total > getSettings().recallExpandMaxLines) {
-                // Too large — tell the agent to narrow down
-                results.push(`#${ex.id}: output is ${total} lines, too large to expand fully. ` +
-                    `Use start/end params to select a line range (e.g. start=1, end=50), ` +
-                    `or use search with a regex to find specific content.`);
-            }
-            else {
-                results.push(text);
-            }
-        }
-        return results.join("\n\n");
+    getEventsSince(afterId) {
+        const fresh = this.exchanges.filter((e) => e.id > afterId && !(e.type === "shell_command" && e.source === "agent"));
+        if (fresh.length === 0)
+            return null;
+        const lastSeq = this.exchanges[this.exchanges.length - 1].id;
+        // Outputs already carry head+tail+spillPath stubs from capture time.
+        const body = fresh.map((ex) => this.formatExchangeTruncated(ex)).join("\n");
+        return {
+            text: `<shell-events>\n${body}</shell-events>`,
+            lastSeq,
+        };
+    }
+    /** Highest exchange id seen so far (0 if none). */
+    lastSeq() {
+        return this.exchanges.length === 0 ? 0 : this.exchanges[this.exchanges.length - 1].id;
     }
     /**
      * One-line summaries of last N exchanges.
@@ -149,108 +143,13 @@ export class ContextManager {
             return "No exchanges yet.";
         return recent.map((ex) => this.exchangeOneLiner(ex)).join("\n");
     }
-    /**
-     * Parse and handle shell_recall commands.
-     */
-    handleRecallCommand(command) {
-        const args = command.replace(/^_*shell_recall\s*/, "").trim();
-        if (!args || args === "--help") {
-            return [
-                "Usage:",
-                "  shell_recall                    Browse recent exchanges",
-                "  shell_recall --search <query>   Search all exchanges",
-                "  shell_recall --expand <id,...>   Show full content of exchanges",
-                "",
-                "Examples:",
-                '  shell_recall --search "test fail"',
-                "  shell_recall --expand 41",
-                "  shell_recall --expand 41,42,43",
-            ].join("\n");
-        }
-        const searchMatch = args.match(/^--search\s+(?:"([^"]+)"|(\S+))/);
-        if (searchMatch) {
-            return this.search(searchMatch[1] ?? searchMatch[2] ?? "");
-        }
-        const expandMatch = args.match(/^--expand\s+([\d,\s]+)/);
-        if (expandMatch) {
-            const ids = expandMatch[1]
-                .split(/[,\s]+/)
-                .map(Number)
-                .filter((n) => !isNaN(n));
-            if (ids.length === 0)
-                return "No valid IDs provided.";
-            return this.expand(ids);
-        }
-        // Default: browse
-        return this.getRecentSummary();
-    }
     /**
      * Clear exchange history (used by /clear command).
      */
     clear() {
         this.exchanges = [];
-        this.firstPrompt = true;
         // Don't reset nextId — IDs should be globally unique within a session
     }
-    // ── Pipeline stages ───────────────────────────────────────────
-    applyWindow(exchanges, windowSize) {
-        windowSize ??= getSettings().contextWindowSize;
-        return exchanges.slice(-windowSize);
-    }
-    applyTruncation(exchanges, budget) {
-        // Deep clone so we don't mutate the source
-        const result = exchanges.map((e) => ({ ...e }));
-        // Pass 1: per-type truncation
-        for (const ex of result) {
-            if (ex.type === "shell_command") {
-                const s = getSettings();
-                ex.output = truncateOutput(ex.output, s.shellTruncateThreshold, s.shellHeadLines, s.shellTailLines, ex.id);
-            }
-            // agent_query has no output to truncate
-        }
-        // Pass 2: budget enforcement — strip output from oldest if over budget
-        let totalSize = result.reduce((sum, ex) => sum + this.exchangeSize(ex), 0);
-        for (let i = 0; i < result.length - 1 && totalSize > budget; i++) {
-            const ex = result[i];
-            const before = this.exchangeSize(ex);
-            if (ex.type === "shell_command") {
-                ex.output = `[output omitted, use shell_recall tool to expand id ${ex.id}]`;
-            }
-            totalSize -= before - this.exchangeSize(ex);
-        }
-        return result;
-    }
-    formatContext(exchanges) {
-        const elapsed = Math.round((Date.now() - this.sessionStart) / 60000);
-        const totalCount = this.exchanges.length;
-        let out = "<shell_context>\n";
-        if (this.firstPrompt) {
-            out += `You are an AI assistant living inside agent-sh, a shell-first terminal.\n`;
-            out += `The user interacts with a real shell (PTY) and sends you queries inline. You are there to help them with their tasks.\n`;
-            out += `\n`;
-            out += `IMPORTANT tool usage rules:\n`;
-            out += `- user_shell runs commands in the user's live shell (PTY). The user sees output directly — no summary needed.\n`;
-            out += `- Your internal tools (bash, read, write, ls, etc.) run in an isolated subprocess. The user CANNOT see their output.\n`;
-            out += `- When the user asks to see, list, view, or display anything, ALWAYS use user_shell. NEVER use internal tools like ls/read/bash for display — the user won't see it.\n`;
-            out += `- Only use internal tools when YOU need to reason about content silently (e.g. reading a file to answer a question about it).\n`;
-            out += `- After a user_shell command, the user already saw the output. Do NOT repeat or summarize it.\n`;
-            out += `- You can browse or search shell history with shell_recall.\n`;
-            out += `- You can browse or search evicted conversation turns with conversation_recall.\n`;
-            out += `\n`;
-            this.firstPrompt = false;
-        }
-        out += `cwd: ${this.currentCwd}\n`;
-        out += `session: ${totalCount} exchanges, ${elapsed}m elapsed\n`;
-        for (const ex of exchanges) {
-            out += "\n" + this.formatExchangeTruncated(ex);
-        }
-        // Allow extensions to inject extra context (e.g. terminal buffer snapshot)
-        const extra = this.handlers?.call("context:build-extra");
-        if (extra)
-            out += "\n" + extra + "\n";
-        out += "\n</shell_context>\n";
-        return out;
-    }
     // ── Internal helpers ──────────────────────────────────────────
     addExchange(partial) {
         const exchange = {
@@ -319,14 +218,11 @@ export class ContextManager {
     }
 }
 // ── Utility functions ─────────────────────────────────────────
-function truncateOutput(text, threshold, headLines, tailLines, id) {
-    const lines = text.split("\n");
-    if (lines.length <= threshold)
-        return text;
+function buildSpillStub(lines, headLines, tailLines, spillPath) {
     const omitted = lines.length - headLines - tailLines;
     return [
         ...lines.slice(0, headLines),
-        `[... ${omitted} lines truncated, use shell_recall tool with expand and id ${id} to see full output ...]`,
+        `[... ${omitted} lines truncated — full output at ${spillPath}; use read_file to expand ...]`,
         ...lines.slice(-tailLines),
     ].join("\n");
 }

package/dist/core.js

@@ -24,7 +24,11 @@ import * as settingsMod from "./settings.js";
 import { HandlerRegistry } from "./utils/handler-registry.js";
 import { TerminalBuffer } from "./utils/terminal-buffer.js";
 import crypto from "node:crypto";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
 import { DefaultCompositor, StdoutSurface } from "./utils/compositor.js";
+const STORAGE_ROOT = path.join(os.homedir(), ".agent-sh");
 // Re-export types that library consumers need
 export { EventBus } from "./event-bus.js";
 export { palette, setPalette, resetPalette } from "./utils/palette.js";
@@ -34,7 +38,10 @@ export function createCore(config) {
     const bus = new EventBus();
     const handlers = new HandlerRegistry();
     const contextManager = new ContextManager(bus, handlers);
-    const instanceId = crypto.randomBytes(2).toString("hex");
+    // 3 bytes = 6 hex chars, ~16M values — ample for per-lineage uniqueness and
+    // short enough to read/remember. Legacy content may have 16-char iids; any
+    // parsers should accept ≥6 hex chars.
+    const instanceId = crypto.randomBytes(3).toString("hex");
     const settings = settingsMod.getSettings();
     // Expose raw CLI config so the agent backend extension can resolve
     // providers and create the LLM client.
@@ -63,7 +70,12 @@ export function createCore(config) {
         backends.set(backend.name, backend);
     });
     bus.on("config:switch-backend", ({ name }) => {
-        activateByName(name);
+        activateByName(name).then(() => {
+            if (activeBackendName === name) {
+                settingsMod.updateSettings({ defaultBackend: name });
+                bus.emit("ui:info", { message: `Saved '${name}' as default backend.` });
+            }
+        });
     });
     bus.on("config:list-backends", () => {
         const names = [...backends.keys()];
@@ -77,7 +89,7 @@ export function createCore(config) {
         return { names, active: activeBackendName };
     });
     // ── Compositor ──────────────────────────────────────────────
-    const compositor = new DefaultCompositor();
+    const compositor = new DefaultCompositor(bus);
     const stdoutSurface = new StdoutSurface();
     compositor.setDefault("agent", stdoutSurface);
     compositor.setDefault("query", stdoutSurface);
@@ -145,7 +157,7 @@ export function createCore(config) {
             bus.emit("agent:cancel-request", {});
         },
         extensionContext(opts) {
-            return {
+            const ctx = {
                 bus,
                 contextManager,
                 instanceId,
@@ -154,15 +166,23 @@ export function createCore(config) {
                 createBlockTransform: (o) => streamTransform.createBlockTransform(bus, o),
                 createFencedBlockTransform: (o) => streamTransform.createFencedBlockTransform(bus, o),
                 getExtensionSettings: settingsMod.getExtensionSettings,
+                getStoragePath: (namespace) => {
+                    const dir = path.join(STORAGE_ROOT, namespace);
+                    fs.mkdirSync(dir, { recursive: true });
+                    return dir;
+                },
                 registerCommand: (name, description, handler) => bus.emit("command:register", { name, description, handler }),
-                registerTool: (tool) => bus.emit("agent:register-tool", { tool }),
+                registerTool: (tool) => bus.emit("agent:register-tool", { tool, extensionName: "" }),
                 unregisterTool: (name) => bus.emit("agent:unregister-tool", { name }),
                 getTools: () => bus.emitPipe("agent:get-tools", { tools: [] }).tools,
-                registerInstruction: (name, text) => bus.emit("agent:register-instruction", { name, text }),
+                registerInstruction: (name, text) => bus.emit("agent:register-instruction", { name, text, extensionName: "" }),
                 removeInstruction: (name) => bus.emit("agent:remove-instruction", { name }),
+                registerSkill: (name, description, filePath) => bus.emit("agent:register-skill", { name, description, filePath, extensionName: "" }),
+                removeSkill: (name) => bus.emit("agent:remove-skill", { name }),
                 define: (name, fn) => handlers.define(name, fn),
                 advise: (name, wrapper) => handlers.advise(name, wrapper),
                 call: (name, ...args) => handlers.call(name, ...args),
+                list: () => handlers.list(),
                 get terminalBuffer() { return getTerminalBuffer(); },
                 compositor,
                 createRemoteSession: (opts) => {
@@ -207,6 +227,7 @@ export function createCore(config) {
                     };
                 },
             };
+            return ctx;
         },
         kill() {
             if (activeBackendName) {

package/dist/event-bus.d.ts

@@ -89,6 +89,28 @@ export interface ShellEvents {
             }>;
         }>;
     };
+    "agent:tool-batch-complete": {
+        results: Array<{
+            name: string;
+            isError: boolean;
+            errorSummary?: string;
+        }>;
+    };
+    "conversation:message-appended": {
+        role: "user" | "assistant" | "tool" | "system";
+        content: string;
+        /** For role="tool": name of the tool whose result this is. */
+        toolName?: string;
+        /** For role="tool": parsed arguments passed to the tool. */
+        toolArgs?: Record<string, unknown>;
+        /** For role="tool": whether the tool errored. */
+        isError?: boolean;
+    };
+    "conversation:after-compact": {
+        beforeTokens: number;
+        afterTokens: number;
+        evictedCount: number;
+    };
     "agent:tool-started": {
         title: string;
         toolCallId?: string;
@@ -115,6 +137,16 @@ export interface ShellEvents {
     "agent:tool-output-chunk": {
         chunk: string;
     };
+    "agent:subagent-started": {
+        taskId: string;
+        task: string;
+    };
+    "agent:subagent-completed": {
+        taskId: string;
+        task: string;
+        result: string;
+        isError: boolean;
+    };
     "tool:interactive-start": Record<string, never>;
     "tool:interactive-end": Record<string, never>;
     "permission:request": {
@@ -130,6 +162,9 @@ export interface ShellEvents {
         description: string;
         handler: (args: string) => Promise<void> | void;
     };
+    "command:unregister": {
+        name: string;
+    };
     "command:execute": {
         name: string;
         args: string;
@@ -143,6 +178,10 @@ export interface ShellEvents {
     "ui:suggestion": {
         text: string;
     };
+    "compositor:write": {
+        stream: string;
+        text: string;
+    };
     "input:keypress": {
         key: string;
     };
@@ -182,8 +221,7 @@ export interface ShellEvents {
     "agent:compact-request": Record<string, never>;
     "context:get-stats": {
         activeTokens: number;
-        nuclearEntries: number;
-        recallArchiveSize: number;
+        totalTokens: number;
         budgetTokens: number;
     };
     "agent:register-backend": {
@@ -200,7 +238,6 @@ export interface ShellEvents {
         active: string | null;
     };
     "config:changed": Record<string, never>;
-    "config:cycle": Record<string, never>;
     "config:switch-model": {
         model: string;
     };
@@ -228,10 +265,12 @@ export interface ShellEvents {
     };
     "config:set-modes": {
         modes: AgentMode[];
+        activeIndex?: number;
     };
     "config:add-modes": {
         modes: AgentMode[];
     };
+    "core:extensions-loaded": Record<string, never>;
     "provider:register": {
         id: string;
         apiKey?: string;
@@ -247,6 +286,7 @@ export interface ShellEvents {
     };
     "agent:register-tool": {
         tool: import("./agent/types.js").ToolDefinition;
+        extensionName?: string;
     };
     "agent:unregister-tool": {
         name: string;
@@ -257,10 +297,26 @@ export interface ShellEvents {
     "agent:register-instruction": {
         name: string;
         text: string;
+        extensionName: string;
     };
     "agent:remove-instruction": {
         name: string;
     };
+    "agent:register-skill": {
+        name: string;
+        description: string;
+        filePath: string;
+        extensionName: string;
+    };
+    "agent:remove-skill": {
+        name: string;
+    };
+    "banner:collect": {
+        sections: Array<{
+            label: string;
+            items: string[];
+        }>;
+    };
     "autocomplete:request": {
         buffer: string;
         /** Parsed slash command name (e.g. "/backend"), or null if not a command. */

package/dist/executor.d.ts

@@ -25,7 +25,8 @@ export declare function executeCommand(opts: {
     done: Promise<void>;
 };
 /**
- * Kill a running session's process group.
- * Sends SIGTERM first, then SIGKILL after 5 seconds.
+ * Kill a running session's process group: SIGTERM, then SIGKILL after 5s.
+ * Returns a cleanup that cancels the pending SIGKILL — callers should invoke
+ * it once the process has exited.
  */
-export declare function killSession(session: ExecutorSession): void;
+export declare function killSession(session: ExecutorSession): () => void;

package/dist/executor.js

@@ -60,14 +60,15 @@ export function executeCommand(opts) {
     };
     child.stdout?.on("data", handleData);
     child.stderr?.on("data", handleData);
-    // Timeout handler
+    let cancelKill;
     const timer = setTimeout(() => {
         if (!session.done) {
-            killSession(session);
+            cancelKill = killSession(session);
         }
     }, timeout);
     child.on("exit", (code, signal) => {
         clearTimeout(timer);
+        cancelKill?.();
         session.exitCode = code ?? (signal ? -1 : null);
         session.done = true;
         session.process = null;
@@ -75,6 +76,7 @@ export function executeCommand(opts) {
     });
     child.on("error", (err) => {
         clearTimeout(timer);
+        cancelKill?.();
         if (!session.done) {
             session.exitCode = -1;
             session.output += `\nProcess error: ${err.message}`;
@@ -86,31 +88,32 @@ export function executeCommand(opts) {
     return { session, done };
 }
 /**
- * Kill a running session's process group.
- * Sends SIGTERM first, then SIGKILL after 5 seconds.
+ * Kill a running session's process group: SIGTERM, then SIGKILL after 5s.
+ * Returns a cleanup that cancels the pending SIGKILL — callers should invoke
+ * it once the process has exited.
  */
 export function killSession(session) {
     const proc = session.process;
     if (!proc || !proc.pid)
-        return;
+        return () => { };
     try {
-        // Kill the entire process group
         process.kill(-proc.pid, "SIGTERM");
     }
-    catch {
-        // Process may already be dead
-    }
-    // Fallback: SIGKILL after 5 seconds
+    catch { }
+    let settled = false;
     const fallback = setTimeout(() => {
-        if (!session.done && proc.pid) {
+        if (!settled && !session.done && proc.pid) {
             try {
                 process.kill(-proc.pid, "SIGKILL");
             }
-            catch {
-                // Ignore
-            }
+            catch { }
         }
     }, 5000);
-    // Don't let the timer keep the process alive
     fallback.unref();
+    return () => {
+        if (!settled) {
+            settled = true;
+            clearTimeout(fallback);
+        }
+    };
 }