la-machina-engine 0.4.0 → 0.6.0

package/dist/index.cjs

@@ -37,24 +37,113 @@ var init_cjs_shims = __esm({
   }
 });
 
+// src/tools/contract.ts
+function defineTool(tool) {
+  return tool;
+}
+var ToolRegistry;
+var init_contract = __esm({
+  "src/tools/contract.ts"() {
+    "use strict";
+    init_cjs_shims();
+    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/fetchData.ts
+var fetchData_exports = {};
+__export(fetchData_exports, {
+  createFetchDataTool: () => createFetchDataTool
+});
+function createFetchDataTool(opts) {
+  return defineTool({
+    name: "FetchData",
+    description: "Fetch the full content of a tool result that was offloaded because it was too large for the main context. Pass the `ref` token from the summarized tool_result message (the text that looked like 'Use FetchData with ref=\"...\"'). Returns the raw bytes of the original tool output.",
+    inputSchema,
+    execute: async ({ ref }) => {
+      if (!SAFE_REF.test(ref)) {
+        return {
+          content: `ERR_OFFLOAD_INVALID_REF: ref "${ref}" contains unsafe characters`,
+          isError: true
+        };
+      }
+      const path = `${opts.logPath}/toolResults/${ref}.json`;
+      const raw = await opts.storage.readFile(path);
+      if (raw === null) {
+        return {
+          content: `ERR_OFFLOAD_REF_NOT_FOUND: no data found for ref "${ref}"`,
+          isError: true
+        };
+      }
+      return {
+        content: raw,
+        isError: false,
+        metadata: { ref, bytes: raw.length }
+      };
+    }
+  });
+}
+var import_zod6, SAFE_REF, inputSchema;
+var init_fetchData = __esm({
+  "src/tools/fetchData.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_zod6 = require("zod");
+    init_contract();
+    SAFE_REF = /^[a-zA-Z0-9_-]+$/;
+    inputSchema = import_zod6.z.object({
+      ref: import_zod6.z.string().min(1)
+    });
+  }
+});
+
 // src/orchestrator/types.ts
-var import_zod25, PlanStepSchema, PlanSchema;
+var import_zod26, PlanStepSchema, PlanSchema;
 var init_types = __esm({
   "src/orchestrator/types.ts"() {
     "use strict";
     init_cjs_shims();
-    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()
+    import_zod26 = require("zod");
+    PlanStepSchema = import_zod26.z.object({
+      id: import_zod26.z.string().min(1),
+      description: import_zod26.z.string().min(1),
+      action: import_zod26.z.enum(["research", "implement", "verify", "review", "custom"]),
+      files: import_zod26.z.array(import_zod26.z.string()).optional(),
+      spec: import_zod26.z.string().optional(),
+      dependsOn: import_zod26.z.array(import_zod26.z.string()).optional()
     });
-    PlanSchema = import_zod25.z.object({
-      summary: import_zod25.z.string().min(1),
-      steps: import_zod25.z.array(PlanStepSchema).min(1)
+    PlanSchema = import_zod26.z.object({
+      summary: import_zod26.z.string().min(1),
+      steps: import_zod26.z.array(PlanStepSchema).min(1)
     });
   }
 });
@@ -787,12 +876,14 @@ __export(index_exports, {
   canSpawnProcesses: () => canSpawnProcesses,
   capabilityStub: () => capabilityStub,
   createApiCallTool: () => createApiCallTool,
+  createFetchDataTool: () => createFetchDataTool,
   createLogger: () => createLogger,
   createModelAdapter: () => createModelAdapter,
   createSendMessageTool: () => createSendMessageTool,
   createSkillPageTool: () => createSkillPageTool,
   createSmartMemory: () => createSmartMemory,
   defaultSamplingHandler: () => defaultSamplingHandler,
+  defaultToolResultSummarizer: () => defaultToolResultSummarizer,
   defineTool: () => defineTool,
   detectRuntime: () => detectRuntime,
   getCoordinatorBasePrompt: () => getCoordinatorBasePrompt,
@@ -817,7 +908,7 @@ __export(index_exports, {
   snapshotFiles: () => snapshotFiles,
   synthesizeSpec: () => synthesizeSpec,
   toResponse: () => toResponse,
-  tryParseJSON: () => tryParseJSON,
+  tryParseJSON: () => tryParseJSON2,
   validateOutput: () => validateOutput,
   withCapabilityCheck: () => withCapabilityCheck
 });
@@ -943,7 +1034,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({
@@ -982,7 +1074,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()),
@@ -1070,13 +1162,19 @@ var McpConfigResolved = import_zod.z.object({
   shutdownTimeoutMs: import_zod.z.number().int().positive()
 }).strict();
 var CompactionStrategyEnum = import_zod.z.enum(["drop-middle", "summarize", "session-memory", "auto"]);
+var ToolResultOffloadConfigResolved = import_zod.z.object({
+  enabled: import_zod.z.boolean(),
+  thresholdBytes: import_zod.z.number().int().positive(),
+  maxPreviewChars: import_zod.z.number().int().positive()
+}).strict();
 var CompactionConfigResolved = import_zod.z.object({
   strategy: CompactionStrategyEnum,
   threshold: import_zod.z.number().min(0).max(1),
   keepLast: import_zod.z.number().int().positive(),
   summaryMaxTokens: import_zod.z.number().int().positive(),
   microcompact: import_zod.z.boolean(),
-  microcompactAgeMs: import_zod.z.number().int().nonnegative()
+  microcompactAgeMs: import_zod.z.number().int().nonnegative(),
+  toolResultOffload: ToolResultOffloadConfigResolved.optional()
 }).strict();
 var CoordinatorConfigResolved = import_zod.z.object({
   enabled: import_zod.z.boolean(),
@@ -1177,7 +1275,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();
@@ -1209,7 +1310,16 @@ var McpConfigUser = import_zod.z.object({
 var PermissionsConfigUser = PermissionsConfigResolved.partial();
 var RunnerConfigUser = RunnerConfigResolved;
 var ApiConfigUser = ApiConfigResolved.partial();
-var CompactionConfigUser = CompactionConfigResolved.partial();
+var ToolResultOffloadConfigUser = ToolResultOffloadConfigResolved.partial();
+var CompactionConfigUser = import_zod.z.object({
+  strategy: CompactionStrategyEnum.optional(),
+  threshold: import_zod.z.number().min(0).max(1).optional(),
+  keepLast: import_zod.z.number().int().positive().optional(),
+  summaryMaxTokens: import_zod.z.number().int().positive().optional(),
+  microcompact: import_zod.z.boolean().optional(),
+  microcompactAgeMs: import_zod.z.number().int().nonnegative().optional(),
+  toolResultOffload: ToolResultOffloadConfigUser.optional()
+}).strict();
 var CoordinatorConfigUser = CoordinatorConfigResolved.partial();
 var OrchestratorConfigUser = OrchestratorConfigResolved.deepPartial();
 var UserConfigSchema = import_zod.z.object({
@@ -1290,8 +1400,41 @@ function splitApiRuntime(user) {
   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" }
+  };
+}
+var OFFLOAD_DEFAULTS = { thresholdBytes: 2048, maxPreviewChars: 500 };
+function splitOffloadRuntime(user) {
+  const block = user.compaction?.toolResultOffload;
+  if (block === void 0) return { stripped: user };
+  const { summarizer, ...schemaSafe } = block;
+  const filled = {
+    enabled: schemaSafe.enabled ?? false,
+    thresholdBytes: schemaSafe.thresholdBytes ?? OFFLOAD_DEFAULTS.thresholdBytes,
+    maxPreviewChars: schemaSafe.maxPreviewChars ?? OFFLOAD_DEFAULTS.maxPreviewChars
+  };
+  const clone = {
+    ...user,
+    compaction: {
+      ...user.compaction ?? {},
+      toolResultOffload: filled
+    }
+  };
+  return { stripped: clone, summarizer };
+}
 function mergeConfig(user) {
-  const { stripped, runtime } = splitApiRuntime(user);
+  const withCoercedScope = coerceDeprecatedMemoryScope(user);
+  const { stripped: afterOffload, summarizer } = splitOffloadRuntime(withCoercedScope);
+  const { stripped, runtime } = splitApiRuntime(afterOffload);
   const validatedUser = UserConfigSchema.parse(stripped);
   const merged = deepMerge(DEFAULTS, validatedUser);
   const resolved = ResolvedConfigSchema.parse(merged);
@@ -1303,6 +1446,13 @@ function mergeConfig(user) {
     };
   } else if (Object.keys(runtime).length > 0) {
   }
+  if (summarizer !== void 0 && resolved.compaction.toolResultOffload !== void 0) {
+    const mutable = resolved.compaction;
+    mutable.toolResultOffload = {
+      ...resolved.compaction.toolResultOffload,
+      summarizer
+    };
+  }
   return resolved;
 }
 
@@ -1949,44 +2099,7 @@ function hasProcessLifecycle() {
 // 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
+init_contract();
 var anyInput = import_zod2.z.unknown();
 function capabilityStub(original) {
   return defineTool({
@@ -2190,7 +2303,7 @@ var SubagentRegistry = class _SubagentRegistry {
 
 // src/tools/agent.ts
 init_cjs_shims();
-var import_zod6 = require("zod");
+var import_zod7 = require("zod");
 
 // src/subagent/runner.ts
 init_cjs_shims();
@@ -2254,6 +2367,131 @@ async function writeSnapshot(storage, logPath, snapshot) {
   await storage.writeFile(snapshotPath(logPath), JSON.stringify(validated, null, 2));
 }
 
+// src/engine/toolResultOffload.ts
+init_cjs_shims();
+
+// src/engine/toolResultSummarizer.ts
+init_cjs_shims();
+var MAX_ITEM_PREVIEW_CHARS = 150;
+var MAX_TOP_LEVEL_KEYS = 8;
+var defaultToolResultSummarizer = (ctx) => {
+  return summarize(ctx);
+};
+function summarize(ctx) {
+  const { toolName, rawContent, rawBytes, ref, maxPreviewChars } = ctx;
+  const parsed = tryParseJSON(rawContent);
+  if (parsed.ok) {
+    if (Array.isArray(parsed.value)) {
+      return summarizeArray(toolName, parsed.value, ref, rawBytes);
+    }
+    if (parsed.value !== null && typeof parsed.value === "object") {
+      return summarizeObject(toolName, parsed.value, ref, rawBytes);
+    }
+  }
+  const preview = rawContent.slice(0, maxPreviewChars);
+  const truncated = rawContent.length > maxPreviewChars ? "\u2026" : "";
+  return `[${toolName}] ${formatBytes(rawBytes)} offloaded.
+` + (preview.length > 0 ? `Preview: ${preview}${truncated}
+` : "") + `Use FetchData with ref="${ref}" to read the full content.`;
+}
+function summarizeArray(toolName, arr, ref, bytes) {
+  const count = arr.length;
+  const firstHint = arr.length > 0 ? compactPreview(arr[0]) : "";
+  const hintLine = firstHint ? `First item preview: ${firstHint}
+` : "";
+  return `[${toolName}] Array of ${count} item${count === 1 ? "" : "s"} (${formatBytes(bytes)}).
+` + hintLine + `Use FetchData with ref="${ref}" to read the full array.`;
+}
+function summarizeObject(toolName, obj, ref, bytes) {
+  const keys = Object.keys(obj);
+  const shown = keys.slice(0, MAX_TOP_LEVEL_KEYS);
+  const overflow = keys.length > MAX_TOP_LEVEL_KEYS ? ` (+${keys.length - shown.length} more)` : "";
+  const parts = shown.map((k) => `${k}=${compactPreview(obj[k])}`).join(", ");
+  return `[${toolName}] Object (${formatBytes(bytes)}). Keys: ${parts}${overflow}
+Use FetchData with ref="${ref}" to read the full object.`;
+}
+function compactPreview(value) {
+  let str;
+  if (value === null) {
+    str = "null";
+  } else if (typeof value === "string") {
+    str = JSON.stringify(value);
+  } else if (Array.isArray(value)) {
+    str = `[${value.length} item${value.length === 1 ? "" : "s"}]`;
+  } else if (typeof value === "object") {
+    const keys = Object.keys(value);
+    str = `{${keys.slice(0, 3).join(", ")}${keys.length > 3 ? ", \u2026" : ""}}`;
+  } else {
+    str = String(value);
+  }
+  if (str.length > MAX_ITEM_PREVIEW_CHARS) {
+    return str.slice(0, MAX_ITEM_PREVIEW_CHARS) + "\u2026";
+  }
+  return str;
+}
+function tryParseJSON(text) {
+  const trimmed = text.replace(/^\uFEFF/, "").trim();
+  if (trimmed.length === 0) return { ok: false };
+  const first = trimmed[0];
+  if (first !== "{" && first !== "[" && first !== '"') return { ok: false };
+  try {
+    return { ok: true, value: JSON.parse(trimmed) };
+  } catch {
+    return { ok: false };
+  }
+}
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+
+// src/engine/toolResultOffload.ts
+async function maybeOffloadToolResult(input) {
+  const {
+    offloadConfig,
+    storage,
+    logPath,
+    toolUseId,
+    toolName,
+    toolInput,
+    rawContent,
+    rawIsError
+  } = input;
+  if (offloadConfig === void 0 || offloadConfig.enabled !== true) {
+    return rawContent;
+  }
+  if (rawIsError) {
+    return rawContent;
+  }
+  if (toolName === "FetchData") {
+    return rawContent;
+  }
+  const rawBytes = byteLength(rawContent);
+  if (rawBytes <= offloadConfig.thresholdBytes) {
+    return rawContent;
+  }
+  const path = `${logPath}/toolResults/${toolUseId}.json`;
+  await storage.writeFile(path, rawContent);
+  const summarizer = offloadConfig.summarizer ?? defaultToolResultSummarizer;
+  const summary = await summarizer({
+    toolName,
+    toolInput,
+    rawContent,
+    rawBytes,
+    ref: toolUseId,
+    maxPreviewChars: offloadConfig.maxPreviewChars
+  });
+  if (!summary.includes(toolUseId)) {
+    return `${summary}
+[offloaded \u2014 ref=${toolUseId}, use FetchData to read the full content]`;
+  }
+  return summary;
+}
+function byteLength(s) {
+  return new TextEncoder().encode(s).byteLength;
+}
+
 // src/hooks/dispatch.ts
 init_cjs_shims();
 async function dispatchHooks(hooks, event) {
@@ -3006,7 +3244,32 @@ async function agentLoop(options) {
           if (typeof missing === "string") {
             ctx.recordCapabilityMissing(missing);
           }
-          await ctx.addToolResult(id, truncateToolResult(result.content), result.isError === true);
+          const call = toolCallsToDispatch.find((c) => c.id === id);
+          let contentForTranscript;
+          if (options.toolResultOffload !== void 0 && options.storage !== void 0) {
+            try {
+              contentForTranscript = await maybeOffloadToolResult({
+                offloadConfig: options.toolResultOffload,
+                storage: options.storage,
+                logPath: options.offloadLogPath ?? transcript.path,
+                toolUseId: id,
+                toolName: call?.name ?? "unknown",
+                toolInput: call?.input,
+                rawContent: result.content,
+                rawIsError: result.isError === true
+              });
+            } catch (err) {
+              const msg = err instanceof Error ? err.message : String(err);
+              contentForTranscript = `[tool-result offload failed: ${msg}] ${result.content.slice(0, 500)}`;
+            }
+          } else {
+            contentForTranscript = result.content;
+          }
+          await ctx.addToolResult(
+            id,
+            truncateToolResult(contentForTranscript),
+            result.isError === true
+          );
         }
       } catch (err) {
         if (err instanceof SubagentPausedError) {
@@ -3140,11 +3403,11 @@ function toAnthropicTool(tool) {
     target: "jsonSchema7",
     $refStrategy: "none"
   });
-  const { $schema: _schema, ...inputSchema17 } = schema;
+  const { $schema: _schema, ...inputSchema18 } = schema;
   return {
     name: tool.name,
     description: tool.description,
-    input_schema: inputSchema17
+    input_schema: inputSchema18
   };
 }
 function partitionToolCalls(calls, registry) {
@@ -3854,6 +4117,19 @@ async function loadWriterState(storage, logPath) {
 // src/subagent/runner.ts
 async function runAgent(options) {
   const childLogPath = `${options.parentLogPath}/subagents/${options.agentId}`;
+  let restorePrevFetchData = null;
+  if (options.toolResultOffload !== void 0 && options.toolResultOffload.enabled) {
+    const { createFetchDataTool: createFetchDataTool2 } = await Promise.resolve().then(() => (init_fetchData(), fetchData_exports));
+    const existing = options.registry.get("FetchData");
+    options.registry.unregister("FetchData");
+    options.registry.register(
+      createFetchDataTool2({ storage: options.storage, logPath: childLogPath })
+    );
+    restorePrevFetchData = () => {
+      options.registry.unregister("FetchData");
+      if (existing !== void 0) options.registry.register(existing);
+    };
+  }
   const writer = new TranscriptWriter({
     storage: options.storage,
     logPath: childLogPath,
@@ -3894,7 +4170,15 @@ async function runAgent(options) {
       // Propagate parent's gate + storage into the child loop when set.
       // Without `storage`, a gate denial would fail the child instead of
       // pausing it, so both must travel together.
-      ...options.gateBeforeTool !== void 0 ? { gateBeforeTool: options.gateBeforeTool, storage: options.storage } : {}
+      ...options.gateBeforeTool !== void 0 ? { gateBeforeTool: options.gateBeforeTool, storage: options.storage } : {},
+      // Plan 021 — the child needs its own storage + offload config
+      // so its own large tool results get offloaded into
+      // `childLogPath/toolResults/...`, not the parent's folder.
+      ...options.toolResultOffload !== void 0 ? {
+        storage: options.storage,
+        toolResultOffload: options.toolResultOffload,
+        offloadLogPath: childLogPath
+      } : {}
     });
     if (result.status === "done") {
       await writer.setStatus("done");
@@ -3950,6 +4234,7 @@ async function runAgent(options) {
     } catch {
     }
     await writer.close();
+    restorePrevFetchData?.();
   }
 }
 
@@ -4022,10 +4307,11 @@ Directive: ${directive}`;
 }
 
 // src/tools/agent.ts
-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()
+init_contract();
+var inputSchema2 = import_zod7.z.object({
+  description: import_zod7.z.string().min(1),
+  subagent_type: import_zod7.z.string().optional(),
+  run_in_background: import_zod7.z.boolean().optional()
 });
 function createAgentTool(options) {
   if (options.agents.length === 0) {
@@ -4045,7 +4331,7 @@ If omitted, defaults to "${defaultAgent.name}".`;
   return defineTool({
     name: "Agent",
     description,
-    inputSchema,
+    inputSchema: inputSchema2,
     isConcurrencySafe: (input) => {
       const typed = input;
       const typeName = typed?.subagent_type ?? defaultAgent.name;
@@ -4086,7 +4372,8 @@ If omitted, defaults to "${defaultAgent.name}".`;
           idleFlushMs: options.idleFlushMs,
           // Fork: prepend parent messages + forked messages
           prependMessages: [...parentMsgs, ...forkedMsgs],
-          ...options.gateBeforeTool !== void 0 ? { gateBeforeTool: options.gateBeforeTool } : {}
+          ...options.gateBeforeTool !== void 0 ? { gateBeforeTool: options.gateBeforeTool } : {},
+          ...options.toolResultOffload !== void 0 ? { toolResultOffload: options.toolResultOffload } : {}
         });
         handlePausedResult(result2, spawn2.agentId, "fork");
         const t2 = result2;
@@ -4135,7 +4422,8 @@ If omitted, defaults to "${defaultAgent.name}".`;
         turnTimeoutMs: options.turnTimeoutMs,
         flushPolicy: options.flushPolicy,
         idleFlushMs: options.idleFlushMs,
-        ...options.gateBeforeTool !== void 0 ? { gateBeforeTool: options.gateBeforeTool } : {}
+        ...options.gateBeforeTool !== void 0 ? { gateBeforeTool: options.gateBeforeTool } : {},
+        ...options.toolResultOffload !== void 0 ? { toolResultOffload: options.toolResultOffload } : {}
       };
       const shouldRunAsync = run_in_background === true || options.coordinatorMode === true;
       if (shouldRunAsync) {
@@ -4230,7 +4518,8 @@ function handlePausedResult(result, agentId, subagentType) {
 
 // src/tools/bash.ts
 init_cjs_shims();
-var import_zod7 = require("zod");
+var import_zod8 = require("zod");
+init_contract();
 var _spawn = null;
 async function getSpawn() {
   if (_spawn === null) {
@@ -4242,15 +4531,15 @@ 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_zod7.z.object({
-  command: import_zod7.z.string().min(1),
-  cwd: import_zod7.z.string().min(1).optional()
+var inputSchema3 = import_zod8.z.object({
+  command: import_zod8.z.string().min(1),
+  cwd: import_zod8.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,
+    inputSchema: inputSchema3,
     requiresNode: true,
     execute: async ({ command, cwd }, ctx) => {
       if (BLOCKED_DEVICE_PATHS.test(command)) {
@@ -4331,16 +4620,17 @@ function createBashTool() {
 
 // src/tools/sendMessage.ts
 init_cjs_shims();
-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.")
+var import_zod9 = require("zod");
+init_contract();
+var inputSchema4 = import_zod9.z.object({
+  to: import_zod9.z.string().min(1).describe("Agent name (subagent_type) or agentId to send the message to."),
+  message: import_zod9.z.string().min(1).describe("Message content to deliver to the target agent.")
 });
 function createSendMessageTool(options) {
   return defineTool({
     name: "SendMessage",
     description: "Send a text message to a running subagent by name or agentId. The message is queued and delivered at the start of the agent's next turn. Use this to redirect, provide additional context, or coordinate with agents you spawned.",
-    inputSchema: inputSchema3,
+    inputSchema: inputSchema4,
     execute: async ({ to, message }) => {
       const { registry } = options;
       let agentId = registry.findByName(to);
@@ -4383,20 +4673,24 @@ function createSendMessageTool(options) {
   });
 }
 
+// src/engine/engine.ts
+init_contract();
+
 // src/tools/fileEdit.ts
 init_cjs_shims();
-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()
+var import_zod10 = require("zod");
+init_contract();
+var inputSchema5 = import_zod10.z.object({
+  path: import_zod10.z.string().min(1),
+  old_string: import_zod10.z.string().min(1),
+  new_string: import_zod10.z.string(),
+  replace_all: import_zod10.z.boolean().optional()
 });
 function createFileEditTool(storage) {
   return defineTool({
     name: "Edit",
     description: "Replace old_string with new_string in a file. By default old_string must be unique; set replace_all to replace every occurrence.",
-    inputSchema: inputSchema4,
+    inputSchema: inputSchema5,
     execute: async ({ path, old_string, new_string, replace_all }) => {
       if (old_string === new_string) {
         return {
@@ -4474,13 +4768,14 @@ function normalizeQuotes(s) {
 
 // src/tools/fileRead.ts
 init_cjs_shims();
-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(),
+var import_zod11 = require("zod");
+init_contract();
+var inputSchema6 = import_zod11.z.object({
+  path: import_zod11.z.string().min(1),
+  offset: import_zod11.z.number().int().positive().optional(),
+  limit: import_zod11.z.number().int().positive().optional(),
   /** PDF page range, e.g. "1-5", "3", "10-20". Max 20 pages per request. */
-  pages: import_zod10.z.string().optional()
+  pages: import_zod11.z.string().optional()
 });
 var IMAGE_EXTENSIONS = /* @__PURE__ */ new Set([".png", ".jpg", ".jpeg", ".gif", ".webp", ".bmp", ".svg"]);
 var PDF_EXTENSION = ".pdf";
@@ -4499,7 +4794,7 @@ function createFileReadTool(storageOrOptions) {
   return defineTool({
     name: "Read",
     description: "Read a file from the workspace. Text files return cat -n style line numbers. PDF files extract text per page (use pages param). Image files return base64 for visual analysis.",
-    inputSchema: inputSchema5,
+    inputSchema: inputSchema6,
     isConcurrencySafe: () => true,
     execute: async ({ path, offset, limit, pages }) => {
       const ext = extname(path);
@@ -4664,10 +4959,11 @@ Base64 data is included in the metadata for visual analysis.`,
 
 // src/tools/fileWrite.ts
 init_cjs_shims();
-var import_zod11 = require("zod");
-var inputSchema6 = import_zod11.z.object({
-  path: import_zod11.z.string().min(1),
-  content: import_zod11.z.string()
+var import_zod12 = require("zod");
+init_contract();
+var inputSchema7 = import_zod12.z.object({
+  path: import_zod12.z.string().min(1),
+  content: import_zod12.z.string()
 });
 function createFileWriteTool(storageOrOptions) {
   const opts = "readFile" in storageOrOptions ? { storage: storageOrOptions } : storageOrOptions;
@@ -4675,7 +4971,7 @@ function createFileWriteTool(storageOrOptions) {
   return defineTool({
     name: "Write",
     description: "Write a file to the workspace. Creates parents and overwrites existing files.",
-    inputSchema: inputSchema6,
+    inputSchema: inputSchema7,
     execute: async ({ path, content }) => {
       if (tracker !== void 0) {
         const exists = await storage.exists(path);
@@ -4706,7 +5002,8 @@ function createFileWriteTool(storageOrOptions) {
 // src/tools/glob.ts
 init_cjs_shims();
 var import_picomatch = __toESM(require("picomatch"), 1);
-var import_zod12 = require("zod");
+var import_zod13 = require("zod");
+init_contract();
 
 // src/tools/walkAdapter.ts
 init_cjs_shims();
@@ -4743,16 +5040,16 @@ async function* walkAdapter(adapter, startPath, options = {}) {
 }
 
 // src/tools/glob.ts
-var inputSchema7 = import_zod12.z.object({
-  pattern: import_zod12.z.string().min(1),
-  path: import_zod12.z.string().optional()
+var inputSchema8 = import_zod13.z.object({
+  pattern: import_zod13.z.string().min(1),
+  path: import_zod13.z.string().optional()
 });
 var MAX_RESULTS = 1e3;
 function createGlobTool(storage) {
   return defineTool({
     name: "Glob",
     description: "Find files by glob pattern. Supports *, **, ?, [abc], {a,b}. Returns paths sorted by mtime descending.",
-    inputSchema: inputSchema7,
+    inputSchema: inputSchema8,
     isConcurrencySafe: () => true,
     execute: async ({ pattern, path: searchPath }) => {
       const startPath = searchPath ?? "";
@@ -4798,22 +5095,23 @@ function createGlobTool(storage) {
 // src/tools/grep.ts
 init_cjs_shims();
 var import_picomatch2 = __toESM(require("picomatch"), 1);
-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 import_zod14 = require("zod");
+init_contract();
+var inputSchema9 = import_zod14.z.object({
+  pattern: import_zod14.z.string().min(1),
+  path: import_zod14.z.string().optional(),
+  glob: import_zod14.z.string().optional(),
+  type: import_zod14.z.string().optional(),
+  output_mode: import_zod14.z.enum(["content", "files_with_matches", "count"]).optional(),
+  "-i": import_zod14.z.boolean().optional(),
+  "-n": import_zod14.z.boolean().optional(),
+  "-A": import_zod14.z.number().int().nonnegative().optional(),
+  "-B": import_zod14.z.number().int().nonnegative().optional(),
+  "-C": import_zod14.z.number().int().nonnegative().optional(),
+  context: import_zod14.z.number().int().nonnegative().optional(),
+  multiline: import_zod14.z.boolean().optional(),
+  head_limit: import_zod14.z.number().int().nonnegative().optional(),
+  offset: import_zod14.z.number().int().nonnegative().optional()
 });
 var MAX_FILES_SCANNED = 5e3;
 var MAX_MATCHES_PER_FILE = 100;
@@ -4859,7 +5157,7 @@ function createGrepTool(storage) {
   return defineTool({
     name: "Grep",
     description: "Search for a regex pattern across files. Supports ripgrep when available (context lines, multiline, type filters, pagination). Falls back to JS RegExp scanner.",
-    inputSchema: inputSchema8,
+    inputSchema: inputSchema9,
     isConcurrencySafe: () => true,
     execute: async (input, ctx) => {
       if (rgAvailable && input.path !== void 0) {
@@ -5037,10 +5335,11 @@ function formatJsResults(results, mode, limit) {
 
 // src/tools/webFetch.ts
 init_cjs_shims();
-var import_zod14 = require("zod");
-var inputSchema9 = import_zod14.z.object({
-  url: import_zod14.z.string().url(),
-  prompt: import_zod14.z.string().optional()
+var import_zod15 = require("zod");
+init_contract();
+var inputSchema10 = import_zod15.z.object({
+  url: import_zod15.z.string().url(),
+  prompt: import_zod15.z.string().optional()
 });
 var MAX_OUTPUT_BYTES2 = 256 * 1024;
 function createWebFetchTool(options = {}) {
@@ -5048,7 +5347,7 @@ function createWebFetchTool(options = {}) {
   return defineTool({
     name: "WebFetch",
     description: "Fetch a URL and return its content as plain text. HTML is stripped to its readable text.",
-    inputSchema: inputSchema9,
+    inputSchema: inputSchema10,
     isConcurrencySafe: () => true,
     execute: async ({ url }, ctx) => {
       let response;
@@ -5169,16 +5468,17 @@ function normalizePath(p) {
 
 // src/tools/webSearch.ts
 init_cjs_shims();
-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()
+var import_zod16 = require("zod");
+init_contract();
+var inputSchema11 = import_zod16.z.object({
+  query: import_zod16.z.string().min(2),
+  max_results: import_zod16.z.number().int().positive().optional()
 });
 function createWebSearchTool() {
   return defineTool({
     name: "WebSearch",
     description: "Search the web for information. Returns search result snippets. Use when you need current information not available in local files.",
-    inputSchema: inputSchema10,
+    inputSchema: inputSchema11,
     isConcurrencySafe: () => true,
     execute: async ({ query }) => {
       const encoded = encodeURIComponent(query);
@@ -5229,16 +5529,17 @@ function htmlToText2(html) {
 
 // src/tools/sleep.ts
 init_cjs_shims();
-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()
+var import_zod17 = require("zod");
+init_contract();
+var inputSchema12 = import_zod17.z.object({
+  durationMs: import_zod17.z.number().int().nonnegative().max(3e5),
+  reason: import_zod17.z.string().optional()
 });
 function createSleepTool() {
   return defineTool({
     name: "Sleep",
     description: "Pause execution for the given number of milliseconds (max 300000 = 5 minutes). Use when you need to wait for an external process or rate limit.",
-    inputSchema: inputSchema11,
+    inputSchema: inputSchema12,
     isConcurrencySafe: () => true,
     execute: async ({ durationMs, reason }, ctx) => {
       if (durationMs === 0) {
@@ -5272,16 +5573,17 @@ function createSleepTool() {
 
 // src/tools/toolSearch.ts
 init_cjs_shims();
-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()
+var import_zod18 = require("zod");
+init_contract();
+var inputSchema13 = import_zod18.z.object({
+  query: import_zod18.z.string().min(1),
+  max_results: import_zod18.z.number().int().positive().optional()
 });
 function createToolSearchTool(registry) {
   return defineTool({
     name: "ToolSearch",
     description: "Search the available tools by keyword. Returns matching tool names and descriptions. Use when you want to discover what tools are available for a task.",
-    inputSchema: inputSchema12,
+    inputSchema: inputSchema13,
     isConcurrencySafe: () => true,
     execute: async ({ query, max_results }) => {
       const limit = max_results ?? 10;
@@ -5318,17 +5620,18 @@ ${lines.join("\n")}`,
 
 // src/tools/memorize.ts
 init_cjs_shims();
-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()
+var import_zod19 = require("zod");
+init_contract();
+var inputSchema14 = import_zod19.z.object({
+  text: import_zod19.z.string().min(1),
+  kind: import_zod19.z.enum(["rule", "lesson"]).default("lesson"),
+  topic: import_zod19.z.string().optional()
 });
 function createMemorizeTool(memory) {
   return defineTool({
     name: "Memorize",
     description: 'Save a fact, rule, or lesson to persistent memory. Memories survive across runs and are included in the system prompt of future runs. Use "rule" for behavioral constraints (always/never do X). Use "lesson" for learnings and observations.',
-    inputSchema: inputSchema13,
+    inputSchema: inputSchema14,
     execute: async ({ text, kind, topic }) => {
       if (memory.mode === "off" || memory.mode === "read-only") {
         return {
@@ -5354,17 +5657,18 @@ function createMemorizeTool(memory) {
 
 // src/tools/recall.ts
 init_cjs_shims();
-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()
+var import_zod20 = require("zod");
+init_contract();
+var inputSchema15 = import_zod20.z.object({
+  query: import_zod20.z.string().min(1),
+  scope: import_zod20.z.enum(["identity", "rules", "lessons", "all"]).default("all"),
+  topic: import_zod20.z.string().optional()
 });
 function createRecallTool(memory) {
   return defineTool({
     name: "Recall",
     description: "Search persistent memory for previously saved facts, rules, and lessons. Use when you need to recall information from prior runs or check what rules/lessons are stored.",
-    inputSchema: inputSchema14,
+    inputSchema: inputSchema15,
     isConcurrencySafe: () => true,
     execute: async ({ query, scope, topic }) => {
       if (memory.mode === "off") {
@@ -5413,19 +5717,20 @@ ${content}`,
 
 // src/tools/notebookEdit.ts
 init_cjs_shims();
-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()
+var import_zod21 = require("zod");
+init_contract();
+var inputSchema16 = import_zod21.z.object({
+  notebook_path: import_zod21.z.string().min(1),
+  edit_mode: import_zod21.z.enum(["replace", "insert", "delete"]).default("replace"),
+  cell_index: import_zod21.z.number().int().nonnegative(),
+  new_source: import_zod21.z.string().optional(),
+  cell_type: import_zod21.z.enum(["code", "markdown"]).optional()
 });
 function createNotebookEditTool(storage) {
   return defineTool({
     name: "NotebookEdit",
     description: "Edit a Jupyter notebook (.ipynb) by inserting, replacing, or deleting cells. Specify the cell_index (0-based) and the operation.",
-    inputSchema: inputSchema15,
+    inputSchema: inputSchema16,
     execute: async ({
       notebook_path,
       edit_mode,
@@ -5574,12 +5879,13 @@ var TaskStore = class {
 
 // src/tools/tasks/tools.ts
 init_cjs_shims();
-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()
+var import_zod22 = require("zod");
+init_contract();
+var TaskStatusEnum = import_zod22.z.enum(["pending", "in_progress", "completed", "deleted"]);
+var createSchema = import_zod22.z.object({
+  subject: import_zod22.z.string().min(1),
+  description: import_zod22.z.string().default(""),
+  metadata: import_zod22.z.record(import_zod22.z.unknown()).optional()
 });
 function createTaskCreateTool(store) {
   return defineTool({
@@ -5595,8 +5901,8 @@ function createTaskCreateTool(store) {
     }
   });
 }
-var getSchema = import_zod21.z.object({
-  taskId: import_zod21.z.string().min(1)
+var getSchema = import_zod22.z.object({
+  taskId: import_zod22.z.string().min(1)
 });
 function createTaskGetTool(store) {
   return defineTool({
@@ -5617,7 +5923,7 @@ ${task.description}`,
     }
   });
 }
-var listSchema = import_zod21.z.object({
+var listSchema = import_zod22.z.object({
   status: TaskStatusEnum.optional()
 });
 function createTaskListTool(store) {
@@ -5643,12 +5949,12 @@ ${lines.join("\n")}`,
     }
   });
 }
-var updateSchema = import_zod21.z.object({
-  taskId: import_zod21.z.string().min(1),
-  subject: import_zod21.z.string().min(1).optional(),
+var updateSchema = import_zod22.z.object({
+  taskId: import_zod22.z.string().min(1),
+  subject: import_zod22.z.string().min(1).optional(),
   status: TaskStatusEnum.optional(),
-  description: import_zod21.z.string().optional(),
-  metadata: import_zod21.z.record(import_zod21.z.unknown()).optional()
+  description: import_zod22.z.string().optional(),
+  metadata: import_zod22.z.record(import_zod22.z.unknown()).optional()
 });
 function createTaskUpdateTool(store) {
   return defineTool({
@@ -6385,8 +6691,8 @@ function normalizeToolList(response, serverName) {
     const name = typeof obj.name === "string" ? obj.name : null;
     if (name === null) continue;
     const description = typeof obj.description === "string" ? obj.description : "";
-    const inputSchema17 = obj.inputSchema !== null && typeof obj.inputSchema === "object" && !Array.isArray(obj.inputSchema) ? obj.inputSchema : { type: "object", properties: {} };
-    out.push({ name, description, inputSchema: inputSchema17 });
+    const inputSchema18 = obj.inputSchema !== null && typeof obj.inputSchema === "object" && !Array.isArray(obj.inputSchema) ? obj.inputSchema : { type: "object", properties: {} };
+    out.push({ name, description, inputSchema: inputSchema18 });
   }
   return out;
 }
@@ -6495,7 +6801,8 @@ function wrapFetchWithHeadersProvider(baseFetch, headersProvider, staticHeaders)
 
 // src/mcp/toolAdapter.ts
 init_cjs_shims();
-var import_zod22 = require("zod");
+var import_zod23 = require("zod");
+init_contract();
 function mcpToolName(serverName, toolName) {
   return `mcp__${serverName}__${toolName}`;
 }
@@ -6504,7 +6811,7 @@ function adaptMcpTool(client, serverName, def) {
   return defineTool({
     name: registeredName,
     description: def.description.length > 0 ? def.description : `MCP tool ${serverName}/${def.name}`,
-    inputSchema: import_zod22.z.unknown(),
+    inputSchema: import_zod23.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).
@@ -7165,7 +7472,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";
@@ -7536,18 +7843,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
@@ -7573,7 +7869,7 @@ function buildSchemaPrompt(schema) {
   }
   return lines.join("\n");
 }
-function tryParseJSON(text) {
+function tryParseJSON2(text) {
   const trimmed = text.trim();
   try {
     return { ok: true, value: JSON.parse(trimmed) };
@@ -7613,17 +7909,18 @@ ${issues.join("\n")}` };
 
 // src/skills/skillPage.ts
 init_cjs_shims();
-var import_zod23 = require("zod");
+var import_zod24 = require("zod");
+init_contract();
 var SAFE_NAME3 = /^[a-zA-Z0-9_-]+$/;
-var inputSchema16 = import_zod23.z.object({
-  skill: import_zod23.z.string().min(1),
-  page: import_zod23.z.string().min(1).optional()
+var inputSchema17 = import_zod24.z.object({
+  skill: import_zod24.z.string().min(1),
+  page: import_zod24.z.string().min(1).optional()
 });
 function createSkillPageTool(options) {
   return defineTool({
     name: "SkillPage",
     description: "Load a skill. Pass `skill` alone to read the main SKILL.md; pass both `skill` and `page` to read a supplemental page. Skill names appear in the system prompt skill index.",
-    inputSchema: inputSchema16,
+    inputSchema: inputSchema17,
     execute: async ({ skill, page }) => {
       if (!SAFE_NAME3.test(skill)) {
         return {
@@ -7675,7 +7972,8 @@ The skill "${skill}" has no pages.`;
 
 // src/tools/apiCall.ts
 init_cjs_shims();
-var import_zod24 = require("zod");
+var import_zod25 = require("zod");
+init_contract();
 var ALL_METHODS = ["GET", "POST", "PUT", "PATCH", "DELETE"];
 var DEFAULT_MAX_BODY_BYTES = 256 * 1024;
 var DEFAULT_MAX_RESPONSE_BYTES = 100 * 1024;
@@ -7700,19 +7998,19 @@ function createApiCallTool(opts) {
   }
   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 inputSchema18 = import_zod25.z.object({
+    service: import_zod25.z.enum(serviceNames),
+    method: import_zod25.z.enum(["GET", "POST", "PUT", "PATCH", "DELETE"]),
+    path: import_zod25.z.string().regex(/^\//, "path must start with /"),
+    query: import_zod25.z.record(import_zod25.z.string(), import_zod25.z.string()).optional(),
+    body: import_zod25.z.unknown().optional(),
+    headers: import_zod25.z.record(import_zod25.z.string(), import_zod25.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,
+    inputSchema: inputSchema18,
     execute: async (input) => {
       const svc = services.get(input.service);
       if (!svc) {
@@ -7731,7 +8029,7 @@ function createApiCallTool(opts) {
       if (input.body !== void 0) {
         bodyText = JSON.stringify(input.body);
         const cap = svc.maxBodyBytes ?? DEFAULT_MAX_BODY_BYTES;
-        if (byteLength(bodyText) > cap) {
+        if (byteLength2(bodyText) > cap) {
           return errResult(`ERR_API_BODY_TOO_LARGE: exceeds ${cap} bytes`);
         }
       }
@@ -7805,7 +8103,7 @@ function pathAllowed(path, allowed) {
   }
   return false;
 }
-function byteLength(s) {
+function byteLength2(s) {
   return new TextEncoder().encode(s).byteLength;
 }
 function buildUrl(baseUrl, path, query) {
@@ -7870,6 +8168,9 @@ async function invokeHook(hook, event) {
   }
 }
 
+// src/engine/engine.ts
+init_fetchData();
+
 // src/skills/storageSkillSource.ts
 init_cjs_shims();
 var SAFE_NAME4 = /^[a-zA-Z0-9_-]+$/;
@@ -7881,14 +8182,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
@@ -7896,8 +8191,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;
@@ -7906,9 +8200,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`;
@@ -7921,9 +8213,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 {
@@ -8506,7 +8796,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,
@@ -8514,7 +8803,6 @@ async function createLocalStorage(config) {
     ENGINE_DATA_FOLDER
   );
   return {
-    global: new LocalStorageAdapter(globalRoot),
     workspace: new LocalStorageAdapter(workspaceRoot)
   };
 }
@@ -8523,10 +8811,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)
   };
 }
@@ -8535,10 +8821,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)
   };
 }
@@ -9044,6 +9328,7 @@ var Engine = class {
     const skillSource = this.resolveSkillSource(options.skills, storage);
     const skillList = skillSource !== void 0 ? await skillSource.list() : void 0;
     const apiConfig = this.resolveApiConfig(options.api);
+    const offloadConfig = this.resolveOffloadConfig(options.compaction?.toolResultOffload);
     let systemPrompt = await buildSystemPrompt({
       ...coordinatorBase !== void 0 ? { base: coordinatorBase } : {},
       memory,
@@ -9076,6 +9361,7 @@ var Engine = class {
       ...this.config.hooks.propagateGateToSubagents === true && gate !== void 0 ? { subagentGate: gate } : {},
       ...skillSource !== void 0 ? { skillSource } : {},
       ...apiConfig !== void 0 ? { apiConfig } : {},
+      ...offloadConfig !== void 0 ? { toolResultOffload: offloadConfig } : {},
       ...this.internals.fetch !== void 0 ? { fetch: this.internals.fetch } : {}
     });
     const writer = new TranscriptWriter({
@@ -9131,7 +9417,8 @@ var Engine = class {
         ...options.tokenBudget !== void 0 ? { tokenBudget: options.tokenBudget } : {},
         ...runTimeout.signal !== void 0 ? { runSignal: runTimeout.signal, runTimeoutMs: this.config.execution.runTimeoutMs } : {},
         ...gate !== void 0 ? { gateBeforeTool: gate } : {},
-        ..._internal?.handoffToRunner === true ? { handoffToRunner: true } : {}
+        ..._internal?.handoffToRunner === true ? { handoffToRunner: true } : {},
+        ...offloadConfig !== void 0 ? { toolResultOffload: offloadConfig } : {}
       });
       const result = await this.finalizeResult(loopResult, writer, logPath, {
         ...options.outputFormat !== void 0 ? { outputFormat: options.outputFormat } : {},
@@ -9186,6 +9473,7 @@ var Engine = class {
     const skillSource = this.resolveSkillSource(options.skills, storage);
     const skillList = skillSource !== void 0 ? await skillSource.list() : void 0;
     const apiConfig = this.resolveApiConfig(options.api);
+    const offloadConfig = this.resolveOffloadConfig(options.compaction?.toolResultOffload);
     let systemPrompt = await buildSystemPrompt({
       ...coordinatorBase !== void 0 ? { base: coordinatorBase } : {},
       memory,
@@ -9218,6 +9506,7 @@ var Engine = class {
       ...this.config.hooks.propagateGateToSubagents === true && gate !== void 0 ? { subagentGate: gate } : {},
       ...skillSource !== void 0 ? { skillSource } : {},
       ...apiConfig !== void 0 ? { apiConfig } : {},
+      ...offloadConfig !== void 0 ? { toolResultOffload: offloadConfig } : {},
       ...this.internals.fetch !== void 0 ? { fetch: this.internals.fetch } : {}
     });
     const priorState = await loadWriterState(storage.workspace, logPath);
@@ -9308,7 +9597,8 @@ ${inputJson}
         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 } : {},
-        ..._internal?.handoffToRunner === true ? { handoffToRunner: true } : {}
+        ..._internal?.handoffToRunner === true ? { handoffToRunner: true } : {},
+        ...offloadConfig !== void 0 ? { toolResultOffload: offloadConfig } : {}
       });
       const result = await this.finalizeResult(loopResult, writer, logPath, {
         ...options.outputFormat !== void 0 ? { outputFormat: options.outputFormat } : {},
@@ -9854,6 +10144,11 @@ ${inputJson}
         names.add("ApiCall");
       }
     }
+    if (this.config.compaction.toolResultOffload?.enabled === true) {
+      if (!disabled.has("FetchData") && (wantAll || enabled.has("FetchData"))) {
+        names.add("FetchData");
+      }
+    }
     for (const tool of this.config.tools.custom) {
       names.add(tool.name);
     }
@@ -9955,7 +10250,7 @@ ${inputJson}
       await writer.setStatus("done");
       let data;
       if (jsonOptions?.outputFormat === "json") {
-        const parsed = tryParseJSON(loopResult.output);
+        const parsed = tryParseJSON2(loopResult.output);
         if (parsed.ok) {
           if (jsonOptions.outputSchema) {
             const validated = validateOutput(parsed.value, jsonOptions.outputSchema);
@@ -10020,6 +10315,31 @@ ${inputJson}
    * tool isn't registered at all. Env + resolveAuth + hooks flow
    * through untouched — they never hit the Zod schema.
    */
+  /**
+   * Plan 021 — resolve the effective tool-result offload config.
+   *
+   * Precedence (each field independently):
+   *   RunOptions.compaction.toolResultOffload.X >
+   *     config.compaction.toolResultOffload.X
+   *
+   * When neither side enables offload, returns undefined and no
+   * `FetchData` tool is registered.
+   */
+  resolveOffloadConfig(override) {
+    const base = this.config.compaction.toolResultOffload;
+    if (override === void 0 && base === void 0) return void 0;
+    const enabled = override?.enabled ?? base?.enabled ?? false;
+    if (!enabled) return void 0;
+    const thresholdBytes = override?.thresholdBytes ?? base?.thresholdBytes ?? 2048;
+    const maxPreviewChars = override?.maxPreviewChars ?? base?.maxPreviewChars ?? 500;
+    const summarizer = override?.summarizer ?? base?.summarizer;
+    return {
+      enabled: true,
+      thresholdBytes,
+      maxPreviewChars,
+      ...summarizer !== void 0 ? { summarizer } : {}
+    };
+  }
   resolveApiConfig(override) {
     const base = this.config.api;
     if (override === void 0 && base === void 0) return void 0;
@@ -10194,6 +10514,15 @@ function buildToolRegistry(options) {
       childRegistry.register(apiTool);
     }
   }
+  if (options.toolResultOffload?.enabled === true) {
+    if (!disabled.has("FetchData") && (wantAll || enabled.has("FetchData"))) {
+      const fetchDataTool = createFetchDataTool({
+        storage: storage.workspace,
+        logPath: options.parentLogPath
+      });
+      registry.register(fetchDataTool);
+    }
+  }
   const agentTool = createAgentTool({
     storage: storage.workspace,
     client,
@@ -10209,7 +10538,8 @@ function buildToolRegistry(options) {
     idleFlushMs: config.transcript.idleFlushMs,
     agents,
     coordinatorMode: isCoordinatorMode(config),
-    ...subagentGate !== void 0 ? { gateBeforeTool: subagentGate } : {}
+    ...subagentGate !== void 0 ? { gateBeforeTool: subagentGate } : {},
+    ...options.toolResultOffload !== void 0 ? { toolResultOffload: options.toolResultOffload } : {}
   });
   if (!disabled.has("Agent") && (wantAll || enabled.has("Agent"))) {
     registry.register(agentTool);
@@ -10238,6 +10568,8 @@ function buildToolRegistry(options) {
 }
 
 // src/index.ts
+init_contract();
+init_fetchData();
 init_orchestrate();
 init_planParser();
 init_retry();
@@ -10318,12 +10650,14 @@ function resolveApiKey(config) {
   canSpawnProcesses,
   capabilityStub,
   createApiCallTool,
+  createFetchDataTool,
   createLogger,
   createModelAdapter,
   createSendMessageTool,
   createSkillPageTool,
   createSmartMemory,
   defaultSamplingHandler,
+  defaultToolResultSummarizer,
   defineTool,
   detectRuntime,
   getCoordinatorBasePrompt,