la-machina-engine 0.3.0 → 0.5.0

package/dist/index.cjs

@@ -38,23 +38,23 @@ var init_cjs_shims = __esm({
 });
 
 // src/orchestrator/types.ts
-var import_zod23, PlanStepSchema, PlanSchema;
+var import_zod25, PlanStepSchema, PlanSchema;
 var init_types = __esm({
   "src/orchestrator/types.ts"() {
     "use strict";
     init_cjs_shims();
-    import_zod23 = require("zod");
-    PlanStepSchema = import_zod23.z.object({
-      id: import_zod23.z.string().min(1),
-      description: import_zod23.z.string().min(1),
-      action: import_zod23.z.enum(["research", "implement", "verify", "review", "custom"]),
-      files: import_zod23.z.array(import_zod23.z.string()).optional(),
-      spec: import_zod23.z.string().optional(),
-      dependsOn: import_zod23.z.array(import_zod23.z.string()).optional()
+    import_zod25 = require("zod");
+    PlanStepSchema = import_zod25.z.object({
+      id: import_zod25.z.string().min(1),
+      description: import_zod25.z.string().min(1),
+      action: import_zod25.z.enum(["research", "implement", "verify", "review", "custom"]),
+      files: import_zod25.z.array(import_zod25.z.string()).optional(),
+      spec: import_zod25.z.string().optional(),
+      dependsOn: import_zod25.z.array(import_zod25.z.string()).optional()
     });
-    PlanSchema = import_zod23.z.object({
-      summary: import_zod23.z.string().min(1),
-      steps: import_zod23.z.array(PlanStepSchema).min(1)
+    PlanSchema = import_zod25.z.object({
+      summary: import_zod25.z.string().min(1),
+      steps: import_zod25.z.array(PlanStepSchema).min(1)
     });
   }
 });
@@ -785,6 +785,8 @@ __export(index_exports, {
   buildSystemPrompt: () => buildSystemPrompt,
   buildWorkerAgent: () => buildWorkerAgent,
   canSpawnProcesses: () => canSpawnProcesses,
+  capabilityStub: () => capabilityStub,
+  createApiCallTool: () => createApiCallTool,
   createLogger: () => createLogger,
   createModelAdapter: () => createModelAdapter,
   createSendMessageTool: () => createSendMessageTool,
@@ -816,7 +818,8 @@ __export(index_exports, {
   synthesizeSpec: () => synthesizeSpec,
   toResponse: () => toResponse,
   tryParseJSON: () => tryParseJSON,
-  validateOutput: () => validateOutput
+  validateOutput: () => validateOutput,
+  withCapabilityCheck: () => withCapabilityCheck
 });
 module.exports = __toCommonJS(index_exports);
 init_cjs_shims();
@@ -940,7 +943,8 @@ var ModelProviderEnum = import_zod.z.enum([
 ]);
 var StorageProviderEnum = import_zod.z.enum(["local", "r2", "r2-binding"]);
 var MemoryModeEnum = import_zod.z.enum(["off", "read-only", "read-write"]);
-var MemoryScopeEnum = import_zod.z.enum(["workspace", "global"]);
+var MemoryScopeUserEnum = import_zod.z.enum(["workspace", "global"]);
+var MemoryScopeResolvedEnum = import_zod.z.enum(["workspace"]);
 var FlushPolicyEnum = import_zod.z.enum(["turn-end", "entry", "manual"]);
 var LogLevelEnum = import_zod.z.enum(["silent", "error", "warn", "info", "debug"]);
 var R2ConfigResolved = import_zod.z.object({
@@ -979,7 +983,7 @@ var StorageConfigResolved = import_zod.z.object({
 });
 var MemoryConfigResolved = import_zod.z.object({
   mode: MemoryModeEnum,
-  scope: MemoryScopeEnum
+  scope: MemoryScopeResolvedEnum
 }).strict();
 var ToolsConfigResolved = import_zod.z.object({
   enabled: import_zod.z.array(import_zod.z.string()),
@@ -1110,6 +1114,42 @@ var LoggingConfigResolved = import_zod.z.object({
   level: LogLevelEnum,
   sink: LogSinkSchema
 }).strict();
+var ApiHttpMethodEnum = import_zod.z.enum(["GET", "POST", "PUT", "PATCH", "DELETE"]);
+var ApiAuthSchema = import_zod.z.discriminatedUnion("type", [
+  import_zod.z.object({ type: import_zod.z.literal("none") }).strict(),
+  import_zod.z.object({ type: import_zod.z.literal("bearer"), tokenRef: import_zod.z.string().min(1) }).strict(),
+  import_zod.z.object({
+    type: import_zod.z.literal("header"),
+    name: import_zod.z.string().min(1),
+    valueRef: import_zod.z.string().min(1)
+  }).strict(),
+  import_zod.z.object({
+    type: import_zod.z.literal("basic"),
+    userRef: import_zod.z.string().min(1),
+    passRef: import_zod.z.string().min(1)
+  }).strict(),
+  import_zod.z.object({ type: import_zod.z.literal("custom"), id: import_zod.z.string().min(1) }).strict()
+]);
+var ApiServiceSchema = import_zod.z.object({
+  name: import_zod.z.string().min(1),
+  description: import_zod.z.string().optional(),
+  baseUrl: import_zod.z.string().url(),
+  auth: ApiAuthSchema.optional(),
+  // Allow both strings and RegExp values via z.union — RegExp is
+  // serialized as its source when cloned, so we accept both.
+  allowedPaths: import_zod.z.array(import_zod.z.union([import_zod.z.string(), import_zod.z.instanceof(RegExp)])).optional(),
+  allowedMethods: import_zod.z.array(ApiHttpMethodEnum).optional(),
+  defaultHeaders: import_zod.z.record(import_zod.z.string(), import_zod.z.string()).optional(),
+  maxBodyBytes: import_zod.z.number().int().positive().optional()
+}).strict();
+var ApiConfigResolved = import_zod.z.object({
+  services: import_zod.z.array(ApiServiceSchema),
+  maxResponseBytes: import_zod.z.number().int().positive().optional()
+}).strict();
+var RunnerConfigResolved = import_zod.z.object({
+  url: import_zod.z.string().url(),
+  secret: import_zod.z.string().min(1, "runner.secret cannot be empty")
+}).strict();
 var ResolvedConfigSchema = import_zod.z.object({
   model: ModelConfigResolved,
   storage: StorageConfigResolved,
@@ -1125,7 +1165,9 @@ var ResolvedConfigSchema = import_zod.z.object({
   permissions: PermissionsConfigResolved,
   compaction: CompactionConfigResolved,
   coordinator: CoordinatorConfigResolved,
-  orchestrator: OrchestratorConfigResolved
+  orchestrator: OrchestratorConfigResolved,
+  runner: RunnerConfigResolved.optional(),
+  api: ApiConfigResolved.optional()
 }).strict();
 var R2ConfigUser = R2ConfigResolved.partial();
 var ModelConfigUser = ModelConfigResolved.partial();
@@ -1136,7 +1178,10 @@ var StorageConfigUser = import_zod.z.object({
   r2: R2ConfigUser.optional(),
   r2Binding: R2BucketBindingShape.optional()
 }).strict();
-var MemoryConfigUser = MemoryConfigResolved.partial();
+var MemoryConfigUser = import_zod.z.object({
+  mode: MemoryModeEnum.optional(),
+  scope: MemoryScopeUserEnum.optional()
+}).strict();
 var ToolsConfigUser = ToolsConfigResolved.partial();
 var AgentsConfigUser = AgentsConfigResolved.partial();
 var SkillsConfigUser = SkillsConfigResolved.partial();
@@ -1166,6 +1211,8 @@ var McpConfigUser = import_zod.z.object({
   shutdownTimeoutMs: import_zod.z.number().int().positive().optional()
 }).strict();
 var PermissionsConfigUser = PermissionsConfigResolved.partial();
+var RunnerConfigUser = RunnerConfigResolved;
+var ApiConfigUser = ApiConfigResolved.partial();
 var CompactionConfigUser = CompactionConfigResolved.partial();
 var CoordinatorConfigUser = CoordinatorConfigResolved.partial();
 var OrchestratorConfigUser = OrchestratorConfigResolved.deepPartial();
@@ -1184,7 +1231,9 @@ var UserConfigSchema = import_zod.z.object({
   permissions: PermissionsConfigUser.optional(),
   compaction: CompactionConfigUser.optional(),
   coordinator: CoordinatorConfigUser.optional(),
-  orchestrator: OrchestratorConfigUser.optional()
+  orchestrator: OrchestratorConfigUser.optional(),
+  runner: RunnerConfigUser.optional(),
+  api: ApiConfigUser.optional()
 }).strict();
 
 // src/config/merge.ts
@@ -1229,10 +1278,49 @@ function deepMerge(base, override) {
   }
   return result;
 }
+var API_RUNTIME_KEYS = ["env", "resolveAuth", "onRequest", "onResponse"];
+function splitApiRuntime(user) {
+  const api = user.api;
+  if (api === void 0) return { stripped: user, runtime: {} };
+  const runtime = {};
+  const schemaSafe = {};
+  for (const [k, v] of Object.entries(api)) {
+    if (API_RUNTIME_KEYS.includes(k)) {
+      runtime[k] = v;
+    } else {
+      schemaSafe[k] = v;
+    }
+  }
+  const clone = { ...user, api: schemaSafe };
+  return { stripped: clone, runtime };
+}
+function coerceDeprecatedMemoryScope(user) {
+  const scope = user.memory?.scope;
+  if (scope !== "global") return user;
+  console.warn(
+    '[la-machina] config.memory.scope: "global" is deprecated and has been rewritten to "workspace". Cross-tenant memory sharing was removed in Plan 022 \u2014 the workspace is the tenant root. This field value will be rejected outright in a future major release.'
+  );
+  const memory = user.memory ?? {};
+  return {
+    ...user,
+    memory: { ...memory, scope: "workspace" }
+  };
+}
 function mergeConfig(user) {
-  const validatedUser = UserConfigSchema.parse(user);
+  const withCoercedScope = coerceDeprecatedMemoryScope(user);
+  const { stripped, runtime } = splitApiRuntime(withCoercedScope);
+  const validatedUser = UserConfigSchema.parse(stripped);
   const merged = deepMerge(DEFAULTS, validatedUser);
-  return ResolvedConfigSchema.parse(merged);
+  const resolved = ResolvedConfigSchema.parse(merged);
+  if (resolved.api !== void 0 && Object.keys(runtime).length > 0) {
+    const mutableResolved = resolved;
+    mutableResolved.api = {
+      ...resolved.api,
+      ...runtime
+    };
+  } else if (Object.keys(runtime).length > 0) {
+  }
+  return resolved;
 }
 
 // src/engine/engine.ts
@@ -1676,8 +1764,8 @@ function toAISdkMessages(messages) {
           textParts.push({ type: "text", text: block.text });
         }
       }
-      if (textParts.length > 0) out.push({ role: "user", content: textParts });
       if (toolResults.length > 0) out.push({ role: "tool", content: toolResults });
+      if (textParts.length > 0) out.push({ role: "user", content: textParts });
     } else if (role === "assistant") {
       if (typeof content === "string") {
         out.push({ role: "assistant", content });
@@ -1875,6 +1963,68 @@ function hasProcessLifecycle() {
   return typeof process !== "undefined" && typeof process.on === "function" && typeof process.removeListener === "function" && detectRuntime() === "node";
 }
 
+// src/tools/capabilityStub.ts
+init_cjs_shims();
+var import_zod2 = require("zod");
+
+// src/tools/contract.ts
+init_cjs_shims();
+function defineTool(tool) {
+  return tool;
+}
+var ToolRegistry = class {
+  tools = /* @__PURE__ */ new Map();
+  register(tool) {
+    if (typeof tool.name !== "string" || tool.name.length === 0) {
+      throw new Error("ToolRegistry: tool.name must be a non-empty string");
+    }
+    if (this.tools.has(tool.name)) {
+      throw new Error(`ToolRegistry: "${tool.name}" is already registered`);
+    }
+    this.tools.set(tool.name, tool);
+  }
+  registerAll(tools) {
+    for (const tool of tools) this.register(tool);
+  }
+  unregister(name) {
+    this.tools.delete(name);
+  }
+  get(name) {
+    return this.tools.get(name);
+  }
+  has(name) {
+    return this.tools.has(name);
+  }
+  list() {
+    return Array.from(this.tools.values());
+  }
+  count() {
+    return this.tools.size;
+  }
+};
+
+// src/tools/capabilityStub.ts
+var anyInput = import_zod2.z.unknown();
+function capabilityStub(original) {
+  return defineTool({
+    name: original.name,
+    description: original.description,
+    inputSchema: anyInput,
+    isCapabilityStub: true,
+    execute: async () => ({
+      isError: true,
+      content: `Tool "${original.name}" requires Node runtime and cannot execute in this environment. To use this tool, run async via engine.start() with config.runner configured so the run can hand off to a Node runner. See README \xA7"Runner contract" for setup.`,
+      metadata: { capabilityMissing: original.name }
+    })
+  });
+}
+function withCapabilityCheck(tool, spawnAvailable) {
+  if (tool.requiresNode === true && !spawnAvailable) {
+    return capabilityStub(tool);
+  }
+  return tool;
+}
+
 // src/subagent/registry.ts
 init_cjs_shims();
 
@@ -2057,7 +2207,7 @@ var SubagentRegistry = class _SubagentRegistry {
 
 // src/tools/agent.ts
 init_cjs_shims();
-var import_zod5 = require("zod");
+var import_zod6 = require("zod");
 
 // src/subagent/runner.ts
 init_cjs_shims();
@@ -2068,48 +2218,49 @@ var import_zod_to_json_schema = require("zod-to-json-schema");
 
 // src/transcript/snapshot.ts
 init_cjs_shims();
-var import_zod2 = require("zod");
+var import_zod3 = require("zod");
 var SNAPSHOT_FILENAME = "snapshot.json";
-var TokenUsageSchema = import_zod2.z.object({
-  input: import_zod2.z.number().int().nonnegative(),
-  output: import_zod2.z.number().int().nonnegative(),
-  cacheCreationInput: import_zod2.z.number().int().nonnegative().optional(),
-  cacheReadInput: import_zod2.z.number().int().nonnegative().optional()
+var TokenUsageSchema = import_zod3.z.object({
+  input: import_zod3.z.number().int().nonnegative(),
+  output: import_zod3.z.number().int().nonnegative(),
+  cacheCreationInput: import_zod3.z.number().int().nonnegative().optional(),
+  cacheReadInput: import_zod3.z.number().int().nonnegative().optional()
 }).strict();
-var PendingToolCallSchema = import_zod2.z.object({
-  toolName: import_zod2.z.string().min(1),
-  toolUseId: import_zod2.z.string().min(1),
-  input: import_zod2.z.unknown(),
-  calledAt: import_zod2.z.string().datetime({ offset: true })
+var PendingToolCallSchema = import_zod3.z.object({
+  toolName: import_zod3.z.string().min(1),
+  toolUseId: import_zod3.z.string().min(1),
+  input: import_zod3.z.unknown(),
+  calledAt: import_zod3.z.string().datetime({ offset: true })
 }).strict();
-var PendingSubagentSchema = import_zod2.z.lazy(
-  () => import_zod2.z.object({
-    subagentType: import_zod2.z.string().min(1),
-    parentToolUseId: import_zod2.z.string().min(1),
+var PendingSubagentSchema = import_zod3.z.lazy(
+  () => import_zod3.z.object({
+    subagentType: import_zod3.z.string().min(1),
+    parentToolUseId: import_zod3.z.string().min(1),
     childSnapshot: RunSnapshotSchema
   }).strict()
 );
-var RunSnapshotSchema = import_zod2.z.lazy(
-  () => import_zod2.z.object({
-    version: import_zod2.z.literal(1),
-    status: import_zod2.z.literal("paused"),
-    runId: import_zod2.z.string().min(1),
-    nodeId: import_zod2.z.string().min(1),
-    pausedAt: import_zod2.z.string().datetime({ offset: true }),
-    pauseReason: import_zod2.z.enum([
+var RunSnapshotSchema = import_zod3.z.lazy(
+  () => import_zod3.z.object({
+    version: import_zod3.z.literal(1),
+    status: import_zod3.z.literal("paused"),
+    runId: import_zod3.z.string().min(1),
+    nodeId: import_zod3.z.string().min(1),
+    pausedAt: import_zod3.z.string().datetime({ offset: true }),
+    pauseReason: import_zod3.z.enum([
       "gate_required",
       "subagent_gate_required",
+      "handoff_to_runner",
       "max_turns",
       "explicit",
       "timeout"
     ]),
-    messageCount: import_zod2.z.number().int().nonnegative(),
-    lastShardIndex: import_zod2.z.number().int().nonnegative(),
-    lastMessageUuid: import_zod2.z.string().uuid(),
+    messageCount: import_zod3.z.number().int().nonnegative(),
+    lastShardIndex: import_zod3.z.number().int().nonnegative(),
+    lastMessageUuid: import_zod3.z.string().uuid(),
     pendingToolCall: PendingToolCallSchema.optional(),
     pendingSubagent: PendingSubagentSchema.optional(),
     tokensUsedSoFar: TokenUsageSchema,
-    turnsUsed: import_zod2.z.number().int().nonnegative()
+    turnsUsed: import_zod3.z.number().int().nonnegative()
   }).strict()
 );
 function snapshotPath(logPath) {
@@ -2837,6 +2988,27 @@ async function agentLoop(options) {
           }
         }
       }
+      if (options.handoffToRunner === true) {
+        for (const call of toolCallsToDispatch) {
+          const tool = options.registry?.get(call.name);
+          if (tool?.isCapabilityStub === true) {
+            const paused = await pauseHere({
+              ctx,
+              transcript,
+              reason: "handoff_to_runner",
+              pendingToolCall: {
+                toolName: call.name,
+                toolUseId: call.id,
+                input: call.input,
+                calledAt: (/* @__PURE__ */ new Date()).toISOString()
+              },
+              storage: options.storage,
+              subagentRegistry: options.subagentRegistry
+            });
+            return paused;
+          }
+        }
+      }
       const firstTool = toolCallsToDispatch[0]?.name;
       await fireProgress("tool_dispatch", firstTool);
       const streamExec = new StreamingToolExecutor(executor);
@@ -2847,6 +3019,10 @@ async function agentLoop(options) {
       }
       try {
         for await (const { id, result } of streamExec.results()) {
+          const missing = result.metadata?.capabilityMissing;
+          if (typeof missing === "string") {
+            ctx.recordCapabilityMissing(missing);
+          }
           await ctx.addToolResult(id, truncateToolResult(result.content), result.isError === true);
         }
       } catch (err) {
@@ -3105,6 +3281,12 @@ var RunContext = class {
   turnCount = 0;
   tokensUsed = { input: 0, output: 0 };
   lastUuid = null;
+  /**
+   * Plan 019 — names of tools whose capability-stub returned an
+   * `isError` result during this run. Aggregated and surfaced on the
+   * response's `meta.capabilitiesMissing` (deduped, insertion-ordered).
+   */
+  capabilitiesMissing = /* @__PURE__ */ new Set();
   constructor(options) {
     this.runId = options.runId;
     this.nodeId = options.nodeId;
@@ -3145,6 +3327,42 @@ var RunContext = class {
       this.episodes.logTurn(this.turnCount, "assistant", summary);
     }
   }
+  /**
+   * Inject a tool_result + a follow-up text block as a SINGLE user
+   * message. Used by the resume() synthetic-release path when a
+   * paused run is resumed without an explicit `gateAnswer`: we need
+   * to both satisfy the tool_use↔tool_result pairing AND give the
+   * model a retry instruction, in the same user turn.
+   *
+   * Splitting this into `addToolResult(...) + addUserMessage(...)`
+   * produces two consecutive user messages, which the AI SDK's
+   * openai-compatible adapter rejects with
+   * `MissingToolResultsError`. Combining them into one user message
+   * is the portable shape that works on every provider we support.
+   *
+   * Writes a single `user` transcript entry carrying the mixed
+   * content, so `rebuildMessagesFromEntries` reconstructs the same
+   * single-message shape on resume.
+   */
+  async addMixedUserMessage(blocks) {
+    this.messages.push({ role: "user", content: blocks });
+    await this.writeEntry({
+      type: "user",
+      uuid: this.nextUuid(),
+      parentUuid: this.lastUuid,
+      ts: this.now(),
+      message: { role: "user", content: blocks }
+    });
+    const summary = blocks.map((b) => {
+      const x = b;
+      if (x.type === "text") return x.text ?? "";
+      if (x.type === "tool_result") {
+        return typeof x.content === "string" ? x.content : JSON.stringify(x.content);
+      }
+      return "";
+    }).filter((s) => s.length > 0).join("\n");
+    this.episodes?.logTurn(this.turnCount, "user", summary);
+  }
   /**
    * Append a tool result to the conversation. The Anthropic Messages
    * API requires tool_result blocks to be wrapped in a user message,
@@ -3190,6 +3408,14 @@ var RunContext = class {
   getTokensUsed() {
     return this.tokensUsed;
   }
+  /** Plan 019 — record that a capability-stubbed tool fired during this run. */
+  recordCapabilityMissing(toolName) {
+    this.capabilitiesMissing.add(toolName);
+  }
+  /** Plan 019 — capability-stubbed tool names observed this run (deduped). */
+  getCapabilitiesMissing() {
+    return [...this.capabilitiesMissing];
+  }
   shouldContinue() {
     return this.turnCount < this.maxTurns;
   }
@@ -3363,9 +3589,9 @@ init_cjs_shims();
 
 // src/transcript/entries.ts
 init_cjs_shims();
-var import_zod3 = require("zod");
-var UuidSchema = import_zod3.z.string().uuid();
-var IsoTsSchema = import_zod3.z.string().datetime({ offset: true });
+var import_zod4 = require("zod");
+var UuidSchema = import_zod4.z.string().uuid();
+var IsoTsSchema = import_zod4.z.string().datetime({ offset: true });
 var TimelineBase = {
   uuid: UuidSchema,
   parentUuid: UuidSchema.nullable(),
@@ -3375,55 +3601,55 @@ var SessionBase = {
   uuid: UuidSchema,
   ts: IsoTsSchema
 };
-var MessageSchema = import_zod3.z.object({
-  role: import_zod3.z.enum(["user", "assistant"]),
-  content: import_zod3.z.array(import_zod3.z.unknown())
+var MessageSchema = import_zod4.z.object({
+  role: import_zod4.z.enum(["user", "assistant"]),
+  content: import_zod4.z.array(import_zod4.z.unknown())
 }).strict();
-var UserEntrySchema = import_zod3.z.object({
-  type: import_zod3.z.literal("user"),
+var UserEntrySchema = import_zod4.z.object({
+  type: import_zod4.z.literal("user"),
   ...TimelineBase,
   message: MessageSchema
 }).strict();
-var AssistantEntrySchema = import_zod3.z.object({
-  type: import_zod3.z.literal("assistant"),
+var AssistantEntrySchema = import_zod4.z.object({
+  type: import_zod4.z.literal("assistant"),
   ...TimelineBase,
   message: MessageSchema
 }).strict();
-var ToolResultEntrySchema = import_zod3.z.object({
-  type: import_zod3.z.literal("tool_result"),
+var ToolResultEntrySchema = import_zod4.z.object({
+  type: import_zod4.z.literal("tool_result"),
   ...TimelineBase,
-  toolUseId: import_zod3.z.string().min(1),
-  content: import_zod3.z.unknown(),
-  isError: import_zod3.z.boolean().optional()
+  toolUseId: import_zod4.z.string().min(1),
+  content: import_zod4.z.unknown(),
+  isError: import_zod4.z.boolean().optional()
 }).strict();
-var SubagentSpawnEntrySchema = import_zod3.z.object({
-  type: import_zod3.z.literal("subagent_spawn"),
+var SubagentSpawnEntrySchema = import_zod4.z.object({
+  type: import_zod4.z.literal("subagent_spawn"),
   ...TimelineBase,
-  agentId: import_zod3.z.string().min(1),
-  agentType: import_zod3.z.string().min(1)
+  agentId: import_zod4.z.string().min(1),
+  agentType: import_zod4.z.string().min(1)
 }).strict();
-var SubagentDoneEntrySchema = import_zod3.z.object({
-  type: import_zod3.z.literal("subagent_done"),
+var SubagentDoneEntrySchema = import_zod4.z.object({
+  type: import_zod4.z.literal("subagent_done"),
   ...TimelineBase,
-  agentId: import_zod3.z.string().min(1),
-  output: import_zod3.z.string()
+  agentId: import_zod4.z.string().min(1),
+  output: import_zod4.z.string()
 }).strict();
-var MetaEntrySchema = import_zod3.z.object({
-  type: import_zod3.z.literal("meta"),
+var MetaEntrySchema = import_zod4.z.object({
+  type: import_zod4.z.literal("meta"),
   ...SessionBase,
-  key: import_zod3.z.string().min(1),
-  value: import_zod3.z.unknown()
+  key: import_zod4.z.string().min(1),
+  value: import_zod4.z.unknown()
 }).strict();
-var ErrorEntrySchema = import_zod3.z.object({
-  type: import_zod3.z.literal("error"),
+var ErrorEntrySchema = import_zod4.z.object({
+  type: import_zod4.z.literal("error"),
   ...SessionBase,
-  error: import_zod3.z.object({
-    code: import_zod3.z.string().min(1),
-    message: import_zod3.z.string(),
-    stack: import_zod3.z.string().optional()
+  error: import_zod4.z.object({
+    code: import_zod4.z.string().min(1),
+    message: import_zod4.z.string(),
+    stack: import_zod4.z.string().optional()
   }).strict()
 }).strict();
-var EntrySchema = import_zod3.z.discriminatedUnion("type", [
+var EntrySchema = import_zod4.z.discriminatedUnion("type", [
   UserEntrySchema,
   AssistantEntrySchema,
   ToolResultEntrySchema,
@@ -3455,16 +3681,16 @@ function parseEntryLine(line) {
 
 // src/transcript/meta.ts
 init_cjs_shims();
-var import_zod4 = require("zod");
-var TranscriptMetaSchema = import_zod4.z.object({
-  version: import_zod4.z.literal(1),
-  status: import_zod4.z.enum(["pending", "running", "paused", "done", "failed"]),
-  startedAt: import_zod4.z.string().datetime({ offset: true }),
-  updatedAt: import_zod4.z.string().datetime({ offset: true }),
-  turnCount: import_zod4.z.number().int().nonnegative(),
-  messageCount: import_zod4.z.number().int().nonnegative(),
-  lastShardIndex: import_zod4.z.number().int().nonnegative().nullable(),
-  shardCount: import_zod4.z.number().int().nonnegative()
+var import_zod5 = require("zod");
+var TranscriptMetaSchema = import_zod5.z.object({
+  version: import_zod5.z.literal(1),
+  status: import_zod5.z.enum(["pending", "running", "paused", "done", "failed"]),
+  startedAt: import_zod5.z.string().datetime({ offset: true }),
+  updatedAt: import_zod5.z.string().datetime({ offset: true }),
+  turnCount: import_zod5.z.number().int().nonnegative(),
+  messageCount: import_zod5.z.number().int().nonnegative(),
+  lastShardIndex: import_zod5.z.number().int().nonnegative().nullable(),
+  shardCount: import_zod5.z.number().int().nonnegative()
 }).strict();
 var META_FILENAME = "meta.json";
 function metaPath(logPath) {
@@ -3812,47 +4038,11 @@ Output format:
 Directive: ${directive}`;
 }
 
-// src/tools/contract.ts
-init_cjs_shims();
-function defineTool(tool) {
-  return tool;
-}
-var ToolRegistry = class {
-  tools = /* @__PURE__ */ new Map();
-  register(tool) {
-    if (typeof tool.name !== "string" || tool.name.length === 0) {
-      throw new Error("ToolRegistry: tool.name must be a non-empty string");
-    }
-    if (this.tools.has(tool.name)) {
-      throw new Error(`ToolRegistry: "${tool.name}" is already registered`);
-    }
-    this.tools.set(tool.name, tool);
-  }
-  registerAll(tools) {
-    for (const tool of tools) this.register(tool);
-  }
-  unregister(name) {
-    this.tools.delete(name);
-  }
-  get(name) {
-    return this.tools.get(name);
-  }
-  has(name) {
-    return this.tools.has(name);
-  }
-  list() {
-    return Array.from(this.tools.values());
-  }
-  count() {
-    return this.tools.size;
-  }
-};
-
 // src/tools/agent.ts
-var inputSchema = import_zod5.z.object({
-  description: import_zod5.z.string().min(1),
-  subagent_type: import_zod5.z.string().optional(),
-  run_in_background: import_zod5.z.boolean().optional()
+var inputSchema = import_zod6.z.object({
+  description: import_zod6.z.string().min(1),
+  subagent_type: import_zod6.z.string().optional(),
+  run_in_background: import_zod6.z.boolean().optional()
 });
 function createAgentTool(options) {
   if (options.agents.length === 0) {
@@ -4057,7 +4247,7 @@ function handlePausedResult(result, agentId, subagentType) {
 
 // src/tools/bash.ts
 init_cjs_shims();
-var import_zod6 = require("zod");
+var import_zod7 = require("zod");
 var _spawn = null;
 async function getSpawn() {
   if (_spawn === null) {
@@ -4069,15 +4259,16 @@ async function getSpawn() {
 var MAX_OUTPUT_BYTES = 512 * 1024;
 var SIGKILL_GRACE_MS = 500;
 var BLOCKED_DEVICE_PATHS = /\b(\/dev\/zero|\/dev\/random|\/dev\/urandom|\/proc\/kcore|\/dev\/sda|\/dev\/mem)\b/;
-var inputSchema2 = import_zod6.z.object({
-  command: import_zod6.z.string().min(1),
-  cwd: import_zod6.z.string().min(1).optional()
+var inputSchema2 = import_zod7.z.object({
+  command: import_zod7.z.string().min(1),
+  cwd: import_zod7.z.string().min(1).optional()
 });
 function createBashTool() {
   return defineTool({
     name: "Bash",
     description: "Execute a shell command via /bin/sh -c. Returns combined stdout+stderr and the exit code.",
     inputSchema: inputSchema2,
+    requiresNode: true,
     execute: async ({ command, cwd }, ctx) => {
       if (BLOCKED_DEVICE_PATHS.test(command)) {
         return {
@@ -4157,10 +4348,10 @@ function createBashTool() {
 
 // src/tools/sendMessage.ts
 init_cjs_shims();
-var import_zod7 = require("zod");
-var inputSchema3 = import_zod7.z.object({
-  to: import_zod7.z.string().min(1).describe("Agent name (subagent_type) or agentId to send the message to."),
-  message: import_zod7.z.string().min(1).describe("Message content to deliver to the target agent.")
+var import_zod8 = require("zod");
+var inputSchema3 = import_zod8.z.object({
+  to: import_zod8.z.string().min(1).describe("Agent name (subagent_type) or agentId to send the message to."),
+  message: import_zod8.z.string().min(1).describe("Message content to deliver to the target agent.")
 });
 function createSendMessageTool(options) {
   return defineTool({
@@ -4211,12 +4402,12 @@ function createSendMessageTool(options) {
 
 // src/tools/fileEdit.ts
 init_cjs_shims();
-var import_zod8 = require("zod");
-var inputSchema4 = import_zod8.z.object({
-  path: import_zod8.z.string().min(1),
-  old_string: import_zod8.z.string().min(1),
-  new_string: import_zod8.z.string(),
-  replace_all: import_zod8.z.boolean().optional()
+var import_zod9 = require("zod");
+var inputSchema4 = import_zod9.z.object({
+  path: import_zod9.z.string().min(1),
+  old_string: import_zod9.z.string().min(1),
+  new_string: import_zod9.z.string(),
+  replace_all: import_zod9.z.boolean().optional()
 });
 function createFileEditTool(storage) {
   return defineTool({
@@ -4300,13 +4491,13 @@ function normalizeQuotes(s) {
 
 // src/tools/fileRead.ts
 init_cjs_shims();
-var import_zod9 = require("zod");
-var inputSchema5 = import_zod9.z.object({
-  path: import_zod9.z.string().min(1),
-  offset: import_zod9.z.number().int().positive().optional(),
-  limit: import_zod9.z.number().int().positive().optional(),
+var import_zod10 = require("zod");
+var inputSchema5 = import_zod10.z.object({
+  path: import_zod10.z.string().min(1),
+  offset: import_zod10.z.number().int().positive().optional(),
+  limit: import_zod10.z.number().int().positive().optional(),
   /** PDF page range, e.g. "1-5", "3", "10-20". Max 20 pages per request. */
-  pages: import_zod9.z.string().optional()
+  pages: import_zod10.z.string().optional()
 });
 var IMAGE_EXTENSIONS = /* @__PURE__ */ new Set([".png", ".jpg", ".jpeg", ".gif", ".webp", ".bmp", ".svg"]);
 var PDF_EXTENSION = ".pdf";
@@ -4474,7 +4665,7 @@ async function readImage(storage, filePath, ext) {
     ".svg": "image/svg+xml"
   };
   const mimeType = mimeMap[ext] ?? "application/octet-stream";
-  const base64 = buffer.toString("base64");
+  const base642 = buffer.toString("base64");
   return {
     content: `[Image: ${filePath} (${mimeType}, ${(buffer.length / 1024).toFixed(1)}KB)]
 
@@ -4483,17 +4674,17 @@ Base64 data is included in the metadata for visual analysis.`,
       format: "image",
       mimeType,
       bytes: buffer.length,
-      base64
+      base64: base642
     }
   };
 }
 
 // src/tools/fileWrite.ts
 init_cjs_shims();
-var import_zod10 = require("zod");
-var inputSchema6 = import_zod10.z.object({
-  path: import_zod10.z.string().min(1),
-  content: import_zod10.z.string()
+var import_zod11 = require("zod");
+var inputSchema6 = import_zod11.z.object({
+  path: import_zod11.z.string().min(1),
+  content: import_zod11.z.string()
 });
 function createFileWriteTool(storageOrOptions) {
   const opts = "readFile" in storageOrOptions ? { storage: storageOrOptions } : storageOrOptions;
@@ -4532,7 +4723,7 @@ function createFileWriteTool(storageOrOptions) {
 // src/tools/glob.ts
 init_cjs_shims();
 var import_picomatch = __toESM(require("picomatch"), 1);
-var import_zod11 = require("zod");
+var import_zod12 = require("zod");
 
 // src/tools/walkAdapter.ts
 init_cjs_shims();
@@ -4569,9 +4760,9 @@ async function* walkAdapter(adapter, startPath, options = {}) {
 }
 
 // src/tools/glob.ts
-var inputSchema7 = import_zod11.z.object({
-  pattern: import_zod11.z.string().min(1),
-  path: import_zod11.z.string().optional()
+var inputSchema7 = import_zod12.z.object({
+  pattern: import_zod12.z.string().min(1),
+  path: import_zod12.z.string().optional()
 });
 var MAX_RESULTS = 1e3;
 function createGlobTool(storage) {
@@ -4624,22 +4815,22 @@ function createGlobTool(storage) {
 // src/tools/grep.ts
 init_cjs_shims();
 var import_picomatch2 = __toESM(require("picomatch"), 1);
-var import_zod12 = require("zod");
-var inputSchema8 = import_zod12.z.object({
-  pattern: import_zod12.z.string().min(1),
-  path: import_zod12.z.string().optional(),
-  glob: import_zod12.z.string().optional(),
-  type: import_zod12.z.string().optional(),
-  output_mode: import_zod12.z.enum(["content", "files_with_matches", "count"]).optional(),
-  "-i": import_zod12.z.boolean().optional(),
-  "-n": import_zod12.z.boolean().optional(),
-  "-A": import_zod12.z.number().int().nonnegative().optional(),
-  "-B": import_zod12.z.number().int().nonnegative().optional(),
-  "-C": import_zod12.z.number().int().nonnegative().optional(),
-  context: import_zod12.z.number().int().nonnegative().optional(),
-  multiline: import_zod12.z.boolean().optional(),
-  head_limit: import_zod12.z.number().int().nonnegative().optional(),
-  offset: import_zod12.z.number().int().nonnegative().optional()
+var import_zod13 = require("zod");
+var inputSchema8 = import_zod13.z.object({
+  pattern: import_zod13.z.string().min(1),
+  path: import_zod13.z.string().optional(),
+  glob: import_zod13.z.string().optional(),
+  type: import_zod13.z.string().optional(),
+  output_mode: import_zod13.z.enum(["content", "files_with_matches", "count"]).optional(),
+  "-i": import_zod13.z.boolean().optional(),
+  "-n": import_zod13.z.boolean().optional(),
+  "-A": import_zod13.z.number().int().nonnegative().optional(),
+  "-B": import_zod13.z.number().int().nonnegative().optional(),
+  "-C": import_zod13.z.number().int().nonnegative().optional(),
+  context: import_zod13.z.number().int().nonnegative().optional(),
+  multiline: import_zod13.z.boolean().optional(),
+  head_limit: import_zod13.z.number().int().nonnegative().optional(),
+  offset: import_zod13.z.number().int().nonnegative().optional()
 });
 var MAX_FILES_SCANNED = 5e3;
 var MAX_MATCHES_PER_FILE = 100;
@@ -4863,10 +5054,10 @@ function formatJsResults(results, mode, limit) {
 
 // src/tools/webFetch.ts
 init_cjs_shims();
-var import_zod13 = require("zod");
-var inputSchema9 = import_zod13.z.object({
-  url: import_zod13.z.string().url(),
-  prompt: import_zod13.z.string().optional()
+var import_zod14 = require("zod");
+var inputSchema9 = import_zod14.z.object({
+  url: import_zod14.z.string().url(),
+  prompt: import_zod14.z.string().optional()
 });
 var MAX_OUTPUT_BYTES2 = 256 * 1024;
 function createWebFetchTool(options = {}) {
@@ -4995,10 +5186,10 @@ function normalizePath(p) {
 
 // src/tools/webSearch.ts
 init_cjs_shims();
-var import_zod14 = require("zod");
-var inputSchema10 = import_zod14.z.object({
-  query: import_zod14.z.string().min(2),
-  max_results: import_zod14.z.number().int().positive().optional()
+var import_zod15 = require("zod");
+var inputSchema10 = import_zod15.z.object({
+  query: import_zod15.z.string().min(2),
+  max_results: import_zod15.z.number().int().positive().optional()
 });
 function createWebSearchTool() {
   return defineTool({
@@ -5055,10 +5246,10 @@ function htmlToText2(html) {
 
 // src/tools/sleep.ts
 init_cjs_shims();
-var import_zod15 = require("zod");
-var inputSchema11 = import_zod15.z.object({
-  durationMs: import_zod15.z.number().int().nonnegative().max(3e5),
-  reason: import_zod15.z.string().optional()
+var import_zod16 = require("zod");
+var inputSchema11 = import_zod16.z.object({
+  durationMs: import_zod16.z.number().int().nonnegative().max(3e5),
+  reason: import_zod16.z.string().optional()
 });
 function createSleepTool() {
   return defineTool({
@@ -5098,10 +5289,10 @@ function createSleepTool() {
 
 // src/tools/toolSearch.ts
 init_cjs_shims();
-var import_zod16 = require("zod");
-var inputSchema12 = import_zod16.z.object({
-  query: import_zod16.z.string().min(1),
-  max_results: import_zod16.z.number().int().positive().optional()
+var import_zod17 = require("zod");
+var inputSchema12 = import_zod17.z.object({
+  query: import_zod17.z.string().min(1),
+  max_results: import_zod17.z.number().int().positive().optional()
 });
 function createToolSearchTool(registry) {
   return defineTool({
@@ -5144,11 +5335,11 @@ ${lines.join("\n")}`,
 
 // src/tools/memorize.ts
 init_cjs_shims();
-var import_zod17 = require("zod");
-var inputSchema13 = import_zod17.z.object({
-  text: import_zod17.z.string().min(1),
-  kind: import_zod17.z.enum(["rule", "lesson"]).default("lesson"),
-  topic: import_zod17.z.string().optional()
+var import_zod18 = require("zod");
+var inputSchema13 = import_zod18.z.object({
+  text: import_zod18.z.string().min(1),
+  kind: import_zod18.z.enum(["rule", "lesson"]).default("lesson"),
+  topic: import_zod18.z.string().optional()
 });
 function createMemorizeTool(memory) {
   return defineTool({
@@ -5180,11 +5371,11 @@ function createMemorizeTool(memory) {
 
 // src/tools/recall.ts
 init_cjs_shims();
-var import_zod18 = require("zod");
-var inputSchema14 = import_zod18.z.object({
-  query: import_zod18.z.string().min(1),
-  scope: import_zod18.z.enum(["identity", "rules", "lessons", "all"]).default("all"),
-  topic: import_zod18.z.string().optional()
+var import_zod19 = require("zod");
+var inputSchema14 = import_zod19.z.object({
+  query: import_zod19.z.string().min(1),
+  scope: import_zod19.z.enum(["identity", "rules", "lessons", "all"]).default("all"),
+  topic: import_zod19.z.string().optional()
 });
 function createRecallTool(memory) {
   return defineTool({
@@ -5239,13 +5430,13 @@ ${content}`,
 
 // src/tools/notebookEdit.ts
 init_cjs_shims();
-var import_zod19 = require("zod");
-var inputSchema15 = import_zod19.z.object({
-  notebook_path: import_zod19.z.string().min(1),
-  edit_mode: import_zod19.z.enum(["replace", "insert", "delete"]).default("replace"),
-  cell_index: import_zod19.z.number().int().nonnegative(),
-  new_source: import_zod19.z.string().optional(),
-  cell_type: import_zod19.z.enum(["code", "markdown"]).optional()
+var import_zod20 = require("zod");
+var inputSchema15 = import_zod20.z.object({
+  notebook_path: import_zod20.z.string().min(1),
+  edit_mode: import_zod20.z.enum(["replace", "insert", "delete"]).default("replace"),
+  cell_index: import_zod20.z.number().int().nonnegative(),
+  new_source: import_zod20.z.string().optional(),
+  cell_type: import_zod20.z.enum(["code", "markdown"]).optional()
 });
 function createNotebookEditTool(storage) {
   return defineTool({
@@ -5400,12 +5591,12 @@ var TaskStore = class {
 
 // src/tools/tasks/tools.ts
 init_cjs_shims();
-var import_zod20 = require("zod");
-var TaskStatusEnum = import_zod20.z.enum(["pending", "in_progress", "completed", "deleted"]);
-var createSchema = import_zod20.z.object({
-  subject: import_zod20.z.string().min(1),
-  description: import_zod20.z.string().default(""),
-  metadata: import_zod20.z.record(import_zod20.z.unknown()).optional()
+var import_zod21 = require("zod");
+var TaskStatusEnum = import_zod21.z.enum(["pending", "in_progress", "completed", "deleted"]);
+var createSchema = import_zod21.z.object({
+  subject: import_zod21.z.string().min(1),
+  description: import_zod21.z.string().default(""),
+  metadata: import_zod21.z.record(import_zod21.z.unknown()).optional()
 });
 function createTaskCreateTool(store) {
   return defineTool({
@@ -5421,8 +5612,8 @@ function createTaskCreateTool(store) {
     }
   });
 }
-var getSchema = import_zod20.z.object({
-  taskId: import_zod20.z.string().min(1)
+var getSchema = import_zod21.z.object({
+  taskId: import_zod21.z.string().min(1)
 });
 function createTaskGetTool(store) {
   return defineTool({
@@ -5443,7 +5634,7 @@ ${task.description}`,
     }
   });
 }
-var listSchema = import_zod20.z.object({
+var listSchema = import_zod21.z.object({
   status: TaskStatusEnum.optional()
 });
 function createTaskListTool(store) {
@@ -5469,12 +5660,12 @@ ${lines.join("\n")}`,
     }
   });
 }
-var updateSchema = import_zod20.z.object({
-  taskId: import_zod20.z.string().min(1),
-  subject: import_zod20.z.string().min(1).optional(),
+var updateSchema = import_zod21.z.object({
+  taskId: import_zod21.z.string().min(1),
+  subject: import_zod21.z.string().min(1).optional(),
   status: TaskStatusEnum.optional(),
-  description: import_zod20.z.string().optional(),
-  metadata: import_zod20.z.record(import_zod20.z.unknown()).optional()
+  description: import_zod21.z.string().optional(),
+  metadata: import_zod21.z.record(import_zod21.z.unknown()).optional()
 });
 function createTaskUpdateTool(store) {
   return defineTool({
@@ -6321,7 +6512,7 @@ function wrapFetchWithHeadersProvider(baseFetch, headersProvider, staticHeaders)
 
 // src/mcp/toolAdapter.ts
 init_cjs_shims();
-var import_zod21 = require("zod");
+var import_zod22 = require("zod");
 function mcpToolName(serverName, toolName) {
   return `mcp__${serverName}__${toolName}`;
 }
@@ -6330,7 +6521,7 @@ function adaptMcpTool(client, serverName, def) {
   return defineTool({
     name: registeredName,
     description: def.description.length > 0 ? def.description : `MCP tool ${serverName}/${def.name}`,
-    inputSchema: import_zod21.z.unknown(),
+    inputSchema: import_zod22.z.unknown(),
     // Pass the MCP server's JSON Schema through to Anthropic verbatim,
     // bypassing Zod-to-JSON-Schema conversion (which would produce `{}`
     // for our `z.unknown()` Zod schema).
@@ -6991,7 +7182,7 @@ ${entries.map((e) => `- ${e}`).join("\n")}
 // src/memory/memoryConfig.ts
 function createSmartMemory(options) {
   const { storage, config } = options;
-  const adapter = config.scope === "global" ? storage.global : storage.workspace;
+  const adapter = storage.workspace;
   const hippocampus = new Hippocampus(adapter, "smart-memory");
   const writesEnabled = config.mode === "read-write";
   const readsEnabled = config.mode !== "off";
@@ -7362,18 +7553,7 @@ ${lessons}`);
 }
 async function collectSkills(storage, skillsDir) {
   const workspace = await loadSkills(storage.workspace, skillsDir);
-  const global = await loadSkills(storage.global, skillsDir);
-  const seen = /* @__PURE__ */ new Set();
-  const out = [];
-  for (const s of workspace) {
-    seen.add(s.name);
-    out.push({ name: s.name, description: s.description });
-  }
-  for (const s of global) {
-    if (seen.has(s.name)) continue;
-    out.push({ name: s.name, description: s.description });
-  }
-  return out;
+  return workspace.map((s) => ({ name: s.name, description: s.description }));
 }
 
 // src/engine/jsonOutput.ts
@@ -7439,11 +7619,11 @@ ${issues.join("\n")}` };
 
 // src/skills/skillPage.ts
 init_cjs_shims();
-var import_zod22 = require("zod");
+var import_zod23 = require("zod");
 var SAFE_NAME3 = /^[a-zA-Z0-9_-]+$/;
-var inputSchema16 = import_zod22.z.object({
-  skill: import_zod22.z.string().min(1),
-  page: import_zod22.z.string().min(1).optional()
+var inputSchema16 = import_zod23.z.object({
+  skill: import_zod23.z.string().min(1),
+  page: import_zod23.z.string().min(1).optional()
 });
 function createSkillPageTool(options) {
   return defineTool({
@@ -7499,6 +7679,203 @@ The skill "${skill}" has no pages.`;
   });
 }
 
+// src/tools/apiCall.ts
+init_cjs_shims();
+var import_zod24 = require("zod");
+var ALL_METHODS = ["GET", "POST", "PUT", "PATCH", "DELETE"];
+var DEFAULT_MAX_BODY_BYTES = 256 * 1024;
+var DEFAULT_MAX_RESPONSE_BYTES = 100 * 1024;
+function createApiCallTool(opts) {
+  if (opts.services.length === 0) {
+    throw new Error("createApiCallTool: services list must be non-empty");
+  }
+  const services = /* @__PURE__ */ new Map();
+  for (const svc of opts.services) {
+    if (services.has(svc.name)) {
+      throw new Error(`createApiCallTool: duplicate service name "${svc.name}"`);
+    }
+    services.set(svc.name, svc);
+  }
+  const serviceNames = [...services.keys()];
+  for (const svc of opts.services) {
+    if (svc.auth?.type === "custom" && opts.resolveAuth === void 0) {
+      throw new Error(
+        `createApiCallTool: service "${svc.name}" uses custom auth (id: ${svc.auth.id}) but no resolveAuth was supplied`
+      );
+    }
+  }
+  const fetchFn = opts.fetch ?? globalThis.fetch.bind(globalThis);
+  const maxResponseBytes = opts.maxResponseBytes ?? DEFAULT_MAX_RESPONSE_BYTES;
+  const inputSchema17 = import_zod24.z.object({
+    service: import_zod24.z.enum(serviceNames),
+    method: import_zod24.z.enum(["GET", "POST", "PUT", "PATCH", "DELETE"]),
+    path: import_zod24.z.string().regex(/^\//, "path must start with /"),
+    query: import_zod24.z.record(import_zod24.z.string(), import_zod24.z.string()).optional(),
+    body: import_zod24.z.unknown().optional(),
+    headers: import_zod24.z.record(import_zod24.z.string(), import_zod24.z.string()).optional()
+  });
+  const description = opts.toolDescription ?? `Call a configured external API. Services: ${serviceNames.join(", ")}. Auth is injected automatically \u2014 do not pass credentials via headers.`;
+  return defineTool({
+    name: opts.toolName ?? "ApiCall",
+    description,
+    inputSchema: inputSchema17,
+    execute: async (input) => {
+      const svc = services.get(input.service);
+      if (!svc) {
+        return errResult(`ERR_API_UNKNOWN_SERVICE: ${input.service}`);
+      }
+      const allowedMethods = svc.allowedMethods ?? ALL_METHODS;
+      if (!allowedMethods.includes(input.method)) {
+        return errResult(
+          `ERR_API_METHOD_NOT_ALLOWED: ${input.method} not permitted for service ${svc.name}`
+        );
+      }
+      if (!pathAllowed(input.path, svc.allowedPaths)) {
+        return errResult(`ERR_API_PATH_NOT_ALLOWED: ${input.path} for service ${svc.name}`);
+      }
+      let bodyText;
+      if (input.body !== void 0) {
+        bodyText = JSON.stringify(input.body);
+        const cap = svc.maxBodyBytes ?? DEFAULT_MAX_BODY_BYTES;
+        if (byteLength(bodyText) > cap) {
+          return errResult(`ERR_API_BODY_TOO_LARGE: exceeds ${cap} bytes`);
+        }
+      }
+      let authHeaders;
+      try {
+        authHeaders = await resolveAuth({
+          auth: svc.auth ?? { type: "none" },
+          env: opts.env,
+          resolver: opts.resolveAuth,
+          ctx: { serviceName: svc.name, method: input.method, path: input.path }
+        });
+      } catch (err) {
+        const raw2 = err instanceof Error ? err.message : String(err);
+        const truncated = raw2.length > 200 ? raw2.slice(0, 200) + "\u2026" : raw2;
+        return errResult(`ERR_API_RESOLVER_FAILED: ${truncated}`);
+      }
+      const userHeaders = sanitizeHeaders(input.headers ?? {}, authHeaders);
+      const url = buildUrl(svc.baseUrl, input.path, input.query);
+      await invokeHook(opts.onRequest, {
+        service: svc.name,
+        method: input.method,
+        path: input.path
+      });
+      const started = Date.now();
+      let res;
+      try {
+        res = await fetchFn(url, {
+          method: input.method,
+          headers: {
+            "Content-Type": "application/json",
+            ...svc.defaultHeaders ?? {},
+            ...userHeaders,
+            ...authHeaders
+            // wins last — model cannot override
+          },
+          ...bodyText !== void 0 ? { body: bodyText } : {}
+        });
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return errResult(`network error: ${msg}`);
+      }
+      const raw = await res.text();
+      const content = raw.length > maxResponseBytes ? raw.slice(0, maxResponseBytes) + "\n\u2026[TRUNCATED]" : raw;
+      await invokeHook(opts.onResponse, {
+        service: svc.name,
+        method: input.method,
+        path: input.path,
+        status: res.status,
+        latencyMs: Date.now() - started,
+        bytesIn: raw.length
+      });
+      return {
+        content,
+        isError: !res.ok,
+        metadata: { status: res.status, service: svc.name }
+      };
+    }
+  });
+}
+function errResult(msg) {
+  return { content: msg, isError: true };
+}
+function pathAllowed(path, allowed) {
+  if (!allowed || allowed.length === 0) return true;
+  for (const a of allowed) {
+    if (typeof a === "string") {
+      if (path.startsWith(a)) return true;
+    } else if (a.test(path)) {
+      return true;
+    }
+  }
+  return false;
+}
+function byteLength(s) {
+  return new TextEncoder().encode(s).byteLength;
+}
+function buildUrl(baseUrl, path, query) {
+  const base = baseUrl.endsWith("/") ? baseUrl.slice(0, -1) : baseUrl;
+  const url = new URL(base + path);
+  for (const [k, v] of Object.entries(query ?? {})) {
+    url.searchParams.set(k, v);
+  }
+  return url.toString();
+}
+function sanitizeHeaders(user, auth) {
+  const banned = new Set(Object.keys(auth).map((k) => k.toLowerCase()));
+  const out = {};
+  for (const [k, v] of Object.entries(user)) {
+    if (banned.has(k.toLowerCase())) continue;
+    out[k] = v;
+  }
+  return out;
+}
+async function resolveAuth(args) {
+  const { auth, env, resolver, ctx } = args;
+  switch (auth.type) {
+    case "none":
+      return {};
+    case "bearer": {
+      const token = envLookup(env, auth.tokenRef);
+      return { Authorization: `Bearer ${token}` };
+    }
+    case "header": {
+      const value = envLookup(env, auth.valueRef);
+      return { [auth.name]: value };
+    }
+    case "basic": {
+      const u = envLookup(env, auth.userRef);
+      const p = envLookup(env, auth.passRef);
+      return { Authorization: `Basic ${base64(`${u}:${p}`)}` };
+    }
+    case "custom":
+      if (resolver === void 0) {
+        throw new Error(`custom auth id "${auth.id}" requires resolveAuth`);
+      }
+      return resolver(auth, ctx);
+  }
+}
+function envLookup(env, ref) {
+  if (env === void 0 || env[ref] === void 0) {
+    throw new Error(`ERR_API_ENV_MISSING: ${ref}`);
+  }
+  return env[ref];
+}
+function base64(input) {
+  if (typeof globalThis.btoa === "function") {
+    return globalThis.btoa(input);
+  }
+  return Buffer.from(input, "utf8").toString("base64");
+}
+async function invokeHook(hook, event) {
+  if (hook === void 0) return;
+  try {
+    await hook(event);
+  } catch {
+  }
+}
+
 // src/skills/storageSkillSource.ts
 init_cjs_shims();
 var SAFE_NAME4 = /^[a-zA-Z0-9_-]+$/;
@@ -7510,14 +7887,8 @@ var StorageSkillSource = class {
     this.baseDir = options.baseDir ?? "skills";
   }
   async list() {
-    const [workspace, global] = await Promise.all([
-      loadSkills(this.storage.workspace, this.baseDir),
-      loadSkills(this.storage.global, this.baseDir)
-    ]);
-    const byName = /* @__PURE__ */ new Map();
-    for (const s of global) byName.set(s.name, s);
-    for (const s of workspace) byName.set(s.name, s);
-    return Array.from(byName.values()).map((s) => ({
+    const loaded = await loadSkills(this.storage.workspace, this.baseDir);
+    return loaded.map((s) => ({
       name: s.name,
       description: s.description,
       hasPages: s.hasPages
@@ -7525,8 +7896,7 @@ var StorageSkillSource = class {
   }
   async getSkillFile(skill) {
     if (!SAFE_NAME4.test(skill)) return null;
-    const found = await this.findFile(skill, "SKILL.md");
-    return found;
+    return this.findFile(skill, "SKILL.md");
   }
   async getPage(skill, page) {
     if (!SAFE_NAME4.test(skill)) return null;
@@ -7535,9 +7905,7 @@ var StorageSkillSource = class {
   }
   async listPages(skill) {
     if (!SAFE_NAME4.test(skill)) return [];
-    const wsPages = await this.listPagesIn(this.storage.workspace, skill);
-    if (wsPages.length > 0) return wsPages;
-    return this.listPagesIn(this.storage.global, skill);
+    return this.listPagesIn(this.storage.workspace, skill);
   }
   async listPagesIn(adapter, skill) {
     const pagesDir = `${this.baseDir}/${skill}/pages`;
@@ -7550,9 +7918,7 @@ var StorageSkillSource = class {
   }
   async findFile(skill, relative) {
     const path = `${this.baseDir}/${skill}/${relative}`;
-    const fromWorkspace = await this.readIfExists(this.storage.workspace, path);
-    if (fromWorkspace !== null) return fromWorkspace;
-    return this.readIfExists(this.storage.global, path);
+    return this.readIfExists(this.storage.workspace, path);
   }
   async readIfExists(adapter, path) {
     try {
@@ -8135,7 +8501,6 @@ async function createEngineStorage(config) {
 }
 async function createLocalStorage(config) {
   const path = await import("path");
-  const globalRoot = path.join(config.rootPath, ENGINE_DATA_FOLDER);
   const workspaceRoot = path.join(
     config.rootPath,
     WORKSPACES_FOLDER,
@@ -8143,7 +8508,6 @@ async function createLocalStorage(config) {
     ENGINE_DATA_FOLDER
   );
   return {
-    global: new LocalStorageAdapter(globalRoot),
     workspace: new LocalStorageAdapter(workspaceRoot)
   };
 }
@@ -8152,10 +8516,8 @@ function createR2Storage(config) {
     throw new StorageError('storage.r2 is required when storage.provider === "r2"');
   }
   const rootPrefix = config.rootPath.replace(/^\/+|\/+$/g, "");
-  const globalPrefix = `${rootPrefix}/${ENGINE_DATA_FOLDER}`;
   const workspacePrefix = `${rootPrefix}/${WORKSPACES_FOLDER}/${config.workspaceId}/${ENGINE_DATA_FOLDER}`;
   return {
-    global: new R2StorageAdapter(config.r2, globalPrefix),
     workspace: new R2StorageAdapter(config.r2, workspacePrefix)
   };
 }
@@ -8164,10 +8526,8 @@ function createR2BindingStorage(config) {
     throw new StorageError('storage.r2Binding is required when storage.provider === "r2-binding"');
   }
   const rootPrefix = config.rootPath.replace(/^\/+|\/+$/g, "");
-  const globalPrefix = `${rootPrefix}/${ENGINE_DATA_FOLDER}`;
   const workspacePrefix = `${rootPrefix}/${WORKSPACES_FOLDER}/${config.workspaceId}/${ENGINE_DATA_FOLDER}`;
   return {
-    global: new R2BindingStorageAdapter(config.r2Binding, globalPrefix),
     workspace: new R2BindingStorageAdapter(config.r2Binding, workspacePrefix)
   };
 }
@@ -8274,6 +8634,7 @@ function rebuildMessagesFromEntries(entries) {
 init_cjs_shims();
 function toResponse(result, extra) {
   const timestamp = Date.now();
+  const capsField = extra.capabilitiesMissing !== void 0 && extra.capabilitiesMissing.length > 0 ? { capabilitiesMissing: extra.capabilitiesMissing } : {};
   if (result.status === "done") {
     return {
       runId: extra.runId,
@@ -8285,7 +8646,8 @@ function toResponse(result, extra) {
         tokensUsed: result.tokensUsed,
         durationMs: extra.durationMs,
         output: result.output,
-        ...extra.logPath !== void 0 ? { transcript: { path: extra.logPath, lastShardIndex: 0 } } : {}
+        ...extra.logPath !== void 0 ? { transcript: { path: extra.logPath, lastShardIndex: 0 } } : {},
+        ...capsField
       },
       errors: [],
       timestamp
@@ -8304,7 +8666,8 @@ function toResponse(result, extra) {
         snapshot: result.snapshot,
         ...result.snapshot.pendingToolCall !== void 0 ? { pendingToolCall: result.snapshot.pendingToolCall } : {},
         pauseReason: result.reason,
-        ...extra.logPath !== void 0 ? { transcript: { path: extra.logPath, lastShardIndex: result.snapshot.lastShardIndex } } : {}
+        ...extra.logPath !== void 0 ? { transcript: { path: extra.logPath, lastShardIndex: result.snapshot.lastShardIndex } } : {},
+        ...capsField
       },
       errors: [],
       timestamp
@@ -8638,7 +9001,15 @@ var Engine = class {
     this.mcpManager = new McpManager(config.mcp, createLogger(config.logging), { samplingHandler });
     this.permissionPolicy = buildPermissionPolicy(config.permissions);
   }
-  async run(options) {
+  /**
+   * Run a task synchronously to completion. The `_internal` parameter is
+   * reserved for the engine's own async wrappers (`start`, `resumeAsync`)
+   * to request runner handoff (Plan 019) — external callers must leave
+   * it unset. Sync callers never hand off; if they hit a Node-only tool
+   * on a restricted runtime, the capability stub returns an error and
+   * the model adapts.
+   */
+  async run(options, _internal) {
     const startTime = Date.now();
     const runId = options.runId ?? `run_${randomUUID()}`;
     const log = createLogger(this.config.logging);
@@ -8661,6 +9032,7 @@ var Engine = class {
     const coordinatorBase = isCoordinatorMode(this.config) ? getCoordinatorBasePrompt() : void 0;
     const skillSource = this.resolveSkillSource(options.skills, storage);
     const skillList = skillSource !== void 0 ? await skillSource.list() : void 0;
+    const apiConfig = this.resolveApiConfig(options.api);
     let systemPrompt = await buildSystemPrompt({
       ...coordinatorBase !== void 0 ? { base: coordinatorBase } : {},
       memory,
@@ -8691,7 +9063,9 @@ var Engine = class {
       mcpTools,
       memory,
       ...this.config.hooks.propagateGateToSubagents === true && gate !== void 0 ? { subagentGate: gate } : {},
-      ...skillSource !== void 0 ? { skillSource } : {}
+      ...skillSource !== void 0 ? { skillSource } : {},
+      ...apiConfig !== void 0 ? { apiConfig } : {},
+      ...this.internals.fetch !== void 0 ? { fetch: this.internals.fetch } : {}
     });
     const writer = new TranscriptWriter({
       storage: storage.workspace,
@@ -8745,7 +9119,8 @@ var Engine = class {
         onProgress: this.buildHeartbeat(storage, runId, options.nodeId),
         ...options.tokenBudget !== void 0 ? { tokenBudget: options.tokenBudget } : {},
         ...runTimeout.signal !== void 0 ? { runSignal: runTimeout.signal, runTimeoutMs: this.config.execution.runTimeoutMs } : {},
-        ...gate !== void 0 ? { gateBeforeTool: gate } : {}
+        ...gate !== void 0 ? { gateBeforeTool: gate } : {},
+        ..._internal?.handoffToRunner === true ? { handoffToRunner: true } : {}
       });
       const result = await this.finalizeResult(loopResult, writer, logPath, {
         ...options.outputFormat !== void 0 ? { outputFormat: options.outputFormat } : {},
@@ -8753,18 +9128,20 @@ var Engine = class {
       });
       this.logRunEnd(log, runId, options.nodeId, result);
       await this.firePostRunHook(runId, options.nodeId, result, ctx, logPath);
+      const capabilitiesMissing = ctx.getCapabilitiesMissing();
       return toResponse(result, {
         runId,
         nodeId: options.nodeId,
         durationMs: Date.now() - startTime,
-        logPath
+        logPath,
+        ...capabilitiesMissing.length > 0 ? { capabilitiesMissing } : {}
       });
     } finally {
       runTimeout.clear();
       await writer.close();
     }
   }
-  async resume(options) {
+  async resume(options, _internal) {
     const startTime = Date.now();
     const log = createLogger(this.config.logging);
     const storage = await this.buildStorage();
@@ -8797,6 +9174,7 @@ var Engine = class {
     const coordinatorBase = isCoordinatorMode(this.config) ? getCoordinatorBasePrompt() : void 0;
     const skillSource = this.resolveSkillSource(options.skills, storage);
     const skillList = skillSource !== void 0 ? await skillSource.list() : void 0;
+    const apiConfig = this.resolveApiConfig(options.api);
     let systemPrompt = await buildSystemPrompt({
       ...coordinatorBase !== void 0 ? { base: coordinatorBase } : {},
       memory,
@@ -8827,7 +9205,9 @@ var Engine = class {
       mcpTools,
       memory,
       ...this.config.hooks.propagateGateToSubagents === true && gate !== void 0 ? { subagentGate: gate } : {},
-      ...skillSource !== void 0 ? { skillSource } : {}
+      ...skillSource !== void 0 ? { skillSource } : {},
+      ...apiConfig !== void 0 ? { apiConfig } : {},
+      ...this.internals.fetch !== void 0 ? { fetch: this.internals.fetch } : {}
     });
     const priorState = await loadWriterState(storage.workspace, logPath);
     const writer = new TranscriptWriter({
@@ -8881,18 +9261,21 @@ var Engine = class {
           const answer = typeof options.gateAnswer === "string" ? options.gateAnswer : JSON.stringify(options.gateAnswer);
           await ctx.addToolResult(pending.toolUseId, answer, false);
         } else {
-          await ctx.addToolResult(
-            pending.toolUseId,
-            `APPROVAL_GATE_RELEASED: the prior ${pending.toolName} call was paused for human approval and has now been approved. Retry is required.`,
-            false
-          );
           const inputJson = JSON.stringify(pending.input ?? {}, null, 2);
-          await ctx.addUserMessage(
-            `The human has approved the paused ${pending.toolName} tool call. You MUST now re-issue the EXACT same tool call to complete the work \u2014 do not change the arguments, do not answer in text, do not declare the task done. Approved arguments (copy verbatim):
+          await ctx.addMixedUserMessage([
+            {
+              type: "tool_result",
+              tool_use_id: pending.toolUseId,
+              content: `APPROVAL_GATE_RELEASED: the prior ${pending.toolName} call was paused for human approval and has now been approved. Retry is required.`
+            },
+            {
+              type: "text",
+              text: `The human has approved the paused ${pending.toolName} tool call. You MUST now re-issue the EXACT same tool call to complete the work \u2014 do not change the arguments, do not answer in text, do not declare the task done. Approved arguments (copy verbatim):
 \`\`\`json
 ${inputJson}
 \`\`\``
-          );
+            }
+          ]);
         }
       }
       await writer.setStatus("running");
@@ -8913,7 +9296,8 @@ ${inputJson}
         stopHooks: this.config.hooks.stopHooks,
         onProgress: this.buildHeartbeat(storage, snapshot.runId, snapshot.nodeId),
         ...runTimeout.signal !== void 0 ? { runSignal: runTimeout.signal, runTimeoutMs: this.config.execution.runTimeoutMs } : {},
-        ...gate !== void 0 ? { gateBeforeTool: gate } : {}
+        ...gate !== void 0 ? { gateBeforeTool: gate } : {},
+        ..._internal?.handoffToRunner === true ? { handoffToRunner: true } : {}
       });
       const result = await this.finalizeResult(loopResult, writer, logPath, {
         ...options.outputFormat !== void 0 ? { outputFormat: options.outputFormat } : {},
@@ -8921,11 +9305,13 @@ ${inputJson}
       });
       this.logRunEnd(log, snapshot.runId, snapshot.nodeId, result);
       await this.firePostRunHook(snapshot.runId, snapshot.nodeId, result, ctx, logPath);
+      const capabilitiesMissing = ctx.getCapabilitiesMissing();
       return toResponse(result, {
         runId: snapshot.runId,
         nodeId: snapshot.nodeId,
         durationMs: Date.now() - startTime,
-        logPath
+        logPath,
+        ...capabilitiesMissing.length > 0 ? { capabilitiesMissing } : {}
       });
     } finally {
       runTimeout.clear();
@@ -8995,13 +9381,15 @@ ${inputJson}
     } : void 0;
     const initial = RunStateManager.initial(runId, options.nodeId, webhook);
     await stateManager.write(initial);
+    const handoffEnabled = this.config.runner !== void 0;
     this.backgroundExecutor.schedule(runId, async (signal) => {
       await stateManager.update(runId, options.nodeId, { status: "running" });
       try {
-        const response = await this.run({ ...options, runId });
+        const response = await this.run({ ...options, runId }, { handoffToRunner: handoffEnabled });
         if (signal.aborted) return;
-        await stateManager.finalize(runId, options.nodeId, response);
-        await this.maybeFireWebhook(stateManager, runId, options.nodeId, response);
+        const postHandoff = await this.maybeHandoffToRunner(runId, options.nodeId, response);
+        await stateManager.finalize(runId, options.nodeId, postHandoff);
+        await this.maybeFireWebhook(stateManager, runId, options.nodeId, postHandoff);
       } catch (err) {
         if (signal.aborted) return;
         const errorMsg = err instanceof Error ? err.message : String(err);
@@ -9049,12 +9437,14 @@ ${inputJson}
     } : { ...RunStateManager.initial(options.runId, nodeId, webhook), status: "running" };
     await stateManager.write(next);
     const resumeNodeId = nodeId;
+    const handoffEnabled = this.config.runner !== void 0;
     this.backgroundExecutor.schedule(options.runId, async (signal) => {
       try {
-        const response = await this.resume(options);
+        const response = await this.resume(options, { handoffToRunner: handoffEnabled });
         if (signal.aborted) return;
-        await stateManager.finalize(options.runId, resumeNodeId, response);
-        await this.maybeFireWebhook(stateManager, options.runId, resumeNodeId, response);
+        const postHandoff = await this.maybeHandoffToRunner(options.runId, resumeNodeId, response);
+        await stateManager.finalize(options.runId, resumeNodeId, postHandoff);
+        await this.maybeFireWebhook(stateManager, options.runId, resumeNodeId, postHandoff);
       } catch (err) {
         if (signal.aborted) return;
         const errorMsg = err instanceof Error ? err.message : String(err);
@@ -9243,6 +9633,68 @@ ${inputJson}
     }
     return orphaned;
   }
+  // ---------- runner handoff (Plan 019) ----------
+  /**
+   * When the response indicates the run paused for runner handoff, POST
+   * `{ runId }` to the configured runner URL. On success, return the
+   * response unchanged — state stays `paused` and the runner will flip
+   * it to `done` (or `failed`) on its side. On POST failure, convert
+   * the response to `failed` with `ERR_RUNNER_UNREACHABLE` so the
+   * caller sees a terminal state instead of a silent hang.
+   *
+   * Called only from `start()` / `resumeAsync()`. Sync `run()` never
+   * produces a `handoff_to_runner` pause (see `_internal.handoffToRunner`).
+   */
+  async maybeHandoffToRunner(runId, nodeId, response) {
+    if (response.status !== "paused") return response;
+    if (response.meta.pauseReason !== "handoff_to_runner") return response;
+    const runner = this.config.runner;
+    if (runner === void 0) {
+      return response;
+    }
+    const fetchFn = this.internals.fetch ?? globalThis.fetch.bind(globalThis);
+    try {
+      const res = await fetchFn(runner.url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${runner.secret}`
+        },
+        body: JSON.stringify({ runId })
+      });
+      if (!res.ok) {
+        return {
+          runId,
+          status: "failed",
+          data: null,
+          meta: { nodeId },
+          errors: [
+            {
+              code: "ERR_RUNNER_UNREACHABLE",
+              message: `Runner returned HTTP ${res.status}`
+            }
+          ],
+          timestamp: Date.now()
+        };
+      }
+      return response;
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      return {
+        runId,
+        status: "failed",
+        data: null,
+        meta: { nodeId },
+        errors: [
+          {
+            code: "ERR_RUNNER_UNREACHABLE",
+            message: `Runner handoff failed: ${msg}`
+          }
+        ],
+        timestamp: Date.now()
+      };
+    }
+  }
   // ---------- webhook helpers ----------
   async maybeFireWebhook(stateManager, runId, nodeId, response) {
     const state = await stateManager.read(runId, nodeId);
@@ -9386,6 +9838,11 @@ ${inputJson}
       if (disabled.has(name)) continue;
       if (wantAll || enabled.has(name)) names.add(name);
     }
+    if ((this.config.api?.services.length ?? 0) > 0) {
+      if (!disabled.has("ApiCall") && (wantAll || enabled.has("ApiCall"))) {
+        names.add("ApiCall");
+      }
+    }
     for (const tool of this.config.tools.custom) {
       names.add(tool.name);
     }
@@ -9542,6 +9999,34 @@ ${inputJson}
     }
     return void 0;
   }
+  /**
+   * Plan 020 — resolve the effective ApiCall config for a run.
+   *
+   * Precedence (each field independently):
+   *   RunOptions.api.X > config.api.X
+   *
+   * If neither side provides any services, returns undefined so the
+   * tool isn't registered at all. Env + resolveAuth + hooks flow
+   * through untouched — they never hit the Zod schema.
+   */
+  resolveApiConfig(override) {
+    const base = this.config.api;
+    if (override === void 0 && base === void 0) return void 0;
+    const services = override?.services ?? base?.services;
+    if (services === void 0 || services.length === 0) return void 0;
+    const env = override?.env ?? base?.env;
+    const resolveAuth2 = override?.resolveAuth ?? base?.resolveAuth;
+    const onRequest = override?.onRequest ?? base?.onRequest;
+    const onResponse = override?.onResponse ?? base?.onResponse;
+    return {
+      services,
+      ...env !== void 0 ? { env } : {},
+      ...resolveAuth2 !== void 0 ? { resolveAuth: resolveAuth2 } : {},
+      ...onRequest !== void 0 ? { onRequest } : {},
+      ...onResponse !== void 0 ? { onResponse } : {},
+      ...base?.maxResponseBytes !== void 0 ? { maxResponseBytes: base.maxResponseBytes } : {}
+    };
+  }
   /**
    * Build a throttled heartbeat callback for agentLoop's `onProgress` hook.
    *
@@ -9636,8 +10121,8 @@ function buildToolRegistry(options) {
   const fileTracker = new FileTracker();
   const spawnAvailable = canSpawnProcesses();
   const candidates = [
-    // Bash — requires child_process.spawn (Node.js only).
-    ...spawnAvailable ? [{ name: "Bash", tool: createBashTool() }] : [],
+    // Bash — requires child_process.spawn. Stubbed on Workers.
+    { name: "Bash", tool: withCapabilityCheck(createBashTool(), spawnAvailable) },
     {
       name: "Read",
       tool: createFileReadTool({ storage: storage.workspace, tracker: fileTracker })
@@ -9683,6 +10168,21 @@ function buildToolRegistry(options) {
       childRegistry.register(skillTool);
     }
   }
+  if (options.apiConfig !== void 0 && options.apiConfig.services.length > 0) {
+    if (!disabled.has("ApiCall") && (wantAll || enabled.has("ApiCall"))) {
+      const apiTool = createApiCallTool({
+        services: options.apiConfig.services,
+        ...options.fetch !== void 0 ? { fetch: options.fetch } : {},
+        ...options.apiConfig.env !== void 0 ? { env: options.apiConfig.env } : {},
+        ...options.apiConfig.resolveAuth !== void 0 ? { resolveAuth: options.apiConfig.resolveAuth } : {},
+        ...options.apiConfig.onRequest !== void 0 ? { onRequest: options.apiConfig.onRequest } : {},
+        ...options.apiConfig.onResponse !== void 0 ? { onResponse: options.apiConfig.onResponse } : {},
+        ...options.apiConfig.maxResponseBytes !== void 0 ? { maxResponseBytes: options.apiConfig.maxResponseBytes } : {}
+      });
+      registry.register(apiTool);
+      childRegistry.register(apiTool);
+    }
+  }
   const agentTool = createAgentTool({
     storage: storage.workspace,
     client,
@@ -9805,6 +10305,8 @@ function resolveApiKey(config) {
   buildSystemPrompt,
   buildWorkerAgent,
   canSpawnProcesses,
+  capabilityStub,
+  createApiCallTool,
   createLogger,
   createModelAdapter,
   createSendMessageTool,
@@ -9836,6 +10338,7 @@ function resolveApiKey(config) {
   synthesizeSpec,
   toResponse,
   tryParseJSON,
-  validateOutput
+  validateOutput,
+  withCapabilityCheck
 });
 //# sourceMappingURL=index.cjs.map