bare-agent 0.8.0 → 0.10.0

package/src/loop.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const { ToolError } = require('./errors');
+const { ToolError, HaltError } = require('./errors');
 
 // Average pricing per 1K tokens (USD). Adjust these to match your provider's rates.
 // Last updated: 2026-03-18. Source: public provider pricing pages.
@@ -43,7 +43,9 @@ class Loop {
    * @param {object} [options.retry] - Retry instance for backoff on failures.
    * @param {object} [options.stream] - Stream instance for event emission.
    * @param {object} [options.store] - Store instance for validate() health check.
-   * @param {Function} [options.policy] - Async (toolName, args, ctx) => true | string. Recommended wiring: closure that delegates to a bareguard Gate (`require('bare-agent/bareguard').wireGate(gate).policy`). Anything other than `true` denies; a string is fed to the LLM verbatim as the deny reason. All policy/budget/audit decisions live in bareguard — Loop just calls the closure and respects the verdict.
+   * @param {Function} [options.policy] - Async (toolName, args, ctx) => true | string. Recommended wiring: closure that delegates to a bareguard Gate (`require('bare-agent/bareguard').wireGate(gate).policy`). Anything other than `true` denies; a string is fed to the LLM verbatim as the deny reason. A throw of `HaltError` exits the loop cleanly. All policy/budget/audit decisions live in bareguard — Loop just calls the closure and respects the verdict.
+   * @param {Function} [options.onLlmResult] - Async ({model, provider, usage, costUsd, durationMs, ctx}) called after every successful provider.generate. Wire via `wireGate(gate).onLlmResult` so `budget.maxCostUsd` covers token-only workloads. Errors route through `_reportError` but never kill the loop.
+   * @param {Function} [options.onToolResult] - Async ({name, args, result, error, durationMs, ctx}) called after every tool.execute (success and failure). Wire via `wireGate(gate).onToolResult` so `gate.record` sees `ctx`. Errors route through `_reportError` but never kill the loop.
    * @throws {Error} `[Loop] requires a provider` — when options.provider is missing.
    */
   constructor(options = {}) {
@@ -62,6 +64,14 @@ class Loop {
       throw new Error('[Loop] options.policy must be a function (toolName, args, ctx) => true | string');
     }
     this.policy = options.policy || null;
+    if (options.onLlmResult != null && typeof options.onLlmResult !== 'function') {
+      throw new Error('[Loop] options.onLlmResult must be a function');
+    }
+    if (options.onToolResult != null && typeof options.onToolResult !== 'function') {
+      throw new Error('[Loop] options.onToolResult must be a function');
+    }
+    this.onLlmResult = options.onLlmResult || null;
+    this.onToolResult = options.onToolResult || null;
     this._stopped = false;
     this._history = []; // for chat() stateful mode
   }
@@ -144,17 +154,19 @@ class Loop {
     let lastUsage = { inputTokens: 0, outputTokens: 0 };
     let totalCost = 0;
 
+    try {
     for (let round = 0; round < HARD_ROUND_LIMIT; round++) {
       if (this._stopped) break;
 
       let result;
+      const llmStartedAt = Date.now();
       try {
         const generate = () => this.provider.generate(msgs, tools, options);
         result = this.retry ? await this.retry.call(generate) : await generate();
       } catch (err) {
         this._reportError('provider', err, { round });
         if (this.throwOnError) throw err;
-        return { text: '', toolCalls: [], usage: lastUsage, cost: totalCost, error: err.message };
+        return { text: '', toolCalls: [], usage: lastUsage, cost: totalCost, error: err.message, msgs };
       }
 
       lastUsage = result.usage || lastUsage;
@@ -162,12 +174,32 @@ class Loop {
       const roundCost = estimateCost(model, lastUsage);
       if (roundCost !== null) totalCost += roundCost;
 
+      // BA1: forward LLM usage to gate.record (via wireGate) so budget.maxCostUsd
+      // covers token-heavy / tool-light workloads. Callback errors route through
+      // _reportError but never kill the loop — governance failure ≠ run failure.
+      if (this.onLlmResult) {
+        try {
+          await this.onLlmResult({
+            model,
+            provider: this.provider.name || null,
+            usage: result.usage || null,
+            costUsd: roundCost,
+            durationMs: Date.now() - llmStartedAt,
+            ctx,
+          });
+        } catch (err) {
+          if (err instanceof HaltError) throw err;
+          this._reportError('onLlmResult', err, { round });
+        }
+      }
+
       // No tool calls — LLM gave a final text response
       if (!result.toolCalls || result.toolCalls.length === 0) {
         this._safeEmit({ type: 'loop:text', data: { text: result.text } });
         this._safeCall('onText', this.onText, result.text);
         this._safeEmit({ type: 'loop:done', data: { text: result.text, usage: lastUsage, cost: totalCost } });
-        return { text: result.text, toolCalls: [], usage: lastUsage, cost: totalCost, error: null };
+        msgs.push({ role: 'assistant', content: result.text });
+        return { text: result.text, toolCalls: [], usage: lastUsage, cost: totalCost, error: null, msgs };
       }
 
       // Execute tool calls
@@ -229,6 +261,9 @@ class Loop {
           try {
             verdict = await this.policy(tc.name, tc.arguments, ctx);
           } catch (err) {
+            // BA2: HaltError bubbles past the per-tool try/catch to the outer
+            // handler so halt exits cleanly without ever reaching the LLM.
+            if (err instanceof HaltError) throw err;
             verdict = `[Loop] policy error: ${err.message}`;
           }
           if (verdict !== true) {
@@ -241,26 +276,57 @@ class Loop {
           }
         }
 
+        const toolStartedAt = Date.now();
+        let toolResult;
+        let toolError;
         try {
           const execute = () => tool.execute(tc.arguments);
-          const toolResult = this.retry ? await this.retry.call(execute) : await execute();
+          toolResult = this.retry ? await this.retry.call(execute) : await execute();
           const content = typeof toolResult === 'string' ? toolResult : JSON.stringify(toolResult);
           msgs.push({ role: 'tool', tool_call_id: tc.id, content });
           this._safeEmit({ type: 'loop:tool_result', data: { tool: tc.name, result: content } });
         } catch (err) {
-          const toolErr = err instanceof ToolError ? err : new ToolError(err.message, { context: { tool: tc.name } });
-          const errMsg = `[Loop] Tool error: ${toolErr.message}`;
+          toolError = err instanceof ToolError ? err : new ToolError(err.message, { context: { tool: tc.name } });
+          const errMsg = `[Loop] Tool error: ${toolError.message}`;
           msgs.push({ role: 'tool', tool_call_id: tc.id, content: errMsg });
           this._safeEmit({ type: 'loop:tool_result', data: { tool: tc.name, error: errMsg } });
         }
+
+        // BA1: forward tool result/error to gate.record (via wireGate) with ctx in
+        // scope — fixes the lost-_ctx issue that wrapTool can't solve.
+        if (this.onToolResult) {
+          try {
+            await this.onToolResult({
+              name: tc.name,
+              args: tc.arguments,
+              result: toolResult,
+              error: toolError || null,
+              durationMs: Date.now() - toolStartedAt,
+              ctx,
+            });
+          } catch (err) {
+            if (err instanceof HaltError) throw err;
+            this._reportError('onToolResult', err, { tool: tc.name });
+          }
+        }
       }
     }
+    } catch (err) {
+      // BA2: HaltError is a clean governance exit, not a runtime failure.
+      // No throw even when throwOnError:true — the gate halted us deliberately.
+      if (err instanceof HaltError) {
+        this._reportError('halt', err, { rule: err.rule, reason: err.decision?.reason ?? null });
+        this._safeEmit({ type: 'loop:done', data: { text: '', halted: true, rule: err.rule, cost: totalCost } });
+        return { text: '', toolCalls: [], usage: lastUsage, cost: totalCost, error: `halt:${err.rule}`, msgs };
+      }
+      throw err;
+    }
 
     // Hard safety limit — should never fire under normal usage; bareguard's
     // limits.maxTurns (or the LLM's natural completion) ends the loop first.
     const warning = `[Loop] hit internal safety limit of ${HARD_ROUND_LIMIT} rounds. Wire bareguard for proper governance — see bare-agent/bareguard.`;
     this._safeEmit({ type: 'loop:done', data: { text: '', warning, cost: totalCost } });
-    return { text: '', toolCalls: [], usage: lastUsage, cost: totalCost, error: warning };
+    return { text: '', toolCalls: [], usage: lastUsage, cost: totalCost, error: warning, msgs };
   }
 
   /**
@@ -329,9 +395,10 @@ class Loop {
   async chat(text, tools = [], options = {}) {
     this._history.push({ role: 'user', content: text });
     const result = await this.run(this._history, tools, options);
-    if (result.text) {
-      this._history.push({ role: 'assistant', content: result.text });
-    }
+    // Sync _history from the full msgs run() built (tool-call messages, tool results,
+    // and final assistant text). Strip the leading system message if one was prepended.
+    const effectiveSystem = options.system || this.system;
+    this._history = effectiveSystem ? result.msgs.slice(1) : result.msgs.slice();
     return result;
   }
 

package/src/mcp-bridge.js

@@ -219,29 +219,30 @@ function wrapTools(serverName, mcpTools, rpc) {
 async function killServer(child) {
   if (child.exitCode !== null) return;
 
-  child.stdin?.destroy();
+  // end() sends FIN so the child sees stdin EOF and can exit cleanly;
+  // destroy() alone does not always propagate.
+  try { child.stdin?.end(); } catch { /* already closed */ }
   child.stdout?.destroy();
   child.stderr?.destroy();
 
-  await new Promise(resolve => {
-    const onClose = () => resolve();
+  // Short grace, then SIGTERM, then SIGKILL. Each wait clears its timer
+  // promptly when the child closes so we don't block the event loop after
+  // exit (which kept node:test's file-level wrapper hanging).
+  const waitClose = (ms) => new Promise(resolve => {
+    let timer;
+    const onClose = () => { clearTimeout(timer); resolve(); };
     child.once('close', onClose);
-    setTimeout(() => {
+    timer = setTimeout(() => {
       child.removeListener('close', onClose);
       resolve();
-    }, 700);
+    }, ms);
   });
 
+  await waitClose(150);
+
   if (child.exitCode === null) {
     child.kill('SIGTERM');
-    await new Promise(resolve => {
-      const onClose = () => resolve();
-      child.once('close', onClose);
-      setTimeout(() => {
-        child.removeListener('close', onClose);
-        resolve();
-      }, 700);
-    });
+    await waitClose(300);
   }
 
   if (child.exitCode === null) {
@@ -262,11 +263,12 @@ async function connectAndListTools(name, def, timeout = 15000) {
     clientInfo: { name: 'bare-agent', version: '0.5.0' },
   });
 
-  const timer = new Promise((_, reject) =>
-    setTimeout(() => reject(new ToolError(`MCP server "${name}" init timed out after ${timeout}ms`)), timeout)
-  );
+  let timerId;
+  const timer = new Promise((_, reject) => {
+    timerId = setTimeout(() => reject(new ToolError(`MCP server "${name}" init timed out after ${timeout}ms`)), timeout);
+  });
 
-  await Promise.race([init, timer]);
+  try { await Promise.race([init, timer]); } finally { clearTimeout(timerId); }
   client.notify('notifications/initialized');
 
   const { tools: mcpTools } = await client.rpc('tools/list');
@@ -282,9 +284,10 @@ function buildSystemContext(servers, tools, denied) {
 
   const byServer = {};
   for (const t of tools) {
-    const parts = t.name.split('_');
-    const server = parts[0];
-    (byServer[server] = byServer[server] || []).push(t.name.replace(`${server}_`, ''));
+    const sep = t.name.indexOf('_');
+    const server = sep > 0 ? t.name.slice(0, sep) : t.name;
+    const tool = sep > 0 ? t.name.slice(sep + 1) : '';
+    (byServer[server] = byServer[server] || []).push(tool);
   }
   for (const [server, toolNames] of Object.entries(byServer)) {
     lines.push(`  ${server}: ${toolNames.join(', ')}`);
@@ -308,6 +311,103 @@ function buildSystemContext(servers, tools, denied) {
   return lines.join('\n');
 }
 
+// --- Meta-tools: mcp_discover + mcp_invoke (v0.9) ---
+
+/**
+ * Build the LLM-callable meta-tool surface from a fully-connected bridge.
+ * Shares the underlying tool array and RPC clients with the bulk surface —
+ * one set of connections, one factory, two output forms. The user picks
+ * `bridge.tools` (bulk) for small catalogs the LLM should see upfront, or
+ * `bridge.metaTools` for large catalogs the LLM should discover on demand.
+ *
+ * Gov shape: when the LLM calls mcp_invoke, the action sent to gate.check
+ * is `{ type: 'mcp_invoke', args: { name, args }, _ctx }` — bareguard sees
+ * `mcp_invoke` as the type. To deny specific MCP tools, use bareguard's
+ * `tools.denyArgPatterns: { mcp_invoke: [/"name":"linear_admin_.*"/] }`
+ * or `content.denyPatterns` over the JSON-serialized form. The inner MCP
+ * tool name doesn't travel as `action.type` — that's a deliberate v0.9
+ * trade for one consistent gate-check call per LLM tool invocation.
+ *
+ * @param {Array} tools - The bulk-loaded, name-prefixed tools array.
+ * @param {string} discoveredAt - ISO timestamp from .mcp-bridge.json.
+ * @returns {Array} [mcp_discover, mcp_invoke]
+ */
+function buildMetaTools(tools, discoveredAt) {
+  // Catalog descriptors: same info the LLM would see for bulk-loaded tools,
+  // but exposed via mcp_discover instead of taking up tool-array slots upfront.
+  const catalog = tools.map(t => {
+    const sep = t.name.indexOf('_');
+    return {
+      name: t.name,
+      description: t.description || '',
+      schema: t.parameters || { type: 'object', properties: {} },
+      server: sep > 0 ? t.name.slice(0, sep) : t.name,
+      tool: sep > 0 ? t.name.slice(sep + 1) : '',
+    };
+  });
+  const byName = new Map(tools.map(t => [t.name, t]));
+
+  const mcpDiscover = {
+    name: 'mcp_discover',
+    description:
+      'List MCP tools currently available across all configured servers. Returns descriptors with name, description, schema, server, and tool. Pass refresh:true to force a fresh discovery (otherwise the catalog is the one loaded at agent startup). Discovery itself is ungated — read-only catalog access. Gov decisions still happen at invoke time via mcp_invoke.',
+    parameters: {
+      type: 'object',
+      properties: {
+        refresh: {
+          type: 'boolean',
+          description: 'Currently a no-op flag in v0.9 — the catalog is loaded once at bridge construction. Set true to signal intent; behavior may change in a later version.',
+        },
+        server: {
+          type: 'string',
+          description: 'Optional: filter the catalog to one server name.',
+        },
+      },
+    },
+    execute: async ({ server } = {}) => {
+      const filtered = server
+        ? catalog.filter(t => t.server === server)
+        : catalog;
+      return {
+        tools: filtered,
+        cachedAt: discoveredAt || new Date().toISOString(),
+        count: filtered.length,
+      };
+    },
+  };
+
+  const mcpInvoke = {
+    name: 'mcp_invoke',
+    description:
+      'Invoke an MCP tool by its canonical bareagent name (the `name` field returned by mcp_discover, e.g. "linear_list_issues"). Args are passed through to the underlying MCP server. Returns the tool result. Bareguard governs every invocation — denies fed back as deny strings, halts as [HALT] strings.',
+    parameters: {
+      type: 'object',
+      properties: {
+        name: {
+          type: 'string',
+          description: 'Canonical MCP tool name (from mcp_discover). Format: <server>_<tool>.',
+        },
+        args: {
+          type: 'object',
+          description: 'Arguments for the MCP tool, matching its schema (also from mcp_discover).',
+        },
+      },
+      required: ['name'],
+    },
+    execute: async ({ name, args }) => {
+      const tool = byName.get(name);
+      if (!tool) {
+        throw new ToolError(`mcp_invoke: unknown tool "${name}". Call mcp_discover for the current catalog.`, {
+          context: { name, knownNames: [...byName.keys()] },
+        });
+      }
+      return await tool.execute(args || {});
+    },
+  };
+
+  return [mcpDiscover, mcpInvoke];
+}
+
 // --- Main entry point ---
 
 /**
@@ -316,13 +416,22 @@ function buildSystemContext(servers, tools, denied) {
  * On subsequent runs, reads .mcp-bridge.json and respects allow/deny per tool.
  * Re-discovers when TTL expires (default: 24h).
  *
+ * Returns BOTH surfaces (v0.9+):
+ *   - `tools`     — bulk-loaded array of name-prefixed tools (small catalogs;
+ *                   LLM sees them upfront).
+ *   - `metaTools` — [mcp_discover, mcp_invoke] LLM-callable pair (large catalogs;
+ *                   LLM picks tools dynamically). Shares the same RPC connections.
+ *
+ * Wire one or the other into Loop's tool array; never both (the LLM would see
+ * the same MCP tool twice). Pick by catalog size and token budget.
+ *
  * @param {object} [opts]
  * @param {string} [opts.bridgePath] - Path to .mcp-bridge.json. Default: .mcp-bridge.json in cwd.
  * @param {string[]} [opts.configPaths] - IDE config paths for discovery.
  * @param {string[]} [opts.servers] - Limit to these server names.
  * @param {number} [opts.timeout=15000] - Per-server init timeout in ms.
  * @param {boolean} [opts.refresh=false] - Force re-discovery regardless of TTL.
- * @returns {Promise<{tools: Array, servers: string[], systemContext: string, denied: Array, close: Function}>}
+ * @returns {Promise<{tools: Array, metaTools: Array, servers: string[], systemContext: string, denied: Array, close: Function}>}
  */
 async function createMCPBridge(opts = {}) {
   if ('policy' in opts) {
@@ -341,43 +450,52 @@ async function createMCPBridge(opts = {}) {
   if (needsRefresh) {
     // Discover from IDE configs
     const discovered = discoverServers(opts.configPaths);
+
     if (discovered.size === 0 && !config) {
       return { tools: [], servers: [], systemContext: '', denied: [], close: async () => {} };
     }
 
-    // Connect to all discovered servers and list their tools
-    const freshTools = new Map();
-    const connectResults = new Map();
-    const errors = [];
-
-    const toDiscover = opts.servers
-      ? [...discovered.entries()].filter(([n]) => opts.servers.includes(n))
-      : [...discovered.entries()];
-
-    await Promise.all(toDiscover.map(async ([name, def]) => {
-      try {
-        const result = await connectAndListTools(name, def, timeout);
-        freshTools.set(name, result.mcpTools);
-        connectResults.set(name, result.client);
-      } catch (err) {
-        errors.push({ server: name, error: err.message });
-      }
-    }));
-
-    if (errors.length > 0) {
-      console.warn('[MCP Bridge] Some servers failed to connect:', errors);
-    }
+    // Only attempt connection when discovery found something.
+    // If discovered.size === 0 but config exists, fall through and use the existing config
+    // rather than wiping it on a transient discovery failure.
+    if (discovered.size > 0) {
+      const freshTools = new Map();
+      const connectResults = new Map();
+      const errors = [];
+
+      const toDiscover = opts.servers
+        ? [...discovered.entries()].filter(([n]) => opts.servers.includes(n))
+        : [...discovered.entries()];
+
+      await Promise.all(toDiscover.map(async ([name, def]) => {
+        try {
+          const result = await connectAndListTools(name, def, timeout);
+          freshTools.set(name, result.mcpTools);
+          connectResults.set(name, result.client);
+        } catch (err) {
+          errors.push({ server: name, error: err.message });
+        }
+      }));
 
-    // Merge with existing config (preserves user's allow/deny)
-    config = mergeBridgeConfig(config, new Map(toDiscover), freshTools);
+      if (errors.length > 0) {
+        console.warn('[MCP Bridge] Some servers failed to connect:', errors);
+      }
 
-    // Write the config file
-    writeBridgeConfig(bridgePath, config);
-    console.log(`[MCP Bridge] Wrote ${bridgePath}`);
+      // Only write config when at least one server connected successfully.
+      // If all servers failed, retain the existing config unchanged so
+      // user-curated allow/deny settings are not destroyed on transient failures.
+      if (freshTools.size > 0) {
+        config = mergeBridgeConfig(config, new Map(toDiscover), freshTools);
+        writeBridgeConfig(bridgePath, config);
+        console.log(`[MCP Bridge] Wrote ${bridgePath}`);
+      } else if (!config) {
+        return { tools: [], servers: [], systemContext: '', denied: [], close: async () => {} };
+      }
 
-    // Close the discovery connections — we'll reconnect below using the config
-    for (const client of connectResults.values()) {
-      await killServer(client.child);
+      // Close the discovery connections — we'll reconnect below using the config
+      for (const client of connectResults.values()) {
+        await killServer(client.child);
+      }
     }
   }
 
@@ -435,8 +553,11 @@ async function createMCPBridge(opts = {}) {
   const systemContext = buildSystemContext(connected, tools, denied);
   if (connected.length > 0) console.log(systemContext);
 
+  const metaTools = buildMetaTools(tools, config?.discovered);
+
   return {
     tools,
+    metaTools,
     servers: connected,
     denied,
     systemContext,
@@ -447,4 +568,4 @@ async function createMCPBridge(opts = {}) {
   };
 }
 
-module.exports = { createMCPBridge, discoverServers };
+module.exports = { createMCPBridge, discoverServers, buildMetaTools };

package/src/mcp.js

@@ -1,5 +1,5 @@
 'use strict';
 
-const { createMCPBridge, discoverServers } = require('./mcp-bridge');
+const { createMCPBridge, discoverServers, buildMetaTools } = require('./mcp-bridge');
 
-module.exports = { createMCPBridge, discoverServers };
+module.exports = { createMCPBridge, discoverServers, buildMetaTools };

package/src/planner.js

@@ -40,7 +40,7 @@ class Planner {
    */
   async plan(goal, context = {}) {
     if (this._cacheTTL > 0) {
-      const cacheKey = goal + '|' + (context.info || '');
+      const cacheKey = JSON.stringify({ goal, info: context.info || '' });
       const cached = this._cache.get(cacheKey);
       if (cached && Date.now() < cached.expiresAt) {
         return cached.result;
@@ -63,7 +63,7 @@ class Planner {
     const steps = this._parse(result.text);
 
     if (this._cacheTTL > 0) {
-      const cacheKey = goal + '|' + (context.info || '');
+      const cacheKey = JSON.stringify({ goal, info: context.info || '' });
       this._cache.set(cacheKey, { result: steps, expiresAt: Date.now() + this._cacheTTL });
     }
 

package/src/provider-clipipe.js

@@ -74,7 +74,7 @@ class CLIPipeProvider {
   /**
    * Spawn the CLI process, pipe prompt to stdin, collect stdout.
    * @param {string} prompt
-   * @param {string[]} [extraArgs=[]] - Additional args prepended to this.args.
+   * @param {string[]} [extraArgs=[]] - Additional args appended after this.args.
    * @returns {Promise<string>}
    */
   _spawn(prompt, extraArgs = []) {

package/src/retry.js

@@ -14,9 +14,9 @@ const DEFAULT_RETRY_ON = (err) => {
 
 class Retry {
   constructor(options = {}) {
-    this.maxAttempts = options.maxAttempts || 3;
+    this.maxAttempts = options.maxAttempts !== undefined ? options.maxAttempts : 3;
     this.backoff = options.backoff || 'exponential';
-    this.timeout = options.timeout || 60000;
+    this.timeout = options.timeout !== undefined ? options.timeout : 60000;
     this.retryOn = options.retryOn || DEFAULT_RETRY_ON;
     this.jitter = options.jitter !== undefined ? options.jitter : false;
   }
@@ -30,20 +30,28 @@ class Retry {
    * @throws {Error} Rethrows the last error when maxAttempts is exhausted or error is not retryable.
    */
   async call(fn, options = {}) {
-    const max = options.maxAttempts || this.maxAttempts;
+    const max = options.maxAttempts !== undefined ? options.maxAttempts : this.maxAttempts;
     const retryOn = options.retryOn || this.retryOn;
-    const timeout = options.timeout || this.timeout;
+    const timeout = options.timeout !== undefined ? options.timeout : this.timeout;
 
     for (let attempt = 1; attempt <= max; attempt++) {
+      let timeoutId;
       try {
         const result = await (timeout
-          ? Promise.race([fn(), new Promise((_, rej) => setTimeout(() => rej(new TimeoutError('[Retry] Timeout')), timeout))])
+          ? Promise.race([
+              fn(),
+              new Promise((_, rej) => {
+                timeoutId = setTimeout(() => rej(new TimeoutError('[Retry] Timeout')), timeout);
+              }),
+            ])
           : fn());
         return result;
       } catch (err) {
         if (attempt === max || !retryOn(err)) throw err;
         const delay = this._delay(attempt);
         await new Promise(r => setTimeout(r, delay));
+      } finally {
+        if (timeoutId) clearTimeout(timeoutId);
       }
     }
   }

package/src/scheduler.js

@@ -22,7 +22,7 @@ class Scheduler {
       : [];
     this._timer = null;
     this._nextId = this._jobs.length
-      ? Math.max(...this._jobs.map(j => j.id)) + 1
+      ? this._jobs.reduce((max, j) => Math.max(max, j.id), 0) + 1
       : 1;
   }
 
@@ -80,15 +80,16 @@ class Scheduler {
         try {
           await handler(job);
         } catch (err) {
-          this.onError?.(err, job);
+          try { this.onError?.(err, job); } catch { /* swallow onError throws */ }
+        } finally {
+          this._running.delete(job.id);
+          if (job.type === 'once') {
+            job.status = 'done';
+          } else {
+            job.nextRun = this._parseSchedule(job.schedule).toISOString();
+          }
+          this._save();
         }
-        this._running.delete(job.id);
-        if (job.type === 'once') {
-          job.status = 'done';
-        } else {
-          job.nextRun = this._parseSchedule(job.schedule).toISOString();
-        }
-        this._save();
       }
     };
     tick();

package/src/store-jsonfile.js

@@ -24,7 +24,7 @@ class JsonFileStore {
       ? JSON.parse(readFileSync(this._path, 'utf8'))
       : [];
     this._nextId = this._data.length
-      ? Math.max(...this._data.map(d => d.id)) + 1
+      ? this._data.reduce((max, d) => Math.max(max, d.id), 0) + 1
       : 1;
   }
 

package/src/tools.js

@@ -3,5 +3,15 @@
 const { createBrowsingTools } = require('../tools/browse');
 const { createMobileTools } = require('../tools/mobile');
 const { createShellTools } = require('../tools/shell');
+const { createSpawnTool, spawnChild } = require('../tools/spawn');
+const { createDeferTool, readQueue: readDeferQueue } = require('../tools/defer');
 
-module.exports = { createBrowsingTools, createMobileTools, createShellTools };
+module.exports = {
+  createBrowsingTools,
+  createMobileTools,
+  createShellTools,
+  createSpawnTool,
+  spawnChild,
+  createDeferTool,
+  readDeferQueue,
+};