norn-cli 3.3.0 → 4.0.0

package/dist/cli.js

@@ -101513,10 +101513,10 @@ var init_values = __esm({
 });
 
 // node_modules/@anthropic-ai/sdk/internal/utils/sleep.mjs
-var sleep2;
+var sleep;
 var init_sleep = __esm({
   "node_modules/@anthropic-ai/sdk/internal/utils/sleep.mjs"() {
-    sleep2 = (ms, signal) => new Promise((resolve28) => {
+    sleep = (ms, signal) => new Promise((resolve28) => {
       if (signal?.aborted)
         return resolve28();
       const onAbort = () => {
@@ -106070,14 +106070,14 @@ var init_poller = __esm({
               const wait = applyJitter(backoff2(attempt));
               log.warn("poll failed, backing off", { error: String(e2), backoff_ms: wait });
               attempt++;
-              await sleep2(wait, __classPrivateFieldGet2(this, _WorkPoller_controller, "f").signal);
+              await sleep(wait, __classPrivateFieldGet2(this, _WorkPoller_controller, "f").signal);
               continue;
             }
             attempt = 0;
             if (work == null) {
               if (__classPrivateFieldGet2(this, _WorkPoller_drain, "f"))
                 return;
-              await sleep2(jitter(1e3, 3e3), __classPrivateFieldGet2(this, _WorkPoller_controller, "f").signal);
+              await sleep(jitter(1e3, 3e3), __classPrivateFieldGet2(this, _WorkPoller_controller, "f").signal);
               continue;
             }
             log.info("claimed work", {
@@ -106470,7 +106470,7 @@ var init_SessionToolRunner = __esm({
           });
         }
         ctrl.signal.throwIfAborted();
-        await sleep2(backoff3, ctrl.signal);
+        await sleep(backoff3, ctrl.signal);
         backoff3 = Math.min(backoff3 * 2, STREAM_BACKOFF_CAP_MS);
       }
     }, _SessionToolRunner_reconcile = /**
@@ -106710,7 +106710,7 @@ var init_SessionToolRunner = __esm({
           if (isFatal4xx(e2))
             break;
           if (i2 < SEND_RETRIES - 1)
-            await sleep2((i2 + 1) * 1e3, ctrl.signal);
+            await sleep((i2 + 1) * 1e3, ctrl.signal);
         }
       }
       __classPrivateFieldGet2(this, _SessionToolRunner_logger, "f").error("failed to send tool result", {
@@ -106722,7 +106722,7 @@ var init_SessionToolRunner = __esm({
     async function _SessionToolRunner_drain2() {
       if (__classPrivateFieldGet2(this, _SessionToolRunner_inFlightCount, "f") === 0)
         return;
-      await Promise.race([new Promise((r2) => __classPrivateFieldSet2(this, _SessionToolRunner_onIdle, r2, "f")), sleep2(DRAIN_TIMEOUT_MS)]);
+      await Promise.race([new Promise((r2) => __classPrivateFieldSet2(this, _SessionToolRunner_onIdle, r2, "f")), sleep(DRAIN_TIMEOUT_MS)]);
       __classPrivateFieldSet2(this, _SessionToolRunner_onIdle, null, "f");
       if (__classPrivateFieldGet2(this, _SessionToolRunner_inFlightCount, "f") > 0) {
         __classPrivateFieldGet2(this, _SessionToolRunner_logger, "f").warn("drain timeout exceeded");
@@ -107698,7 +107698,7 @@ async function heartbeatLoop(client, work, ctrl, logger, requestOptions) {
   };
   await beat();
   while (!ctrl.signal.aborted) {
-    await sleep2(intervalMs, ctrl.signal);
+    await sleep(intervalMs, ctrl.signal);
     ctrl.signal.throwIfAborted();
     await beat();
   }
@@ -113627,7 +113627,7 @@ var init_client = __esm({
           const maxRetries = options.maxRetries ?? this.maxRetries;
           timeoutMillis = this.calculateDefaultRetryTimeoutMillis(retriesRemaining, maxRetries);
         }
-        await sleep2(timeoutMillis);
+        await sleep(timeoutMillis);
         return this.makeRequest(options, retriesRemaining - 1, requestLogID);
       }
       calculateDefaultRetryTimeoutMillis(retriesRemaining, maxRetries) {
@@ -149218,7 +149218,7 @@ async function uploadBlobInternal(file2, uploadUrl, apiClient, httpOptions) {
         break;
       }
       retryCount++;
-      await sleep3(currentDelayMs);
+      await sleep2(currentDelayMs);
       currentDelayMs = currentDelayMs * DELAY_MULTIPLIER;
     }
     offset += chunkSize;
@@ -149235,7 +149235,7 @@ async function getBlobStat(file2) {
   const fileStat = { size: file2.size, type: file2.type };
   return fileStat;
 }
-function sleep3(ms) {
+function sleep2(ms) {
   return new Promise((resolvePromise) => setTimeout(resolvePromise, ms));
 }
 function resolveCloudFlag(options) {
@@ -156759,7 +156759,7 @@ var init_node2 = __esm({
                 break;
               }
               retryCount++;
-              await sleep3(currentDelayMs);
+              await sleep2(currentDelayMs);
               currentDelayMs = currentDelayMs * DELAY_MULTIPLIER;
             }
             offset += bytesRead;
@@ -158648,11 +158648,20 @@ function readAgentPromptBlock(lines, openingLineNumber, opening, stripTrailingCo
   };
 }
 
+// src/agents/agentTypes.ts
+var AGENT_REASONING_EFFORTS = ["none", "low", "medium", "high", "xhigh", "max"];
+var DEFAULT_AGENT_MAX_TOKENS = 16e3;
+var DEFAULT_LOCAL_AGENT_MAX_TOKENS = 4096;
+var DEFAULT_AGENT_MAX_DEPTH = 5;
+var DEFAULT_AGENT_MAX_INVOCATIONS = 25;
+var DEFAULT_AGENT_MAX_TURNS = 100;
+var DEFAULT_AGENT_CONTRACT_RETRIES = 2;
+
 // src/agents/nornAgentParser.ts
 var IDENTIFIER = "[a-zA-Z_][a-zA-Z0-9_]*";
-var MODEL_PROVIDERS = ["anthropic", "google", "local", "openai"];
+var MODEL_PROVIDERS = ["anthropic", "google", "local", "openai", "openai_compatible"];
 var MODEL_PROVIDER = new RegExp(`^(${MODEL_PROVIDERS.join("|")})$`, "i");
-var MODEL_DIRECTIVES = ["provider", "name", "apiKey", "baseUrl"];
+var MODEL_DIRECTIVES = ["provider", "name", "reasoning", "apiKey", "baseUrl"];
 var MCP_DIRECTIVES = {
   transport: { transport: "both", repeatable: false },
   command: { transport: "stdio", repeatable: false },
@@ -158691,6 +158700,7 @@ function splitHeaderDirective(value) {
 }
 var LIMIT_DIRECTIVES = {
   max_tokens: "maxTokens",
+  max_input_tokens: "maxInputTokens",
   max_depth: "maxDepth",
   max_invocations: "maxInvocations",
   max_turns: "maxTurns",
@@ -159125,6 +159135,23 @@ end mcp
       ));
       model.invalid = true;
     }
+    const reasoning = model.values.reasoning;
+    if (reasoning && !reasoning.value.includes("{{") && !AGENT_REASONING_EFFORTS.some((effort) => effort === reasoning.value.toLowerCase())) {
+      errors.push(parseError(
+        reasoning.lineNumber,
+        `Unknown reasoning effort '${reasoning.value}' in model '${model.alias}'. Expected one of: ${AGENT_REASONING_EFFORTS.join(", ")}.`,
+        "agent-model-reasoning-invalid"
+      ));
+      model.invalid = true;
+    }
+    if (reasoning && provider && !provider.value.includes("{{") && provider.value.toLowerCase() !== "openai") {
+      errors.push(parseError(
+        reasoning.lineNumber,
+        `Model '${model.alias}' can declare reasoning only with provider openai. Provider '${provider.value}' does not support this directive yet.`,
+        "agent-model-reasoning-provider"
+      ));
+      model.invalid = true;
+    }
     if (model.invalid || !provider || !name) {
       return;
     }
@@ -159133,6 +159160,7 @@ end mcp
       providerTemplate: provider.value,
       nameTemplate: name.value,
       targetTemplate: `${provider.value}/${name.value}`,
+      ...reasoning ? { reasoningTemplate: reasoning.value } : {},
       ...model.values.apiKey ? { apiKeyTemplate: model.values.apiKey.value } : {},
       ...model.values.baseUrl ? { baseUrlTemplate: model.values.baseUrl.value } : {},
       lineNumber: model.lineNumber,
@@ -159172,6 +159200,13 @@ end mcp
             "agent-model-alias-unknown"
           ));
           pending.invalid = true;
+        } else if (model.alias !== pending.modelAlias.value) {
+          errors.push(parseError(
+            pending.modelAlias.lineNumber,
+            `Model alias '${pending.modelAlias.value}' in agent '${pending.name}' does not match the declared alias '${model.alias}'. Model aliases are case-sensitive.`,
+            "agent-model-alias-case-mismatch"
+          ));
+          pending.invalid = true;
         }
       }
     }
@@ -159207,6 +159242,7 @@ end mcp
         accepts: pending.accepts,
         returns: pending.returns,
         maxTokens: pending.maxTokens?.value,
+        maxInputTokens: pending.maxInputTokens?.value,
         maxDepth: pending.maxDepth?.value,
         maxInvocations: pending.maxInvocations?.value,
         maxTurns: pending.maxTurns?.value,
@@ -159611,29 +159647,38 @@ end model`,
     }
     const knowledgeGrantMatch = trimmed.match(/^knowledge(?:\s+(.*))?$/i);
     if (knowledgeGrantMatch) {
-      const alias = (knowledgeGrantMatch[1] ?? "").trim();
-      if (!new RegExp(`^${IDENTIFIER}$`).test(alias)) {
+      const rawValue = (knowledgeGrantMatch[1] ?? "").trim();
+      const aliases = rawValue ? rawValue.split(",").map((part) => part.trim()) : [];
+      if (aliases.length === 0 || aliases.some((alias) => !new RegExp(`^${IDENTIFIER}$`).test(alias))) {
         errors.push(parseError(
           index,
-          `Invalid knowledge grant '${trimmed}' in agent '${pending.name}'. Expected: knowledge <Alias>.`,
+          `Invalid knowledge grant '${trimmed}' in agent '${pending.name}'. Expected: knowledge <Alias>[, <Alias>\u2026].`,
           "agent-knowledge-grant-invalid"
         ));
         pending.invalid = true;
-      } else if (pending.knowledge.some((grant) => grant.alias.toLowerCase() === alias.toLowerCase())) {
-        errors.push(parseError(
-          index,
-          `Agent '${pending.name}' grants knowledge '${alias}' more than once.`,
-          "agent-knowledge-grant-duplicate"
-        ));
-        pending.invalid = true;
-      } else if (!knowledgeBases.has(alias.toLowerCase())) {
-        errors.push(parseError(
-          index,
-          `Unknown knowledge alias '${alias}' in agent '${pending.name}'.`,
-          "agent-knowledge-alias-unknown"
-        ));
-        pending.invalid = true;
-      } else {
+        continue;
+      }
+      const granted = new Set(pending.knowledge.map((grant) => grant.alias.toLowerCase()));
+      for (const alias of aliases) {
+        if (granted.has(alias.toLowerCase())) {
+          errors.push(parseError(
+            index,
+            `Agent '${pending.name}' grants knowledge '${alias}' more than once.`,
+            "agent-knowledge-grant-duplicate"
+          ));
+          pending.invalid = true;
+          continue;
+        }
+        if (!knowledgeBases.has(alias.toLowerCase())) {
+          errors.push(parseError(
+            index,
+            `Unknown knowledge alias '${alias}' in agent '${pending.name}'.`,
+            "agent-knowledge-alias-unknown"
+          ));
+          pending.invalid = true;
+          continue;
+        }
+        granted.add(alias.toLowerCase());
         pending.knowledge.push({ alias, lineNumber: index });
       }
       continue;
@@ -159948,6 +159993,7 @@ function isNonNegativeInteger(value) {
 var AGENT_LIMIT_CONFIG_KEYS = /* @__PURE__ */ new Set([
   "_comment",
   "max_tokens",
+  "max_input_tokens",
   "max_depth",
   "max_invocations",
   "max_turns",
@@ -159957,7 +160003,7 @@ function hasOnlyKeys(value, allowedKeys) {
   return Object.keys(value).every((key) => allowedKeys.has(key));
 }
 function hasValidNornAgentLimits(value) {
-  return (value.max_tokens === void 0 || isPositiveInteger(value.max_tokens)) && (value.max_depth === void 0 || isPositiveInteger(value.max_depth)) && (value.max_invocations === void 0 || isPositiveInteger(value.max_invocations)) && (value.max_turns === void 0 || isPositiveInteger(value.max_turns)) && (value.contract_retries === void 0 || isNonNegativeInteger(value.contract_retries));
+  return (value.max_tokens === void 0 || isPositiveInteger(value.max_tokens)) && (value.max_input_tokens === void 0 || isPositiveInteger(value.max_input_tokens)) && (value.max_depth === void 0 || isPositiveInteger(value.max_depth)) && (value.max_invocations === void 0 || isPositiveInteger(value.max_invocations)) && (value.max_turns === void 0 || isPositiveInteger(value.max_turns)) && (value.contract_retries === void 0 || isNonNegativeInteger(value.contract_retries));
 }
 function isNornAgentProviderConfig(value) {
   if (!isObjectRecord(value)) {
@@ -159977,7 +160023,13 @@ function isNornAgentRecordingConfig(value) {
   }
   return hasOnlyKeys(value, /* @__PURE__ */ new Set(["_comment", "enabled"])) && (value.enabled === void 0 || typeof value.enabled === "boolean");
 }
-var AGENT_PROVIDER_NAMES = /* @__PURE__ */ new Set(["openai", "anthropic", "google", "local"]);
+var AGENT_PROVIDER_NAMES = /* @__PURE__ */ new Set([
+  "openai",
+  "openai_compatible",
+  "anthropic",
+  "google",
+  "local"
+]);
 function isNornAgentsConfig(value) {
   if (value === void 0) {
     return true;
@@ -166666,6 +166718,68 @@ function encodeFormUrlEncodedBody(body) {
   };
 }
 
+// src/sequenceCancellation.ts
+var SEQUENCE_CANCELLED_MESSAGE = "Sequence run cancelled by user.";
+var SequenceCancelledError = class extends Error {
+  constructor() {
+    super(SEQUENCE_CANCELLED_MESSAGE);
+    this.name = "SequenceCancelledError";
+  }
+};
+function throwIfSequenceCancelled(signal) {
+  if (signal?.aborted) {
+    throw new SequenceCancelledError();
+  }
+}
+function raceWithSequenceCancellation(operation, signal) {
+  if (!signal) {
+    return operation;
+  }
+  throwIfSequenceCancelled(signal);
+  return new Promise((resolve28, reject) => {
+    const cancel = () => {
+      signal.removeEventListener("abort", cancel);
+      reject(new SequenceCancelledError());
+    };
+    signal.addEventListener("abort", cancel, { once: true });
+    if (signal.aborted) {
+      cancel();
+      return;
+    }
+    operation.then(
+      (value) => {
+        signal.removeEventListener("abort", cancel);
+        resolve28(value);
+      },
+      (error2) => {
+        signal.removeEventListener("abort", cancel);
+        reject(error2);
+      }
+    );
+  });
+}
+function cancellableDelay(ms, signal) {
+  if (!signal) {
+    return new Promise((resolve28) => setTimeout(resolve28, ms));
+  }
+  throwIfSequenceCancelled(signal);
+  return new Promise((resolve28, reject) => {
+    const timer = setTimeout(() => {
+      signal.removeEventListener("abort", cancel);
+      resolve28();
+    }, ms);
+    const cancel = () => {
+      clearTimeout(timer);
+      signal.removeEventListener("abort", cancel);
+      reject(new SequenceCancelledError());
+    };
+    signal.addEventListener("abort", cancel, { once: true });
+    if (signal.aborted) {
+      cancel();
+    }
+  });
+}
+
 // src/httpClient.ts
 var sharedCookieJar = new CookieJar();
 var insecureHttpsAgent = new https2.Agent({ rejectUnauthorized: false });
@@ -166688,11 +166802,8 @@ async function getAllCookies(jar) {
     secure: Boolean(c.secure)
   }));
 }
-async function sendRequest(request, retryOptions) {
-  return sendRequestWithJar(request, sharedCookieJar, retryOptions);
-}
-function sleep(ms) {
-  return new Promise((resolve28) => setTimeout(resolve28, ms));
+async function sendRequest(request, retryOptions, signal) {
+  return sendRequestWithJar(request, sharedCookieJar, retryOptions, signal);
 }
 function shouldRetry(response, error2) {
   if (error2) {
@@ -166703,13 +166814,14 @@ function shouldRetry(response, error2) {
   }
   return false;
 }
-async function sendRequestWithJar(request, jar, retryOptions) {
+async function sendRequestWithJar(request, jar, retryOptions, signal) {
   const totalAttempts = (retryOptions?.retryCount ?? 0) + 1;
   const backoffMs = retryOptions?.backoffMs ?? 1e3;
   const retriedErrors = [];
   let lastError = null;
   let attemptsMade = 0;
   for (let attempt = 1; attempt <= totalAttempts; attempt++) {
+    throwIfSequenceCancelled(signal);
     attemptsMade = attempt;
     const startTime = Date.now();
     const maxRedirects = 10;
@@ -166722,6 +166834,7 @@ async function sendRequestWithJar(request, jar, retryOptions) {
     let sentRequestHeaders = {};
     try {
       while (redirectCount <= maxRedirects) {
+        throwIfSequenceCancelled(signal);
         const existingCookies = await jar.getCookies(currentUrl);
         const cookieHeader = existingCookies.map((c) => `${c.key}=${c.value}`).join("; ");
         const headers = { ...request.headers };
@@ -166776,7 +166889,8 @@ async function sendRequestWithJar(request, jar, retryOptions) {
           timeout: getRequestTimeoutMs(),
           maxRedirects: 0,
           validateStatus: () => true,
-          httpsAgent: getHttpsAgent()
+          httpsAgent: getHttpsAgent(),
+          signal
         });
         const setCookieHeader = response.headers["set-cookie"];
         if (setCookieHeader) {
@@ -166811,7 +166925,7 @@ async function sendRequestWithJar(request, jar, retryOptions) {
         if (retryOptions?.onRetry) {
           retryOptions.onRetry(attempt, totalAttempts, errorMessage, waitMs);
         }
-        await sleep(waitMs);
+        await cancellableDelay(waitMs, signal);
         continue;
       }
       const cookies = await getAllCookies(jar);
@@ -166834,6 +166948,9 @@ async function sendRequestWithJar(request, jar, retryOptions) {
       }
       return result;
     } catch (error2) {
+      if (signal?.aborted) {
+        throw new SequenceCancelledError();
+      }
       const errorMessage = error2.message || String(error2);
       const effectiveUrl = currentUrl || request.url;
       const isUrlError = /invalid url/i.test(errorMessage) || /unsupported protocol/i.test(errorMessage);
@@ -166876,7 +166993,7 @@ URL used: ${effectiveUrl}`);
         if (retryOptions?.onRetry) {
           retryOptions.onRetry(attempt, totalAttempts, errorMessage, waitMs);
         }
-        await sleep(waitMs);
+        await cancellableDelay(waitMs, signal);
         continue;
       }
       throw lastError;
@@ -167080,7 +167197,8 @@ function isRunCommand(line2) {
   const trimmed = line2.trim();
   return /^(var\s+[a-zA-Z_][a-zA-Z0-9_]*\s*=\s*)?run\s+(bash|powershell|pwsh|js)\s+/i.test(trimmed);
 }
-async function runScript(type, scriptPath, args, workingDir, variables = {}, captureVar) {
+async function runScript(type, scriptPath, args, workingDir, variables = {}, captureVar, signal) {
+  throwIfSequenceCancelled(signal);
   const startTime = Date.now();
   const resolvedPath = path5.isAbsolute(scriptPath) ? scriptPath : path5.resolve(workingDir, scriptPath);
   let command;
@@ -167111,7 +167229,7 @@ async function runScript(type, scriptPath, args, workingDir, variables = {}, cap
         captureVar
       };
   }
-  return new Promise((resolve28) => {
+  return new Promise((resolve28, reject) => {
     const env4 = {
       ...process.env,
       // Pass variables as environment variables with NORN_ prefix
@@ -167128,6 +167246,28 @@ async function runScript(type, scriptPath, args, workingDir, variables = {}, cap
     });
     let stdout = "";
     let stderr = "";
+    let settled = false;
+    const cancel = () => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      signal?.removeEventListener("abort", cancel);
+      child.kill("SIGTERM");
+      reject(new SequenceCancelledError());
+    };
+    signal?.addEventListener("abort", cancel, { once: true });
+    if (signal?.aborted) {
+      cancel();
+    }
+    const finish = (result) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      signal?.removeEventListener("abort", cancel);
+      resolve28(result);
+    };
     child.stdout.on("data", (data) => {
       stdout += data.toString();
     });
@@ -167135,7 +167275,7 @@ async function runScript(type, scriptPath, args, workingDir, variables = {}, cap
       stderr += data.toString();
     });
     child.on("error", (err) => {
-      resolve28({
+      finish({
         success: false,
         output: cleanScriptOutput(stdout),
         error: `Failed to execute script: ${err.message}`,
@@ -167149,7 +167289,7 @@ async function runScript(type, scriptPath, args, workingDir, variables = {}, cap
     child.on("close", (code) => {
       const exitCode = code ?? 0;
       const cleanedOutput = cleanScriptOutput(stdout);
-      resolve28({
+      finish({
         success: exitCode === 0,
         output: cleanedOutput,
         error: stderr.trim(),
@@ -168730,7 +168870,8 @@ function buildAdapterError(message, stderr, stdout) {
   }
   return new Error(details.join("\n"));
 }
-async function runExternalSqlAdapter(command, request, workingDir) {
+async function runExternalSqlAdapter(command, request, workingDir, signal) {
+  throwIfSequenceCancelled(signal);
   if (!command.length) {
     throw new Error("SQL adapter command is empty");
   }
@@ -168743,11 +168884,25 @@ async function runExternalSqlAdapter(command, request, workingDir) {
     let stdout = "";
     let stderr = "";
     let settled = false;
+    const cancel = () => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      signal?.removeEventListener("abort", cancel);
+      child.kill("SIGTERM");
+      reject(new SequenceCancelledError());
+    };
+    signal?.addEventListener("abort", cancel, { once: true });
+    if (signal?.aborted) {
+      cancel();
+    }
     const fail3 = (error2) => {
       if (settled) {
         return;
       }
       settled = true;
+      signal?.removeEventListener("abort", cancel);
       reject(error2);
     };
     const succeed = (response) => {
@@ -168755,6 +168910,7 @@ async function runExternalSqlAdapter(command, request, workingDir) {
         return;
       }
       settled = true;
+      signal?.removeEventListener("abort", cancel);
       resolve28(response);
     };
     child.stdout.on("data", (chunk) => {
@@ -168812,11 +168968,11 @@ async function runExternalSqlAdapter(command, request, workingDir) {
     }
   });
 }
-async function runSqlAdapter(target, request, workingDir) {
+async function runSqlAdapter(target, request, workingDir, signal) {
   if (target.kind === "builtin") {
-    return runBuiltInSqlAdapter(target.adapterId, request);
+    return raceWithSequenceCancellation(runBuiltInSqlAdapter(target.adapterId, request), signal);
   }
-  return runExternalSqlAdapter(target.command, request, workingDir);
+  return runExternalSqlAdapter(target.command, request, workingDir, signal);
 }
 
 // src/mcpClient.ts
@@ -168831,10 +168987,10 @@ var util3;
   function assertIs2(_arg) {
   }
   util4.assertIs = assertIs2;
-  function assertNever5(_x) {
+  function assertNever6(_x) {
     throw new Error();
   }
-  util4.assertNever = assertNever5;
+  util4.assertNever = assertNever6;
   util4.arrayToEnum = (items) => {
     const obj = {};
     for (const item of items) {
@@ -186229,15 +186385,155 @@ function describeUnmetExpectations(verdict) {
 
 // src/agents/providers/providerUtils.ts
 var import_crypto6 = require("crypto");
+
+// src/agents/toolResultContext.ts
+var MAX_INLINE_TOOL_RESULT_TOKENS = 2e4;
+var MAX_INLINE_TOOL_RESULT_CHARACTERS = MAX_INLINE_TOOL_RESULT_TOKENS * 4;
+var MAX_RETAINED_INLINE_TOOL_RESULTS = 3;
+var TOOL_RESULT_PREVIEW_CHARACTERS = 2e3;
+var TOOL_RESULT_READ_CHARACTERS = 12e3;
+function outputToText(output2) {
+  if (typeof output2 === "string") {
+    return output2;
+  }
+  if (output2 === void 0) {
+    return "";
+  }
+  try {
+    return JSON.stringify(output2);
+  } catch {
+    return String(output2);
+  }
+}
+function referenceText(input2) {
+  return JSON.stringify({
+    nornToolResult: {
+      status: input2.released ? "released_from_context" : "offloaded",
+      handle: input2.handle,
+      tool: input2.toolName,
+      originalCharacters: input2.originalCharacters,
+      estimatedTokens: input2.estimatedTokens,
+      ...input2.preview !== void 0 ? { preview: input2.preview } : {},
+      instruction: `Use norn_read_tool_result with handle '${input2.handle}' to read or search bounded portions.`
+    }
+  });
+}
+var PreparedAgentToolResult = class {
+  constructor(recordedOutput, immediateOutput, immediateText, historyPlaceholder) {
+    this.recordedOutput = recordedOutput;
+    this.immediateOutput = immediateOutput;
+    this.immediateText = immediateText;
+    this.historyPlaceholder = historyPlaceholder;
+  }
+};
+var AgentToolResultStore = class {
+  results = /* @__PURE__ */ new Map();
+  nextHandle = 1;
+  prepare(toolName2, output2) {
+    const text = outputToText(output2);
+    const handle = `tool-result-${this.nextHandle++}`;
+    const estimatedTokens = Math.ceil(text.length / 4);
+    const stored = { handle, toolName: toolName2, text, estimatedTokens };
+    this.results.set(handle, stored);
+    const historyPlaceholder = referenceText({
+      handle,
+      toolName: toolName2,
+      originalCharacters: text.length,
+      estimatedTokens,
+      released: true
+    });
+    if (text.length <= MAX_INLINE_TOOL_RESULT_CHARACTERS) {
+      return new PreparedAgentToolResult(output2, output2, text, historyPlaceholder);
+    }
+    const offloadedReference = referenceText({
+      handle,
+      toolName: toolName2,
+      originalCharacters: text.length,
+      estimatedTokens,
+      preview: text.slice(0, TOOL_RESULT_PREVIEW_CHARACTERS),
+      released: false
+    });
+    return new PreparedAgentToolResult(output2, offloadedReference, offloadedReference, historyPlaceholder);
+  }
+  read(input2) {
+    const handle = typeof input2.handle === "string" ? input2.handle : "";
+    const stored = this.results.get(handle);
+    if (!stored) {
+      return { error: `Unknown or expired tool-result handle '${handle}'.` };
+    }
+    const query = typeof input2.query === "string" ? input2.query.trim() : "";
+    if (query) {
+      return this.search(stored, query);
+    }
+    const requestedOffset = typeof input2.offset === "number" && Number.isSafeInteger(input2.offset) ? input2.offset : 0;
+    const offset = Math.max(0, Math.min(requestedOffset, stored.text.length));
+    const text = stored.text.slice(offset, offset + TOOL_RESULT_READ_CHARACTERS);
+    return {
+      handle,
+      tool: stored.toolName,
+      offset,
+      returnedCharacters: text.length,
+      totalCharacters: stored.text.length,
+      hasMore: offset + text.length < stored.text.length,
+      text
+    };
+  }
+  search(stored, query) {
+    const haystack = stored.text.toLocaleLowerCase();
+    const needle = query.toLocaleLowerCase();
+    const matches = [];
+    let from = 0;
+    while (matches.length < 5) {
+      const index = haystack.indexOf(needle, from);
+      if (index < 0) {
+        break;
+      }
+      const start = Math.max(0, index - 300);
+      const end = Math.min(stored.text.length, index + query.length + 500);
+      matches.push({ offset: start, text: stored.text.slice(start, end) });
+      from = Math.max(index + needle.length, index + 1);
+    }
+    return {
+      handle: stored.handle,
+      tool: stored.toolName,
+      query,
+      totalCharacters: stored.text.length,
+      matches
+    };
+  }
+};
+var AgentToolResultHistory = class {
+  retained = [];
+  retain(replaceWithReference) {
+    this.retained.push(replaceWithReference);
+    while (this.retained.length > MAX_RETAINED_INLINE_TOOL_RESULTS) {
+      this.retained.shift()?.();
+    }
+  }
+};
+function normalizePreparedAgentToolResult(output2) {
+  if (output2 instanceof PreparedAgentToolResult) {
+    return output2;
+  }
+  return {
+    recordedOutput: output2,
+    immediateOutput: output2,
+    immediateText: outputToText(output2),
+    historyPlaceholder: "[Older tool result released from active context by Norn.]"
+  };
+}
+
+// src/agents/providers/providerUtils.ts
 var PROVIDER_NAME_PATTERN = /^[A-Za-z_][A-Za-z0-9_-]{0,63}$/;
 var PROVIDER_NAME_MAX_LENGTH = 64;
 var AgentTurnLimitError = class extends Error {
-  constructor(provider, maxTurns, toolCallCount, lastToolName) {
+  constructor(provider, maxTurns, toolCallCount, lastToolName, usage) {
     super(`${provider} tool loop reached its ${maxTurns}-turn limit before the model finished.`);
     this.provider = provider;
     this.maxTurns = maxTurns;
     this.toolCallCount = toolCallCount;
     this.lastToolName = lastToolName;
+    this.usage = usage;
     this.name = "AgentTurnLimitError";
   }
 };
@@ -186310,19 +186606,6 @@ function agentInputToText(input2) {
     return String(input2);
   }
 }
-function providerToolOutputToText(output2) {
-  if (typeof output2 === "string") {
-    return output2;
-  }
-  if (output2 === void 0) {
-    return "";
-  }
-  try {
-    return JSON.stringify(output2);
-  } catch {
-    return String(output2);
-  }
-}
 function tryParseStructuredAgentOutput(text, hasSchema) {
   if (!hasSchema) {
     return void 0;
@@ -186405,7 +186688,70 @@ function createRecordedToolCall(records, name, input2, kind) {
 
 // src/agents/providers/anthropicAdapter.ts
 init_sdk();
-init_json_schema();
+
+// src/agents/agentTokenBudget.ts
+function estimateSerializedInputTokens(value) {
+  let text;
+  try {
+    text = JSON.stringify(value) ?? "";
+  } catch {
+    text = String(value);
+  }
+  return Math.ceil(text.length / 3);
+}
+function formatAgentInputTokenLimitError(agentName, outcome) {
+  const next = outcome.estimatedNextInputTokens === void 0 ? "" : ` The next request was estimated at ${outcome.estimatedNextInputTokens} input tokens.`;
+  return `Agent '${agentName}' reached the top-level run's max_input_tokens budget (${outcome.usedInputTokens}/${outcome.maxInputTokens}) and stopped before continuing.${next} Raise max_input_tokens in ${outcome.sourcePath}:${outcome.lineNumber + 1}, or under 'agents' in norn.config.json.`;
+}
+function sumAgentTurnUsage(turns) {
+  return {
+    inputTokens: turns.reduce((total, turn) => total + turn.inputTokens, 0),
+    outputTokens: turns.reduce((total, turn) => total + turn.outputTokens, 0),
+    turns: turns.map((turn) => ({ ...turn }))
+  };
+}
+var AgentInputTokenLimitError = class extends Error {
+  constructor(provider, maxInputTokens, usedInputTokens, usage, estimatedNextInputTokens) {
+    const reason = estimatedNextInputTokens === void 0 ? `after using ${usedInputTokens}` : `before an estimated ${estimatedNextInputTokens}-token request with ${usedInputTokens} already used`;
+    super(`${provider} agent input budget ${maxInputTokens} was reached ${reason}.`);
+    this.provider = provider;
+    this.maxInputTokens = maxInputTokens;
+    this.usedInputTokens = usedInputTokens;
+    this.usage = usage;
+    this.estimatedNextInputTokens = estimatedNextInputTokens;
+    this.name = "AgentInputTokenLimitError";
+  }
+};
+function assertInputBudgetAllowsCall(provider, budget, estimatedNextInputTokens, turns) {
+  if (!budget || budget.usedInputTokens + estimatedNextInputTokens <= budget.maxInputTokens) {
+    return;
+  }
+  throw new AgentInputTokenLimitError(
+    provider,
+    budget.maxInputTokens,
+    budget.usedInputTokens,
+    sumAgentTurnUsage(turns),
+    estimatedNextInputTokens
+  );
+}
+function recordAgentTurnUsage(provider, budget, turns, usage) {
+  const turn = { turn: turns.length + 1, ...usage };
+  turns.push(turn);
+  if (!budget) {
+    return;
+  }
+  budget.usedInputTokens += turn.inputTokens;
+  if (budget.usedInputTokens > budget.maxInputTokens) {
+    throw new AgentInputTokenLimitError(
+      provider,
+      budget.maxInputTokens,
+      budget.usedInputTokens,
+      sumAgentTurnUsage(turns)
+    );
+  }
+}
+
+// src/agents/providers/anthropicAdapter.ts
 function supportsAdaptiveThinking(modelId) {
   return /^claude-(?:opus-(?:4-(?:[6-9]|\d{2,})|[5-9])|sonnet-(?:4-[6-9]|[5-9])|fable-[5-9]|mythos(?:-[5-9]|-preview))/i.test(modelId);
 }
@@ -186487,67 +186833,136 @@ var AnthropicAgentAdapter = class {
       })),
       inputMessage
     ];
-    let finalMessage;
-    let inputTokens = 0;
-    let outputTokens = 0;
-    if (request.tools.length > 0) {
-      const runnableTools = prepareAgentProviderTools(request.tools).map(({ tool, providerName }) => {
-        if (tool.inputSchema.type !== "object") {
-          throw new Error(`Tool '${tool.name}' must expose an object input schema.`);
-        }
-        return betaTool({
-          name: providerName,
-          description: tool.description || `Run ${tool.name}`,
-          inputSchema: tool.inputSchema,
-          run: async (rawInput) => {
-            const input2 = parseToolInput(rawInput);
-            const recorded = createRecordedToolCall(toolCalls, tool.name, input2, tool.kind);
-            try {
-              const output2 = await tool.execute(input2);
-              recorded.complete(output2);
-              return providerToolOutputToText(output2);
-            } catch (error2) {
-              const output2 = { error: error2 instanceof Error ? error2.message : String(error2) };
-              recorded.complete(output2);
-              if (error2 instanceof AgentToolFatalError) {
-                throw error2;
-              }
-              return providerToolOutputToText(output2);
-            }
-          }
-        });
-      });
-      const runner = client.beta.messages.toolRunner({
+    const turns = [];
+    if (request.tools.length === 0) {
+      const call = {
         model: request.modelId,
         max_tokens: request.maxTokens,
         system: request.systemPrompt,
         messages,
-        tools: runnableTools,
-        tool_choice: { type: "auto", disable_parallel_tool_use: true },
         output_config: outputConfig,
-        thinking,
-        max_iterations: request.maxTurns,
-        stream: false
+        thinking
+      };
+      assertInputBudgetAllowsCall(
+        this.provider,
+        request.inputTokenBudget,
+        estimateSerializedInputTokens(call),
+        turns
+      );
+      const finalMessage = await client.messages.create(
+        call,
+        request.signal ? { signal: request.signal } : void 0
+      );
+      recordAgentTurnUsage(this.provider, request.inputTokenBudget, turns, {
+        inputTokens: finalMessage.usage.input_tokens + (finalMessage.usage.cache_creation_input_tokens ?? 0) + (finalMessage.usage.cache_read_input_tokens ?? 0),
+        outputTokens: finalMessage.usage.output_tokens,
+        ...typeof finalMessage.usage.cache_read_input_tokens === "number" ? { cachedInputTokens: finalMessage.usage.cache_read_input_tokens } : {},
+        ...typeof finalMessage.usage.cache_creation_input_tokens === "number" ? { cacheWriteInputTokens: finalMessage.usage.cache_creation_input_tokens } : {}
       });
-      let latest;
-      for await (const message of runner) {
-        latest = message;
-        inputTokens += message.usage.input_tokens + (message.usage.cache_creation_input_tokens ?? 0) + (message.usage.cache_read_input_tokens ?? 0);
-        outputTokens += message.usage.output_tokens;
+      return this.completeResponse(request, finalMessage, toolCalls, turns);
+    }
+    const preparedTools = prepareAgentProviderTools(request.tools);
+    const betaMessages = messages;
+    const toolsByProviderName = new Map(
+      preparedTools.map((prepared) => [prepared.providerName, prepared.tool])
+    );
+    const tools = preparedTools.map(({ tool, providerName }) => {
+      if (tool.inputSchema.type !== "object") {
+        throw new Error(`Tool '${tool.name}' must expose an object input schema.`);
       }
-      finalMessage = latest ?? await runner.done();
-    } else {
-      finalMessage = await client.messages.create({
+      return {
+        name: providerName,
+        description: tool.description || `Run ${tool.name}`,
+        input_schema: tool.inputSchema
+      };
+    });
+    const toolHistory = new AgentToolResultHistory();
+    for (let turn = 1; turn <= request.maxTurns; turn++) {
+      const call = {
         model: request.modelId,
         max_tokens: request.maxTokens,
         system: request.systemPrompt,
-        messages,
+        messages: betaMessages,
+        tools,
+        tool_choice: { type: "auto", disable_parallel_tool_use: true },
         output_config: outputConfig,
         thinking
+      };
+      assertInputBudgetAllowsCall(
+        this.provider,
+        request.inputTokenBudget,
+        estimateSerializedInputTokens(call),
+        turns
+      );
+      const response = await client.beta.messages.create(
+        call,
+        request.signal ? { signal: request.signal } : void 0
+      );
+      recordAgentTurnUsage(this.provider, request.inputTokenBudget, turns, {
+        inputTokens: response.usage.input_tokens + (response.usage.cache_creation_input_tokens ?? 0) + (response.usage.cache_read_input_tokens ?? 0),
+        outputTokens: response.usage.output_tokens,
+        ...typeof response.usage.cache_read_input_tokens === "number" ? { cachedInputTokens: response.usage.cache_read_input_tokens } : {},
+        ...typeof response.usage.cache_creation_input_tokens === "number" ? { cacheWriteInputTokens: response.usage.cache_creation_input_tokens } : {}
+      });
+      const calls = response.content.filter((block) => block.type === "tool_use");
+      if (calls.length === 0) {
+        return this.completeResponse(request, response, toolCalls, turns);
+      }
+      if (turn >= request.maxTurns) {
+        throw new AgentTurnLimitError(
+          this.provider,
+          request.maxTurns,
+          toolCalls.length,
+          toolCalls[toolCalls.length - 1]?.name,
+          sumAgentTurnUsage(turns)
+        );
+      }
+      betaMessages.push({
+        role: "assistant",
+        content: response.content
       });
-      inputTokens = finalMessage.usage.input_tokens + (finalMessage.usage.cache_creation_input_tokens ?? 0) + (finalMessage.usage.cache_read_input_tokens ?? 0);
-      outputTokens = finalMessage.usage.output_tokens;
+      const resultBlocks = [];
+      for (const callBlock of calls) {
+        const tool = toolsByProviderName.get(callBlock.name);
+        if (!tool) {
+          throw new Error(`Anthropic requested unknown tool '${callBlock.name}'.`);
+        }
+        const input2 = parseToolInput(callBlock.input);
+        const recorded = createRecordedToolCall(toolCalls, tool.name, input2, tool.kind);
+        let preparedOutput;
+        try {
+          const output2 = await tool.execute(input2);
+          preparedOutput = normalizePreparedAgentToolResult(output2);
+          recorded.complete(preparedOutput.recordedOutput);
+        } catch (error2) {
+          const output2 = { error: error2 instanceof Error ? error2.message : String(error2) };
+          recorded.complete(output2);
+          if (error2 instanceof AgentToolFatalError) {
+            throw error2;
+          }
+          preparedOutput = normalizePreparedAgentToolResult(output2);
+        }
+        const resultBlock = {
+          type: "tool_result",
+          tool_use_id: callBlock.id,
+          content: preparedOutput.immediateText
+        };
+        resultBlocks.push(resultBlock);
+        toolHistory.retain(() => {
+          resultBlock.content = preparedOutput.historyPlaceholder;
+        });
+      }
+      betaMessages.push({ role: "user", content: resultBlocks });
     }
+    throw new AgentTurnLimitError(
+      this.provider,
+      request.maxTurns,
+      toolCalls.length,
+      toolCalls[toolCalls.length - 1]?.name,
+      sumAgentTurnUsage(turns)
+    );
+  }
+  completeResponse(request, finalMessage, toolCalls, turns) {
     const text = getVisibleText(finalMessage, Boolean(request.outputSchema));
     if (finalMessage.stop_reason === "refusal") {
       throw new AgentProviderRefusalError(`Anthropic model refused the request${text ? `: ${text}` : "."}`, text);
@@ -186560,7 +186975,8 @@ var AnthropicAgentAdapter = class {
         this.provider,
         request.maxTurns,
         toolCalls.length,
-        toolCalls[toolCalls.length - 1]?.name
+        toolCalls[toolCalls.length - 1]?.name,
+        sumAgentTurnUsage(turns)
       );
     }
     if (finalMessage.stop_reason === "model_context_window_exceeded") {
@@ -186573,7 +186989,7 @@ var AnthropicAgentAdapter = class {
       text,
       parsed: tryParseStructuredAgentOutput(text, Boolean(request.outputSchema)),
       toolCalls,
-      usage: { inputTokens, outputTokens },
+      usage: sumAgentTurnUsage(turns),
       resolvedModelId: finalMessage.model || request.modelId
     };
   }
@@ -186759,6 +187175,7 @@ var GoogleAgentAdapter = class {
     const config2 = {
       systemInstruction: request.systemPrompt,
       maxOutputTokens: request.maxTokens,
+      ...request.signal ? { abortSignal: request.signal } : {},
       ...request.outputSchema ? {
         responseMimeType: "application/json",
         responseJsonSchema: request.outputSchema
@@ -186777,18 +187194,28 @@ var GoogleAgentAdapter = class {
         automaticFunctionCalling: { disable: true }
       } : {}
     };
-    let inputTokens = 0;
-    let outputTokens = 0;
     let resolvedModelId2 = request.modelId;
+    const turns = [];
+    const toolHistory = new AgentToolResultHistory();
     for (let turn = 0; turn < request.maxTurns; turn++) {
+      const estimatedInputTokens = estimateSerializedInputTokens({ contents, config: config2 });
+      assertInputBudgetAllowsCall(
+        this.provider,
+        request.inputTokenBudget,
+        estimatedInputTokens,
+        turns
+      );
       const response = await client.models.generateContent({
         model: request.modelId,
         contents,
         config: config2
       });
       const usage = response.usageMetadata;
-      inputTokens += (usage?.promptTokenCount ?? 0) + (usage?.toolUsePromptTokenCount ?? 0);
-      outputTokens += (usage?.candidatesTokenCount ?? 0) + (usage?.thoughtsTokenCount ?? 0);
+      recordAgentTurnUsage(this.provider, request.inputTokenBudget, turns, {
+        inputTokens: usage ? (usage.promptTokenCount ?? 0) + (usage.toolUsePromptTokenCount ?? 0) : estimatedInputTokens,
+        outputTokens: (usage?.candidatesTokenCount ?? 0) + (usage?.thoughtsTokenCount ?? 0),
+        ...usage?.cachedContentTokenCount !== void 0 ? { cachedInputTokens: usage.cachedContentTokenCount } : {}
+      });
       resolvedModelId2 = response.modelVersion || resolvedModelId2;
       const requestedCalls = getFunctionCalls(response);
       const text = getVisibleText2(
@@ -186803,7 +187230,7 @@ var GoogleAgentAdapter = class {
           text,
           parsed: tryParseStructuredAgentOutput(text, Boolean(request.outputSchema)),
           toolCalls,
-          usage: { inputTokens, outputTokens },
+          usage: sumAgentTurnUsage(turns),
           resolvedModelId: resolvedModelId2
         };
       }
@@ -186817,7 +187244,8 @@ var GoogleAgentAdapter = class {
           this.provider,
           request.maxTurns,
           toolCalls.length,
-          toolCalls[toolCalls.length - 1]?.name
+          toolCalls[toolCalls.length - 1]?.name,
+          sumAgentTurnUsage(turns)
         );
       }
       const modelContent = getCandidate(response)?.content;
@@ -186838,8 +187266,12 @@ var GoogleAgentAdapter = class {
       let responseBody;
       try {
         const output2 = await tool.execute(input2);
-        recorded.complete(output2);
-        responseBody = { output: output2 };
+        const preparedOutput = normalizePreparedAgentToolResult(output2);
+        recorded.complete(preparedOutput.recordedOutput);
+        responseBody = { output: preparedOutput.immediateOutput };
+        toolHistory.retain(() => {
+          responseBody.output = preparedOutput.historyPlaceholder;
+        });
       } catch (error2) {
         const message = error2 instanceof Error ? error2.message : String(error2);
         const output2 = { error: message };
@@ -186864,7 +187296,8 @@ var GoogleAgentAdapter = class {
       this.provider,
       request.maxTurns,
       toolCalls.length,
-      toolCalls[toolCalls.length - 1]?.name
+      toolCalls[toolCalls.length - 1]?.name,
+      sumAgentTurnUsage(turns)
     );
   }
 };
@@ -187108,7 +187541,7 @@ var safeJSON2 = (text) => {
 };
 
 // node_modules/openai/internal/utils/sleep.mjs
-var sleep4 = (ms) => new Promise((resolve28) => setTimeout(resolve28, ms));
+var sleep3 = (ms) => new Promise((resolve28) => setTimeout(resolve28, ms));
 
 // node_modules/openai/version.mjs
 var VERSION4 = "6.49.0";
@@ -194427,7 +194860,7 @@ var Runs = class extends APIResource2 {
               }
             }
           }
-          await sleep4(sleepInterval);
+          await sleep3(sleepInterval);
           break;
         //We return the run in any terminal state.
         case "requires_action":
@@ -195036,7 +195469,7 @@ var Files4 = class extends APIResource2 {
     const start = Date.now();
     let file2 = await this.retrieve(id);
     while (!file2.status || !TERMINAL_STATES.has(file2.status)) {
-      await sleep4(pollInterval);
+      await sleep3(pollInterval);
       file2 = await this.retrieve(id);
       if (Date.now() - start > maxWait) {
         throw new APIConnectionTimeoutError3({
@@ -196732,7 +197165,7 @@ var FileBatches = class extends APIResource2 {
               }
             }
           }
-          await sleep4(sleepInterval);
+          await sleep3(sleepInterval);
           break;
         case "failed":
         case "cancelled":
@@ -196872,7 +197305,7 @@ var Files5 = class extends APIResource2 {
               }
             }
           }
-          await sleep4(sleepInterval);
+          await sleep3(sleepInterval);
           break;
         case "failed":
         case "completed":
@@ -197648,7 +198081,7 @@ var OpenAI = class {
       const maxRetries = options.maxRetries ?? this.maxRetries;
       timeoutMillis = this.calculateDefaultRetryTimeoutMillis(retriesRemaining, maxRetries);
     }
-    await sleep4(timeoutMillis);
+    await sleep3(timeoutMillis);
     return this.makeRequest(options, retriesRemaining - 1, requestLogID);
   }
   calculateDefaultRetryTimeoutMillis(retriesRemaining, maxRetries) {
@@ -197816,6 +198249,93 @@ function isUndiciDispatcherVersionMismatchError(error2) {
   return false;
 }
 
+// node_modules/openai/lib/responses/ResponseInputItems.mjs
+function toResponseInputItems(items) {
+  const inputItems = [];
+  for (const item of items) {
+    const inputItem = toResponseInputItem(item);
+    if (inputItem) {
+      inputItems.push(inputItem);
+    }
+  }
+  return inputItems;
+}
+function toResponseInputItem(item) {
+  switch (item.type) {
+    case "additional_tools": {
+      if (item.role !== "developer") {
+        return null;
+      }
+      return stripCreatedBy(item);
+    }
+    case "shell_call_output": {
+      const output2 = item.output.map((chunk) => stripCreatedBy(chunk));
+      return {
+        ...stripCreatedBy(item),
+        output: output2
+      };
+    }
+    case "computer_call_output": {
+      const { created_by: _createdBy, ...withoutCreatedBy } = item;
+      if (withoutCreatedBy.status === "failed") {
+        return null;
+      }
+      return withoutCreatedBy;
+    }
+    case "custom_tool_call_output": {
+      if ("status" in item && item.status !== "completed") {
+        return null;
+      }
+      const { created_by: _createdBy, status: _status, ...inputItem } = item;
+      return inputItem;
+    }
+    case "apply_patch_call":
+    case "apply_patch_call_output":
+    case "code_interpreter_call":
+    case "compaction":
+    case "compaction_trigger":
+    case "computer_call":
+    case "custom_tool_call":
+    case "file_search_call":
+    case "function_call":
+    case "function_call_output":
+    case "image_generation_call":
+    case "item_reference":
+    case "local_shell_call":
+    case "local_shell_call_output":
+    case "mcp_approval_request":
+    case "mcp_approval_response":
+    case "mcp_call":
+    case "mcp_list_tools":
+    case "message":
+    case "program":
+    case "program_output":
+    case "reasoning":
+    case "shell_call":
+    case "tool_search_call":
+    case "tool_search_output":
+    case "web_search_call":
+    case null:
+    case void 0: {
+      return stripCreatedBy(item);
+    }
+    default: {
+      return assertNever5(item);
+    }
+  }
+}
+function stripCreatedBy(item) {
+  if (!("created_by" in item)) {
+    return item;
+  }
+  const { created_by: _createdBy, ...rest } = item;
+  return rest;
+}
+function assertNever5(value) {
+  const type = value.type;
+  throw new TypeError(`Unsupported response item type: ${String(type)}`);
+}
+
 // src/agents/providers/openaiAdapter.ts
 function parseToolArguments(raw) {
   const parsed = JSON.parse(raw);
@@ -197825,7 +198345,251 @@ function parseToolArguments(raw) {
   return parsed;
 }
 var OpenAIAgentAdapter = class {
-  constructor(provider = "openai") {
+  provider = "openai";
+  createClient(request) {
+    const apiKey = request.credentials?.apiKey ?? getScopedEnvironmentValue(request.environment, "OPENAI_API_KEY");
+    const baseURL = request.credentials?.baseUrl ?? getScopedEnvironmentValue(request.environment, "OPENAI_BASE_URL");
+    try {
+      return new OpenAI({
+        ...apiKey ? { apiKey } : {},
+        ...baseURL ? { baseURL } : {}
+      });
+    } catch (error2) {
+      if (error2 instanceof Error && error2.message.includes("Missing credentials")) {
+        throw new Error(
+          "OpenAI authentication failed. Add an apiKey directive to the model block, for example: apiKey {{$env.OPENAI_API_KEY}}.",
+          { cause: error2 }
+        );
+      }
+      throw error2;
+    }
+  }
+  async run(request) {
+    if (request.provider !== this.provider) {
+      throw new Error(`The openai provider adapter cannot run a ${request.provider} request.`);
+    }
+    try {
+      return await this.runRequest(request);
+    } catch (error2) {
+      if (error2 instanceof AgentProviderRefusalError) {
+        throw error2;
+      }
+      if (error2 instanceof OpenAI.APIError) {
+        if (isAgentProviderMaxTokensRejection(error2)) {
+          throw new AgentProviderMaxTokensError(
+            this.provider,
+            request.maxTokens,
+            error2.message,
+            error2
+          );
+        }
+        const status = error2.status ? ` (HTTP ${error2.status})` : "";
+        const requestId = error2.requestID ? ` [request ${error2.requestID}]` : "";
+        throw new Error(`OpenAI API request failed${status}: ${error2.message}${requestId}`, {
+          cause: error2
+        });
+      }
+      throw error2;
+    }
+  }
+  async runRequest(request) {
+    const client = this.createClient(request);
+    const toolCalls = [];
+    const input2 = [
+      ...(request.conversation ?? []).map((message) => ({
+        type: "message",
+        role: message.role,
+        content: message.content
+      })),
+      {
+        type: "message",
+        role: "user",
+        content: agentInputToText(request.input)
+      }
+    ];
+    const preparedTools = prepareAgentProviderTools(request.tools);
+    const tools = preparedTools.map(({ tool, providerName }) => ({
+      type: "function",
+      name: providerName,
+      description: tool.description || `Run ${tool.name}`,
+      parameters: tool.inputSchema,
+      strict: false
+    }));
+    const toolsByProviderName = new Map(
+      preparedTools.map((prepared) => [prepared.providerName, prepared])
+    );
+    const text = request.outputSchema ? {
+      format: {
+        type: "json_schema",
+        name: toProviderSchemaName(request.outputSchemaName),
+        schema: request.outputSchema,
+        strict: true
+      }
+    } : void 0;
+    let resolvedModelId2 = request.modelId;
+    const turns = [];
+    const toolHistory = new AgentToolResultHistory();
+    for (let turn = 1; turn <= request.maxTurns; turn++) {
+      const estimatedInputTokens = estimateSerializedInputTokens({
+        instructions: request.systemPrompt,
+        input: input2,
+        tools,
+        text
+      });
+      assertInputBudgetAllowsCall(
+        this.provider,
+        request.inputTokenBudget,
+        estimatedInputTokens,
+        turns
+      );
+      const response = await client.responses.create({
+        model: request.modelId,
+        instructions: request.systemPrompt,
+        input: input2,
+        max_output_tokens: request.maxTokens,
+        store: false,
+        parallel_tool_calls: false,
+        ...request.reasoningEffort ? { reasoning: { effort: request.reasoningEffort } } : {},
+        ...tools.length > 0 ? {
+          tools,
+          tool_choice: "auto",
+          include: ["reasoning.encrypted_content"]
+        } : {},
+        ...text ? { text } : {}
+      }, request.signal ? { signal: request.signal } : void 0);
+      resolvedModelId2 = response.model || request.modelId;
+      const turnInputTokens = response.usage?.input_tokens ?? estimatedInputTokens;
+      const turnOutputTokens = response.usage?.output_tokens ?? 0;
+      recordAgentTurnUsage(this.provider, request.inputTokenBudget, turns, {
+        inputTokens: turnInputTokens,
+        outputTokens: turnOutputTokens,
+        ...response.usage?.input_tokens_details?.cached_tokens !== void 0 ? { cachedInputTokens: response.usage.input_tokens_details.cached_tokens } : {},
+        ...response.usage?.input_tokens_details?.cache_write_tokens !== void 0 ? { cacheWriteInputTokens: response.usage.input_tokens_details.cache_write_tokens } : {}
+      });
+      const refusal = response.output.filter((item) => item.type === "message").flatMap((message) => message.content).find((content) => content.type === "refusal");
+      if (refusal?.type === "refusal") {
+        throw new AgentProviderRefusalError(
+          `OpenAI model refused the request: ${refusal.refusal}`,
+          response.output_text || refusal.refusal
+        );
+      }
+      if (response.error) {
+        throw new Error(`OpenAI response failed: ${response.error.message}`);
+      }
+      const calls = response.output.filter((item) => item.type === "function_call");
+      if (calls.length === 0) {
+        this.assertCompleted(response, request);
+        const responseText = response.output_text || "";
+        return {
+          text: responseText,
+          parsed: tryParseStructuredAgentOutput(responseText, Boolean(request.outputSchema)),
+          toolCalls,
+          usage: sumAgentTurnUsage(turns),
+          resolvedModelId: resolvedModelId2
+        };
+      }
+      if (turn >= request.maxTurns) {
+        throw new AgentTurnLimitError(
+          this.provider,
+          request.maxTurns,
+          toolCalls.length,
+          toolCalls[toolCalls.length - 1]?.name,
+          sumAgentTurnUsage(turns)
+        );
+      }
+      input2.push(...toResponseInputItems(response.output));
+      for (const call of calls) {
+        const prepared = toolsByProviderName.get(call.name);
+        if (!prepared) {
+          throw new Error(`OpenAI requested unknown agent tool '${call.name}'.`);
+        }
+        let toolInput = {};
+        let output2;
+        try {
+          toolInput = parseToolArguments(call.arguments);
+          const recorded = createRecordedToolCall(
+            toolCalls,
+            prepared.tool.name,
+            toolInput,
+            prepared.tool.kind
+          );
+          try {
+            output2 = await prepared.tool.execute(toolInput);
+            recorded.complete(normalizePreparedAgentToolResult(output2).recordedOutput);
+          } catch (error2) {
+            output2 = { error: error2 instanceof Error ? error2.message : String(error2) };
+            recorded.complete(output2);
+            if (error2 instanceof AgentToolFatalError) {
+              throw error2;
+            }
+          }
+        } catch (error2) {
+          if (error2 instanceof AgentToolFatalError) {
+            throw error2;
+          }
+          output2 = { error: error2 instanceof Error ? error2.message : String(error2) };
+          const recorded = createRecordedToolCall(
+            toolCalls,
+            prepared.tool.name,
+            toolInput,
+            prepared.tool.kind
+          );
+          recorded.complete(output2);
+        }
+        const preparedOutput = normalizePreparedAgentToolResult(output2);
+        const outputItem = {
+          type: "function_call_output",
+          call_id: call.call_id,
+          output: preparedOutput.immediateText
+        };
+        input2.push(outputItem);
+        toolHistory.retain(() => {
+          outputItem.output = preparedOutput.historyPlaceholder;
+        });
+      }
+    }
+    throw new AgentTurnLimitError(
+      this.provider,
+      request.maxTurns,
+      toolCalls.length,
+      toolCalls[toolCalls.length - 1]?.name,
+      sumAgentTurnUsage(turns)
+    );
+  }
+  assertCompleted(response, request) {
+    if (response.status === "incomplete") {
+      if (response.incomplete_details?.reason === "content_filter") {
+        throw new AgentProviderRefusalError(
+          "OpenAI blocked the response through its content filter.",
+          response.output_text || ""
+        );
+      }
+      if (response.incomplete_details?.reason === "max_output_tokens") {
+        throw new Error(
+          `OpenAI model reached its ${request.maxTokens}-token completion limit before finishing.`
+        );
+      }
+      throw new Error("OpenAI returned an incomplete response.");
+    }
+    if (response.status === "failed" || response.status === "cancelled") {
+      throw new Error(`OpenAI response ended with status '${response.status}'.`);
+    }
+    if (response.status === "in_progress" || response.status === "queued") {
+      throw new Error(`OpenAI returned unexpected non-terminal status '${response.status}'.`);
+    }
+  }
+};
+
+// src/agents/providers/openaiCompatibleAdapter.ts
+function parseToolArguments2(raw) {
+  const parsed = JSON.parse(raw);
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error("Tool input must be a JSON object.");
+  }
+  return parsed;
+}
+var OpenAICompatibleAgentAdapter = class {
+  constructor(provider = "openai_compatible") {
     this.provider = provider;
   }
   createClient(request) {
@@ -197839,17 +198603,19 @@ var OpenAIAgentAdapter = class {
       const apiKey2 = request.credentials?.apiKey ?? getEnvironmentValue(request.environment, "LOCAL_API_KEY") ?? "norn-local";
       return new OpenAI({ apiKey: apiKey2, baseURL: baseURL2 });
     }
-    const apiKey = request.credentials?.apiKey ?? getScopedEnvironmentValue(request.environment, "OPENAI_API_KEY");
-    const baseURL = request.credentials?.baseUrl ?? getScopedEnvironmentValue(request.environment, "OPENAI_BASE_URL");
+    const apiKey = request.credentials?.apiKey ?? getScopedEnvironmentValue(request.environment, "OPENAI_COMPATIBLE_API_KEY") ?? "norn-openai-compatible";
+    const baseURL = request.credentials?.baseUrl ?? getScopedEnvironmentValue(request.environment, "OPENAI_COMPATIBLE_BASE_URL");
+    if (!baseURL) {
+      throw new Error(
+        "An OpenAI-compatible model needs an endpoint. Add a baseUrl directive to the model block, or set OPENAI_COMPATIBLE_BASE_URL in .nornenv or the process environment."
+      );
+    }
     try {
-      return new OpenAI({
-        ...apiKey ? { apiKey } : {},
-        ...baseURL ? { baseURL } : {}
-      });
+      return new OpenAI({ apiKey, baseURL });
     } catch (error2) {
       if (error2 instanceof Error && error2.message.includes("Missing credentials")) {
         throw new Error(
-          "OpenAI authentication failed. Add an apiKey directive to the model block, for example: apiKey {{$env.OPENAI_API_KEY}}.",
+          "OpenAI-compatible authentication failed. Add an apiKey directive to the model block.",
           { cause: error2 }
         );
       }
@@ -197875,7 +198641,7 @@ var OpenAIAgentAdapter = class {
             error2
           );
         }
-        const providerLabel = this.provider === "local" ? "Local OpenAI-compatible" : "OpenAI";
+        const providerLabel = this.provider === "local" ? "Local OpenAI-compatible" : "OpenAI-compatible";
         const status = error2.status ? ` (HTTP ${error2.status})` : "";
         const requestId = error2.requestID ? ` [request ${error2.requestID}]` : "";
         throw new Error(`${providerLabel} API request failed${status}: ${error2.message}${requestId}`, {
@@ -197904,82 +198670,128 @@ var OpenAIAgentAdapter = class {
         strict: true
       }
     } : void 0;
-    const tokenLimit = this.provider === "local" ? { max_tokens: request.maxTokens } : { max_completion_tokens: request.maxTokens };
-    let text = "";
+    const tokenLimit = { max_tokens: request.maxTokens };
     let resolvedModelId2 = request.modelId;
-    let inputTokens = 0;
-    let outputTokens = 0;
-    if (request.tools.length > 0) {
-      const runnableTools = prepareAgentProviderTools(request.tools).map(({ tool, providerName }) => ({
-        type: "function",
-        function: {
-          name: providerName,
-          description: tool.description || `Run ${tool.name}`,
-          parameters: tool.inputSchema,
-          parse: parseToolArguments,
-          function: async (input2) => {
+    const preparedTools = prepareAgentProviderTools(request.tools);
+    const toolsByProviderName = new Map(
+      preparedTools.map((prepared) => [prepared.providerName, prepared.tool])
+    );
+    const tools = preparedTools.map(({ tool, providerName }) => ({
+      type: "function",
+      function: {
+        name: providerName,
+        description: tool.description || `Run ${tool.name}`,
+        parameters: tool.inputSchema
+      }
+    }));
+    const turns = [];
+    const toolHistory = new AgentToolResultHistory();
+    for (let turn = 1; turn <= request.maxTurns; turn++) {
+      const call = {
+        model: request.modelId,
+        messages,
+        ...tools.length > 0 ? {
+          tools,
+          tool_choice: "auto",
+          parallel_tool_calls: false
+        } : {},
+        response_format: responseFormat,
+        ...tokenLimit
+      };
+      const estimatedInputTokens = estimateSerializedInputTokens(call);
+      assertInputBudgetAllowsCall(
+        this.provider,
+        request.inputTokenBudget,
+        estimatedInputTokens,
+        turns
+      );
+      const completion = await client.chat.completions.create(
+        call,
+        request.signal ? { signal: request.signal } : void 0
+      );
+      const message = completion.choices[0]?.message;
+      if (!message) {
+        throw new Error("OpenAI returned no assistant message.");
+      }
+      resolvedModelId2 = completion.model || request.modelId;
+      recordAgentTurnUsage(this.provider, request.inputTokenBudget, turns, {
+        inputTokens: completion.usage?.prompt_tokens ?? estimatedInputTokens,
+        outputTokens: completion.usage?.completion_tokens ?? 0,
+        ...completion.usage?.prompt_tokens_details?.cached_tokens !== void 0 ? { cachedInputTokens: completion.usage.prompt_tokens_details.cached_tokens } : {}
+      });
+      const requestedCalls = message.tool_calls?.filter((call2) => call2.type === "function") ?? [];
+      const text = message.content || "";
+      if (requestedCalls.length === 0) {
+        this.assertCompleted(message, completion.choices[0]?.finish_reason, text, request, toolCalls);
+        return {
+          text,
+          parsed: tryParseStructuredAgentOutput(text, Boolean(request.outputSchema)),
+          toolCalls,
+          usage: sumAgentTurnUsage(turns),
+          resolvedModelId: resolvedModelId2
+        };
+      }
+      if (turn >= request.maxTurns) {
+        throw new AgentTurnLimitError(
+          this.provider,
+          request.maxTurns,
+          toolCalls.length,
+          toolCalls[toolCalls.length - 1]?.name,
+          sumAgentTurnUsage(turns)
+        );
+      }
+      messages.push(message);
+      for (const callItem of requestedCalls) {
+        const tool = toolsByProviderName.get(callItem.function.name);
+        let input2 = {};
+        let preparedOutput;
+        if (!tool) {
+          preparedOutput = normalizePreparedAgentToolResult({
+            error: `Unknown tool '${callItem.function.name}'.`
+          });
+        } else {
+          try {
+            input2 = parseToolArguments2(callItem.function.arguments);
             const recorded = createRecordedToolCall(toolCalls, tool.name, input2, tool.kind);
             try {
               const output2 = await tool.execute(input2);
-              recorded.complete(output2);
-              return providerToolOutputToText(output2);
+              preparedOutput = normalizePreparedAgentToolResult(output2);
+              recorded.complete(preparedOutput.recordedOutput);
             } catch (error2) {
               const output2 = { error: error2 instanceof Error ? error2.message : String(error2) };
               recorded.complete(output2);
               if (error2 instanceof AgentToolFatalError) {
                 throw error2;
               }
-              return providerToolOutputToText(output2);
+              preparedOutput = normalizePreparedAgentToolResult(output2);
             }
+          } catch (error2) {
+            if (error2 instanceof AgentToolFatalError) {
+              throw error2;
+            }
+            preparedOutput = normalizePreparedAgentToolResult({
+              error: error2 instanceof Error ? error2.message : String(error2)
+            });
           }
         }
-      }));
-      const runner = client.chat.completions.runTools({
-        model: request.modelId,
-        messages,
-        tools: runnableTools,
-        tool_choice: "auto",
-        parallel_tool_calls: false,
-        response_format: responseFormat,
-        ...tokenLimit
-      }, { maxChatCompletions: request.maxTurns });
-      const [finalCompletion, usage] = await Promise.all([
-        runner.finalChatCompletion(),
-        runner.totalUsage()
-      ]);
-      const finalChoice = finalCompletion.choices[0];
-      if (!finalChoice) {
-        throw new Error("OpenAI returned no completion choice.");
-      }
-      text = finalChoice.message.content || "";
-      this.assertCompleted(finalChoice.message, finalChoice.finish_reason, text, request, toolCalls);
-      resolvedModelId2 = finalCompletion.model || request.modelId;
-      inputTokens = usage.prompt_tokens;
-      outputTokens = usage.completion_tokens;
-    } else {
-      const completion = await client.chat.completions.create({
-        model: request.modelId,
-        messages,
-        response_format: responseFormat,
-        ...tokenLimit
-      });
-      const message = completion.choices[0]?.message;
-      if (!message) {
-        throw new Error("OpenAI returned no assistant message.");
+        const toolMessage = {
+          role: "tool",
+          tool_call_id: callItem.id,
+          content: preparedOutput.immediateText
+        };
+        messages.push(toolMessage);
+        toolHistory.retain(() => {
+          toolMessage.content = preparedOutput.historyPlaceholder;
+        });
       }
-      text = message.content || "";
-      this.assertCompleted(message, completion.choices[0]?.finish_reason, text, request, toolCalls);
-      resolvedModelId2 = completion.model || request.modelId;
-      inputTokens = completion.usage?.prompt_tokens ?? 0;
-      outputTokens = completion.usage?.completion_tokens ?? 0;
     }
-    return {
-      text,
-      parsed: tryParseStructuredAgentOutput(text, Boolean(request.outputSchema)),
-      toolCalls,
-      usage: { inputTokens, outputTokens },
-      resolvedModelId: resolvedModelId2
-    };
+    throw new AgentTurnLimitError(
+      this.provider,
+      request.maxTurns,
+      toolCalls.length,
+      toolCalls[toolCalls.length - 1]?.name,
+      sumAgentTurnUsage(turns)
+    );
   }
   assertCompleted(message, finishReason, rawText, request, toolCalls) {
     if (message.refusal) {
@@ -198020,8 +198832,9 @@ var StaticAgentProviderRegistry = class {
 };
 function createDefaultAgentProviderRegistry() {
   return new StaticAgentProviderRegistry([
-    new OpenAIAgentAdapter("openai"),
-    new OpenAIAgentAdapter("local"),
+    new OpenAIAgentAdapter(),
+    new OpenAICompatibleAgentAdapter("openai_compatible"),
+    new OpenAICompatibleAgentAdapter("local"),
     new AnthropicAgentAdapter(),
     new GoogleAgentAdapter()
   ]);
@@ -198223,21 +199036,15 @@ function getContractDisplaySeverity(assertion) {
 // src/knowledge/knowledgeTypes.ts
 var KNOWLEDGE_TOKEN_ESTIMATOR_VERSION = "knowledge-token-estimate-v1";
 
-// src/agents/agentTypes.ts
-var DEFAULT_AGENT_MAX_TOKENS = 16e3;
-var DEFAULT_LOCAL_AGENT_MAX_TOKENS = 4096;
-var DEFAULT_AGENT_MAX_DEPTH = 5;
-var DEFAULT_AGENT_MAX_INVOCATIONS = 25;
-var DEFAULT_AGENT_MAX_TURNS = 100;
-var DEFAULT_AGENT_CONTRACT_RETRIES = 2;
-
 // src/agents/agentConfig.ts
 function resolveAgentRuntimeLimits(startPath, provider, agent) {
   const loadedConfig = startPath && findNearestConfigFile(startPath, NORN_CONFIG_FILENAME) ? loadNornConfig(startPath).config.agents : void 0;
   const providerConfig = loadedConfig?.providers?.[provider];
   const defaultMaxTokens = provider === "local" ? DEFAULT_LOCAL_AGENT_MAX_TOKENS : DEFAULT_AGENT_MAX_TOKENS;
+  const maxInputTokens = agent.maxInputTokens ?? providerConfig?.max_input_tokens ?? loadedConfig?.max_input_tokens;
   return {
     maxTokens: agent.maxTokens ?? providerConfig?.max_tokens ?? loadedConfig?.max_tokens ?? defaultMaxTokens,
+    ...maxInputTokens !== void 0 ? { maxInputTokens } : {},
     maxDepth: agent.maxDepth ?? providerConfig?.max_depth ?? loadedConfig?.max_depth ?? DEFAULT_AGENT_MAX_DEPTH,
     maxInvocations: agent.maxInvocations ?? providerConfig?.max_invocations ?? loadedConfig?.max_invocations ?? DEFAULT_AGENT_MAX_INVOCATIONS,
     maxTurns: agent.maxTurns ?? providerConfig?.max_turns ?? loadedConfig?.max_turns ?? DEFAULT_AGENT_MAX_TURNS,
@@ -198421,7 +199228,7 @@ function adaptAgentSchemaForGeneration(original, provider) {
   if (provider === "anthropic" && containsRecursiveReference(original)) {
     throw new AgentSchemaAdaptationError("Anthropic structured outputs do not support recursive JSON Schemas.");
   }
-  if ((provider === "openai" || provider === "local") && getMaximumObjectDepth(original) > 5) {
+  if ((provider === "openai" || provider === "openai_compatible" || provider === "local") && getMaximumObjectDepth(original) > 5) {
     throw new AgentSchemaAdaptationError("Norn limits OpenAI generation schemas to at most 5 nested object levels.");
   }
   const strippedKeywords = /* @__PURE__ */ new Set();
@@ -198477,7 +199284,7 @@ function adaptAgentSchemaForGeneration(original, provider) {
       transformed.additionalProperties = false;
       additionalPropertiesChanges++;
     }
-    if ((provider === "openai" || provider === "local") && properties) {
+    if ((provider === "openai" || provider === "openai_compatible" || provider === "local") && properties) {
       const authoredRequired = new Set(
         Array.isArray(schemaValue.required) ? schemaValue.required.filter((entry) => typeof entry === "string") : []
       );
@@ -198531,6 +199338,19 @@ var DEFAULT_TOOL_INPUT_SCHEMA = {
   required: ["input"],
   additionalProperties: false
 };
+function mergeAgentUsage(left, right) {
+  const leftTurns = left.turns ?? [];
+  const rightTurns = right.turns ?? [];
+  const turns = [...leftTurns, ...rightTurns].map((turn, index) => ({
+    ...turn,
+    turn: index + 1
+  }));
+  return {
+    inputTokens: left.inputTokens + right.inputTokens,
+    outputTokens: left.outputTokens + right.outputTokens,
+    ...turns.length > 0 ? { turns } : {}
+  };
+}
 function emptyAgentResult(hasReturns = false) {
   return {
     ...hasReturns ? { body: void 0 } : {},
@@ -198546,16 +199366,36 @@ function resolveAgentModelTarget(template, runtimeVariables) {
   if (/\{\{[^}]+\}\}/.test(resolved)) {
     throw new Error(`Could not resolve model target '${template}'.`);
   }
-  const match2 = resolved.match(/^(openai|anthropic|google|local)\/(.+)$/i);
+  const match2 = resolved.match(/^(openai|openai_compatible|anthropic|google|local)\/(.+)$/i);
   if (!match2 || !match2[2].trim()) {
     throw new Error(
-      `Invalid resolved model '${resolved}'. Expected openai/<model>, anthropic/<model>, google/<model>, or local/<model>.`
+      `Invalid resolved model '${resolved}'. Expected openai/<model>, openai_compatible/<model>, anthropic/<model>, google/<model>, or local/<model>.`
     );
   }
   const provider = match2[1].toLowerCase();
   const modelId = match2[2].trim();
   return { provider, modelId, displayName: `${provider}/${modelId}` };
 }
+function resolveAgentReasoningEffort(model, provider, runtimeVariables) {
+  if (model.reasoningTemplate === void 0) {
+    return void 0;
+  }
+  const resolved = substituteVariables(model.reasoningTemplate, runtimeVariables).trim().toLowerCase();
+  if (/\{\{[^}]+\}\}/.test(resolved)) {
+    throw new Error(`Could not resolve reasoning for model '${model.alias}'.`);
+  }
+  if (provider !== "openai") {
+    throw new Error(
+      `Model '${model.alias}' can declare reasoning only with provider openai; the resolved provider is '${provider}'.`
+    );
+  }
+  if (!AGENT_REASONING_EFFORTS.some((effort) => effort === resolved)) {
+    throw new Error(
+      `Invalid resolved reasoning effort '${resolved}' for model '${model.alias}'. Expected one of: ${AGENT_REASONING_EFFORTS.join(", ")}.`
+    );
+  }
+  return resolved;
+}
 function resolveAgentModelCredentials(model, runtimeVariables) {
   const resolveField = (template, directive) => {
     if (template === void 0) {
@@ -198660,8 +199500,11 @@ var AgentInvocationRunner = class {
   definitions = /* @__PURE__ */ new Map();
   conversations = /* @__PURE__ */ new Map();
   invocationBudget;
+  inputTokenBudget;
   invocationCount = 0;
+  toolResultStore = new AgentToolResultStore();
   async run(agent, input2) {
+    throwIfSequenceCancelled(this.options.signal);
     const rootInvocationIndex2 = this.options.rootInvocationIndex ?? 1;
     if (!Number.isSafeInteger(rootInvocationIndex2) || rootInvocationIndex2 < 1) {
       throw new Error(`Agent root invocation index must be a positive integer, received '${rootInvocationIndex2}'.`);
@@ -198750,6 +199593,7 @@ var AgentInvocationRunner = class {
       provider: request.provider,
       modelId: request.modelId,
       displayModel: request.displayModel,
+      ...request.reasoningEffort ? { reasoningEffort: request.reasoningEffort } : {},
       systemPrompt: request.systemPrompt,
       input: cloneSnapshotValue(request.input, null),
       conversation: (request.conversation ?? []).map((message) => ({ ...message })),
@@ -198757,6 +199601,7 @@ var AgentInvocationRunner = class {
       ...request.outputSchema ? { outputSchema: cloneSnapshotValue(request.outputSchema, {}) } : {},
       ...request.outputSchemaName ? { outputSchemaName: request.outputSchemaName } : {},
       maxTokens: request.maxTokens,
+      ...request.inputTokenBudget ? { maxInputTokens: request.inputTokenBudget.maxInputTokens } : {},
       maxTurns: request.maxTurns,
       ...mcpServerGrants?.length ? { mcpServerGrants: mcpServerGrants.map((grant) => ({
         alias: grant.alias,
@@ -198775,7 +199620,25 @@ var AgentInvocationRunner = class {
         routingRule: knowledge.routing.rule,
         selectedDomainIds: knowledge.assembly.selectedDomainIds,
         estimatedTokens: knowledge.assembly.estimatedTokens,
-        estimatorVersion: KNOWLEDGE_TOKEN_ESTIMATOR_VERSION
+        estimatorVersion: KNOWLEDGE_TOKEN_ESTIMATOR_VERSION,
+        domains: knowledge.projection.domains.map((domain2) => {
+          const selected = knowledge.assembly.selectedDomainIds.includes(domain2.encodedId);
+          return {
+            domainId: domain2.encodedId,
+            declarationAlias: domain2.declarationAlias,
+            sourcePath: domain2.sourcePath,
+            domainPath: domain2.ref.domainPath,
+            disposition: selected ? domain2.estimatedTokens <= knowledge.config.domainInlineTokenLimit ? "inline" : "index" : "manifest",
+            estimatedTokens: domain2.estimatedTokens,
+            topicCount: domain2.topics.length,
+            topics: domain2.topics.map((topic) => ({
+              topicHash: topic.topicHash,
+              ...topic.headingText ? { heading: topic.headingText } : {},
+              estimatedTokens: topic.estimatedTokens,
+              itemPaths: [...new Set(topic.occurrences.map((occurrence) => occurrence.ref.itemPath))].sort()
+            }))
+          };
+        })
       } } : {}
     };
   }
@@ -198796,7 +199659,7 @@ var AgentInvocationRunner = class {
         try {
           const output2 = await execute(input2, context);
           record2.output = cloneSnapshotValue(output2, null);
-          return output2;
+          return definition.kind === "context" ? output2 : this.toolResultStore.prepare(definition.name, output2);
         } catch (error2) {
           record2.output = getToolErrorOutput(error2);
           throw error2;
@@ -198839,6 +199702,7 @@ var AgentInvocationRunner = class {
     return hop;
   }
   async invokeAgent(agent, input2, depth, parentInvocationId, ancestors, conversation, hopPath) {
+    throwIfSequenceCancelled(this.options.signal);
     const startedAt = Date.now();
     const invocationId = this.nextInvocationId();
     const hop = {
@@ -198869,6 +199733,7 @@ var AgentInvocationRunner = class {
     let resolvedModel;
     let fatalToolError;
     let preparedKnowledge;
+    let accumulatedProviderUsage = { inputTokens: 0, outputTokens: 0 };
     try {
       const requestOverride = await this.options.resolveRequestOverride?.(hopPath);
       const authoredModel = requestOverride?.provider && requestOverride.modelId ? void 0 : resolveAgentModelTarget(
@@ -198883,6 +199748,7 @@ var AgentInvocationRunner = class {
         modelId,
         displayName: requestOverride?.displayModel ?? `${provider}/${modelId}`
       };
+      const reasoningEffort = requestOverride ? requestOverride.reasoningEffort : resolveAgentReasoningEffort(agent.model, provider, this.options.runtimeVariables);
       hop.output.model = resolvedModel.displayName;
       const configuredLimits = resolveAgentRuntimeLimits(
         this.options.startPath,
@@ -198891,7 +199757,8 @@ var AgentInvocationRunner = class {
       );
       const limits = {
         ...configuredLimits,
-        ...requestOverride?.maxTokens !== void 0 ? { maxTokens: requestOverride.maxTokens } : {}
+        ...requestOverride?.maxTokens !== void 0 ? { maxTokens: requestOverride.maxTokens } : {},
+        ...requestOverride?.maxInputTokens !== void 0 ? { maxInputTokens: requestOverride.maxInputTokens } : {}
       };
       if (!this.invocationBudget) {
         this.invocationBudget = {
@@ -198899,6 +199766,12 @@ var AgentInvocationRunner = class {
           maxInvocations: limits.maxInvocations
         };
       }
+      if (depth === 0 && limits.maxInputTokens !== void 0) {
+        this.inputTokenBudget = {
+          maxInputTokens: limits.maxInputTokens,
+          usedInputTokens: 0
+        };
+      }
       this.invocationCount++;
       this.addDefinition(agent, resolvedModel);
       const authoredSystemPrompt = requestOverride?.systemPrompt ?? substituteVariables(
@@ -198954,6 +199827,7 @@ var AgentInvocationRunner = class {
         provider: resolvedModel.provider,
         modelId: resolvedModel.modelId,
         displayModel: resolvedModel.displayName,
+        ...reasoningEffort ? { reasoningEffort } : {},
         systemPrompt,
         input: input2,
         conversation,
@@ -198961,9 +199835,11 @@ var AgentInvocationRunner = class {
         outputSchema,
         outputSchemaName,
         maxTokens: limits.maxTokens,
+        ...this.inputTokenBudget ? { inputTokenBudget: this.inputTokenBudget } : {},
         maxTurns: limits.maxTurns,
         environment: this.options.environment,
-        ...credentials ? { credentials } : {}
+        ...credentials ? { credentials } : {},
+        ...this.options.signal ? { signal: this.options.signal } : {}
       };
       hop.request = this.createRequestSnapshot(
         providerRequest,
@@ -198985,6 +199861,10 @@ var AgentInvocationRunner = class {
           ...providerRequest,
           conversation: correctionConversation
         });
+        accumulatedProviderUsage = mergeAgentUsage(
+          accumulatedProviderUsage,
+          providerResponse.usage
+        );
         hop.providerCompleted = true;
         if (fatalToolError) {
           throw fatalToolError;
@@ -198995,7 +199875,7 @@ var AgentInvocationRunner = class {
           text: providerResponse.text,
           toolCalls,
           model: `${resolvedModel.provider}/${providerResponse.resolvedModelId}`,
-          usage: providerResponse.usage,
+          usage: accumulatedProviderUsage,
           ms: Date.now() - startedAt
         };
         const returnValue = providerResponse.parsed !== void 0 ? providerResponse.parsed : providerResponse.text;
@@ -199033,10 +199913,32 @@ var AgentInvocationRunner = class {
       }
       hop.success = true;
     } catch (error2) {
+      throwIfSequenceCancelled(this.options.signal);
       const reportedError = fatalToolError ?? error2;
       if (reportedError instanceof AgentProviderMaxTokensError) {
         hop.error = formatAgentProviderMaxTokensError(agent.name, reportedError);
+      } else if (reportedError instanceof AgentInputTokenLimitError) {
+        accumulatedProviderUsage = mergeAgentUsage(
+          accumulatedProviderUsage,
+          reportedError.usage
+        );
+        hop.output.usage = accumulatedProviderUsage;
+        hop.inputTokenLimit = {
+          maxInputTokens: reportedError.maxInputTokens,
+          usedInputTokens: reportedError.usedInputTokens,
+          ...reportedError.estimatedNextInputTokens !== void 0 ? { estimatedNextInputTokens: reportedError.estimatedNextInputTokens } : {},
+          sourcePath: agent.sourcePath,
+          lineNumber: agent.lineNumber
+        };
+        hop.error = formatAgentInputTokenLimitError(agent.name, hop.inputTokenLimit);
       } else if (reportedError instanceof AgentTurnLimitError) {
+        if (reportedError.usage) {
+          accumulatedProviderUsage = mergeAgentUsage(
+            accumulatedProviderUsage,
+            reportedError.usage
+          );
+          hop.output.usage = accumulatedProviderUsage;
+        }
         hop.turnLimit = {
           maxTurns: reportedError.maxTurns,
           toolCallCount: reportedError.toolCallCount,
@@ -199097,10 +199999,12 @@ var AgentInvocationRunner = class {
       overrideKeys.add(key);
     }
     let callerLimitBreaches = 0;
-    if (agent.callableAgents.some((reference) => reference.name.toLowerCase() === "load_knowledge")) {
-      throw new Error("Agent name 'load_knowledge' is reserved by Norn for knowledge retrieval.");
+    if (agent.callableAgents.some((reference) => ["load_knowledge", "norn_read_tool_result"].includes(reference.name.toLowerCase()))) {
+      throw new Error(
+        "Agent names 'load_knowledge' and 'norn_read_tool_result' are reserved by Norn."
+      );
     }
-    if (knowledge) {
+    if (knowledge?.hasLoadableKnowledge) {
       const offeredOverride = requestToolsOverride?.find((tool) => tool.kind === "knowledge");
       providerTools.push(this.createRecordedProviderTool(parentHop, {
         name: "load_knowledge",
@@ -199403,6 +200307,25 @@ var AgentInvocationRunner = class {
         return Object.prototype.hasOwnProperty.call(child.output, "body") ? child.output.body : child.output.text;
       }));
     }
+    const offeredContext = requestToolsOverride?.find((tool) => tool.kind === "context");
+    if (!requestToolsOverride && providerTools.length > 0 || offeredContext) {
+      providerTools.push(this.createRecordedProviderTool(parentHop, {
+        name: "norn_read_tool_result",
+        providerName: offeredContext?.providerName ?? "norn_read_tool_result",
+        kind: "context",
+        description: offeredContext?.description ?? "Read or search a bounded portion of a tool result that Norn offloaded from active context.",
+        inputSchema: offeredContext?.inputSchema ?? {
+          type: "object",
+          properties: {
+            handle: { type: "string" },
+            offset: { type: "integer", minimum: 0 },
+            query: { type: "string" }
+          },
+          required: ["handle"],
+          additionalProperties: false
+        }
+      }, async (input2) => this.toolResultStore.read(input2)));
+    }
     if (requestToolsOverride) {
       const currentKeys = new Set(providerTools.map(
         (tool) => `${tool.kind ?? ""}\0${tool.name.toLowerCase()}`
@@ -200542,6 +201465,18 @@ function normalizeHopForDisk(hop, projectRoot) {
     ...extended.request !== void 0 ? {
       request: relativizeTopLevelSourcePaths(extended.request, projectRoot, true)
     } : {},
+    ...hop.turnLimit ? {
+      turnLimit: {
+        ...hop.turnLimit,
+        sourcePath: path26.isAbsolute(hop.turnLimit.sourcePath) ? projectRelativePath(projectRoot, hop.turnLimit.sourcePath) : hop.turnLimit.sourcePath
+      }
+    } : {},
+    ...hop.inputTokenLimit ? {
+      inputTokenLimit: {
+        ...hop.inputTokenLimit,
+        sourcePath: path26.isAbsolute(hop.inputTokenLimit.sourcePath) ? projectRelativePath(projectRoot, hop.inputTokenLimit.sourcePath) : hop.inputTokenLimit.sourcePath
+      }
+    } : {},
     children: hop.children.map((child) => normalizeHopForDisk(child, projectRoot))
   };
   return normalized;
@@ -200709,28 +201644,35 @@ function isSafeProjectRelativePath(value) {
   return isRelativePath(value) && !normalizePathSeparators(value).split("/").includes("..");
 }
 function isAgentToolCall(value) {
-  return isObjectRecord2(value) && typeof value.name === "string" && (value.kind === void 0 || value.kind === "mcp" || value.kind === "agent" || value.kind === "knowledge") && isObjectRecord2(value.input) && isFiniteNonNegativeNumber(value.ms) && (value.childInvocationId === void 0 || typeof value.childInvocationId === "string");
+  return isObjectRecord2(value) && typeof value.name === "string" && (value.kind === void 0 || value.kind === "mcp" || value.kind === "agent" || value.kind === "knowledge" || value.kind === "context") && isObjectRecord2(value.input) && isFiniteNonNegativeNumber(value.ms) && (value.childInvocationId === void 0 || typeof value.childInvocationId === "string");
+}
+function isAgentKnowledgeTopicSnapshot(value) {
+  return isObjectRecord2(value) && typeof value.topicHash === "string" && (value.heading === void 0 || typeof value.heading === "string") && isFiniteNonNegativeNumber(value.estimatedTokens) && isStringArray(value.itemPaths);
+}
+function isAgentKnowledgeDomainSnapshot(value) {
+  return isObjectRecord2(value) && typeof value.domainId === "string" && typeof value.declarationAlias === "string" && typeof value.sourcePath === "string" && value.sourcePath.length > 0 && typeof value.domainPath === "string" && ["inline", "index", "manifest"].includes(String(value.disposition)) && isFiniteNonNegativeNumber(value.estimatedTokens) && Number.isSafeInteger(value.topicCount) && value.topicCount >= 0 && Array.isArray(value.topics) && value.topics.every(isAgentKnowledgeTopicSnapshot);
 }
 function isAgentRequestSnapshot(value) {
-  if (!isObjectRecord2(value) || !["openai", "anthropic", "google", "local"].includes(String(value.provider)) || typeof value.modelId !== "string" || typeof value.displayModel !== "string" || typeof value.systemPrompt !== "string" || !Array.isArray(value.conversation) || !Array.isArray(value.tools) || !Number.isSafeInteger(value.maxTokens) || value.maxTokens <= 0 || !/^[0-9a-f]{64}$/.test(String(value.promptHash))) {
+  if (!isObjectRecord2(value) || !["openai", "openai_compatible", "anthropic", "google", "local"].includes(String(value.provider)) || typeof value.modelId !== "string" || typeof value.displayModel !== "string" || typeof value.systemPrompt !== "string" || !Array.isArray(value.conversation) || !Array.isArray(value.tools) || !Number.isSafeInteger(value.maxTokens) || value.maxTokens <= 0 || !/^[0-9a-f]{64}$/.test(String(value.promptHash))) {
     return false;
   }
   const validConversation = value.conversation.every(
     (message) => isObjectRecord2(message) && (message.role === "user" || message.role === "assistant") && typeof message.content === "string"
   );
   const validTools = value.tools.every(
-    (tool) => isObjectRecord2(tool) && typeof tool.name === "string" && typeof tool.providerName === "string" && (tool.kind === void 0 || tool.kind === "mcp" || tool.kind === "agent" || tool.kind === "knowledge") && (tool.description === void 0 || typeof tool.description === "string") && isObjectRecord2(tool.inputSchema)
+    (tool) => isObjectRecord2(tool) && typeof tool.name === "string" && typeof tool.providerName === "string" && (tool.kind === void 0 || tool.kind === "mcp" || tool.kind === "agent" || tool.kind === "knowledge" || tool.kind === "context") && (tool.description === void 0 || typeof tool.description === "string") && isObjectRecord2(tool.inputSchema)
   );
   const validKnowledge = value.knowledge === void 0 || isObjectRecord2(value.knowledge) && typeof value.knowledge.runId === "string" && typeof value.knowledge.snapshotId === "string" && isStringArray(value.knowledge.declarationIds) && ["exact_entity", "lexical_unique", "lexical_ambiguous", "no_match"].includes(
     String(value.knowledge.routingRule)
-  ) && isStringArray(value.knowledge.selectedDomainIds) && isFiniteNonNegativeNumber(value.knowledge.estimatedTokens) && typeof value.knowledge.estimatorVersion === "string";
-  return validConversation && validTools && validKnowledge && (value.outputSchema === void 0 || isObjectRecord2(value.outputSchema)) && (value.outputSchemaName === void 0 || typeof value.outputSchemaName === "string") && (value.sourcePath === void 0 || isSafeProjectRelativePath(value.sourcePath)) && isSafeProjectRelativePath(value.agentSourcePath) && Number.isSafeInteger(value.agentLineNumber) && value.agentLineNumber >= 0 && (value.sequenceName === void 0 || typeof value.sequenceName === "string") && (value.runLineNumber === void 0 || Number.isSafeInteger(value.runLineNumber));
+  ) && isStringArray(value.knowledge.selectedDomainIds) && isFiniteNonNegativeNumber(value.knowledge.estimatedTokens) && typeof value.knowledge.estimatorVersion === "string" && (value.knowledge.domains === void 0 || Array.isArray(value.knowledge.domains) && value.knowledge.domains.every(isAgentKnowledgeDomainSnapshot));
+  return validConversation && validTools && validKnowledge && (value.reasoningEffort === void 0 || ["none", "low", "medium", "high", "xhigh", "max"].includes(String(value.reasoningEffort))) && (value.outputSchema === void 0 || isObjectRecord2(value.outputSchema)) && (value.outputSchemaName === void 0 || typeof value.outputSchemaName === "string") && (value.maxInputTokens === void 0 || Number.isSafeInteger(value.maxInputTokens) && value.maxInputTokens > 0) && (value.maxTurns === void 0 || Number.isSafeInteger(value.maxTurns) && value.maxTurns > 0) && (value.sourcePath === void 0 || isSafeProjectRelativePath(value.sourcePath)) && isSafeProjectRelativePath(value.agentSourcePath) && Number.isSafeInteger(value.agentLineNumber) && value.agentLineNumber >= 0 && (value.sequenceName === void 0 || typeof value.sequenceName === "string") && (value.runLineNumber === void 0 || Number.isSafeInteger(value.runLineNumber));
 }
 function isAgentResult(value) {
   if (!isObjectRecord2(value) || typeof value.text !== "string" || typeof value.model !== "string" || !Array.isArray(value.toolCalls) || !value.toolCalls.every(isAgentToolCall) || !isFiniteNonNegativeNumber(value.ms) || !isObjectRecord2(value.usage)) {
     return false;
   }
-  return isFiniteNonNegativeNumber(value.usage.inputTokens) && isFiniteNonNegativeNumber(value.usage.outputTokens);
+  const validTurns = value.usage.turns === void 0 || Array.isArray(value.usage.turns) && value.usage.turns.every((turn, index) => isObjectRecord2(turn) && turn.turn === index + 1 && isFiniteNonNegativeNumber(turn.inputTokens) && isFiniteNonNegativeNumber(turn.outputTokens) && (turn.cachedInputTokens === void 0 || isFiniteNonNegativeNumber(turn.cachedInputTokens)) && (turn.cacheWriteInputTokens === void 0 || isFiniteNonNegativeNumber(turn.cacheWriteInputTokens)));
+  return isFiniteNonNegativeNumber(value.usage.inputTokens) && isFiniteNonNegativeNumber(value.usage.outputTokens) && validTurns;
 }
 function isAgentContract(value) {
   return isObjectRecord2(value) && (value.kind === "accepts" || value.kind === "returns") && typeof value.path === "string" && isObjectRecord2(value.assertion);
@@ -200742,7 +201684,7 @@ function isAgentHop(value) {
   if (!isObjectRecord2(value) || typeof value.invocationId !== "string" || typeof value.agent !== "string" || typeof value.success !== "boolean" || !Number.isSafeInteger(value.depth) || value.depth < 0 || typeof value.cycle !== "boolean" || !isAgentResult(value.output) || !Array.isArray(value.children) || !Array.isArray(value.retries) || !isStringArray(value.warnings)) {
     return false;
   }
-  return (value.parentInvocationId === void 0 || typeof value.parentInvocationId === "string") && (value.hopPath === void 0 || typeof value.hopPath === "string") && (value.request === void 0 || isAgentRequestSnapshot(value.request)) && (value.providerAttempted === void 0 || typeof value.providerAttempted === "boolean") && (value.providerCompleted === void 0 || typeof value.providerCompleted === "boolean") && (value.contractExhausted === void 0 || typeof value.contractExhausted === "boolean") && (value.error === void 0 || typeof value.error === "string") && (value.accepts === void 0 || isAgentContract(value.accepts)) && (value.returns === void 0 || isAgentContract(value.returns)) && value.retries.every(isAgentRetry) && value.children.every(isAgentHop);
+  return (value.parentInvocationId === void 0 || typeof value.parentInvocationId === "string") && (value.hopPath === void 0 || typeof value.hopPath === "string") && (value.request === void 0 || isAgentRequestSnapshot(value.request)) && (value.providerAttempted === void 0 || typeof value.providerAttempted === "boolean") && (value.providerCompleted === void 0 || typeof value.providerCompleted === "boolean") && (value.contractExhausted === void 0 || typeof value.contractExhausted === "boolean") && (value.inputTokenLimit === void 0 || isObjectRecord2(value.inputTokenLimit) && Number.isSafeInteger(value.inputTokenLimit.maxInputTokens) && value.inputTokenLimit.maxInputTokens > 0 && isFiniteNonNegativeNumber(value.inputTokenLimit.usedInputTokens) && (value.inputTokenLimit.estimatedNextInputTokens === void 0 || isFiniteNonNegativeNumber(value.inputTokenLimit.estimatedNextInputTokens)) && isSafeProjectRelativePath(value.inputTokenLimit.sourcePath) && Number.isSafeInteger(value.inputTokenLimit.lineNumber) && value.inputTokenLimit.lineNumber >= 0) && (value.error === void 0 || typeof value.error === "string") && (value.accepts === void 0 || isAgentContract(value.accepts)) && (value.returns === void 0 || isAgentContract(value.returns)) && value.retries.every(isAgentRetry) && value.children.every(isAgentHop);
 }
 function isAgentTrace(value) {
   if (!isObjectRecord2(value) || !Array.isArray(value.agents) || !Array.isArray(value.hops)) {
@@ -202959,6 +203901,14 @@ function readKnowledgeSnapshot(startPath, snapshotId, options = {}) {
 function encodeKnowledgeId(parts) {
   return Buffer.from(canonicalJson(parts), "utf8").toString("base64url");
 }
+function decodeKnowledgeId(value) {
+  try {
+    const parsed = JSON.parse(Buffer.from(value, "base64url").toString("utf8"));
+    return Array.isArray(parsed) ? parsed : void 0;
+  } catch {
+    return void 0;
+  }
+}
 
 // src/knowledge/knowledgeAssembly.ts
 function estimateKnowledgeTokens(rendered) {
@@ -202998,10 +203948,10 @@ function renderKnowledgeTopicIndex(domain2) {
     }))
   };
 }
-function renderKnowledgeDomainBodies(domain2) {
+function renderKnowledgeDomainBodies(domain2, topics = domain2.topics) {
   return {
     domainId: domain2.encodedId,
-    topics: domain2.topics.map((topic) => ({
+    topics: topics.map((topic) => ({
       topicHash: topic.topicHash,
       heading: topic.headingText,
       body: topic.body,
@@ -203363,20 +204313,30 @@ var KnowledgeRunCoordinator = class {
     const routing = routeKnowledge(this.projectRoot, input2, projection, config2, agent.name);
     const assembly = assembleKnowledgePrompt(authoredSystemPrompt, projection, routing, config2, agent.name);
     const loadEvents = [];
+    const loadedTopicHashes = new Set(assembly.initiallyLoadedTopics.map((topic) => topic.topicHash));
+    const loadedTopicIndexes = new Set(projection.domains.filter((domain2) => assembly.selectedDomainIds.includes(domain2.encodedId) && domain2.estimatedTokens > config2.domainInlineTokenLimit).map((domain2) => domain2.encodedId));
+    const loadableDomains = projection.domains.filter(
+      (domain2) => domain2.topics.some((topic) => !loadedTopicHashes.has(topic.topicHash)) || domain2.estimatedTokens > config2.domainInlineTokenLimit && !loadedTopicIndexes.has(domain2.encodedId)
+    );
+    const loadableTopicHashes = [...new Set(loadableDomains.flatMap((domain2) => domain2.topics).filter((topic) => !loadedTopicHashes.has(topic.topicHash)).map((topic) => topic.topicHash))];
     let usedTokens = 0;
     const tool = {
       name: "load_knowledge",
       providerName: "norn_load_knowledge",
       kind: "knowledge",
-      description: "Load one granted knowledge domain or a topic occurrence by the exact IDs in the manifest.",
+      description: "Load only knowledge that remains available. Never request a domain listed in norn_routed_knowledge.inlineDomainIds; those bodies were already supplied. For an oversized routed domain whose topic index was supplied, request a specific topicHash rather than the domain index again.",
       inputSchema: { type: "object", properties: {
-        domainId: { type: "string" },
-        topicHash: { type: "string" },
+        domainId: { type: "string", enum: loadableDomains.map((domain2) => domain2.encodedId) },
+        topicHash: { type: "string", enum: loadableTopicHashes },
         occurrenceId: { type: "string" }
       }, required: ["domainId"], additionalProperties: false },
       execute: async (raw) => {
         const request = raw;
         const before = usedTokens;
+        const alreadyLoaded = () => ({
+          alreadyLoaded: true,
+          message: "This knowledge has already been loaded."
+        });
         const refuse = (code, message) => {
           loadEvents.push({
             order: loadEvents.length + 1,
@@ -203402,6 +204362,8 @@ var KnowledgeRunCoordinator = class {
           return refuse("unknown_or_ungranted_domain", "The requested domain ID is unknown or not granted.");
         }
         let value;
+        let newlyLoadedTopicHashes = [];
+        let loadedTopicIndex = false;
         if (request.topicHash) {
           const topic = domain2.topics.find((item) => item.topicHash === request.topicHash);
           if (!topic) {
@@ -203423,6 +204385,9 @@ var KnowledgeRunCoordinator = class {
               return refuse("unknown_or_ungranted_occurrence", "The occurrence ID is not exposed by this domain.");
             }
           }
+          if (loadedTopicHashes.has(topic.topicHash)) {
+            return alreadyLoaded();
+          }
           value = { domainId: domain2.encodedId, topic: {
             topicHash: topic.topicHash,
             heading: topic.headingText,
@@ -203434,8 +204399,22 @@ var KnowledgeRunCoordinator = class {
               useWhen: item.metadata.useWhen?.value
             }))
           } };
+          newlyLoadedTopicHashes = [topic.topicHash];
         } else {
-          value = domain2.estimatedTokens <= config2.domainInlineTokenLimit ? renderKnowledgeDomainBodies(domain2) : renderKnowledgeTopicIndex(domain2);
+          if (domain2.estimatedTokens <= config2.domainInlineTokenLimit) {
+            const unloadedTopics = domain2.topics.filter((topic) => !loadedTopicHashes.has(topic.topicHash));
+            if (!unloadedTopics.length) {
+              return alreadyLoaded();
+            }
+            value = renderKnowledgeDomainBodies(domain2, unloadedTopics);
+            newlyLoadedTopicHashes = unloadedTopics.map((topic) => topic.topicHash);
+          } else {
+            if (loadedTopicIndexes.has(domain2.encodedId)) {
+              return alreadyLoaded();
+            }
+            value = renderKnowledgeTopicIndex(domain2);
+            loadedTopicIndex = true;
+          }
         }
         const output2 = escapedCanonicalKnowledgeJson(value);
         const estimatedTokens = estimateKnowledgeTokens(output2);
@@ -203443,11 +204422,18 @@ var KnowledgeRunCoordinator = class {
           return refuse("tool_token_limit", `The request would exceed knowledge.toolTokenLimit=${config2.toolTokenLimit}.`);
         }
         usedTokens += estimatedTokens;
+        for (const topicHash of newlyLoadedTopicHashes) {
+          loadedTopicHashes.add(topicHash);
+        }
+        if (loadedTopicIndex) {
+          loadedTopicIndexes.add(domain2.encodedId);
+        }
         loadEvents.push({
           order: loadEvents.length + 1,
           request,
           accepted: true,
           estimatedTokens,
+          loadedTopicHashes: newlyLoadedTopicHashes,
           budgetBefore: before,
           budgetAfter: usedTokens
         });
@@ -203455,7 +204441,17 @@ var KnowledgeRunCoordinator = class {
       }
     };
     void invocationId;
-    return { runId: this.runId, snapshotId, projection, routing, assembly, tool, loadEvents, config: config2 };
+    return {
+      runId: this.runId,
+      snapshotId,
+      projection,
+      routing,
+      assembly,
+      tool,
+      hasLoadableKnowledge: loadableDomains.length > 0,
+      loadEvents,
+      config: config2
+    };
   }
   recordInvocation(agent, hop, knowledge) {
     this.invocations.push({ agent, hop, knowledge });
@@ -203510,7 +204506,8 @@ var KnowledgeRunCoordinator = class {
               accepts: item.hop.accepts,
               returns: item.hop.returns,
               judge: item.hop.judge,
-              turnLimit: item.hop.turnLimit
+              turnLimit: item.hop.turnLimit,
+              inputTokenLimit: item.hop.inputTokenLimit
             })
           );
           if (!item.knowledge) {
@@ -203614,7 +204611,11 @@ var KnowledgeRunCoordinator = class {
                   event.estimatedTokens
                 );
               } else if (event.accepted) {
+                const loadedTopicHashes = event.loadedTopicHashes ? new Set(event.loadedTopicHashes) : void 0;
                 for (const topic of domain2.topics) {
+                  if (loadedTopicHashes && !loadedTopicHashes.has(topic.topicHash)) {
+                    continue;
+                  }
                   for (const occurrence of topic.occurrences) {
                     index.run(
                       `INSERT OR REPLACE INTO run_topics(run_id, invocation_id,
@@ -204824,9 +205825,6 @@ function valueToString2(value) {
   }
   return String(value);
 }
-function sleep5(ms) {
-  return new Promise((resolve28) => setTimeout(resolve28, ms));
-}
 function isIfCommand(line2) {
   return /^if\s+.+$/i.test(line2.trim());
 }
@@ -205333,6 +206331,10 @@ async function runSequenceWithJar(sequenceContent, fileVariables, cookieJar, wor
   };
   const runtimeVariables = copyEnvironmentScope({ ...fileVariables, ...sequenceArgs }, fileVariables);
   const mcpSessionManager = executionContext?.mcpSessionManager ?? new McpSessionManager();
+  const cancelMcpSessions = () => {
+    void mcpSessionManager.closeAll();
+  };
+  executionContext?.signal?.addEventListener("abort", cancelMcpSessions, { once: true });
   const agentProviderRegistry = executionContext?.agentProviderRegistry ?? createDefaultAgentProviderRegistry();
   const agentWarningKeys = executionContext?.agentWarningKeys ?? /* @__PURE__ */ new Set();
   const agentEventLog = executionContext?.agentEventLog ?? [];
@@ -205547,6 +206549,7 @@ async function runSequenceWithJar(sequenceContent, fileVariables, cookieJar, wor
       }
     };
     for (const step of steps) {
+      throwIfSequenceCancelled(executionContext?.signal);
       if (step.type === "judge") {
         const parsedJudge = parseJudgeStep(step);
         const blockingError = parsedJudge.errors[0];
@@ -205644,6 +206647,7 @@ async function runSequenceWithJar(sequenceContent, fileVariables, cookieJar, wor
       try {
         await preflightAgentGraph(definition, scope);
       } catch (error2) {
+        throwIfSequenceCancelled(executionContext?.signal);
         await mcpSessionManager.closeScope(MCP_PREFLIGHT_SCOPE);
         const message = `Agent '${definition.name}' tool preflight failed: ${error2 instanceof Error ? error2.message : String(error2)}`;
         errors.push(message);
@@ -205663,8 +206667,10 @@ async function runSequenceWithJar(sequenceContent, fileVariables, cookieJar, wor
       await mcpSessionManager.closeScope(MCP_PREFLIGHT_SCOPE);
     }
     for (let stepIdx = 0; stepIdx < steps.length; stepIdx++) {
+      throwIfSequenceCancelled(executionContext?.signal);
       const step = steps[stepIdx];
       await emitBeforeStep(step, stepIdx);
+      throwIfSequenceCancelled(executionContext?.signal);
       const stepStartTime = Date.now();
       try {
         if (step.type === "if") {
@@ -205752,7 +206758,7 @@ async function runSequenceWithJar(sequenceContent, fileVariables, cookieJar, wor
         if (step.type === "wait") {
           const durationMs = parseWaitCommand(step.content);
           reportProgress(stepIdx, "wait", `wait: ${durationMs}ms`);
-          await sleep5(durationMs);
+          await cancellableDelay(durationMs, executionContext?.signal);
           const stepResult = createPrintStepResult(
             stepIdx,
             stepStartTime,
@@ -205954,6 +206960,7 @@ async function runSequenceWithJar(sequenceContent, fileVariables, cookieJar, wor
               runLineNumber: debugLocation.absoluteLine,
               rootInvocationIndex: rootInvocationIndex2,
               knowledgeCoordinator,
+              signal: executionContext?.signal,
               expandMcpServerGrants: (_hopPath, grantedAgent) => mcpGrantExpansions.get(agentDefinitionKey(grantedAgent)) ?? expandMcpGrantsLive(grantedAgent),
               onInvocationProgress: (agentEvent) => {
                 const recordedEvent = cloneSerializableValue(agentEvent);
@@ -206012,6 +207019,7 @@ async function runSequenceWithJar(sequenceContent, fileVariables, cookieJar, wor
               }
             }
           } catch (error2) {
+            throwIfSequenceCancelled(executionContext?.signal);
             execution.error = error2 instanceof Error ? error2.message : String(error2);
           }
           const stepResult = {
@@ -206090,6 +207098,7 @@ ${describeUnmetExpectations(verdict).map((line2) => `  - ${line2}`).join("\n")}`
               runLineNumber: debugLocation.absoluteLine,
               rootInvocationIndex: rootInvocationIndex2,
               knowledgeCoordinator,
+              signal: executionContext?.signal,
               expandMcpServerGrants: (_hopPath, grantedAgent) => mcpGrantExpansions.get(agentDefinitionKey(grantedAgent)) ?? expandMcpGrantsLive(grantedAgent),
               onInvocationProgress: (agentEvent) => {
                 const recordedEvent = cloneSerializableValue(agentEvent);
@@ -206116,6 +207125,7 @@ ${describeUnmetExpectations(verdict).map((line2) => `  - ${line2}`).join("\n")}`
               addTraceDefinition(definition);
             }
           } catch (error2) {
+            throwIfSequenceCancelled(executionContext?.signal);
             const message = error2 instanceof Error ? error2.message : String(error2);
             if (agent?.returns) {
               output2 = { ...output2, body: void 0 };
@@ -206314,7 +207324,8 @@ ${describeUnmetExpectations(verdict).map((line2) => `  - ${line2}`).join("\n")}`
                   workingDir: adapterWorkingDir
                 }
               },
-              adapterWorkingDir
+              adapterWorkingDir,
+              executionContext?.signal
             );
             let storedValue;
             let sqlResult;
@@ -206361,6 +207372,7 @@ ${describeUnmetExpectations(verdict).map((line2) => `  - ${line2}`).join("\n")}`
             const description = operation.type === "query" ? `run sql ${operation.name} \u2192 ${sqlResult.rowCount ?? 0} row(s)` : `run sql ${operation.name} \u2192 ${sqlResult.affectedRows ?? 0} affected`;
             reportProgress(stepIdx, "sql", description, stepResult);
           } catch (error2) {
+            throwIfSequenceCancelled(executionContext?.signal);
             errors.push(`SQL execution failed for '${operation.name}': ${error2.message || String(error2)}`);
             await emitFailure(`SQL execution failed for '${operation.name}'`, step, stepIdx);
             return {
@@ -206414,6 +207426,7 @@ ${describeUnmetExpectations(verdict).map((line2) => `  - ${line2}`).join("\n")}`
             orderedSteps.push(stepResult);
             reportProgress(stepIdx, "mcp", `run mcp list ${parsed.serverAlias} \u2192 ${listResult.tools.length} tool(s)`, stepResult);
           } catch (error2) {
+            throwIfSequenceCancelled(executionContext?.signal);
             const message = `MCP list failed for '${parsed.serverAlias}': ${error2?.message || String(error2)}`;
             errors.push(message);
             await emitFailure(message, step, stepIdx);
@@ -206465,6 +207478,7 @@ ${describeUnmetExpectations(verdict).map((line2) => `  - ${line2}`).join("\n")}`
               parsed.toolName
             );
           } catch (error2) {
+            throwIfSequenceCancelled(executionContext?.signal);
             const message = `MCP call failed for '${parsed.serverAlias}.${parsed.toolName}': ${error2?.message || String(error2)}`;
             errors.push(message);
             await emitFailure(message, step, stepIdx);
@@ -206534,6 +207548,7 @@ ${describeUnmetExpectations(verdict).map((line2) => `  - ${line2}`).join("\n")}`
               };
             }
           } catch (error2) {
+            throwIfSequenceCancelled(executionContext?.signal);
             const message = `MCP call failed for '${parsed.serverAlias}.${parsed.toolName}': ${error2?.message || String(error2)}`;
             errors.push(message);
             await emitFailure(message, step, stepIdx);
@@ -206596,7 +207611,7 @@ ${describeUnmetExpectations(verdict).map((line2) => `  - ${line2}`).join("\n")}`
                 reportProgress(stepIdx, "request", `[Retry ${attempt}/${total}] ${requestDescription} - waiting ${waitMs}ms`, void 0);
               }
             } : void 0;
-            const response = cookieJar ? await sendRequestWithJar(requestParsed, cookieJar, retryOpts) : await sendRequest(requestParsed, retryOpts);
+            const response = cookieJar ? await sendRequestWithJar(requestParsed, cookieJar, retryOpts, executionContext?.signal) : await sendRequest(requestParsed, retryOpts, executionContext?.signal);
             addResponse(response);
             runContractValidation(preparedRequest.endpointName, response, step, stepIdx);
             responseIndexToVariable.set(responses.length, parsed.varName);
@@ -206622,6 +207637,7 @@ ${describeUnmetExpectations(verdict).map((line2) => `  - ${line2}`).join("\n")}`
               }
             }
           } catch (error2) {
+            throwIfSequenceCancelled(executionContext?.signal);
             const userMessage = formatUserFacingError(
               error2,
               buildRequestValidationContext(stepIdx + 1, void 0, void 0, `var ${parsed.varName}`)
@@ -206674,7 +207690,8 @@ ${indentMultiline(userMessage)}`;
               substitutedArgs,
               workingDir || process.cwd(),
               runtimeVariables,
-              parsed.captureAs
+              parsed.captureAs,
+              executionContext?.signal
             );
             scriptResults.push(result);
             const stepResult = {
@@ -206707,6 +207724,7 @@ ${indentMultiline(userMessage)}`;
               runtimeVariables[parsed.captureAs] = outputValue;
             }
           } catch (error2) {
+            throwIfSequenceCancelled(executionContext?.signal);
             errors.push(`Script execution error: ${error2.message}`);
             return {
               name: "",
@@ -206812,7 +207830,8 @@ ${indentMultiline(userMessage)}`;
               agentEventLog,
               agentRootInvocationCounts,
               recordAgentRuns: executionContext?.recordAgentRuns,
-              knowledgeCoordinator
+              knowledgeCoordinator,
+              signal: executionContext?.signal
             };
             const subResult = await runSequenceWithJar(
               targetSequence.content,
@@ -206905,7 +207924,7 @@ ${indentMultiline(userMessage)}`;
                 reportProgress(stepIdx, "request", `[Retry ${attempt}/${total}] run ${targetName} - waiting ${waitMs}ms`, void 0);
               }
             } : void 0;
-            const response = cookieJar ? await sendRequestWithJar(requestParsed, cookieJar, retryOpts) : await sendRequest(requestParsed, retryOpts);
+            const response = cookieJar ? await sendRequestWithJar(requestParsed, cookieJar, retryOpts, executionContext?.signal) : await sendRequest(requestParsed, retryOpts, executionContext?.signal);
             addResponse(response);
             const stepResult = {
               type: "request",
@@ -206927,6 +207946,7 @@ ${indentMultiline(userMessage)}`;
               }
             }
           } catch (error2) {
+            throwIfSequenceCancelled(executionContext?.signal);
             const userMessage = formatUserFacingError(
               error2,
               buildRequestValidationContext(stepIdx + 1, requestMethod || void 0, requestUrl || void 0, targetName)
@@ -207016,7 +208036,7 @@ ${indentMultiline(userMessage)}`;
                   reportProgress(stepIdx, "request", `[Retry ${attempt}/${total}] var ${varName} = run ${sequenceName} - waiting ${waitMs}ms`, void 0);
                 }
               } : void 0;
-              const response = cookieJar ? await sendRequestWithJar(requestParsed, cookieJar, retryOpts) : await sendRequest(requestParsed, retryOpts);
+              const response = cookieJar ? await sendRequestWithJar(requestParsed, cookieJar, retryOpts, executionContext?.signal) : await sendRequest(requestParsed, retryOpts, executionContext?.signal);
               addResponse(response);
               responseIndexToVariable.set(responses.length, varName);
               const stepResult = {
@@ -207047,6 +208067,7 @@ ${indentMultiline(userMessage)}`;
                 }
               }
             } catch (error2) {
+              throwIfSequenceCancelled(executionContext?.signal);
               const userMessage = formatUserFacingError(
                 error2,
                 buildRequestValidationContext(stepIdx + 1, requestMethod || void 0, requestUrl || void 0, `${varName} = run ${sequenceName}`)
@@ -207132,7 +208153,8 @@ ${indentMultiline(userMessage)}`;
             agentEventLog,
             agentRootInvocationCounts,
             recordAgentRuns: executionContext?.recordAgentRuns,
-            knowledgeCoordinator
+            knowledgeCoordinator,
+            signal: executionContext?.signal
           };
           const subResult = await runSequenceWithJar(
             targetSequence.content,
@@ -207224,7 +208246,7 @@ ${indentMultiline(userMessage)}`;
                 reportProgress(stepIdx, "request", `[Retry ${attempt}/${total}] ${requestDescription} - waiting ${waitMs}ms`, void 0);
               }
             } : void 0;
-            const response = cookieJar ? await sendRequestWithJar(parsed, cookieJar, retryOpts) : await sendRequest(parsed, retryOpts);
+            const response = cookieJar ? await sendRequestWithJar(parsed, cookieJar, retryOpts, executionContext?.signal) : await sendRequest(parsed, retryOpts, executionContext?.signal);
             addResponse(response);
             const stepResult = {
               type: "request",
@@ -207247,6 +208269,7 @@ ${indentMultiline(userMessage)}`;
               }
             }
           } catch (error2) {
+            throwIfSequenceCancelled(executionContext?.signal);
             const userMessage = formatUserFacingError(
               error2,
               buildRequestValidationContext(stepIdx + 1)
@@ -207272,7 +208295,9 @@ ${indentMultiline(userMessage)}`;
           }
         }
       } finally {
-        await emitAfterStep(step, stepIdx);
+        if (!executionContext?.signal?.aborted) {
+          await emitAfterStep(step, stepIdx);
+        }
       }
     }
     return {
@@ -207288,16 +208313,23 @@ ${indentMultiline(userMessage)}`;
       agentTrace,
       completed: true
     };
+  } catch (error2) {
+    if (executionContext?.signal?.aborted) {
+      throw new SequenceCancelledError();
+    }
+    throw error2;
   } finally {
+    executionContext?.signal?.removeEventListener("abort", cancelMcpSessions);
+    const wasCancelled = executionContext?.signal?.aborted === true;
     let recordingPath;
-    const shouldRecordAgentRun = nestingDepth === 0 && agentTrace.hops.length > 0 && (executionContext?.recordAgentRuns ?? executionContext?.agentProviderRegistry === void 0);
+    const shouldRecordAgentRun = !wasCancelled && nestingDepth === 0 && agentTrace.hops.length > 0 && (executionContext?.recordAgentRuns ?? executionContext?.agentProviderRegistry === void 0);
     if (shouldRecordAgentRun && executionContext?.filePath) {
       try {
         recordingPath = writeAgentRunRecording({
           sourcePath: executionContext.filePath,
           sequenceName: executionContext.sequenceName || "sequence",
           ...executionContext.environment?.activeEnvironment ? { environmentName: executionContext.environment.activeEnvironment } : {},
-          success: errors.filter((error2) => !error2.startsWith("Warning")).length === 0 && contractViolations === 0 && agentFailures === 0,
+          success: !wasCancelled && errors.filter((error2) => !error2.startsWith("Warning")).length === 0 && contractViolations === 0 && agentFailures === 0,
           durationMs: Date.now() - startTime,
           ...knowledgeCoordinator?.pinnedSnapshotId ? {
             runId: knowledgeCoordinator.runId,
@@ -207322,7 +208354,7 @@ ${indentMultiline(userMessage)}`;
           environmentName: executionContext.environment?.activeEnvironment,
           startedAt: new Date(startTime),
           durationMs: Date.now() - startTime,
-          success: errors.filter((error2) => !error2.startsWith("Warning")).length === 0 && contractViolations === 0 && agentFailures === 0,
+          success: !wasCancelled && errors.filter((error2) => !error2.startsWith("Warning")).length === 0 && contractViolations === 0 && agentFailures === 0,
           recordingPath,
           secrets: resolveAgentRecordingSecretValues(
             executionContext.filePath,
@@ -207654,6 +208686,20 @@ function redactAgentRequestForJson(request, redaction) {
     agentSourcePath: redactString(request.agentSourcePath, redaction),
     sourcePath: request.sourcePath ? redactString(request.sourcePath, redaction) : void 0,
     sequenceName: request.sequenceName ? redactString(request.sequenceName, redaction) : void 0,
+    knowledge: request.knowledge ? {
+      ...request.knowledge,
+      domains: request.knowledge.domains?.map((domain2) => ({
+        ...domain2,
+        declarationAlias: redactString(domain2.declarationAlias, redaction),
+        sourcePath: redactString(domain2.sourcePath, redaction),
+        domainPath: redactString(domain2.domainPath, redaction),
+        topics: domain2.topics.map((topic) => ({
+          ...topic,
+          heading: topic.heading ? redactString(topic.heading, redaction) : void 0,
+          itemPaths: topic.itemPaths.map((itemPath) => redactString(itemPath, redaction))
+        }))
+      }))
+    } : void 0,
     promptHash: (0, import_crypto11.createHash)("sha256").update(systemPrompt, "utf8").digest("hex")
   };
 }
@@ -207673,6 +208719,10 @@ function redactAgentHopForJson(hop, redaction) {
       sourcePath: redactString(hop.turnLimit.sourcePath, redaction),
       ...hop.turnLimit.lastToolName ? { lastToolName: redactString(hop.turnLimit.lastToolName, redaction) } : {}
     } : void 0,
+    inputTokenLimit: hop.inputTokenLimit ? {
+      ...hop.inputTokenLimit,
+      sourcePath: redactString(hop.inputTokenLimit.sourcePath, redaction)
+    } : void 0,
     warnings: hop.warnings.map((warning) => redactString(warning, redaction)),
     accepts: redactAgentContractForJson(hop.accepts, redaction),
     returns: redactAgentContractForJson(hop.returns, redaction),
@@ -207689,7 +208739,7 @@ function redactAgentHopForJson(hop, redaction) {
       body: redactBody(hop.output.body, redaction),
       text: typeof redactedText === "string" ? redactedText : String(redactedText ?? ""),
       model: redactString(hop.output.model, redaction),
-      toolCalls: hop.output.toolCalls.map((toolCall) => ({
+      toolCalls: hop.output.toolCalls.filter((toolCall) => toolCall.kind !== "context" && !(toolCall.kind === "knowledge" && toolCall.output && typeof toolCall.output === "object" && !Array.isArray(toolCall.output) && toolCall.output.alreadyLoaded === true)).map((toolCall) => ({
         ...toolCall,
         name: redactString(toolCall.name, redaction),
         input: redactBody(toolCall.input, redaction),
@@ -207929,6 +208979,9 @@ function isFailedToolResult(value) {
   const record2 = value;
   return Object.keys(record2).length === 1 && typeof record2.error === "string";
 }
+function isKnowledgeAlreadyLoaded(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value) && value.alreadyLoaded === true);
+}
 function getReplyValue(hop) {
   if (hop.output.text.trim().length > 0) {
     return { present: true, value: hop.output.text };
@@ -208006,6 +209059,9 @@ function formatAgentHopAtDepth(hop, options, displayDepth) {
   const renderedChildren = /* @__PURE__ */ new Set();
   const childrenByInvocationId = new Map(hop.children.map((child) => [child.invocationId, child]));
   for (const toolCall of hop.output.toolCalls) {
+    if (toolCall.kind === "context" || toolCall.kind === "knowledge" && isKnowledgeAlreadyLoaded(toolCall.output)) {
+      continue;
+    }
     if (toolCall.kind === "agent" || toolCall.childInvocationId) {
       const child = toolCall.childInvocationId ? childrenByInvocationId.get(toolCall.childInvocationId) : void 0;
       if (child) {
@@ -210854,6 +211910,42 @@ async function runK8sRunbooks(text, options = {}) {
 var import_util8 = require("util");
 
 // src/agents/agentHopPresentation.ts
+function buildAgentKnowledgePresentation(knowledge) {
+  if (!knowledge) {
+    return void 0;
+  }
+  const domains = knowledge.domains ? knowledge.domains.map((domain2) => ({
+    domainId: domain2.domainId,
+    declarationAlias: domain2.declarationAlias,
+    sourcePath: domain2.sourcePath,
+    domainPath: domain2.domainPath,
+    disposition: domain2.disposition,
+    estimatedTokens: domain2.estimatedTokens,
+    topicCount: domain2.topicCount,
+    topics: domain2.topics.map((topic) => ({
+      topicHash: topic.topicHash,
+      ...topic.heading ? { heading: topic.heading } : {},
+      estimatedTokens: topic.estimatedTokens,
+      itemPaths: [...topic.itemPaths]
+    }))
+  })) : knowledge.selectedDomainIds.map((domainId) => {
+    const parts = decodeKnowledgeId(domainId);
+    const domainPath = typeof parts?.[2] === "string" ? parts[2] : "Recorded domain";
+    return {
+      domainId,
+      domainPath,
+      disposition: "selected",
+      topics: []
+    };
+  });
+  return {
+    routingRule: knowledge.routingRule,
+    estimatedTokens: knowledge.estimatedTokens,
+    estimatorVersion: knowledge.estimatorVersion,
+    detailsComplete: knowledge.domains !== void 0,
+    domains
+  };
+}
 function isSameAgentContract(left, right) {
   return Boolean(
     left && right && left.kind === right.kind && left.path === right.path && left.assertion.passed === right.assertion.passed && left.assertion.expression === right.assertion.expression && left.assertion.error === right.assertion.error
@@ -210906,15 +211998,25 @@ function deriveAgentHopPresentation(hop) {
         ...hop.turnLimit.lastToolName ? { lastToolName: hop.turnLimit.lastToolName } : {}
       }
     } : {},
+    ...hop.inputTokenLimit ? {
+      inputTokenLimit: {
+        maxInputTokens: hop.inputTokenLimit.maxInputTokens,
+        usedInputTokens: hop.inputTokenLimit.usedInputTokens,
+        ...hop.inputTokenLimit.estimatedNextInputTokens !== void 0 ? { estimatedNextInputTokens: hop.inputTokenLimit.estimatedNextInputTokens } : {}
+      }
+    } : {},
+    ...hop.request?.maxInputTokens !== void 0 ? { maxInputTokens: hop.request.maxInputTokens } : {},
     ...hop.error ? { error: hop.error } : {},
     warnings: [...hop.warnings],
     ...hop.judge ? { judge: buildAgentJudgePresentation(hop.judge) } : {},
+    ...hop.request?.knowledge ? { knowledge: buildAgentKnowledgePresentation(hop.request.knowledge) } : {},
     output: {
       model: hop.output.model,
       ms: hop.output.ms,
       usage: {
         inputTokens: hop.output.usage.inputTokens,
-        outputTokens: hop.output.usage.outputTokens
+        outputTokens: hop.output.usage.outputTokens,
+        ...hop.output.usage.turns ? { turns: hop.output.usage.turns.map((turn) => ({ ...turn })) } : {}
       },
       text: hop.output.text,
       ...Object.prototype.hasOwnProperty.call(hop.output, "body") && hop.output.body !== void 0 ? { body: hop.output.body } : {},
@@ -211008,7 +212110,13 @@ var ReplayAgentProviderAdapter = class {
 };
 
 // src/agents/agentReplay.ts
-var PROVIDERS = ["openai", "anthropic", "google", "local"];
+var PROVIDERS = [
+  "openai",
+  "openai_compatible",
+  "anthropic",
+  "google",
+  "local"
+];
 function normalizedPath(value) {
   return value.replace(/\\/g, "/").toLowerCase();
 }
@@ -211034,7 +212142,10 @@ function recordedProviderResponse(hop, provider) {
     text: hop.output.text,
     ...hasOwn4(hop.output, "body") ? { parsed: structuredClone(hop.output.body) } : {},
     toolCalls: cloneToolCalls(hop.output.toolCalls),
-    usage: { ...hop.output.usage },
+    usage: {
+      ...hop.output.usage,
+      ...hop.output.usage.turns ? { turns: hop.output.usage.turns.map((turn) => ({ ...turn })) } : {}
+    },
     resolvedModelId: resolvedModelId(hop, provider)
   };
 }
@@ -211196,8 +212307,10 @@ var ReplayCoordinator = class {
       provider: hop.request.provider,
       modelId: hop.request.modelId,
       displayModel: hop.request.displayModel,
+      ...hop.request.reasoningEffort ? { reasoningEffort: hop.request.reasoningEffort } : {},
       systemPrompt: hop.request.systemPrompt,
       maxTokens: hop.request.maxTokens,
+      ...hop.request.maxInputTokens !== void 0 ? { maxInputTokens: hop.request.maxInputTokens } : {},
       tools: hop.request.tools.map((tool) => ({
         ...tool,
         inputSchema: structuredClone(tool.inputSchema)
@@ -211375,7 +212488,8 @@ var ReplayCoordinator = class {
       let actualOutput;
       let actualError;
       try {
-        actualOutput = await currentTool.execute(structuredClone(recordedCall.input));
+        const executed = await currentTool.execute(structuredClone(recordedCall.input));
+        actualOutput = normalizePreparedAgentToolResult(executed).recordedOutput;
       } catch (error2) {
         if (kind === "mcp") {
           throw error2;