@axiom-lattice/core 10.0.0 → 10.0.2

package/dist/index.mjs

@@ -249,6 +249,11 @@ var ModelLattice = class extends BaseChatModel {
   }
 };
 
+// src/model_lattice/ModelLatticeManager.ts
+import {
+  DEFAULT_MODEL_KEY
+} from "@axiom-lattice/protocols";
+
 // src/store_lattice/InMemoryThreadStore.ts
 var InMemoryThreadStore = class {
   constructor() {
@@ -1940,10 +1945,17 @@ var InMemoryModelProviderStore = class {
       previous.map((model) => [model.modelId, model])
     );
     const incomingIds = new Set(models.map((model) => model.id));
-    const namesDefault = models.some((model) => model.isDefault === true);
-    if (namesDefault) {
+    const namedDefaultKinds = /* @__PURE__ */ new Set();
+    for (const model of models) {
+      if (model.isDefault === true) {
+        namedDefaultKinds.add(
+          model.kind ?? previousById.get(model.id)?.kind ?? "chat"
+        );
+      }
+    }
+    if (namedDefaultKinds.size > 0) {
       for (const [key5, entry] of this.models.entries()) {
-        if (entry.tenantId === tenantId2 && entry.isDefault) {
+        if (entry.tenantId === tenantId2 && entry.isDefault && namedDefaultKinds.has(entry.kind)) {
           this.models.set(key5, { ...entry, isDefault: false });
         }
       }
@@ -1968,6 +1980,7 @@ var InMemoryModelProviderStore = class {
     for (const model of models) {
       const existing = previousById.get(model.id);
       const carried = model.extra ?? existing?.extra;
+      const kind = model.kind ?? existing?.kind ?? "chat";
       const entry = {
         id: `${providerId}:${model.id}`,
         tenantId: tenantId2,
@@ -1984,10 +1997,8 @@ var InMemoryModelProviderStore = class {
         // explicit flag marks one.
         stale: model.stale ?? false,
         extra: carried && Object.keys(carried).length > 0 ? carried : void 0,
-        // Same rule as `extra`: an omitted kind keeps the stored one, and a new
-        // row — which discovery creates without a kind — starts as chat.
-        kind: model.kind ?? existing?.kind ?? "chat",
-        isDefault: model.isDefault ?? (namesDefault ? false : existing?.isDefault) ?? false,
+        kind,
+        isDefault: model.isDefault ?? (namedDefaultKinds.has(kind) ? false : existing?.isDefault) ?? false,
         discoveredAt: now
       };
       this.models.set(this.getModelKey(tenantId2, providerId, model.id), entry);
@@ -6153,6 +6164,9 @@ var scheduleLatticeManager = ScheduleLatticeManager.getInstance();
 var registerScheduleLattice = (key5, config, client) => scheduleLatticeManager.registerLattice(key5, config, client);
 var getScheduleLattice = (key5) => scheduleLatticeManager.getScheduleLattice(key5);
 
+// src/vectorstore_lattice/VectorStoreProviderManager.ts
+import { EMBEDDING_DEFAULT_KEY as EMBEDDING_DEFAULT_KEY2 } from "@axiom-lattice/protocols";
+
 // src/collection_lattice/SimpleMemoryVectorStore.ts
 import { VectorStore } from "@langchain/core/vectorstores";
 function cosineSimilarity(a, b) {
@@ -6246,6 +6260,7 @@ var SimpleMemoryVectorStore = class extends VectorStore {
 
 // src/embeddings_lattice/EmbeddingsLatticeManager.ts
 import { OpenAIEmbeddings } from "@langchain/openai";
+import { EMBEDDING_DEFAULT_KEY } from "@axiom-lattice/protocols";
 
 // src/model_lattice/buildModelLlmConfig.ts
 var ALLOWED_LLM_PROVIDERS = /* @__PURE__ */ new Set(["openai"]);
@@ -6296,6 +6311,56 @@ function buildModelLlmConfig(provider2, model) {
 }
 
 // src/model_lattice/buildModelConfig.ts
+var DEFAULT_CONTENTS_EMBEDDING_PATH = "/api/v1/services/embeddings/multimodal-embedding/multimodal-embedding";
+var DEFAULT_TEXTS_EMBEDDING_PATH = "/api/v1/services/embeddings/text-embedding/text-embedding";
+var EMBEDDING_SHAPES = [
+  "openai",
+  "contents",
+  "texts"
+];
+function trimTrailingSlashes(value) {
+  return value.replace(/\/+$/, "");
+}
+function isEmbeddingShape(value) {
+  return typeof value === "string" && EMBEDDING_SHAPES.includes(value);
+}
+function isMultimodalEmbeddingId(modelId) {
+  return /vl-embedding|multimodal-embedding/i.test(modelId);
+}
+function shapeImpliedByPath(path8) {
+  if (/\/embeddings\/text-embedding\//.test(path8)) {
+    return "texts";
+  }
+  return path8.includes("/services/embeddings/") ? "contents" : void 0;
+}
+function resolveEmbeddingShape(modelId, extra) {
+  if (isEmbeddingShape(extra.embeddingShape)) {
+    return extra.embeddingShape;
+  }
+  if (typeof extra.embeddingPath === "string") {
+    const implied = shapeImpliedByPath(extra.embeddingPath);
+    if (implied) {
+      return implied;
+    }
+  }
+  return isMultimodalEmbeddingId(modelId) ? "contents" : "openai";
+}
+function embeddingProbeCandidates(initial, modelId) {
+  const nativeOrder = /text-embedding/i.test(modelId) ? ["texts", "contents"] : ["contents", "texts"];
+  const alternates = initial === "openai" ? nativeOrder : initial === "contents" ? ["openai", "texts"] : ["openai", "contents"];
+  return [initial, ...alternates];
+}
+function resolveEmbeddingEndpoint(baseURL, shape, extra) {
+  if (shape === "openai") {
+    return `${trimTrailingSlashes(baseURL)}/embeddings`;
+  }
+  const origin = new URL(baseURL).origin;
+  const configuredPath = typeof extra.embeddingPath === "string" && extra.embeddingPath.startsWith("/") ? extra.embeddingPath : void 0;
+  const implied = configuredPath ? shapeImpliedByPath(configuredPath) : void 0;
+  const usablePath = configuredPath && (implied === void 0 || implied === shape) ? configuredPath : void 0;
+  const fallback = shape === "texts" ? DEFAULT_TEXTS_EMBEDDING_PATH : DEFAULT_CONTENTS_EMBEDDING_PATH;
+  return `${origin}${usablePath ?? fallback}`;
+}
 function numberOrUndefined(value) {
   return typeof value === "number" && Number.isFinite(value) ? value : void 0;
 }
@@ -6303,11 +6368,14 @@ function buildModelEmbeddingsConfig(provider2, model) {
   const extra = { ...model.extra ?? {} };
   delete extra.apiKeyEnvName;
   const encodingFormat = extra.encodingFormat === "float" || extra.encodingFormat === "base64" ? extra.encodingFormat : void 0;
+  const shape = resolveEmbeddingShape(model.modelId, extra);
   return {
     ...extra,
     model: model.modelId,
     baseURL: provider2.baseURL,
     apiKey: provider2.apiKey || "EMPTY",
+    shape,
+    endpoint: resolveEmbeddingEndpoint(provider2.baseURL, shape, extra),
     dimensions: numberOrUndefined(extra.dimensions),
     timeout: numberOrUndefined(extra.timeout),
     batchSize: numberOrUndefined(extra.batchSize),
@@ -6374,6 +6442,131 @@ async function loadTenantModelRow(tenantId2, key5) {
     return void 0;
   }
 }
+async function loadTenantDefaultModelRow(tenantId2, kind) {
+  try {
+    const { store: store2 } = getStoreLattice("default", "modelProvider");
+    const models = await store2.listModels(tenantId2);
+    const marked = models.find(
+      (model) => model.isDefault === true && model.kind === kind
+    );
+    if (!marked || !marked.enabled) {
+      return void 0;
+    }
+    const provider2 = await store2.getProviderById(tenantId2, marked.providerId);
+    if (!provider2 || !provider2.enabled) {
+      return void 0;
+    }
+    return { provider: provider2, model: marked };
+  } catch (error) {
+    console.error(
+      `[model_lattice] Failed to load the ${kind} default for tenant "${tenantId2}":`,
+      error
+    );
+    return void 0;
+  }
+}
+
+// src/embeddings_lattice/ServiceShapeEmbeddings.ts
+import { Embeddings } from "@langchain/core/embeddings";
+var ServiceShapeEmbeddings = class extends Embeddings {
+  constructor(params) {
+    super({});
+    this.params = params;
+  }
+  async embedDocuments(documents) {
+    if (documents.length === 0) {
+      return [];
+    }
+    return this.request(documents);
+  }
+  async embedQuery(document) {
+    const [first] = await this.request([document]);
+    if (!first) {
+      throw new Error(
+        `Embedding response for "${this.params.model}" carried no vector`
+      );
+    }
+    return first;
+  }
+  /**
+   * Build the request body for this shape.
+   *
+   * Kept in one place so the probe in the gateway and the runtime client cannot
+   * drift into testing a different body than the one actually sent.
+   */
+  body(texts) {
+    if (this.params.shape === "texts") {
+      return JSON.stringify({
+        model: this.params.model,
+        input: { texts }
+      });
+    }
+    return JSON.stringify({
+      model: this.params.model,
+      input: { contents: texts.map((text) => ({ text })) }
+    });
+  }
+  async request(texts) {
+    const controller = new AbortController();
+    const timer = setTimeout(
+      () => controller.abort(),
+      this.params.timeout && this.params.timeout > 0 ? this.params.timeout : 3e4
+    );
+    try {
+      const response = await fetch(this.params.endpoint, {
+        method: "POST",
+        headers: {
+          Accept: "application/json",
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${this.params.apiKey}`
+        },
+        body: this.body(texts),
+        signal: controller.signal
+      });
+      const body = await response.text();
+      if (!response.ok) {
+        throw new Error(
+          `Embedding upstream returned ${response.status}: ${body.slice(0, 300)}`
+        );
+      }
+      let parsed;
+      try {
+        parsed = JSON.parse(body);
+      } catch {
+        throw new Error(
+          `Embedding upstream returned invalid JSON: ${body.slice(0, 200)}`
+        );
+      }
+      const embeddings = parsed.output?.embeddings;
+      if (!Array.isArray(embeddings)) {
+        throw new Error(
+          `Embedding upstream response carried no "output.embeddings": ${body.slice(0, 200)}`
+        );
+      }
+      if (embeddings.length !== texts.length) {
+        throw new Error(
+          `Embedding upstream returned ${embeddings.length} vectors for ${texts.length} inputs`
+        );
+      }
+      return embeddings.map((entry, index) => {
+        const vector = entry?.embedding;
+        if (!Array.isArray(vector) || vector.some((value) => typeof value !== "number")) {
+          throw new Error(`Embedding ${index} is not a numeric vector`);
+        }
+        return vector;
+      });
+    } catch (error) {
+      if (error instanceof Error && error.name === "AbortError") {
+        throw new Error(
+          `Embedding request to "${this.params.endpoint}" timed out`
+        );
+      }
+      throw error;
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+};
 
 // src/embeddings_lattice/EmbeddingsLatticeManager.ts
 var EmbeddingsLatticeManager = class _EmbeddingsLatticeManager extends BaseLatticeManager {
@@ -6419,14 +6612,14 @@ var EmbeddingsLatticeManager = class _EmbeddingsLatticeManager extends BaseLatti
    * @param key `${providerId}/${modelId}`
    */
   async loadItemFromStore(tenantId2, key5) {
-    const row = await loadTenantModelRow(tenantId2, key5);
+    const row = key5 === EMBEDDING_DEFAULT_KEY ? await loadTenantDefaultModelRow(tenantId2, "embedding") : await loadTenantModelRow(tenantId2, key5);
     if (!row || row.model.kind !== "embedding") {
       return void 0;
     }
     const config = buildModelEmbeddingsConfig(row.provider, row.model);
     return {
       key: key5,
-      client: new OpenAIEmbeddings({
+      client: config.shape === "openai" ? new OpenAIEmbeddings({
         model: config.model,
         apiKey: config.apiKey,
         dimensions: config.dimensions,
@@ -6434,6 +6627,12 @@ var EmbeddingsLatticeManager = class _EmbeddingsLatticeManager extends BaseLatti
         batchSize: config.batchSize,
         encodingFormat: config.encodingFormat,
         configuration: { baseURL: config.baseURL }
+      }) : new ServiceShapeEmbeddings({
+        shape: config.shape,
+        endpoint: config.endpoint,
+        apiKey: config.apiKey,
+        model: config.model,
+        timeout: config.timeout
       }),
       label: row.model.displayName ?? row.model.modelId
     };
@@ -6558,16 +6757,20 @@ var getEmbeddingsClient = (key5) => embeddingsLatticeManager.getEmbeddingsClient
 var MemoryVectorStoreProvider = class {
   async create(params) {
     const tenantId2 = params.tenantId ?? "default";
+    const requestedKey = params.embeddingKey || EMBEDDING_DEFAULT_KEY2;
     const embeddings = await embeddingsLatticeManager.getEmbeddingsClientWithTenant(
       tenantId2,
-      params.embeddingKey
-    ) ?? await embeddingsLatticeManager.getEmbeddingsClientWithTenant(
+      requestedKey
+    ) ?? (requestedKey === EMBEDDING_DEFAULT_KEY2 ? void 0 : await embeddingsLatticeManager.getEmbeddingsClientWithTenant(
+      tenantId2,
+      EMBEDDING_DEFAULT_KEY2
+    )) ?? await embeddingsLatticeManager.getEmbeddingsClientWithTenant(
       tenantId2,
       "default"
     );
     if (!embeddings) {
       throw new Error(
-        `No embedding model "${params.embeddingKey}" registered for tenant "${tenantId2}", and no deployment default. Configure one in the model provider panel.`
+        `No embedding model "${params.embeddingKey}" registered for tenant "${tenantId2}", and no tenant or deployment default. Configure one in the model service panel.`
       );
     }
     return new SimpleMemoryVectorStore(embeddings);
@@ -11847,7 +12050,6 @@ var InMemoryMenuStore = class {
 };
 
 // src/model_lattice/ModelLatticeManager.ts
-var DEFAULT_MODEL_KEY = "default";
 var TENANT_DEFAULT_MISS_TTL_MS = 3e4;
 var ModelLatticeManager = class _ModelLatticeManager extends BaseLatticeManager {
   constructor() {
@@ -12180,6 +12382,60 @@ function listModelLatticesForTenant(tenantId2) {
   return [...byKey.values()];
 }
 
+// src/model_lattice/summarizationTrigger.ts
+var DEFAULT_SUMMARIZATION_TRIGGER_TOKENS = 17e4;
+var SUMMARIZATION_TRIGGER_RATIO = 0.85;
+function isPositiveNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0;
+}
+function unwrapBinding(model) {
+  let current = model;
+  const seen = /* @__PURE__ */ new Set();
+  while (typeof current === "object" && current !== null && !seen.has(current) && "bound" in current) {
+    seen.add(current);
+    const next = current.bound;
+    if (next === void 0 || next === current) {
+      break;
+    }
+    current = next;
+  }
+  return current;
+}
+function readContextWindow(model) {
+  const unwrapped = unwrapBinding(model);
+  if (typeof unwrapped !== "object" || unwrapped === null) {
+    return void 0;
+  }
+  const getConfig = unwrapped.getConfig;
+  if (typeof getConfig === "function") {
+    const config = getConfig.call(unwrapped);
+    if (typeof config === "object" && config !== null) {
+      const declared = config.contextWindow;
+      if (isPositiveNumber(declared)) {
+        return declared;
+      }
+    }
+  }
+  const profile = unwrapped.profile;
+  if (typeof profile === "object" && profile !== null) {
+    const maxInputTokens = profile.maxInputTokens;
+    if (isPositiveNumber(maxInputTokens)) {
+      return maxInputTokens;
+    }
+  }
+  return void 0;
+}
+function resolveSummarizationTriggerTokens(model) {
+  const contextWindow = readContextWindow(model);
+  if (contextWindow === void 0) {
+    return DEFAULT_SUMMARIZATION_TRIGGER_TOKENS;
+  }
+  return Math.max(
+    1,
+    Math.floor(contextWindow * SUMMARIZATION_TRIGGER_RATIO)
+  );
+}
+
 // src/tool_lattice/get_current_date_time/index.ts
 import z from "zod";
 
@@ -16441,26 +16697,427 @@ function withToolCallLimitStateSchema(schema6) {
   return schema6 ? schema6.extend(toolCallLimitStateSchema.shape) : toolCallLimitStateSchema;
 }
 
+// src/middlewares/runGovernance.ts
+import {
+  AIMessage as AIMessage2,
+  SystemMessage,
+  ToolMessage as ToolMessage2,
+  createMiddleware as createMiddleware2
+} from "langchain";
+import { z as z42 } from "zod";
+
+// src/middlewares/repeatedToolCallBreaker.ts
+import { AIMessage, HumanMessage, ToolMessage, createMiddleware } from "langchain";
+import { z as z41 } from "zod";
+var RepeatedToolCallError = class extends Error {
+  constructor(toolName2, count, stopThreshold, argsPreview) {
+    super(`Repeated identical tool call '${toolName2 ?? "unknown"}' ${count} times (stop threshold ${stopThreshold}).`);
+    this.name = "RepeatedToolCallError";
+    this.toolName = toolName2;
+    this.count = count;
+    this.stopThreshold = stopThreshold;
+    this.argsPreview = argsPreview;
+  }
+};
+function readLoopBreakerConfig(env = process.env) {
+  const parse = (raw, fallback) => {
+    if (raw === void 0 || raw.trim() === "") return fallback;
+    const parsed = Number(raw);
+    if (!Number.isFinite(parsed) || parsed < 0) return fallback;
+    return Math.floor(parsed);
+  };
+  return {
+    repeatWarn: parse(env.AGENT_REPEATED_TOOL_CALL_WARN, 20),
+    repeatStop: parse(env.AGENT_REPEATED_TOOL_CALL_STOP, 25),
+    runLimit: parse(env.AGENT_TOOL_CALL_RUN_LIMIT, 300),
+    skillRunLimit: parse(env.AGENT_SKILL_CALL_RUN_LIMIT, 8)
+  };
+}
+function stableStringify(value) {
+  if (Array.isArray(value)) return "[" + value.map(stableStringify).join(",") + "]";
+  if (value && typeof value === "object") {
+    const body = Object.entries(value).filter(([, item]) => item !== void 0).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([key5, item]) => JSON.stringify(key5) + ":" + stableStringify(item)).join(",");
+    return "{" + body + "}";
+  }
+  return JSON.stringify(value) ?? "null";
+}
+function normalizeToolCalls(toolCalls) {
+  return toolCalls.map((call) => ({ name: call.name ?? "", args: call.args ?? {} }));
+}
+var BREAKER_STATE_SCHEMA = z41.object({
+  repeatedToolCallSignature: z41.string().default(""),
+  repeatedToolCallCount: z41.number().default(0),
+  repeatedToolCallRunMarker: z41.string().default(""),
+  repeatedToolCallMemberSignatures: z41.array(z41.string()).default([])
+});
+function createRepeatedToolCallBreakerMiddleware(options = {}) {
+  const rawWarn = options.warnThreshold ?? 20;
+  const warnThreshold = rawWarn > 0 ? Math.max(2, rawWarn) : 0;
+  const stopThreshold = Math.max(1, options.stopThreshold ?? 25);
+  return createMiddleware({
+    name: "RepeatedToolCallBreaker",
+    stateSchema: BREAKER_STATE_SCHEMA,
+    afterModel: {
+      canJumpTo: ["end"],
+      hook: (state) => {
+        const lastAI = [...state.messages].reverse().find(AIMessage.isInstance);
+        if (!lastAI || !lastAI.tool_calls?.length) return void 0;
+        const lastHuman = [...state.messages].reverse().find(HumanMessage.isInstance);
+        const runMarker = lastHuman?.id ?? "";
+        const isNewRun = runMarker !== (state.repeatedToolCallRunMarker ?? "");
+        const normalized = normalizeToolCalls(lastAI.tool_calls);
+        const signature = stableStringify(normalized);
+        const count = !isNewRun && signature === state.repeatedToolCallSignature ? (state.repeatedToolCallCount ?? 0) + 1 : 1;
+        if (count >= stopThreshold) {
+          const toolName2 = lastAI.tool_calls.length === 1 ? lastAI.tool_calls[0]?.name : void 0;
+          throw new RepeatedToolCallError(toolName2, count, stopThreshold, signature.slice(0, 500));
+        }
+        return {
+          repeatedToolCallSignature: signature,
+          repeatedToolCallCount: count,
+          repeatedToolCallRunMarker: runMarker,
+          repeatedToolCallMemberSignatures: normalized.map((call) => stableStringify(call))
+        };
+      }
+    },
+    wrapToolCall: async (request, handler) => {
+      const state = request.state;
+      const count = state.repeatedToolCallCount ?? 0;
+      const members = state.repeatedToolCallMemberSignatures ?? [];
+      const current = stableStringify({ name: request.toolCall.name ?? "", args: request.toolCall.args ?? {} });
+      if (warnThreshold > 0 && count >= warnThreshold && members.includes(current)) {
+        return new ToolMessage({
+          name: request.toolCall.name,
+          tool_call_id: request.toolCall.id ?? "repeated-tool-call",
+          status: "error",
+          content: JSON.stringify({
+            success: false,
+            code: "REPEATED_TOOL_CALL",
+            error: `You have already called '${request.toolCall.name}' with identical arguments ${count} times. The result will not change. Do not call it again \u2014 use the result already in context and take the next action (edit, re-run with different input, or finish).`
+          })
+        });
+      }
+      return handler(request);
+    }
+  });
+}
+
+// src/middlewares/runGovernance.ts
+var runGovernanceStateSchema = z42.object({
+  governRunId: z42.string().default(""),
+  governModelCalls: z42.number().default(0),
+  governToolRounds: z42.number().default(0),
+  governToolCalls: z42.number().default(0),
+  governSkillCalls: z42.number().default(0),
+  governWarned: z42.boolean().default(false),
+  governNotice: z42.string().default(""),
+  governLastSignature: z42.string().default(""),
+  governRepeatCount: z42.number().default(0),
+  governTerminationReason: z42.string().default(""),
+  governStopSummary: z42.string().default(""),
+  governForceFinal: z42.boolean().default(false),
+  governForcedRounds: z42.number().default(0)
+});
+function withRunGovernanceStateSchema(schema6) {
+  return schema6 ? schema6.extend(runGovernanceStateSchema.shape) : runGovernanceStateSchema;
+}
+function positiveInt(raw, fallback) {
+  if (raw === void 0 || raw.trim() === "") return fallback;
+  const parsed = Number(raw);
+  return Number.isFinite(parsed) && parsed > 0 ? Math.floor(parsed) : fallback;
+}
+function readRunGovernanceConfig(env = process.env) {
+  return {
+    maxModelCalls: positiveInt(env.AGENT_RUN_MODEL_CALLS, 50),
+    maxModelCallsMax: positiveInt(env.AGENT_RUN_MODEL_CALLS_MAX, 600),
+    wrapUpReserve: positiveInt(env.AGENT_RUN_WRAP_UP_CALLS, 3),
+    repeatWarn: positiveInt(env.AGENT_REPEATED_TOOL_CALL_WARN, 5),
+    repeatStop: positiveInt(env.AGENT_REPEATED_TOOL_CALL_STOP, 8),
+    maxToolCalls: positiveInt(env.AGENT_TOOL_CALL_RUN_LIMIT, 300),
+    maxSkillCalls: positiveInt(env.AGENT_SKILL_CALL_RUN_LIMIT, 8)
+  };
+}
+function isPlainRecord(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+function resolveRequestedMaxModelCalls(requested, config = readRunGovernanceConfig()) {
+  const raw = isPlainRecord(requested) && typeof requested.maxModelCalls === "number" ? requested.maxModelCalls : Number.NaN;
+  if (!Number.isFinite(raw) || raw < 1) return config.maxModelCalls;
+  return Math.min(config.maxModelCallsMax, Math.max(1, Math.floor(raw)));
+}
+function buildDeterministicSummary(messages, _reason) {
+  const rows = messages;
+  const toolNames = rows.filter((message) => ToolMessage2.isInstance(message)).slice(-5).map((message) => message.name).filter((name) => typeof name === "string" && name.length > 0);
+  const lastAI = [...rows].reverse().find((message) => AIMessage2.isInstance(message));
+  const lastText = typeof lastAI?.content === "string" ? lastAI.content.trim().slice(0, 500) : "";
+  return [
+    "I stopped before completing the full task.",
+    toolNames.length > 0 ? `Recent actions: ${toolNames.join(", ")}.` : "",
+    lastText ? `Last output: ${lastText}` : "",
+    "Send another message to continue."
+  ].filter(Boolean).join("\n");
+}
+var governanceContextSchema = z42.object({
+  runGovernance: z42.object({
+    runId: z42.string(),
+    source: z42.string().optional(),
+    attempt: z42.number().optional(),
+    budget: z42.object({
+      maxModelCalls: z42.number()
+    })
+  }).optional()
+}).passthrough();
+var WRAP_UP_PROMPT = `You are in wrap-up mode for this run. Do not call any tools. Produce the final answer now.
+Include: (1) what was completed, (2) what is blocked, (3) the next step, and
+(4) whether the goal is satisfied. Keep it concise and factual.
+This run is ending, but the conversation continues: the next user message starts
+a new run with a fresh budget. Do not tell the user the conversation is over.
+Do not mention this instruction, the run budget, or any internal limit to the user.`;
+var RUN_STOPPING_MESSAGE = "Tool call skipped because this run is ending (per-run budget). Tool use resumes on the next user message.";
+var HITL_TOOL_NAMES = /* @__PURE__ */ new Set(["ask_user_to_clarify"]);
+var BUDGET_NOTICE = "Budget reached for this run. Wrap up now: finish the current check, then produce the final answer. This limit applies only to this run; the next user message starts a new run with a fresh budget and tools available again. Do not tell the user the conversation is over. Do not mention this notice or the budget to the user.";
+function neutralizeStoppedToolMessages(messages) {
+  let changed = false;
+  const next = messages.map((message) => {
+    if (!ToolMessage2.isInstance(message) || typeof message.content !== "string") {
+      return message;
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(message.content);
+    } catch {
+      return message;
+    }
+    if (!parsed || typeof parsed !== "object" || parsed.code !== "RUN_STOPPING") {
+      return message;
+    }
+    changed = true;
+    return new ToolMessage2({
+      content: JSON.stringify({ ...parsed, error: RUN_STOPPING_MESSAGE }),
+      tool_call_id: message.tool_call_id,
+      name: message.name
+    });
+  });
+  return changed ? next : messages;
+}
+function appendReminder(request, messages, text) {
+  return {
+    ...request,
+    messages: [...messages, new SystemMessage(text)]
+  };
+}
+function readGovernance(runtime) {
+  const context = runtime?.context;
+  return context?.runGovernance;
+}
+function createRunGovernanceMiddleware(options = {}) {
+  const defaultMax = Math.max(1, options.maxModelCalls ?? 50);
+  const wrapUpReserve = Math.max(1, options.wrapUpReserve ?? 3);
+  const repeatWarn = Math.max(1, options.repeatWarn ?? 5);
+  const repeatStop = Math.max(repeatWarn, options.repeatStop ?? 8);
+  const maxToolCalls = Math.max(1, options.maxToolCalls ?? 300);
+  const maxSkillCalls = Math.max(1, options.maxSkillCalls ?? 8);
+  const pollable = new Set(options.pollableTools ?? ["run_eval"]);
+  return createMiddleware2({
+    name: "RunGovernanceMiddleware",
+    contextSchema: governanceContextSchema,
+    stateSchema: runGovernanceStateSchema,
+    beforeAgent: (state, runtime) => {
+      const gov = readGovernance(runtime);
+      if (!gov || state.governRunId === gov.runId) return void 0;
+      return {
+        governRunId: gov.runId,
+        governModelCalls: 0,
+        governToolRounds: 0,
+        governToolCalls: 0,
+        governSkillCalls: 0,
+        governWarned: false,
+        governNotice: "",
+        governLastSignature: "",
+        governRepeatCount: 0,
+        governTerminationReason: "",
+        governStopSummary: "",
+        governForceFinal: false,
+        governForcedRounds: 0
+      };
+    },
+    beforeModel: {
+      canJumpTo: ["end"],
+      hook: (state, runtime) => {
+        const gov = readGovernance(runtime);
+        if (!gov) return void 0;
+        const maxCalls = Math.max(1, gov.budget.maxModelCalls ?? defaultMax);
+        const modelCalls = state.governModelCalls ?? 0;
+        const hardCap = maxCalls + wrapUpReserve;
+        const reason = state.governTerminationReason ?? "";
+        if (modelCalls >= hardCap) {
+          const summary = buildDeterministicSummary(
+            state.messages ?? [],
+            reason || "budget_exhausted"
+          );
+          return {
+            governTerminationReason: reason || "budget_exhausted",
+            governStopSummary: summary,
+            governForceFinal: true,
+            jumpTo: "end",
+            messages: [new AIMessage2(summary)]
+          };
+        }
+        if (modelCalls >= hardCap - 1) {
+          return {
+            governTerminationReason: reason || "budget_exhausted",
+            governForceFinal: true,
+            governWarned: true
+          };
+        }
+        if (modelCalls >= maxCalls - 1) {
+          return { governWarned: true };
+        }
+        return void 0;
+      }
+    },
+    afterModel: {
+      canJumpTo: ["end"],
+      hook: (state, runtime) => {
+        if (!readGovernance(runtime)) return void 0;
+        const messages = state.messages ?? [];
+        const lastAI = [...messages].reverse().find((message) => AIMessage2.isInstance(message));
+        const toolCalls = lastAI?.tool_calls ?? [];
+        const hasTools2 = toolCalls.length > 0;
+        const modelCalls = (state.governModelCalls ?? 0) + 1;
+        const toolRounds = (state.governToolRounds ?? 0) + (hasTools2 ? 1 : 0);
+        const toolCallsThisRound = toolCalls.length;
+        const skillCallsThisRound = toolCalls.filter((call) => call.name === "skill").length;
+        const totalToolCalls = (state.governToolCalls ?? 0) + toolCallsThisRound;
+        const totalSkillCalls = (state.governSkillCalls ?? 0) + skillCallsThisRound;
+        let notice = "";
+        const warned = state.governWarned ?? false;
+        let reason = state.governTerminationReason ?? "";
+        let forceFinal = state.governForceFinal ?? false;
+        let signature = state.governLastSignature ?? "";
+        let repeatCount = state.governRepeatCount ?? 0;
+        const nonPollable = toolCalls.filter((call) => !pollable.has(call.name ?? ""));
+        if (hasTools2 && nonPollable.length > 0) {
+          const nextSignature = stableStringify(normalizeToolCalls(nonPollable));
+          repeatCount = nextSignature === signature ? repeatCount + 1 : 1;
+          signature = nextSignature;
+          if (!reason && repeatCount === repeatWarn) {
+            notice = `You have called the same tool with identical arguments ${repeatCount} times. The result will not change. Use the existing result or take a different action.`;
+          }
+          if (!reason && repeatCount >= repeatStop) {
+            reason = "repeated_calls";
+            forceFinal = true;
+          }
+        }
+        if (!reason && (totalToolCalls >= maxToolCalls || totalSkillCalls >= maxSkillCalls)) {
+          reason = "tool_limit";
+          forceFinal = true;
+        }
+        let forcedRounds = state.governForcedRounds ?? 0;
+        if (forceFinal && hasTools2) forcedRounds += 1;
+        const counters = {
+          governModelCalls: modelCalls,
+          governToolRounds: toolRounds,
+          governToolCalls: totalToolCalls,
+          governSkillCalls: totalSkillCalls,
+          governWarned: warned,
+          governNotice: notice,
+          governLastSignature: signature,
+          governRepeatCount: repeatCount,
+          governTerminationReason: reason,
+          governForceFinal: forceFinal,
+          governForcedRounds: forcedRounds
+        };
+        if (forceFinal && hasTools2 && forcedRounds >= 2) {
+          const summary = buildDeterministicSummary(messages, reason);
+          return {
+            ...counters,
+            governStopSummary: summary,
+            jumpTo: "end",
+            messages: [new AIMessage2(summary)]
+          };
+        }
+        return counters;
+      }
+    },
+    wrapModelCall: async (request, handler) => {
+      const state = request.state ?? {};
+      const gov = readGovernance(request.runtime);
+      const maxCalls = Math.max(1, gov?.budget.maxModelCalls ?? defaultMax);
+      const used = state.governModelCalls ?? 0;
+      const hardCap = maxCalls + wrapUpReserve;
+      const forceByBudget = used >= hardCap - 1;
+      const forceFinal = Boolean(state.governForceFinal) || forceByBudget;
+      const budgetNotice = !forceByBudget && used >= maxCalls - 1 ? BUDGET_NOTICE : "";
+      if (used >= hardCap) {
+        return new AIMessage2(
+          buildDeterministicSummary(request.messages ?? [], state.governTerminationReason)
+        );
+      }
+      const messages = Array.isArray(request.messages) ? neutralizeStoppedToolMessages(request.messages) : request.messages;
+      const nextRequest = messages === request.messages ? request : { ...request, messages };
+      const pending = [state.governNotice, budgetNotice].filter((part) => typeof part === "string" && part.length > 0).join("\n\n");
+      if (forceFinal) {
+        const reminder = [pending, WRAP_UP_PROMPT].filter((part) => typeof part === "string" && part.length > 0).join("\n\n");
+        return handler({
+          ...appendReminder(nextRequest, nextRequest.messages ?? [], reminder),
+          tools: [],
+          toolChoice: "none"
+        });
+      }
+      if (pending) {
+        return handler(
+          appendReminder(nextRequest, nextRequest.messages ?? [], pending)
+        );
+      }
+      return handler(nextRequest);
+    },
+    wrapToolCall: async (request, handler) => {
+      const state = request.state ?? {};
+      const gov = readGovernance(request.runtime);
+      const maxCalls = Math.max(1, gov?.budget.maxModelCalls ?? defaultMax);
+      const hardCap = maxCalls + wrapUpReserve;
+      const forceByBudget = (state.governModelCalls ?? 0) >= hardCap;
+      const isHitlTool = HITL_TOOL_NAMES.has(String(request.toolCall?.name ?? ""));
+      if (!isHitlTool && (state.governForceFinal || forceByBudget)) {
+        return new ToolMessage2({
+          name: request.toolCall?.name,
+          tool_call_id: request.toolCall?.id ?? "run-governance-blocked",
+          status: "error",
+          content: JSON.stringify({
+            success: false,
+            code: "RUN_STOPPING",
+            error: RUN_STOPPING_MESSAGE
+          })
+        });
+      }
+      return handler(request);
+    }
+  });
+}
+
 // src/agent_lattice/builders/state.ts
 var createReactAgentSchema = (schema6) => {
-  return MessagesZodState.extend(schema6?.shape ?? {}).extend(toolCallLimitStateSchema.shape);
+  return MessagesZodState.extend(schema6?.shape ?? {}).extend(toolCallLimitStateSchema.shape).extend(runGovernanceStateSchema.shape);
 };
 
 // src/agent_lattice/builders/ReActAgentGraphBuilder.ts
 import { createAgent } from "langchain";
 
 // src/middlewares/codeEvalMiddleware.ts
-import { createMiddleware } from "langchain";
+import { createMiddleware as createMiddleware3 } from "langchain";
 
 // src/middlewares/contextSchema.ts
-import z41 from "zod";
-var contextSchema = z41.object({
-  runConfig: z41.any()
+import z43 from "zod";
+var contextSchema = z43.object({
+  runConfig: z43.any()
 });
 
 // src/middlewares/codeEvalMiddleware.ts
 function createCodeEvalMiddleware(params = { vmIsolation: "agent" }) {
-  return createMiddleware({
+  return createMiddleware3({
     name: "codeEvalMiddleware",
     contextSchema,
     tools: [createShellExecTool({ vmIsolation: params.vmIsolation })]
@@ -16494,7 +17151,7 @@ var codeEvalPlugin = {
 };
 
 // src/middlewares/browserMiddleware.ts
-import { createMiddleware as createMiddleware2 } from "langchain";
+import { createMiddleware as createMiddleware4 } from "langchain";
 function createBrowserMiddleware(params = { vmIsolation: "agent" }) {
   const vmIsolation = params.vmIsolation || "agent";
   const tools = [
@@ -16521,7 +17178,7 @@ function createBrowserMiddleware(params = { vmIsolation: "agent" }) {
     createBrowserGetDownloadListTool({ vmIsolation }),
     createBrowserGetInfoTool({ vmIsolation })
   ];
-  return createMiddleware2({
+  return createMiddleware4({
     name: "browserMiddleware",
     contextSchema,
     tools
@@ -16555,11 +17212,11 @@ var browserPlugin = {
 };
 
 // src/middlewares/sqlMiddleware.ts
-import { createMiddleware as createMiddleware3 } from "langchain";
+import { createMiddleware as createMiddleware5 } from "langchain";
 function createSqlMiddleware(params) {
   const { databaseKeys = [], databaseDescriptions, compileStableCandidateTools = false } = params;
   if (!compileStableCandidateTools && databaseKeys.length === 0) {
-    return createMiddleware3({
+    return createMiddleware5({
       name: "sqlMiddleware",
       tools: []
     });
@@ -16568,7 +17225,7 @@ function createSqlMiddleware(params) {
     databaseKeys,
     databaseDescriptions
   };
-  return createMiddleware3({
+  return createMiddleware5({
     name: "sqlMiddleware",
     contextSchema,
     tools: [
@@ -16613,7 +17270,7 @@ var sqlPlugin = {
 };
 
 // src/deep_agent_new/middleware/fs.ts
-import { createMiddleware as createMiddleware4, tool as tool38, ToolMessage } from "langchain";
+import { createMiddleware as createMiddleware6, tool as tool38, ToolMessage as ToolMessage3 } from "langchain";
 import { Command, isCommand, getCurrentTaskInput } from "@langchain/langgraph";
 import { z as z310 } from "zod/v3";
 import { withLangGraph as withLangGraph2 } from "@langchain/langgraph/zod";
@@ -17143,7 +17800,7 @@ function validateAudioSize(sizeBytes) {
 }
 
 // src/deep_agent_new/backends/describeImage.ts
-import { HumanMessage } from "@langchain/core/messages";
+import { HumanMessage as HumanMessage2 } from "@langchain/core/messages";
 async function describeImage(options) {
   const { modelKey, tenantId: tenantId2, mimeType, base64, prompt } = options;
   const resolved = await resolveModelLatticeForTenant(
@@ -17158,7 +17815,7 @@ async function describeImage(options) {
     throw new Error(`Model "${modelKey}" does not support vision.`);
   }
   const result = await client.invoke([
-    new HumanMessage({
+    new HumanMessage2({
       content: [
         {
           type: "text",
@@ -17174,6 +17831,9 @@ async function describeImage(options) {
   return result.content || "";
 }
 
+// src/stt_model_lattice/STTModelLatticeManager.ts
+import { ASR_DEFAULT_KEY } from "@axiom-lattice/protocols";
+
 // src/stt_model_lattice/STTModelLattice.ts
 import { OpenAIClient, toFile } from "@langchain/openai";
 var STTModelLattice = class {
@@ -17308,7 +17968,7 @@ var STTModelLatticeManager = class _STTModelLatticeManager extends BaseLatticeMa
    * chat key must never resolve to a speech client.
    */
   async loadItemFromStore(tenantId2, key5) {
-    const row = await loadTenantModelRow(tenantId2, key5);
+    const row = key5 === ASR_DEFAULT_KEY ? await loadTenantDefaultModelRow(tenantId2, "asr") : await loadTenantModelRow(tenantId2, key5);
     if (!row || row.model.kind !== "asr") {
       return void 0;
     }
@@ -17432,15 +18092,23 @@ var getSTTClient = (key5) => sttModelLatticeManager.getSTTClient(key5);
 var getSTTClientWithTenant = (tenantId2, key5) => sttModelLatticeManager.getSTTClientWithTenant(tenantId2, key5);
 
 // src/deep_agent_new/backends/transcribeAudio.ts
+import { ASR_DEFAULT_KEY as ASR_DEFAULT_KEY2 } from "@axiom-lattice/protocols";
 async function transcribeAudio(options) {
-  const { audioBuffer, format, tenantId: tenantId2 = "default", modelKey = "default" } = options;
+  const { audioBuffer, format, tenantId: tenantId2 = "default", modelKey } = options;
+  const requestedKey = modelKey || ASR_DEFAULT_KEY2;
   const client = await sttModelLatticeManager.getSTTClientWithTenantAsync(
     tenantId2,
-    modelKey
+    requestedKey
+  ) ?? (requestedKey === ASR_DEFAULT_KEY2 ? void 0 : await sttModelLatticeManager.getSTTClientWithTenantAsync(
+    tenantId2,
+    ASR_DEFAULT_KEY2
+  )) ?? await sttModelLatticeManager.getSTTClientWithTenantAsync(
+    tenantId2,
+    "default"
   );
   if (!client) {
     throw new Error(
-      `No STT model "${modelKey}" registered for tenant "${tenantId2}". Configure one in the model provider panel, or register a deployment default.`
+      `No STT model "${requestedKey}" registered for tenant "${tenantId2}", and no tenant or deployment default. Configure one in the model service panel.`
     );
   }
   return await client.transcribe(audioBuffer, format);
@@ -17671,7 +18339,7 @@ function createWriteFileTool(backend, options) {
       if (result.error) {
         return result.error;
       }
-      const message = new ToolMessage({
+      const message = new ToolMessage3({
         content: `Successfully wrote to '${file_path}'`,
         tool_call_id: config.toolCall?.id,
         name: "write_file",
@@ -17715,7 +18383,7 @@ function createEditFileTool(backend, options) {
       if (result.error) {
         return result.error;
       }
-      const message = new ToolMessage({
+      const message = new ToolMessage3({
         content: `Successfully replaced ${result.occurrences} occurrence(s) in '${file_path}'`,
         tool_call_id: config.toolCall?.id,
         name: "edit_file",
@@ -17760,7 +18428,7 @@ function createDeleteFileTool(backend, options) {
       if (result.error) {
         return result.error;
       }
-      const message = new ToolMessage({
+      const message = new ToolMessage3({
         content: `Successfully deleted '${file_path}'`,
         tool_call_id: toolConfig.toolCall?.id ?? "",
         name: "delete_file",
@@ -17883,7 +18551,7 @@ function createFilesystemMiddleware(options = {}) {
       customDescription: customToolDescriptions?.grep
     })
   ];
-  return createMiddleware4({
+  return createMiddleware6({
     name: "FilesystemMiddleware",
     contextSchema,
     stateSchema: FilesystemStateSchema,
@@ -17915,7 +18583,7 @@ ${systemPrompt}` : systemPrompt;
           if (writeResult.error) {
             return { message: msg, filesUpdate: null };
           }
-          const truncatedMessage = new ToolMessage({
+          const truncatedMessage = new ToolMessage3({
             content: `Tool result too large (${Math.round(
               msg.content.length / 4
             )} tokens). Content saved to ${evictPath}`,
@@ -17929,7 +18597,7 @@ ${systemPrompt}` : systemPrompt;
         }
         return { message: msg, filesUpdate: null };
       }
-      if (result instanceof ToolMessage) {
+      if (result instanceof ToolMessage3) {
         const processed = await processToolMessage(result);
         if (processed.filesUpdate) {
           return new Command({
@@ -17952,7 +18620,7 @@ ${systemPrompt}` : systemPrompt;
         };
         const processedMessages = [];
         for (const msg of update.messages) {
-          if (msg instanceof ToolMessage) {
+          if (msg instanceof ToolMessage3) {
             const processed = await processToolMessage(msg);
             processedMessages.push(processed.message);
             if (processed.filesUpdate) {
@@ -18005,11 +18673,11 @@ var filesystemPlugin = {
 };
 
 // src/middlewares/metricsMiddleware.ts
-import { createMiddleware as createMiddleware5 } from "langchain";
+import { createMiddleware as createMiddleware7 } from "langchain";
 function createMetricsMiddleware(params) {
   const { serverKeys, serverDescriptions, connectAll, compileStableCandidateTools = false } = params;
   if (!compileStableCandidateTools && (!serverKeys || serverKeys.length === 0)) {
-    return createMiddleware5({
+    return createMiddleware7({
       name: "metricsMiddleware",
       tools: []
     });
@@ -18023,7 +18691,7 @@ function createMetricsMiddleware(params) {
     getTenantId: void 0
     // Tools will extract tenantId from _exeConfig.configurable.runConfig
   };
-  return createMiddleware5({
+  return createMiddleware7({
     name: "metricsMiddleware",
     contextSchema,
     tools: [
@@ -18080,9 +18748,9 @@ var metricsPlugin = {
 };
 
 // src/middlewares/modelSelectorMiddleware.ts
-import { createMiddleware as createMiddleware6 } from "langchain";
+import { createMiddleware as createMiddleware8 } from "langchain";
 function createModelSelectorMiddleware() {
-  return createMiddleware6({
+  return createMiddleware8({
     name: "modelSelector",
     wrapModelCall: async (request, handler) => {
       const runConfig = request.runtime?.context?.runConfig;
@@ -18131,7 +18799,7 @@ function createModelSelectorMiddleware() {
 }
 
 // src/deep_agent_new/middleware/clawMiddleware.ts
-import { createMiddleware as createMiddleware7 } from "langchain";
+import { createMiddleware as createMiddleware9 } from "langchain";
 
 // src/deep_agent_new/middleware/AGENTS_MD.ts
 var AGENTS_MD = `
@@ -18656,7 +19324,7 @@ function createClawMiddleware(options = {}) {
     bootstrapFiles = {},
     injectBootstrapFiles = true
   } = options;
-  return createMiddleware7({
+  return createMiddleware9({
     name: "ClawMiddleware",
     contextSchema,
     beforeAgent: async (state, runtime) => {
@@ -18724,8 +19392,8 @@ var clawPlugin = {
 };
 
 // src/middlewares/unknownToolHandlerMiddleware.ts
-import { createMiddleware as createMiddleware8 } from "langchain";
-import { AIMessage, ToolMessage as ToolMessage2 } from "@langchain/core/messages";
+import { createMiddleware as createMiddleware10 } from "langchain";
+import { AIMessage as AIMessage3, ToolMessage as ToolMessage4 } from "@langchain/core/messages";
 function createUnknownToolHandlerMiddleware(config = {}) {
   const {
     strategy = "error",
@@ -18736,7 +19404,7 @@ Available tools:
 
 Please select a valid tool from the list above.`
   } = config;
-  return createMiddleware8({
+  return createMiddleware10({
     name: "UnknownToolHandlerMiddleware",
     /**
      * wrapModelCall hook
@@ -18780,7 +19448,7 @@ Please select a valid tool from the list above.`
       }));
       const unknownToolIds = new Set(unknownToolCalls.map((toolCall) => toolCall.id));
       const remainingToolCalls = aiResponse.tool_calls.filter((toolCall) => unknownToolIds.has(toolCall.id));
-      const modifiedResponse = new AIMessage({
+      const modifiedResponse = new AIMessage3({
         content: aiResponse.content,
         tool_calls: remainingToolCalls,
         response_metadata: {
@@ -18810,7 +19478,7 @@ Please select a valid tool from the list above.`
           return;
         }
         const lastMessage = messages[messages.length - 1];
-        if (!AIMessage.isInstance(lastMessage)) {
+        if (!AIMessage3.isInstance(lastMessage)) {
           return;
         }
         const unknownToolErrors = lastMessage.response_metadata?._unknownToolErrors;
@@ -18818,7 +19486,7 @@ Please select a valid tool from the list above.`
           return;
         }
         const errorToolMessages = unknownToolErrors.map(
-          (error) => new ToolMessage2({
+          (error) => new ToolMessage4({
             content: error.errorMessage,
             name: error.toolName,
             tool_call_id: error.toolCallId,
@@ -18837,13 +19505,13 @@ Please select a valid tool from the list above.`
 
 // src/deep_agent_new/middleware/patch_tool_calls.ts
 import {
-  createMiddleware as createMiddleware9,
-  ToolMessage as ToolMessage3,
-  AIMessage as AIMessage2
+  createMiddleware as createMiddleware11,
+  ToolMessage as ToolMessage5,
+  AIMessage as AIMessage4
 } from "langchain";
-import { HumanMessage as HumanMessage2 } from "@langchain/core/messages";
+import { HumanMessage as HumanMessage3 } from "@langchain/core/messages";
 function createPatchToolCallsMiddleware() {
-  return createMiddleware9({
+  return createMiddleware11({
     name: "patchToolCallsMiddleware",
     wrapModelCall: async (request, handler) => {
       const messages = repairToolMessages(request.messages);
@@ -18855,9 +19523,9 @@ function repairToolMessages(messages) {
   const repaired = [];
   for (let index = 0; index < messages.length; index += 1) {
     const message = messages[index];
-    if (!AIMessage2.isInstance(message) || !message.tool_calls?.length) {
-      if (!ToolMessage3.isInstance(message) || !hasMatchingToolCall(messages, index, message.tool_call_id)) {
-        if (!ToolMessage3.isInstance(message)) repaired.push(message);
+    if (!AIMessage4.isInstance(message) || !message.tool_calls?.length) {
+      if (!ToolMessage5.isInstance(message) || !hasMatchingToolCall(messages, index, message.tool_call_id)) {
+        if (!ToolMessage5.isInstance(message)) repaired.push(message);
       }
       continue;
     }
@@ -18872,17 +19540,17 @@ function repairToolMessages(messages) {
     let cursor = index + 1;
     for (; cursor < messages.length; cursor += 1) {
       const following = messages[cursor];
-      if (HumanMessage2.isInstance(following) || AIMessage2.isInstance(following)) break;
-      if (ToolMessage3.isInstance(following) && !followingTools.has(following.tool_call_id)) {
+      if (HumanMessage3.isInstance(following) || AIMessage4.isInstance(following)) break;
+      if (ToolMessage5.isInstance(following) && !followingTools.has(following.tool_call_id)) {
         followingTools.set(following.tool_call_id, following);
-      } else if (!ToolMessage3.isInstance(following)) {
+      } else if (!ToolMessage5.isInstance(following)) {
         followingMessages.push(following);
       }
     }
     if (validCalls.length === message.tool_calls.length) {
       repaired.push(message);
     } else {
-      repaired.push(new AIMessage2({
+      repaired.push(new AIMessage4({
         id: message.id,
         content: message.content,
         name: message.name,
@@ -18894,7 +19562,7 @@ function repairToolMessages(messages) {
       }));
     }
     for (const call of validCalls) {
-      repaired.push(followingTools.get(call.id) ?? new ToolMessage3({
+      repaired.push(followingTools.get(call.id) ?? new ToolMessage5({
         id: `tool-result-repair:${call.id}`,
         name: call.name,
         tool_call_id: call.id,
@@ -18922,112 +19590,28 @@ function withoutToolCalls(additionalKwargs) {
 function hasMatchingToolCall(messages, toolIndex, toolCallId) {
   for (let index = toolIndex - 1; index >= 0; index -= 1) {
     const message = messages[index];
-    if (HumanMessage2.isInstance(message)) return false;
-    if (AIMessage2.isInstance(message)) {
+    if (HumanMessage3.isInstance(message)) return false;
+    if (AIMessage4.isInstance(message)) {
       return message.tool_calls?.some((call) => call.id === toolCallId) ?? false;
     }
   }
   return false;
 }
-
-// src/middlewares/repeatedToolCallBreaker.ts
-import { AIMessage as AIMessage3, HumanMessage as HumanMessage3, ToolMessage as ToolMessage4, createMiddleware as createMiddleware10 } from "langchain";
-import { z as z42 } from "zod";
-var RepeatedToolCallError = class extends Error {
-  constructor(toolName2, count, stopThreshold, argsPreview) {
-    super(`Repeated identical tool call '${toolName2 ?? "unknown"}' ${count} times (stop threshold ${stopThreshold}).`);
-    this.name = "RepeatedToolCallError";
-    this.toolName = toolName2;
-    this.count = count;
-    this.stopThreshold = stopThreshold;
-    this.argsPreview = argsPreview;
-  }
-};
-function readLoopBreakerConfig(env = process.env) {
-  const parse = (raw, fallback) => {
-    if (raw === void 0 || raw.trim() === "") return fallback;
-    const parsed = Number(raw);
-    if (!Number.isFinite(parsed) || parsed < 0) return fallback;
-    return Math.floor(parsed);
-  };
-  return {
-    repeatWarn: parse(env.AGENT_REPEATED_TOOL_CALL_WARN, 20),
-    repeatStop: parse(env.AGENT_REPEATED_TOOL_CALL_STOP, 25),
-    runLimit: parse(env.AGENT_TOOL_CALL_RUN_LIMIT, 300),
-    skillRunLimit: parse(env.AGENT_SKILL_CALL_RUN_LIMIT, 8)
-  };
-}
-function stableStringify(value) {
-  if (Array.isArray(value)) return "[" + value.map(stableStringify).join(",") + "]";
-  if (value && typeof value === "object") {
-    const body = Object.entries(value).filter(([, item]) => item !== void 0).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([key5, item]) => JSON.stringify(key5) + ":" + stableStringify(item)).join(",");
-    return "{" + body + "}";
-  }
-  return JSON.stringify(value) ?? "null";
-}
-function normalizeToolCalls(toolCalls) {
-  return toolCalls.map((call) => ({ name: call.name ?? "", args: call.args ?? {} }));
-}
-var BREAKER_STATE_SCHEMA = z42.object({
-  repeatedToolCallSignature: z42.string().default(""),
-  repeatedToolCallCount: z42.number().default(0),
-  repeatedToolCallRunMarker: z42.string().default(""),
-  repeatedToolCallMemberSignatures: z42.array(z42.string()).default([])
-});
-function createRepeatedToolCallBreakerMiddleware(options = {}) {
-  const rawWarn = options.warnThreshold ?? 20;
-  const warnThreshold = rawWarn > 0 ? Math.max(2, rawWarn) : 0;
-  const stopThreshold = Math.max(1, options.stopThreshold ?? 25);
-  return createMiddleware10({
-    name: "RepeatedToolCallBreaker",
-    stateSchema: BREAKER_STATE_SCHEMA,
-    afterModel: {
-      canJumpTo: ["end"],
-      hook: (state) => {
-        const lastAI = [...state.messages].reverse().find(AIMessage3.isInstance);
-        if (!lastAI || !lastAI.tool_calls?.length) return void 0;
-        const lastHuman = [...state.messages].reverse().find(HumanMessage3.isInstance);
-        const runMarker = lastHuman?.id ?? "";
-        const isNewRun = runMarker !== (state.repeatedToolCallRunMarker ?? "");
-        const normalized = normalizeToolCalls(lastAI.tool_calls);
-        const signature = stableStringify(normalized);
-        const count = !isNewRun && signature === state.repeatedToolCallSignature ? (state.repeatedToolCallCount ?? 0) + 1 : 1;
-        if (count >= stopThreshold) {
-          const toolName2 = lastAI.tool_calls.length === 1 ? lastAI.tool_calls[0]?.name : void 0;
-          throw new RepeatedToolCallError(toolName2, count, stopThreshold, signature.slice(0, 500));
-        }
-        return {
-          repeatedToolCallSignature: signature,
-          repeatedToolCallCount: count,
-          repeatedToolCallRunMarker: runMarker,
-          repeatedToolCallMemberSignatures: normalized.map((call) => stableStringify(call))
-        };
-      }
-    },
-    wrapToolCall: async (request, handler) => {
-      const state = request.state;
-      const count = state.repeatedToolCallCount ?? 0;
-      const members = state.repeatedToolCallMemberSignatures ?? [];
-      const current = stableStringify({ name: request.toolCall.name ?? "", args: request.toolCall.args ?? {} });
-      if (warnThreshold > 0 && count >= warnThreshold && members.includes(current)) {
-        return new ToolMessage4({
-          name: request.toolCall.name,
-          tool_call_id: request.toolCall.id ?? "repeated-tool-call",
-          status: "error",
-          content: JSON.stringify({
-            success: false,
-            code: "REPEATED_TOOL_CALL",
-            error: `You have already called '${request.toolCall.name}' with identical arguments ${count} times. The result will not change. Do not call it again \u2014 use the result already in context and take the next action (edit, re-run with different input, or finish).`
-          })
-        });
-      }
-      return handler(request);
-    }
+function ensurePatchToolCallsMiddleware(middleware) {
+  const matches = middleware.filter((candidate) => candidate.name === "patchToolCallsMiddleware");
+  if (matches.length === 0) return [createPatchToolCallsMiddleware(), ...middleware];
+  if (matches.length === 1) return middleware;
+  let kept = false;
+  return middleware.filter((candidate) => {
+    if (candidate.name !== "patchToolCallsMiddleware") return true;
+    if (kept) return false;
+    kept = true;
+    return true;
   });
 }
 
 // src/agent_lattice/builders/commonMiddleware.ts
-import { summarizationMiddleware, toolCallLimitMiddleware } from "langchain";
+import { summarizationMiddleware } from "langchain";
 
 // src/agent_lattice/builders/CustomMiddlewareRegistry.ts
 var CustomMiddlewareRegistry = class {
@@ -19118,8 +19702,8 @@ function createSandboxResolver(getSandboxFromConfig) {
 }
 
 // src/middlewares/evalMiddleware.ts
-import { createMiddleware as createMiddleware11, tool as tool39 } from "langchain";
-import { z as z43 } from "zod";
+import { createMiddleware as createMiddleware12, tool as tool39 } from "langchain";
+import { z as z44 } from "zod";
 import { v4 as uuidv43 } from "uuid";
 
 // src/eval_lattice/EvalRunnerHolder.ts
@@ -19298,24 +19882,6 @@ Use read_eval get_run_results (compact by default) for multiple runs and present
  ` }
 };
 
-// src/tool_lattice/withToolTimeout.ts
-function withToolTimeout(executor, timeoutMs = 18e4) {
-  return async (input, exeConfig) => {
-    return new Promise((resolve4, reject) => {
-      const timer = setTimeout(() => {
-        reject(new Error(`Tool execution timed out after ${timeoutMs}ms`));
-      }, timeoutMs);
-      executor(input, exeConfig).then((result) => {
-        clearTimeout(timer);
-        resolve4(result);
-      }).catch((err) => {
-        clearTimeout(timer);
-        reject(err);
-      });
-    });
-  };
-}
-
 // src/middlewares/evalMiddleware.ts
 var RUN_EVAL_SYNC_WAIT_MS = 15e4;
 function getStore() {
@@ -19364,8 +19930,8 @@ async function runWithResults(tid, store2, svc, run, runnerAlive) {
   return { ...run, runnerAlive, results };
 }
 function createReadEvalTool() {
-  const schema6 = z43.object({
-    action: z43.enum([
+  const schema6 = z44.object({
+    action: z44.enum([
       "list_projects",
       "get_project",
       "list_suites",
@@ -19377,13 +19943,13 @@ function createReadEvalTool() {
       "get_run_results",
       "get_project_report"
     ]).describe("Operation"),
-    projectId: z43.string().optional(),
-    name: z43.string().optional().describe("For list_projects \u2014 exact project name filter (names are unique per tenant). Use this instead of listing all projects."),
-    suiteId: z43.string().optional(),
-    caseId: z43.string().optional(),
-    runId: z43.string().optional(),
-    verbose: z43.boolean().optional().describe("For get_run_results \u2014 return full per-case results. Omit for a compact summary (counts + failing cases only)."),
-    status: z43.string().optional().describe("Filter: running|completed|failed|aborted")
+    projectId: z44.string().optional(),
+    name: z44.string().optional().describe("For list_projects \u2014 exact project name filter (names are unique per tenant). Use this instead of listing all projects."),
+    suiteId: z44.string().optional(),
+    caseId: z44.string().optional(),
+    runId: z44.string().optional(),
+    verbose: z44.boolean().optional().describe("For get_run_results \u2014 return full per-case results. Omit for a compact summary (counts + failing cases only)."),
+    status: z44.string().optional().describe("Filter: running|completed|failed|aborted")
   });
   return tool39(
     async (input, exeConfig) => {
@@ -19500,8 +20066,8 @@ function requireEvalVerifyDeclaration(evalVerifyLoaded) {
   return void 0;
 }
 function createManageEvalTool() {
-  const schema6 = z43.object({
-    action: z43.enum([
+  const schema6 = z44.object({
+    action: z44.enum([
       "create_project",
       "update_project",
       "delete_project",
@@ -19512,24 +20078,24 @@ function createManageEvalTool() {
       "update_case",
       "delete_case"
     ]).describe("Operation"),
-    projectId: z43.string().optional(),
-    name: z43.string().optional(),
-    description: z43.string().optional(),
-    judgeModelKey: z43.string().optional(),
-    concurrency: z43.number().optional(),
-    evalVerifyLoaded: z43.boolean().optional().describe("Required on create_project: load the 'eval-verify' skill first via the skill tool (skill_name 'eval-verify'), then pass evalVerifyLoaded: true. Calls without evalVerifyLoaded: true fail. Never omit or pass false."),
-    targetAgentId: z43.string().optional().describe("Optional for create_project \u2014 the agent this eval project verifies. Recorded in targetServerConfig so the agent's detail page can find its eval data without relying on project naming."),
-    suiteId: z43.string().optional(),
-    caseId: z43.string().optional(),
-    inputMessage: z43.string().optional(),
-    inputFiles: z43.record(z43.string()).optional(),
-    steps: z43.array(z43.object({ agent_id: z43.string(), override_message: z43.string().optional() })).optional(),
-    outputType: z43.enum(["file_content", "message_content"]).optional(),
-    contentAssertion: z43.string().optional(),
-    rubrics: z43.array(z43.object({ name: z43.string(), weight: z43.number(), description: z43.string() })).optional(),
-    interruptPolicy: z43.object({
-      mode: z43.enum(["stop", "auto-approve", "auto-reject", "canned-response"]).describe("stop=judge the pause; auto-approve/auto-reject/canned-response=resume the agent to test the flow after the human input"),
-      value: z43.string().optional().describe("Response to inject (defaults: \u540C\u610F / \u62D2\u7EDD; required for canned-response)")
+    projectId: z44.string().optional(),
+    name: z44.string().optional(),
+    description: z44.string().optional(),
+    judgeModelKey: z44.string().optional(),
+    concurrency: z44.number().optional(),
+    evalVerifyLoaded: z44.boolean().optional().describe("Required on create_project: load the 'eval-verify' skill first via the skill tool (skill_name 'eval-verify'), then pass evalVerifyLoaded: true. Calls without evalVerifyLoaded: true fail. Never omit or pass false."),
+    targetAgentId: z44.string().optional().describe("Optional for create_project \u2014 the agent this eval project verifies. Recorded in targetServerConfig so the agent's detail page can find its eval data without relying on project naming."),
+    suiteId: z44.string().optional(),
+    caseId: z44.string().optional(),
+    inputMessage: z44.string().optional(),
+    inputFiles: z44.record(z44.string()).optional(),
+    steps: z44.array(z44.object({ agent_id: z44.string(), override_message: z44.string().optional() })).optional(),
+    outputType: z44.enum(["file_content", "message_content"]).optional(),
+    contentAssertion: z44.string().optional(),
+    rubrics: z44.array(z44.object({ name: z44.string(), weight: z44.number(), description: z44.string() })).optional(),
+    interruptPolicy: z44.object({
+      mode: z44.enum(["stop", "auto-approve", "auto-reject", "canned-response"]).describe("stop=judge the pause; auto-approve/auto-reject/canned-response=resume the agent to test the flow after the human input"),
+      value: z44.string().optional().describe("Response to inject (defaults: \u540C\u610F / \u62D2\u7EDD; required for canned-response)")
     }).optional().describe("Optional for create_case/update_case \u2014 how HITL interrupts are handled")
   });
   return tool39(
@@ -19665,107 +20231,105 @@ Case: create_case(suiteId, inputMessage, steps, outputType, contentAssertion, in
   );
 }
 function createRunEvalTool() {
-  const schema6 = z43.object({
-    action: z43.enum(["start", "status", "resume", "abort"]).describe("Operation"),
-    projectId: z43.string().optional().describe("Required for start"),
-    suiteIds: z43.array(z43.string()).optional().describe("Optional for start \u2014 only run these suites (e.g. dev set only). Omit to run all."),
-    caseIds: z43.array(z43.string()).optional().describe("Optional for start \u2014 only run these cases across the selected suites. Omit to run all cases in those suites."),
-    runId: z43.string().optional().describe("Required for status, resume, abort"),
-    taskId: z43.string().optional().describe("Optional for start \u2014 training task ID this run belongs to (round association)"),
-    sleepMs: z43.number().int().min(0).max(12e4).optional().describe("Optional for status \u2014 sleep this many ms BEFORE checking the run, to pace polling (e.g. 15000 \u2192 30000 \u2192 60000 \u2192 120000). Omit to check immediately."),
-    wait: z43.boolean().optional().describe("Optional for start \u2014 defaults to true: block synchronously (up to ~150s) and return final results in one call. Set false to return the runId immediately and poll.")
+  const schema6 = z44.object({
+    action: z44.enum(["start", "status", "resume", "abort"]).describe("Operation"),
+    projectId: z44.string().optional().describe("Required for start"),
+    suiteIds: z44.array(z44.string()).optional().describe("Optional for start \u2014 only run these suites (e.g. dev set only). Omit to run all."),
+    caseIds: z44.array(z44.string()).optional().describe("Optional for start \u2014 only run these cases across the selected suites. Omit to run all cases in those suites."),
+    runId: z44.string().optional().describe("Required for status, resume, abort"),
+    taskId: z44.string().optional().describe("Optional for start \u2014 training task ID this run belongs to (round association)"),
+    sleepMs: z44.number().int().min(0).max(12e4).optional().describe("Optional for status \u2014 sleep this many ms BEFORE checking the run, to pace polling (e.g. 15000 \u2192 30000 \u2192 60000 \u2192 120000). Omit to check immediately."),
+    wait: z44.boolean().optional().describe("Optional for start \u2014 defaults to true: block synchronously (up to ~150s) and return final results in one call. Set false to return the runId immediately and poll.")
   });
   return tool39(
-    withToolTimeout(
-      async (input, exeConfig) => {
-        const tid = tenantId(exeConfig);
-        if (!tid) {
-          return JSON.stringify({ success: false, error: "No tenant context. Agent must be invoked through gateway." });
-        }
-        try {
-          const store2 = getStore();
-          const svc = getEvalRunService();
-          let data;
-          switch (input.action) {
-            case "start": {
-              const ctx = workspaceContext(exeConfig);
-              const runId = await svc.startRun(tid, input.projectId, input.suiteIds, input.caseIds, ctx, input.taskId);
-              if (input.wait === false) {
-                data = sanitize({ runId, message: "Run started. Poll with run_eval status (backoff: 15s\u219230s\u219260s\u2192max 120s)." });
-                break;
-              }
-              let timer;
-              try {
-                await Promise.race([
-                  svc.waitForRun(runId).catch(() => {
-                  }),
-                  new Promise((resolve4) => {
-                    timer = setTimeout(resolve4, RUN_EVAL_SYNC_WAIT_MS);
-                  })
-                ]);
-              } finally {
-                if (timer) clearTimeout(timer);
-              }
-              const run = await store2.getRunById(tid, runId);
-              if (!run) return JSON.stringify({ success: false, error: "Run not found" });
-              if (run.status === "running") {
-                data = sanitize({
-                  runId,
-                  status: "running",
-                  runnerAlive: svc.isRunning(runId),
-                  message: `Run not finished within ${RUN_EVAL_SYNC_WAIT_MS / 1e3}s \u2014 poll with run_eval status(runId, sleepMs) (e.g. 15000, doubling up to 120000), or abort with run_eval abort.`
-                });
-                break;
-              }
-              data = sanitize({ synced: true, ...await runWithResults(tid, store2, svc, run, svc.isRunning(runId)) });
+    async (input, exeConfig) => {
+      const tid = tenantId(exeConfig);
+      if (!tid) {
+        return JSON.stringify({ success: false, error: "No tenant context. Agent must be invoked through gateway." });
+      }
+      try {
+        const store2 = getStore();
+        const svc = getEvalRunService();
+        let data;
+        switch (input.action) {
+          case "start": {
+            const ctx = workspaceContext(exeConfig);
+            const runId = await svc.startRun(tid, input.projectId, input.suiteIds, input.caseIds, ctx, input.taskId);
+            if (input.wait === false) {
+              data = sanitize({ runId, message: "Run started. Poll with run_eval status (backoff: 15s\u219230s\u219260s\u2192max 120s)." });
               break;
             }
-            case "status": {
-              if (input.sleepMs && input.sleepMs > 0) {
-                await new Promise((resolve4) => setTimeout(resolve4, input.sleepMs));
-              }
-              const run = await store2.getRunById(tid, input.runId);
-              if (!run) return JSON.stringify({ success: false, error: "Run not found" });
-              data = sanitize({ ...run, runnerAlive: svc.isRunning(input.runId) });
-              break;
+            let timer;
+            try {
+              await Promise.race([
+                svc.waitForRun(runId).catch(() => {
+                }),
+                new Promise((resolve4) => {
+                  timer = setTimeout(resolve4, RUN_EVAL_SYNC_WAIT_MS);
+                })
+              ]);
+            } finally {
+              if (timer) clearTimeout(timer);
             }
-            case "resume": {
-              const run = await store2.getRunById(tid, input.runId);
-              if (!run) return JSON.stringify({ success: false, error: "Run not found" });
-              const runnerAlive = svc.isRunning(input.runId);
-              if (run.status === "running" && !runnerAlive) {
-                await store2.updateRunStatus(tid, run.id, {
-                  status: "failed",
-                  error: "Gateway restarted \u2014 run orphaned",
-                  completedAt: /* @__PURE__ */ new Date()
-                });
-                data = sanitize({
-                  ...run,
-                  status: "failed",
-                  runnerAlive: false,
-                  message: "Run was orphaned \u2014 marked failed. Start a new run."
-                });
-                break;
-              }
-              data = sanitize(await runWithResults(tid, store2, svc, run, runnerAlive));
+            const run = await store2.getRunById(tid, runId);
+            if (!run) return JSON.stringify({ success: false, error: "Run not found" });
+            if (run.status === "running") {
+              data = sanitize({
+                runId,
+                status: "running",
+                runnerAlive: svc.isRunning(runId),
+                message: `Run not finished within ${RUN_EVAL_SYNC_WAIT_MS / 1e3}s \u2014 poll with run_eval status(runId, sleepMs) (e.g. 15000, doubling up to 120000), or abort with run_eval abort.`
+              });
               break;
             }
-            case "abort": {
-              const run = await store2.getRunById(tid, input.runId);
-              if (!run) return JSON.stringify({ success: false, error: "Run not found" });
-              const ok = await svc.abortRun(input.runId);
-              data = sanitize({ aborted: ok });
+            data = sanitize({ synced: true, ...await runWithResults(tid, store2, svc, run, svc.isRunning(runId)) });
+            break;
+          }
+          case "status": {
+            if (input.sleepMs && input.sleepMs > 0) {
+              await new Promise((resolve4) => setTimeout(resolve4, input.sleepMs));
+            }
+            const run = await store2.getRunById(tid, input.runId);
+            if (!run) return JSON.stringify({ success: false, error: "Run not found" });
+            data = sanitize({ ...run, runnerAlive: svc.isRunning(input.runId) });
+            break;
+          }
+          case "resume": {
+            const run = await store2.getRunById(tid, input.runId);
+            if (!run) return JSON.stringify({ success: false, error: "Run not found" });
+            const runnerAlive = svc.isRunning(input.runId);
+            if (run.status === "running" && !runnerAlive) {
+              await store2.updateRunStatus(tid, run.id, {
+                status: "failed",
+                error: "Gateway restarted \u2014 run orphaned",
+                completedAt: /* @__PURE__ */ new Date()
+              });
+              data = sanitize({
+                ...run,
+                status: "failed",
+                runnerAlive: false,
+                message: "Run was orphaned \u2014 marked failed. Start a new run."
+              });
               break;
             }
-            default:
-              return JSON.stringify({ success: false, error: `Unknown action: ${input.action}` });
+            data = sanitize(await runWithResults(tid, store2, svc, run, runnerAlive));
+            break;
           }
-          return JSON.stringify({ success: true, data });
-        } catch (e) {
-          return JSON.stringify({ success: false, error: e.message });
+          case "abort": {
+            const run = await store2.getRunById(tid, input.runId);
+            if (!run) return JSON.stringify({ success: false, error: "Run not found" });
+            const ok = await svc.abortRun(input.runId);
+            data = sanitize({ aborted: ok });
+            break;
+          }
+          default:
+            return JSON.stringify({ success: false, error: `Unknown action: ${input.action}` });
         }
+        return JSON.stringify({ success: true, data });
+      } catch (e) {
+        return JSON.stringify({ success: false, error: e.message });
       }
-    ),
+    },
     {
       name: "run_eval",
       description: `Execute and manage evaluation runs.
@@ -19806,7 +20370,7 @@ var evalPlugin = {
     defaultConfig: {}
   },
   skills: EVAL_SKILLS,
-  middleware: () => createMiddleware11({
+  middleware: () => createMiddleware12({
     name: "EvalMiddleware",
     tools: [createReadEvalTool(), createManageEvalTool(), createRunEvalTool()]
   })
@@ -20348,7 +20912,7 @@ function getPluginDeploymentService() {
 import { createHash as createHash3 } from "crypto";
 
 // src/sandbox_plugin/jsonSchemaToZod.ts
-import { z as z44 } from "zod";
+import { z as z45 } from "zod";
 function isRecord6(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -20368,25 +20932,25 @@ function jsonSchemaToZod(schema6) {
         const child = jsonSchemaToZod(sub);
         shape[key5] = required.includes(key5) ? child : child.optional();
       }
-      return withDescription(z44.object(shape), schema6);
+      return withDescription(z45.object(shape), schema6);
     }
     case "array": {
-      const item = schema6.items === void 0 ? z44.unknown() : jsonSchemaToZod(schema6.items);
-      return withDescription(z44.array(item), schema6);
+      const item = schema6.items === void 0 ? z45.unknown() : jsonSchemaToZod(schema6.items);
+      return withDescription(z45.array(item), schema6);
     }
     case "string": {
       if (Array.isArray(schema6.enum) && schema6.enum.length > 0) {
         const values = schema6.enum.filter((x) => typeof x === "string");
-        return withDescription(z44.enum(values), schema6);
+        return withDescription(z45.enum(values), schema6);
       }
-      return withDescription(z44.string(), schema6);
+      return withDescription(z45.string(), schema6);
     }
     case "number":
-      return withDescription(z44.number(), schema6);
+      return withDescription(z45.number(), schema6);
     case "integer":
-      return withDescription(z44.number().int(), schema6);
+      return withDescription(z45.number().int(), schema6);
     case "boolean":
-      return withDescription(z44.boolean(), schema6);
+      return withDescription(z45.boolean(), schema6);
     default:
       throw new Error(`unsupported JSON Schema type: ${String(type)}`);
   }
@@ -20666,7 +21230,7 @@ function validateSandboxPluginManifest(args) {
 }
 
 // src/sandbox_plugin/SandboxPluginCompiler.ts
-import { createMiddleware as createMiddleware12, tool as tool40 } from "langchain";
+import { createMiddleware as createMiddleware13, tool as tool40 } from "langchain";
 
 // src/connection/PluginConnectionResolver.ts
 async function resolvePluginConnections(type, config, scope) {
@@ -21021,7 +21585,7 @@ function compileSandboxPlugin(args) {
           { name: t.name, description: t.description, schema: jsonSchemaToZod(t.schema) }
         )
       );
-      return createMiddleware12({ name: `SandboxPlugin:${manifest.type}`, tools });
+      return createMiddleware13({ name: `SandboxPlugin:${manifest.type}`, tools });
     },
     skills: manifest.skills,
     agents: manifest.agents
@@ -21897,8 +22461,8 @@ var CapabilityToolRegistry = class {
 };
 
 // src/middlewares/capabilityGuardMiddleware.ts
-import { ToolMessage as ToolMessage5 } from "@langchain/core/messages";
-import { createMiddleware as createMiddleware13 } from "langchain";
+import { ToolMessage as ToolMessage6 } from "@langchain/core/messages";
+import { createMiddleware as createMiddleware14 } from "langchain";
 function isRecord11(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -21956,7 +22520,7 @@ async function standardConnectionAllowed(request, capabilityType, config) {
   }
 }
 function denialMessage(toolCall, denial) {
-  return new ToolMessage5({
+  return new ToolMessage6({
     content: JSON.stringify({ success: false, ...denial }),
     name: toolCall.name,
     tool_call_id: toolCall.id ?? "",
@@ -21964,7 +22528,7 @@ function denialMessage(toolCall, denial) {
   });
 }
 function createCapabilityGuardMiddleware(registry4) {
-  return createMiddleware13({
+  return createMiddleware14({
     name: "CapabilityGuardMiddleware",
     wrapToolCall: async (request, handler) => {
       const toolName2 = request.toolCall.name;
@@ -22199,24 +22763,21 @@ async function createCommonMiddlewares(middlewareConfigs, filesystemBackend, fsI
   middlewares.push(createCapabilityGuardMiddleware(capabilityTools));
   middlewares.push(createModelSelectorMiddleware());
   middlewares.push(createPatchToolCallsMiddleware());
-  const loopBreaker = readLoopBreakerConfig();
-  if (loopBreaker.repeatStop > 0) {
-    middlewares.push(createRepeatedToolCallBreakerMiddleware({
-      warnThreshold: loopBreaker.repeatWarn,
-      stopThreshold: loopBreaker.repeatStop
-    }));
-  }
-  if (loopBreaker.runLimit > 0) {
-    middlewares.push(toolCallLimitMiddleware({ runLimit: loopBreaker.runLimit, exitBehavior: "error" }));
-  }
-  if (loopBreaker.skillRunLimit > 0) {
-    middlewares.push(toolCallLimitMiddleware({ toolName: "skill", runLimit: loopBreaker.skillRunLimit, exitBehavior: "error" }));
-  }
+  const governance = readRunGovernanceConfig();
+  middlewares.push(createRunGovernanceMiddleware({
+    maxModelCalls: governance.maxModelCalls,
+    wrapUpReserve: governance.wrapUpReserve,
+    repeatWarn: governance.repeatWarn,
+    repeatStop: governance.repeatStop,
+    maxToolCalls: governance.maxToolCalls,
+    maxSkillCalls: governance.maxSkillCalls,
+    pollableTools: ["run_eval"]
+  }));
   if (model) {
     middlewares.push(
       summarizationMiddleware({
         model,
-        trigger: { tokens: 17e4 },
+        trigger: { tokens: resolveSummarizationTriggerTokens(model) },
         keep: { messages: 6 }
       })
     );
@@ -22586,12 +23147,12 @@ import {
 } from "langchain";
 
 // src/deep_agent_new/middleware/subagents.ts
-import { z as z46 } from "zod/v3";
+import { z as z47 } from "zod/v3";
 import {
-  createMiddleware as createMiddleware14,
+  createMiddleware as createMiddleware15,
   createAgent as createAgent2,
   tool as tool41,
-  ToolMessage as ToolMessage7,
+  ToolMessage as ToolMessage8,
   humanInTheLoopMiddleware
 } from "langchain";
 import { Command as Command3, getCurrentTaskInput as getCurrentTaskInput2, GraphInterrupt } from "@langchain/langgraph";
@@ -23290,7 +23851,7 @@ function normalizeAgentInterrupts(state, threadId) {
 }
 
 // src/services/Agent.ts
-import { AIMessage as AIMessage4, filterMessages, HumanMessage as HumanMessage4, SystemMessage, ToolMessage as ToolMessage6 } from "langchain";
+import { AIMessage as AIMessage5, filterMessages, HumanMessage as HumanMessage4, SystemMessage as SystemMessage2, ToolMessage as ToolMessage7 } from "langchain";
 
 // src/chunk_buffer_lattice/types.ts
 var ThreadEndError = class extends Error {
@@ -24284,7 +24845,7 @@ registerChunkBuffer("default", buffer);
 import { v4 as v42 } from "uuid";
 
 // src/capability/CapabilityRuntimeResolver.ts
-import { z as z45 } from "zod";
+import { z as z46 } from "zod";
 
 // src/capability/CapabilityBundleMerger.ts
 import { createHash as createHash4 } from "crypto";
@@ -25077,9 +25638,9 @@ var CapabilityRuntimeResolutionError = class extends Error {
     this.actualRevision = context.actualRevision;
   }
 };
-var bundleIdsSchema = z45.array(z45.string().uuid()).superRefine((ids, context) => {
+var bundleIdsSchema = z46.array(z46.string().uuid()).superRefine((ids, context) => {
   if (new Set(ids).size !== ids.length) {
-    context.addIssue({ code: z45.ZodIssueCode.custom, message: "Bundle IDs must be unique" });
+    context.addIssue({ code: z46.ZodIssueCode.custom, message: "Bundle IDs must be unique" });
   }
 });
 function projectBundleIds(config) {
@@ -25386,12 +25947,12 @@ function stripDelegatedWorkerContext(target) {
 // src/services/DelegationContext.ts
 var DELEGATION_CONTEXT_TOKEN = Symbol("delegation-context");
 var delegationContextSecret = Object.freeze({});
-function positiveInt(value, fallback) {
+function positiveInt2(value, fallback) {
   const parsed = Number(value);
   return Number.isInteger(parsed) && parsed > 0 ? parsed : fallback;
 }
-var DELEGATION_MAX_DEPTH = positiveInt(process.env.DELEGATION_MAX_DEPTH, 3);
-var DELEGATION_MAX_CHILDREN_PER_ROOT = positiveInt(
+var DELEGATION_MAX_DEPTH = positiveInt2(process.env.DELEGATION_MAX_DEPTH, 3);
+var DELEGATION_MAX_CHILDREN_PER_ROOT = positiveInt2(
   process.env.DELEGATION_MAX_CHILDREN_PER_ROOT,
   20
 );
@@ -25727,7 +26288,7 @@ var RESERVED_CALLER_RUN_KEYS = /* @__PURE__ */ new Set([
   "delegatedTaskId",
   "taskExecutionRole"
 ]);
-function isPlainRecord(value) {
+function isPlainRecord2(value) {
   if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
   const prototype = Object.getPrototypeOf(value);
   return prototype === Object.prototype || prototype === null;
@@ -25928,7 +26489,7 @@ function trustedCapabilityRevision(value) {
   return requireTrustedCapabilityRevision(value);
 }
 function finalAiMessageMarker(state) {
-  if (!isPlainRecord(state) || !isPlainRecord(state.values) || !Array.isArray(state.values.messages)) {
+  if (!isPlainRecord2(state) || !isPlainRecord2(state.values) || !Array.isArray(state.values.messages)) {
     return void 0;
   }
   const messages = state.values.messages;
@@ -25950,44 +26511,44 @@ function finalAiMessageMarker(state) {
   return { index, totalMessageCount: messages.length, id, text };
 }
 function checkpointIdFromSnapshot(state) {
-  if (!isPlainRecord(state)) return void 0;
+  if (!isPlainRecord2(state)) return void 0;
   const config = state.config;
-  if (isPlainRecord(config)) {
+  if (isPlainRecord2(config)) {
     const configurable = config.configurable;
-    if (isPlainRecord(configurable)) {
+    if (isPlainRecord2(configurable)) {
       const checkpointId = configurable.checkpoint_id;
       if (typeof checkpointId === "string" && checkpointId.length > 0) return checkpointId;
     }
   }
   const checkpoint = state.checkpoint;
-  if (isPlainRecord(checkpoint)) {
+  if (isPlainRecord2(checkpoint)) {
     const checkpointId = checkpoint.checkpoint_id;
     if (typeof checkpointId === "string" && checkpointId.length > 0) return checkpointId;
   }
   return void 0;
 }
 function checkpointRunIdFromSnapshot(state) {
-  if (!isPlainRecord(state)) return void 0;
+  if (!isPlainRecord2(state)) return void 0;
   const config = state.config;
-  if (isPlainRecord(config)) {
+  if (isPlainRecord2(config)) {
     const configurable = config.configurable;
-    if (isPlainRecord(configurable)) {
+    if (isPlainRecord2(configurable)) {
       const runId = configurable.run_id;
       if (typeof runId === "string" && runId.length > 0) return runId;
     }
     const configMetadata = config.metadata;
-    if (isPlainRecord(configMetadata)) {
+    if (isPlainRecord2(configMetadata)) {
       const runId = configMetadata.run_id;
       if (typeof runId === "string" && runId.length > 0) return runId;
     }
   }
   const metadata = state.metadata;
-  if (isPlainRecord(metadata)) {
+  if (isPlainRecord2(metadata)) {
     const runId = metadata.run_id;
     if (typeof runId === "string" && runId.length > 0) return runId;
   }
   const checkpoint = state.checkpoint;
-  if (isPlainRecord(checkpoint)) {
+  if (isPlainRecord2(checkpoint)) {
     const runId = checkpoint.run_id;
     if (typeof runId === "string" && runId.length > 0) return runId;
   }
@@ -25999,7 +26560,7 @@ function normalizeBaseCheckpointId(value) {
   return trimmed.length > 0 ? trimmed : void 0;
 }
 function isInterruptResumeMap(value) {
-  if (!isPlainRecord(value)) return false;
+  if (!isPlainRecord2(value)) return false;
   const keys = Object.keys(value);
   return keys.length > 0 && keys.every((key5) => isOfficialInterruptId(key5));
 }
@@ -26070,11 +26631,11 @@ function executeRunInputMessages(input, fallbackMessageId) {
       };
       switch (message.role) {
         case "system":
-          return new SystemMessage(fields);
+          return new SystemMessage2(fields);
         case "assistant":
-          return new AIMessage4(fields);
+          return new AIMessage5(fields);
         case "tool":
-          return new ToolMessage6({
+          return new ToolMessage7({
             ...fields,
             tool_call_id: typeof message.metadata?.tool_call_id === "string" ? message.metadata.tool_call_id : ""
           });
@@ -26090,19 +26651,19 @@ function executeRunInputMessages(input, fallbackMessageId) {
   return [new HumanMessage4({ id, content: input.message })];
 }
 function statusFromSnapshot(state) {
-  if (!isPlainRecord(state)) return "error" /* ERROR */;
-  if (Array.isArray(state.tasks) && state.tasks.some((task) => isPlainRecord(task) && Array.isArray(task.interrupts) && task.interrupts.length > 0)) return "interrupted" /* INTERRUPTED */;
-  if (Array.isArray(state.tasks) && state.tasks.some((task) => isPlainRecord(task) && task.error !== void 0)) return "error" /* ERROR */;
+  if (!isPlainRecord2(state)) return "error" /* ERROR */;
+  if (Array.isArray(state.tasks) && state.tasks.some((task) => isPlainRecord2(task) && Array.isArray(task.interrupts) && task.interrupts.length > 0)) return "interrupted" /* INTERRUPTED */;
+  if (Array.isArray(state.tasks) && state.tasks.some((task) => isPlainRecord2(task) && task.error !== void 0)) return "error" /* ERROR */;
   if (Array.isArray(state.next) && state.next.length > 0) return "busy" /* BUSY */;
   return "idle" /* IDLE */;
 }
 var MAX_EXECUTION_ERROR_LENGTH = 2e3;
 function executionErrorFromSnapshot(state) {
-  if (!isPlainRecord(state) || !Array.isArray(state.tasks)) return void 0;
+  if (!isPlainRecord2(state) || !Array.isArray(state.tasks)) return void 0;
   for (const task of state.tasks) {
-    if (!isPlainRecord(task) || task.error === void 0 || task.error === null) continue;
+    if (!isPlainRecord2(task) || task.error === void 0 || task.error === null) continue;
     const raw = task.error;
-    const message = typeof raw === "string" ? raw : raw instanceof Error ? raw.message : isPlainRecord(raw) && typeof raw.message === "string" ? raw.message : (() => {
+    const message = typeof raw === "string" ? raw : raw instanceof Error ? raw.message : isPlainRecord2(raw) && typeof raw.message === "string" ? raw.message : (() => {
       try {
         return JSON.stringify(raw);
       } catch {
@@ -26235,7 +26796,8 @@ var Agent = class {
           command ? new Command2(command) : { ...stateInput, "x-tenant-id": this.tenant_id },
           {
             context: {
-              runConfig: executionRunConfig
+              runConfig: executionRunConfig,
+              runGovernance: this.runGovernanceContext(runId, executionRunConfig)
             },
             configurable: {
               ...executionRunConfig,
@@ -26318,7 +26880,8 @@ var Agent = class {
           },
           {
             context: {
-              runConfig: executionRunConfig
+              runConfig: executionRunConfig,
+              runGovernance: this.runGovernanceContext(runId, executionRunConfig)
             },
             configurable: {
               ...executionRunConfig,
@@ -26769,7 +27332,7 @@ var Agent = class {
    */
   async [TRUSTED_AGENT_DISPATCH](queueMessage, options) {
     this.rejectDelegatedQueueAuthority(queueMessage);
-    if (!isPlainRecord(options) || !hasExactKeys(options, ["trustedRunContext", "executionMode"]) || options.executionMode !== "followup") {
+    if (!isPlainRecord2(options) || !hasExactKeys(options, ["trustedRunContext", "executionMode"]) || options.executionMode !== "followup") {
       throw invalidTrustedRunContext();
     }
     this.validateTrustedRunContext(options.trustedRunContext, queueMessage.input.id);
@@ -26803,14 +27366,14 @@ var Agent = class {
     const markedRows = rows.filter((row2) => row2.trusted_run_context !== void 0 || row2.execution_mode !== void 0);
     if (markedRows.length === 0) {
       const revisions = rows.map((row2) => {
-        const config = isPlainRecord(row2.custom_run_config) ? row2.custom_run_config : {};
+        const config = isPlainRecord2(row2.custom_run_config) ? row2.custom_run_config : {};
         return typeof config.capabilityRuntimeRevision === "string" ? config.capabilityRuntimeRevision : void 0;
       });
       if (new Set(revisions).size > 1) {
         throw new Error("Processing rows have inconsistent capability runtime revisions");
       }
       return {
-        customRunConfig: isPlainRecord(rows[0].custom_run_config) ? rows[0].custom_run_config : {},
+        customRunConfig: isPlainRecord2(rows[0].custom_run_config) ? rows[0].custom_run_config : {},
         inputMessageId: rows[0].id,
         consumedInputMessageIds: rows.map(({ id }) => id)
       };
@@ -26831,7 +27394,7 @@ var Agent = class {
       throw new TrustedRunContextRecoveryError("Trusted processing context is invalid");
     }
     return {
-      customRunConfig: isPlainRecord(row.custom_run_config) ? row.custom_run_config : {},
+      customRunConfig: isPlainRecord2(row.custom_run_config) ? row.custom_run_config : {},
       trustedRunContext,
       inputMessageId: row.id,
       consumedInputMessageIds: [row.id]
@@ -26886,8 +27449,21 @@ var Agent = class {
     }
     return base;
   }
+  runGovernanceContext(runId, executionRunConfig) {
+    const config = readRunGovernanceConfig();
+    const execution = isPlainRecord2(executionRunConfig.execution) ? executionRunConfig.execution : void 0;
+    const taskId = typeof executionRunConfig.taskId === "string" ? executionRunConfig.taskId : typeof execution?.taskId === "string" ? execution.taskId : "";
+    const isTask = taskId.length > 0;
+    return {
+      runId,
+      source: isTask ? "task" : "chat",
+      budget: {
+        maxModelCalls: resolveRequestedMaxModelCalls(executionRunConfig.budget, config)
+      }
+    };
+  }
   observabilityCallbacks(runConfig, runId, source) {
-    const execution = isPlainRecord(runConfig.execution) ? runConfig.execution : void 0;
+    const execution = isPlainRecord2(runConfig.execution) ? runConfig.execution : void 0;
     const taskId = typeof runConfig.taskId === "string" ? runConfig.taskId : execution && typeof execution.taskId === "string" ? execution.taskId : void 0;
     const callbacks = resolveObservabilityCallbacks({
       tenantId: this.tenant_id,
@@ -26928,11 +27504,11 @@ var Agent = class {
       };
       switch (message.role) {
         case "system":
-          return new SystemMessage(fields);
+          return new SystemMessage2(fields);
         case "assistant":
-          return new AIMessage4(fields);
+          return new AIMessage5(fields);
         case "tool":
-          return new ToolMessage6({
+          return new ToolMessage7({
             ...fields,
             tool_call_id: typeof message.metadata?.tool_call_id === "string" ? message.metadata.tool_call_id : ""
           });
@@ -27137,7 +27713,10 @@ var Agent = class {
       const result = await runnable_agent.invoke(
         inputMessage.command ? new Command2(inputMessage.command) : { ...rest, messages, "x-tenant-id": this.tenant_id },
         {
-          context: { runConfig: executionRunConfig },
+          context: {
+            runConfig: executionRunConfig,
+            runGovernance: this.runGovernanceContext(runId, executionRunConfig)
+          },
           configurable: {
             ...executionRunConfig,
             run_id: runId,
@@ -27550,7 +28129,8 @@ var Agent = class {
       null,
       {
         context: {
-          runConfig: executionRunConfig
+          runConfig: executionRunConfig,
+          runGovernance: this.runGovernanceContext(runId, executionRunConfig)
         },
         configurable: {
           ...executionRunConfig,
@@ -29269,11 +29849,24 @@ var EXCLUDED_STATE_KEYS = [
   "repeatedToolCallSignature",
   "repeatedToolCallCount",
   "repeatedToolCallRunMarker",
-  "repeatedToolCallMemberSignatures"
+  "repeatedToolCallMemberSignatures",
+  "governRunId",
+  "governModelCalls",
+  "governToolRounds",
+  "governToolCalls",
+  "governSkillCalls",
+  "governWarned",
+  "governNotice",
+  "governLastSignature",
+  "governRepeatCount",
+  "governTerminationReason",
+  "governStopSummary",
+  "governForceFinal",
+  "governForcedRounds"
 ];
 var DEFAULT_GENERAL_PURPOSE_DESCRIPTION = "General-purpose agent for researching complex questions, searching for files and content, and executing multi-step tasks. When you are searching for a keyword or file and are not confident that you will find the right match in the first few tries use this agent to perform the search for you. This agent has access to all tools as the main agent.";
 function createGeneralPurposeAgent(options) {
-  const middleware = [...options.middleware];
+  const middleware = ensurePatchToolCallsMiddleware([...options.middleware]);
   if (options.interruptOn) {
     middleware.push(humanInTheLoopMiddleware({ interruptOn: options.interruptOn }));
   }
@@ -29282,7 +29875,7 @@ function createGeneralPurposeAgent(options) {
     systemPrompt: DEFAULT_SUBAGENT_PROMPT,
     tools: options.tools,
     middleware,
-    stateSchema: withToolCallLimitStateSchema(),
+    stateSchema: withRunGovernanceStateSchema(withToolCallLimitStateSchema()),
     checkpointer: getCheckpointSaver("default"),
     name: "general-purpose"
   });
@@ -29444,7 +30037,7 @@ function returnCommandWithStateUpdate(result, toolCallId) {
     update: {
       ...stateUpdate,
       messages: [
-        new ToolMessage7({
+        new ToolMessage8({
           content: lastMessage?.content || "Task Failed to complete",
           tool_call_id: toolCallId,
           name: "task"
@@ -29483,7 +30076,9 @@ function getSubagents(options) {
     if ("runnable" in agentParams) {
       agents[agentParams.key] = agentParams.runnable;
     } else {
-      const middleware = agentParams.middleware ? [...defaultSubagentMiddleware, ...agentParams.middleware] : [...defaultSubagentMiddleware];
+      const middleware = ensurePatchToolCallsMiddleware(
+        agentParams.middleware ? [...defaultSubagentMiddleware, ...agentParams.middleware] : [...defaultSubagentMiddleware]
+      );
       const interruptOn = agentParams.interruptOn || defaultInterruptOn;
       if (interruptOn)
         middleware.push(humanInTheLoopMiddleware({ interruptOn }));
@@ -29492,7 +30087,7 @@ function getSubagents(options) {
         systemPrompt: agentParams.systemPrompt,
         tools: agentParams.tools ?? defaultTools,
         middleware,
-        stateSchema: withToolCallLimitStateSchema(),
+        stateSchema: withRunGovernanceStateSchema(withToolCallLimitStateSchema()),
         checkpointer: getCheckpointSaver("default")
       });
     }
@@ -29532,7 +30127,7 @@ function createTaskTool(options) {
           return new Command3({
             update: {
               messages: [
-                new ToolMessage7({
+                new ToolMessage8({
                   content: JSON.stringify({
                     success: false,
                     code: "TASK_MIDDLEWARE_REQUIRED",
@@ -29612,7 +30207,7 @@ You are executing a persistent task (ID: ${input.taskId}). Use manage_task.updat
         return new Command3({
           update: {
             messages: [
-              new ToolMessage7({
+              new ToolMessage8({
                 content: error instanceof Error ? error.message : "Task Failed to complete",
                 tool_call_id: config.toolCall.id,
                 name: "task"
@@ -29625,14 +30220,14 @@ You are executing a persistent task (ID: ${input.taskId}). Use manage_task.updat
     {
       name: "task",
       description: finalTaskDescription,
-      schema: z46.object({
-        description: z46.string().describe("The task to execute with the selected agent"),
-        subagent_type: z46.string().describe(
+      schema: z47.object({
+        description: z47.string().describe("The task to execute with the selected agent"),
+        subagent_type: z47.string().describe(
           `Name of the agent to use. Available: ${Object.keys(
             subagentGraphs
           ).join(", ")}`
         ),
-        taskId: z46.string().optional().describe(
+        taskId: z47.string().optional().describe(
           "Optional: ID of a TaskItem created via manage_task. When set, the subagent will update this task's status as it works. Use this when executing a persistent task from the task board."
         )
       })
@@ -29661,7 +30256,7 @@ function createSubAgentMiddleware(options) {
   });
   const allTools = [taskTool];
   const effectiveSystemPrompt = systemPrompt;
-  return createMiddleware14({
+  return createMiddleware15({
     name: "subAgentMiddleware",
     tools: allTools,
     wrapModelCall: async (request, handler) => {
@@ -29681,8 +30276,8 @@ ${effectiveSystemPrompt}` : effectiveSystemPrompt;
 }
 
 // src/deep_agent_new/middleware/date.ts
-import { createMiddleware as createMiddleware15, tool as tool42 } from "langchain";
-import { z as z47 } from "zod";
+import { createMiddleware as createMiddleware16, tool as tool42 } from "langchain";
+import { z as z48 } from "zod";
 function formatCurrentDate(timezone = "UTC") {
   const now = /* @__PURE__ */ new Date();
   let validTimezone = timezone;
@@ -29710,7 +30305,7 @@ function generateDateContext(timezone = "UTC") {
 function createDateMiddleware(options = {}) {
   const timezone = options.timezone || "UTC";
   const dateContext = generateDateContext(timezone);
-  return createMiddleware15({
+  return createMiddleware16({
     name: "DateMiddleware",
     tools: [
       tool42(
@@ -29743,7 +30338,7 @@ function createDateMiddleware(options = {}) {
         {
           name: "get_current_date_time",
           description: "Get the exact current date and time at the moment of invocation. Use this when the user asks about the current time (e.g., 'what time is it', '\u51E0\u70B9\u4E86', '\u73B0\u5728\u51E0\u70B9'), or when you need to know the precise time for scheduling, deadlines, or time-sensitive operations.",
-          schema: z47.object({})
+          schema: z48.object({})
         }
       )
     ],
@@ -29809,8 +30404,8 @@ var datePlugin = {
 };
 
 // src/deep_agent_new/middleware/scheduler.ts
-import { tool as tool43, createMiddleware as createMiddleware16 } from "langchain";
-import { z as z48 } from "zod";
+import { tool as tool43, createMiddleware as createMiddleware17 } from "langchain";
+import { z as z49 } from "zod";
 import { v4 as uuidv44 } from "uuid";
 import { ScheduledTaskStatus as ScheduledTaskStatus3, ScheduleExecutionType as ScheduleExecutionType3 } from "@axiom-lattice/protocols";
 var SCHEDULE_LATTICE_KEY = "default";
@@ -29891,7 +30486,7 @@ function registerAgentAddMessageHandler() {
 function createSchedulerMiddleware(options = {}) {
   const defaultMaxRetries = options.defaultMaxRetries ?? 0;
   registerAgentAddMessageHandler();
-  return createMiddleware16({
+  return createMiddleware17({
     name: "SchedulerMiddleware",
     tools: [
       tool43(
@@ -29922,10 +30517,10 @@ function createSchedulerMiddleware(options = {}) {
         {
           name: "schedule_at",
           description: "Schedule a system message for an absolute future timestamp",
-          schema: z48.object({
-            executeAt: z48.number(),
-            maxRetries: z48.number().int().min(0).optional(),
-            message: z48.string()
+          schema: z49.object({
+            executeAt: z49.number(),
+            maxRetries: z49.number().int().min(0).optional(),
+            message: z49.string()
           })
         }
       ),
@@ -29957,10 +30552,10 @@ function createSchedulerMiddleware(options = {}) {
         {
           name: "schedule_after",
           description: "Schedule a system message after a relative delay",
-          schema: z48.object({
-            delayMs: z48.number().positive(),
-            maxRetries: z48.number().int().min(0).optional(),
-            message: z48.string()
+          schema: z49.object({
+            delayMs: z49.number().positive(),
+            maxRetries: z49.number().int().min(0).optional(),
+            message: z49.string()
           })
         }
       ),
@@ -29999,12 +30594,12 @@ function createSchedulerMiddleware(options = {}) {
         {
           name: "schedule_recurring",
           description: "Schedule a recurring system message with a cron expression",
-          schema: z48.object({
-            cronExpression: z48.string(),
-            maxRuns: z48.number().int().positive().optional(),
-            expiresAt: z48.number().optional(),
-            maxRetries: z48.number().int().min(0).optional(),
-            message: z48.string()
+          schema: z49.object({
+            cronExpression: z49.string(),
+            maxRuns: z49.number().int().positive().optional(),
+            expiresAt: z49.number().optional(),
+            maxRetries: z49.number().int().min(0).optional(),
+            message: z49.string()
           })
         }
       ),
@@ -30017,8 +30612,8 @@ function createSchedulerMiddleware(options = {}) {
         {
           name: "cancel_scheduled_task",
           description: "Cancel a scheduled task by task id",
-          schema: z48.object({
-            taskId: z48.string()
+          schema: z49.object({
+            taskId: z49.string()
           })
         }
       ),
@@ -30044,11 +30639,11 @@ function createSchedulerMiddleware(options = {}) {
         {
           name: "list_scheduled_tasks",
           description: "List scheduled tasks for the current agent context",
-          schema: z48.object({
-            status: z48.enum(["pending", "running", "completed", "failed", "cancelled", "paused"]).optional(),
-            executionType: z48.enum(["once", "cron"]).optional(),
-            limit: z48.number().int().positive().optional(),
-            offset: z48.number().int().min(0).optional()
+          schema: z49.object({
+            status: z49.enum(["pending", "running", "completed", "failed", "cancelled", "paused"]).optional(),
+            executionType: z49.enum(["once", "cron"]).optional(),
+            limit: z49.number().int().positive().optional(),
+            offset: z49.number().int().min(0).optional()
           })
         }
       )
@@ -31305,8 +31900,8 @@ var MemoryBackend = class {
 
 // src/deep_agent_new/middleware/todos.ts
 import { Command as Command4 } from "@langchain/langgraph";
-import { z as z49 } from "zod";
-import { createMiddleware as createMiddleware17, tool as tool44, ToolMessage as ToolMessage8 } from "langchain";
+import { z as z50 } from "zod";
+import { createMiddleware as createMiddleware18, tool as tool44, ToolMessage as ToolMessage9 } from "langchain";
 var WRITE_TODOS_DESCRIPTION = `Use this tool to create and manage a structured task list for your current work session. This helps you track progress, organize complex tasks, and demonstrate thoroughness to the user.
 It also helps the user understand the progress of the task and overall progress of their requests.
 Only use this tool if you think it will be helpful in staying organized. If the user's request is trivial and takes less than 3 steps, it is better to NOT use this tool and just do the taks directly.
@@ -31533,12 +32128,12 @@ Writing todos takes time and tokens, use it when it is helpful for managing comp
 ## Important To-Do List Usage Notes to Remember
 - The \`write_todos\` tool should never be called multiple times in parallel.
 - Don't be afraid to revise the To-Do list as you go. New information may reveal new tasks that need to be done, or old tasks that are irrelevant.`;
-var TodoStatus = z49.enum(["pending", "in_progress", "completed"]).describe("Status of the todo");
-var TodoSchema = z49.object({
-  content: z49.string().describe("Content of the todo item"),
+var TodoStatus = z50.enum(["pending", "in_progress", "completed"]).describe("Status of the todo");
+var TodoSchema = z50.object({
+  content: z50.string().describe("Content of the todo item"),
   status: TodoStatus
 });
-var stateSchema = z49.object({ todos: z49.array(TodoSchema).default([]) });
+var stateSchema = z50.object({ todos: z50.array(TodoSchema).default([]) });
 function todoListMiddleware(options) {
   const writeTodos = tool44(
     ({ todos }, config) => {
@@ -31546,7 +32141,7 @@ function todoListMiddleware(options) {
         update: {
           todos,
           messages: [
-            new ToolMessage8({
+            new ToolMessage9({
               content: genUIMarkdown("todo_list", todos),
               tool_call_id: config.toolCall?.id
             })
@@ -31557,12 +32152,12 @@ function todoListMiddleware(options) {
     {
       name: "write_todos",
       description: options?.toolDescription ?? WRITE_TODOS_DESCRIPTION,
-      schema: z49.object({
-        todos: z49.array(TodoSchema).describe("List of todo items to update")
+      schema: z50.object({
+        todos: z50.array(TodoSchema).describe("List of todo items to update")
       })
     }
   );
-  return createMiddleware17({
+  return createMiddleware18({
     name: "todoListMiddleware",
     stateSchema,
     tools: [writeTodos],
@@ -31610,7 +32205,7 @@ function createDeepAgent(params = {}) {
 ${BASE_PROMPT}` : BASE_PROMPT;
   const filesystemBackend = backend ? backend : async (config) => new StateBackend(config);
   const postDelegationMiddleware = interruptOn ? [humanInTheLoopMiddleware2({ interruptOn })] : [];
-  const middleware = assembleDeepAgentMiddleware(
+  const middleware = ensurePatchToolCallsMiddleware(assembleDeepAgentMiddleware(
     customMiddleware,
     [
       // Provides todo list management capabilities for tracking tasks
@@ -31623,7 +32218,7 @@ ${BASE_PROMPT}` : BASE_PROMPT;
       createSubAgentMiddleware({
         defaultModel: model,
         defaultTools: tools,
-        defaultMiddleware: [
+        defaultMiddleware: ensurePatchToolCallsMiddleware([
           // Subagent middleware: Todo list management
           todoListMiddleware(),
           // Subagent middleware: Filesystem operations
@@ -31635,7 +32230,7 @@ ${BASE_PROMPT}` : BASE_PROMPT;
             unsupportedModelBehavior: "ignore"
           }),
           ...customMiddleware
-        ],
+        ]),
         defaultInterruptOn: interruptOn,
         subagents,
         generalPurposeAgent: true
@@ -31646,7 +32241,7 @@ ${BASE_PROMPT}` : BASE_PROMPT;
     //   unsupportedModelBehavior: "ignore",
     // })
     postDelegationMiddleware
-  );
+  ));
   return createAgent3({
     model,
     systemPrompt: finalSystemPrompt,
@@ -31654,7 +32249,7 @@ ${BASE_PROMPT}` : BASE_PROMPT;
     middleware,
     responseFormat,
     contextSchema: contextSchema2,
-    stateSchema: withToolCallLimitStateSchema(),
+    stateSchema: withRunGovernanceStateSchema(withToolCallLimitStateSchema()),
     checkpointer,
     store: store2,
     name
@@ -31740,7 +32335,7 @@ var DeepAgentGraphBuilder = class {
 
 // src/agent_lattice/builders/RemoteAgentGraphBuilder.ts
 import { StateGraph as StateGraph2, MessagesAnnotation } from "@langchain/langgraph";
-import { AIMessage as AIMessage5 } from "@langchain/core/messages";
+import { AIMessage as AIMessage6 } from "@langchain/core/messages";
 
 // src/services/a2a-client.ts
 import { v4 as uuidv45 } from "uuid";
@@ -32079,7 +32674,7 @@ var RemoteAgentGraphBuilder = class {
       if (!text) {
         return {
           messages: [
-            new AIMessage5("No text input provided to remote agent.")
+            new AIMessage6("No text input provided to remote agent.")
           ]
         };
       }
@@ -32091,13 +32686,13 @@ ${text}` : text;
         const threadId = langGraphConfig?.configurable?.thread_id;
         const response = await client.sendMessage(fullPrompt, threadId);
         return {
-          messages: [new AIMessage5(response)]
+          messages: [new AIMessage6(response)]
         };
       } catch (error) {
         const msg = error.message ?? String(error);
         return {
           messages: [
-            new AIMessage5(`Remote A2A agent error: ${msg}`)
+            new AIMessage6(`Remote A2A agent error: ${msg}`)
           ]
         };
       }
@@ -32128,9 +32723,10 @@ import { createAgent as createAgent4 } from "langchain";
 import { isWorkflowAgentConfig } from "@axiom-lattice/protocols";
 
 // src/agent_lattice/builders/middlewareSanitize.ts
-function stripWrapModelCallHook(middlewares) {
+function stripWrapModelCallHook(middlewares, preserveNames = []) {
+  const preserved = new Set(preserveNames);
   return middlewares.map((m) => {
-    if (typeof m.wrapModelCall !== "function") {
+    if (preserved.has(m.name) || typeof m.wrapModelCall !== "function") {
       return m;
     }
     const clone3 = { ...m };
@@ -32185,8 +32781,11 @@ var WorkflowAgentGraphBuilder = class {
         config: {}
       }
     ], void 0, false, void 0, params.model);
-    const noWrapMiddlewares = stripWrapModelCallHook(middlewares);
-    const noWrapAskMiddlewares = stripWrapModelCallHook(askMiddlewares);
+    const preservedMiddlewareNames = [
+      "patchToolCallsMiddleware"
+    ];
+    const noWrapMiddlewares = stripWrapModelCallHook(middlewares, preservedMiddlewareNames);
+    const noWrapAskMiddlewares = stripWrapModelCallHook(askMiddlewares, preservedMiddlewareNames);
     console.log(`[WF BUILDER] building default agent | toolCount=${tools.length} | middlewareCount=${middlewares.length}`);
     const defaultAgent = createAgent4({
       model: params.model,
@@ -32195,7 +32794,7 @@ var WorkflowAgentGraphBuilder = class {
       name: agentName,
       checkpointer,
       middleware: middlewares,
-      stateSchema: withToolCallLimitStateSchema()
+      stateSchema: withRunGovernanceStateSchema(withToolCallLimitStateSchema())
     });
     console.log(`[WF BUILDER] default agent built`);
     const agentCache = /* @__PURE__ */ new Map();
@@ -32217,7 +32816,7 @@ var WorkflowAgentGraphBuilder = class {
             name: agentName,
             checkpointer,
             middleware: isAsk ? noWrapAskMiddlewares : noWrapMiddlewares,
-            stateSchema: withToolCallLimitStateSchema(),
+            stateSchema: withRunGovernanceStateSchema(withToolCallLimitStateSchema()),
             responseFormat
           });
           agentCache.set(key5, agent);
@@ -32413,7 +33012,7 @@ function mergeAgentConfig(parent, child) {
 }
 
 // src/agent_lattice/agentArchitectTools.ts
-import z50 from "zod";
+import z51 from "zod";
 import { v4 as v43 } from "uuid";
 import { AgentType as AgentType4 } from "@axiom-lattice/protocols";
 function getTenantId2(exeConfig) {
@@ -32527,7 +33126,7 @@ registerToolLattice(
   {
     name: "list_agents",
     description: "List all agents for the current workspace. Returns a summary with id, name, description, and type for each agent.",
-    schema: z50.object({})
+    schema: z51.object({})
   },
   async (_input, exeConfig) => {
     try {
@@ -32553,9 +33152,9 @@ registerToolLattice(
   "get_agent",
   {
     name: "get_agent",
-    description: "Get the full configuration of a specific agent by its ID. Returns the complete AgentConfig including prompt, middleware, tools, and sub-agents.",
-    schema: z50.object({
-      id: z50.string().describe("The agent ID to retrieve")
+    description: "Get the full configuration of a specific agent by its ID. Returns the complete AgentConfig including prompt, middleware, tools, and sub-agents. Pass only { id: string }; this tool has no action, collection, or other parameters.",
+    schema: z51.object({
+      id: z51.string().describe("The agent ID to retrieve")
     })
   },
   async (input, exeConfig) => {
@@ -32572,27 +33171,27 @@ registerToolLattice(
     }
   }
 );
-var middlewareConfigSchema = z50.object({
-  id: z50.string(),
-  type: z50.string(),
-  name: z50.string(),
-  description: z50.string(),
-  enabled: z50.boolean(),
-  allowedTools: z50.array(z50.string()).optional().describe("Optional tool-name allowlist. Omit it or pass [] to enable all tools from this middleware. A non-empty task middleware allowlist must include both manage_task and task."),
-  config: z50.record(z50.any()).optional()
+var middlewareConfigSchema = z51.object({
+  id: z51.string(),
+  type: z51.string(),
+  name: z51.string(),
+  description: z51.string(),
+  enabled: z51.boolean(),
+  allowedTools: z51.array(z51.string()).optional().describe("Optional tool-name allowlist. Omit it or pass [] to enable all tools from this middleware. A non-empty task middleware allowlist must include both manage_task and task."),
+  config: z51.record(z51.any()).optional()
 });
-var createAgentSchema = z50.object({
-  skillLoaded: z50.boolean().optional().describe("Required on every call: load the 'agent-architecture' skill first via the skill tool (skill_name 'agent-architecture'), then pass skillLoaded: true. Calls without skillLoaded: true fail. Never omit or pass false."),
-  name: z50.string().describe("Human-friendly display name for the agent. The machine ID (used in other tools) is auto-generated as a slug from this name (e.g. 'My Cool Agent' \u2192 'my-cool-agent')."),
-  description: z50.string().optional().describe("Short description"),
-  type: z50.enum(["react", "deep_agent"]).describe("Agent type. Use 'react' for simple single-responsibility agents, 'deep_agent' for complex open-ended agents. For PROCESSING agents (workflow orchestration), use create_processing_agent instead."),
-  prompt: z50.string().describe("System prompt for the agent"),
-  tools: z50.array(z50.string()).optional().describe("Tool keys (strings) to assign. Call list_tools first to see available keys. Each element is a plain string like 'sap_api_search'. IMPORTANT: tools is a FLAT string array of tool names. Do NOT put middleware-like objects here \u2014 middleware goes in the separate 'middleware' field."),
-  middleware: z50.array(middlewareConfigSchema).optional().describe("Middleware configuration objects. Each has {id, type, name, description, enabled, config}. IMPORTANT: middleware objects are NOT tools. Do NOT put tool keys (strings) here \u2014 tool names go in the separate 'tools' array. For user approval/confirmation scenarios, use type: 'ask_user_to_clarify' with config: {}."),
-  subAgents: z50.array(z50.string()).optional().describe("Sub-agent IDs (deep_agent only)"),
-  internalSubAgents: z50.array(z50.any()).optional().describe("Inline sub-agent configs (deep_agent only)"),
-  modelKey: z50.string().optional().describe("Model key to use"),
-  metadata: z50.record(z50.string(), z50.string()).optional().describe("Arbitrary metadata key-value pairs (e.g. verified: 'human-reviewed', version: '1.0', source: 'PO-Format-SAP.pdf')")
+var createAgentSchema = z51.object({
+  skillLoaded: z51.boolean().optional().describe("Required on every call: load the 'agent-architecture' skill first via the skill tool (skill_name 'agent-architecture'), then pass skillLoaded: true. Calls without skillLoaded: true fail. Never omit or pass false."),
+  name: z51.string().describe("Human-friendly display name for the agent. The machine ID (used in other tools) is auto-generated as a slug from this name (e.g. 'My Cool Agent' \u2192 'my-cool-agent')."),
+  description: z51.string().optional().describe("Short description"),
+  type: z51.enum(["react", "deep_agent"]).describe("Agent type. Use 'react' for simple single-responsibility agents, 'deep_agent' for complex open-ended agents. For PROCESSING agents (workflow orchestration), use create_processing_agent instead."),
+  prompt: z51.string().describe("System prompt for the agent"),
+  tools: z51.array(z51.string()).optional().describe("Tool keys (strings) to assign. Call list_tools first to see available keys. Each element is a plain string like 'sap_api_search'. IMPORTANT: tools is a FLAT string array of tool names. Do NOT put middleware-like objects here \u2014 middleware goes in the separate 'middleware' field."),
+  middleware: z51.array(middlewareConfigSchema).optional().describe("Middleware configuration objects. Each has {id, type, name, description, enabled, config}. IMPORTANT: middleware objects are NOT tools. Do NOT put tool keys (strings) here \u2014 tool names go in the separate 'tools' array. For user approval/confirmation scenarios, use type: 'ask_user_to_clarify' with config: {}."),
+  subAgents: z51.array(z51.string()).optional().describe("Sub-agent IDs (deep_agent only)"),
+  internalSubAgents: z51.array(z51.any()).optional().describe("Inline sub-agent configs (deep_agent only)"),
+  modelKey: z51.string().optional().describe("Model key to use"),
+  metadata: z51.record(z51.string(), z51.string()).optional().describe("Arbitrary metadata key-value pairs (e.g. verified: 'human-reviewed', version: '1.0', source: 'PO-Format-SAP.pdf')")
 });
 registerToolLattice(
   "create_agent",
@@ -32637,14 +33236,14 @@ registerToolLattice(
     }
   }
 );
-var createWorkflowSchema = z50.object({
-  name: z50.string().describe("Display name for the workflow agent"),
-  description: z50.string().optional().describe("Short description"),
-  skillLoaded: z50.boolean().optional().describe("Required on every call: load the 'agent-architecture' skill first via the skill tool (skill_name 'agent-architecture'), then pass skillLoaded: true. Calls without skillLoaded: true fail. Never omit or pass false."),
-  yaml: z50.string().describe("The YAML workflow definition in linear DSL format (steps execute top-to-bottom, use parallel: for concurrency)"),
-  tools: z50.array(z50.string()).optional().describe("Tool keys for the workflow agent"),
-  middleware: z50.array(middlewareConfigSchema).optional().describe("Middleware configs"),
-  modelKey: z50.string().optional().describe("Model key")
+var createWorkflowSchema = z51.object({
+  name: z51.string().describe("Display name for the workflow agent"),
+  description: z51.string().optional().describe("Short description"),
+  skillLoaded: z51.boolean().optional().describe("Required on every call: load the 'agent-architecture' skill first via the skill tool (skill_name 'agent-architecture'), then pass skillLoaded: true. Calls without skillLoaded: true fail. Never omit or pass false."),
+  yaml: z51.string().describe("The YAML workflow definition in linear DSL format (steps execute top-to-bottom, use parallel: for concurrency)"),
+  tools: z51.array(z51.string()).optional().describe("Tool keys for the workflow agent"),
+  middleware: z51.array(middlewareConfigSchema).optional().describe("Middleware configs"),
+  modelKey: z51.string().optional().describe("Model key")
 });
 registerToolLattice(
   "create_workflow",
@@ -32697,8 +33296,8 @@ registerToolLattice(
   {
     name: "validate_workflow",
     description: "Validate a workflow agent's DSL for correctness by compiling it.",
-    schema: z50.object({
-      id: z50.string().describe("The workflow agent ID to validate")
+    schema: z51.object({
+      id: z51.string().describe("The workflow agent ID to validate")
     })
   },
   async (input, exeConfig) => {
@@ -32795,15 +33394,15 @@ registerToolLattice(
     }
   }
 );
-var updateWorkflowSchema = z50.object({
-  id: z50.string().describe("The workflow agent ID to update"),
-  skillLoaded: z50.boolean().optional().describe("Required on every call: load the 'agent-architecture' skill first via the skill tool (skill_name 'agent-architecture'), then pass skillLoaded: true. Calls without skillLoaded: true fail. Never omit or pass false."),
-  name: z50.string().optional().describe("New display name"),
-  description: z50.string().optional().describe("New description"),
-  yaml: z50.string().optional().describe("Replacement YAML workflow DSL. Omit to keep existing."),
-  tools: z50.array(z50.string()).optional().describe("Replacement tool keys"),
-  middleware: z50.array(middlewareConfigSchema).optional().describe("Replacement middleware configs"),
-  modelKey: z50.string().optional().describe("Replacement model key")
+var updateWorkflowSchema = z51.object({
+  id: z51.string().describe("The workflow agent ID to update"),
+  skillLoaded: z51.boolean().optional().describe("Required on every call: load the 'agent-architecture' skill first via the skill tool (skill_name 'agent-architecture'), then pass skillLoaded: true. Calls without skillLoaded: true fail. Never omit or pass false."),
+  name: z51.string().optional().describe("New display name"),
+  description: z51.string().optional().describe("New description"),
+  yaml: z51.string().optional().describe("Replacement YAML workflow DSL. Omit to keep existing."),
+  tools: z51.array(z51.string()).optional().describe("Replacement tool keys"),
+  middleware: z51.array(middlewareConfigSchema).optional().describe("Replacement middleware configs"),
+  modelKey: z51.string().optional().describe("Replacement model key")
 });
 registerToolLattice(
   "update_workflow",
@@ -32909,20 +33508,20 @@ registerToolLattice(
     }
   }
 );
-var updateAgentSchema = z50.object({
-  id: z50.string().describe("The agent ID to update"),
-  skillLoaded: z50.boolean().optional().describe("Required on every call: load the 'agent-architecture' skill first via the skill tool (skill_name 'agent-architecture'), then pass skillLoaded: true. Calls without skillLoaded: true fail. Never omit or pass false."),
-  config: z50.object({
-    name: z50.string().optional().describe("New display name for the agent"),
-    description: z50.string().optional().describe("New short description"),
-    type: z50.enum(["react", "deep_agent"]).optional().describe("Agent type"),
-    prompt: z50.string().optional().describe("New system prompt for the agent"),
-    tools: z50.array(z50.string()).optional().describe("Tool keys to assign to this agent. These are registered tool names (strings), NOT middleware objects."),
-    middleware: z50.array(middlewareConfigSchema).optional().describe("Middleware configurations. NOTE: middleware objects have type/name/description/enabled/config fields and are NOT the same as tools. Tool keys go in the 'tools' array. For user approval/confirmation scenarios, use type: 'ask_user_to_clarify' with config: {}."),
-    subAgents: z50.array(z50.string()).optional().describe("Sub-agent IDs (deep_agent only)"),
-    internalSubAgents: z50.array(z50.any()).optional().describe("Inline sub-agent configs (deep_agent only)"),
-    modelKey: z50.string().optional().describe("Model key to use"),
-    metadata: z50.record(z50.string(), z50.string()).optional().describe("Arbitrary metadata key-value pairs (e.g. verified: 'machine-confirmed', version: '1.1'). Replaces the whole map when provided.")
+var updateAgentSchema = z51.object({
+  id: z51.string().describe("The agent ID to update"),
+  skillLoaded: z51.boolean().optional().describe("Required on every call: load the 'agent-architecture' skill first via the skill tool (skill_name 'agent-architecture'), then pass skillLoaded: true. Calls without skillLoaded: true fail. Never omit or pass false."),
+  config: z51.object({
+    name: z51.string().optional().describe("New display name for the agent"),
+    description: z51.string().optional().describe("New short description"),
+    type: z51.enum(["react", "deep_agent"]).optional().describe("Agent type"),
+    prompt: z51.string().optional().describe("New system prompt for the agent"),
+    tools: z51.array(z51.string()).optional().describe("Tool keys to assign to this agent. These are registered tool names (strings), NOT middleware objects."),
+    middleware: z51.array(middlewareConfigSchema).optional().describe("Middleware configurations. NOTE: middleware objects have type/name/description/enabled/config fields and are NOT the same as tools. Tool keys go in the 'tools' array. For user approval/confirmation scenarios, use type: 'ask_user_to_clarify' with config: {}."),
+    subAgents: z51.array(z51.string()).optional().describe("Sub-agent IDs (deep_agent only)"),
+    internalSubAgents: z51.array(z51.any()).optional().describe("Inline sub-agent configs (deep_agent only)"),
+    modelKey: z51.string().optional().describe("Model key to use"),
+    metadata: z51.record(z51.string(), z51.string()).optional().describe("Arbitrary metadata key-value pairs (e.g. verified: 'machine-confirmed', version: '1.1'). Replaces the whole map when provided.")
   }).describe("Configuration fields to update. Only include the fields you want to change.")
 });
 registerToolLattice(
@@ -33044,8 +33643,8 @@ registerToolLattice(
   {
     name: "delete_agent",
     description: "Permanently delete an agent by its ID. This action cannot be undone.",
-    schema: z50.object({
-      id: z50.string().describe("The agent ID to delete")
+    schema: z51.object({
+      id: z51.string().describe("The agent ID to delete")
     })
   },
   async (input, exeConfig) => {
@@ -33071,7 +33670,7 @@ registerToolLattice(
   {
     name: "list_tools",
     description: "List all available tools that can be assigned to agents. Returns each tool's registry key (use this string value in the 'tools' array), name, description, and whether it requires user approval.",
-    schema: z50.object({})
+    schema: z51.object({})
   },
   async (_input, _exeConfig) => {
     try {
@@ -33095,7 +33694,7 @@ registerToolLattice(
   {
     name: "list_models",
     description: "List all registered models. Returns each model's key (use this string as modelKey when creating eval projects via manage_eval create_project, or as an agent's modelKey in create_agent/update_agent) and its display name.",
-    schema: z50.object({})
+    schema: z51.object({})
   },
   async (_input, exeConfig) => {
     try {
@@ -33116,9 +33715,9 @@ registerToolLattice(
   {
     name: "invoke_agent",
     description: "Invoke an agent with a test message and return its response. Use this to verify an agent works correctly after creating or modifying it. The agent must be compiled (already created and valid).",
-    schema: z50.object({
-      id: z50.string().describe("The agent ID to invoke"),
-      message: z50.string().describe("The test message to send to the agent")
+    schema: z51.object({
+      id: z51.string().describe("The agent ID to invoke"),
+      message: z51.string().describe("The test message to send to the agent")
     })
   },
   async (input, exeConfig) => {
@@ -33154,7 +33753,7 @@ registerToolLattice(
   {
     name: "list_middleware_types",
     description: "\u5217\u51FA\u5F53\u524D\u7CFB\u7EDF\u4E2D\u6240\u6709\u53EF\u7528\u7684\u4E2D\u95F4\u4EF6\u7C7B\u578B\uFF08Middlewares\uFF09\uFF0C\u5305\u62EC\u5185\u7F6E\u548C\u81EA\u5B9A\u4E49\u63D2\u4EF6\u3002\u8FD4\u56DE\u6BCF\u4E2A\u4E2D\u95F4\u4EF6\u7684 type\u3001name\u3001description\u3001tools \u6E05\u5355\uFF08\u652F\u6301 allowedTools \u8FC7\u6EE4\uFF09\u3001configSchema\uFF08\u914D\u7F6E\u9762\u677F\u9700\u8981\u54EA\u4E9B\u5B57\u6BB5\uFF09\u548C connectionSchema\uFF08\u662F\u5426\u652F\u6301\u8FDE\u63A5\u6D4B\u8BD5\u548C\u8D44\u6E90\u53D1\u73B0\uFF09\u3002\n\n\u4F7F\u7528\u573A\u666F\uFF1A\n1. \u5728\u521B\u5EFA agent \u524D\uFF0C\u5148\u8C03\u6B64\u5DE5\u5177\u4E86\u89E3\u6709\u54EA\u4E9B\u4E2D\u95F4\u4EF6\u53EF\u914D\u7F6E\n2. \u6839\u636E configSchema \u51B3\u5B9A\u9700\u8981\u63D0\u4F9B\u54EA\u4E9B\u914D\u7F6E\u5B57\u6BB5\uFF1B\u65B0\u8FDE\u63A5\u578B\u63D2\u4EF6\u4F7F\u7528 connections \u548C connectAll\uFF0C\u5185\u7F6E\u65E7\u63D2\u4EF6\u7684 selector \u5B57\u6BB5\u7531 core \u7684 legacy compatibility map \u5B9A\u4E49\n3. \u5982\u679C\u67D0\u4E2A\u4E2D\u95F4\u4EF6\u7684 connectionSchema \u5B58\u5728\uFF0C\u8BF4\u660E\u5B83\u662F\u8FDE\u63A5\u578B\u4E2D\u95F4\u4EF6\uFF0C\u9700\u8981\u518D\u8C03 list_connections \u83B7\u53D6\u53EF\u7528\u8FDE\u63A5\n4. \u7528\u8FD4\u56DE\u7684 type \u5B57\u6BB5\u6784\u5EFA middleware \u6570\u7EC4\u4F20\u7ED9 create_agent / update_agent",
-    schema: z50.object({})
+    schema: z51.object({})
   },
   async (_input, exeConfig) => {
     const tenantId2 = getTenantId2(exeConfig);
@@ -33168,8 +33767,8 @@ registerToolLattice(
   {
     name: "list_connections",
     description: "\u5217\u51FA\u6307\u5B9A\u63D2\u4EF6\u7C7B\u578B\u7684\u6240\u6709\u5DF2\u914D\u7F6E\u8FDE\u63A5\u3002\u7528\u4E8E\u67E5\u8BE2\u6709\u54EA\u4E9B\u53EF\u7528\u7684\u8FDE\u63A5\u5B9E\u4F8B\uFF08\u5982 'sap-prod', 'sap-dev'\uFF09\uFF0C\u65B9\u4FBF\u5728 agent \u914D\u7F6E\u4E2D\u9009\u62E9\u5177\u4F53\u8FDE\u63A5\u3002\n\n\u4F7F\u7528\u573A\u666F\uFF1A\n1. \u5148\u8C03 list_middleware_types \u786E\u5B9A\u67D0\u4E2A\u4E2D\u95F4\u4EF6\u662F\u8FDE\u63A5\u578B\uFF08\u6709 connectionSchema\uFF09\n2. \u8C03\u6B64\u5DE5\u5177\u4F20\u5165 type\uFF08\u5982 'erp'\uFF09\uFF0C\u83B7\u53D6\u8BE5\u7C7B\u578B\u4E0B\u5DF2\u914D\u597D\u7684\u8FDE\u63A5\u5217\u8868\n3. \u5728 create_agent \u7684 middleware[i].config.connections \u4E2D\u586B\u5165\u5BF9\u5E94\u7684 key \u503C\n\n\u8FD4\u56DE\u683C\u5F0F\uFF1A{ success: true, data: { records: [{ key, name, ... }] } }",
-    schema: z50.object({
-      type: z50.string().describe("\u63D2\u4EF6\u7C7B\u578B\u6807\u8BC6\uFF0C\u5982 'erp'\u3002\u4ECE list_middleware_types \u7684\u8FD4\u56DE\u4E2D\u83B7\u53D6")
+    schema: z51.object({
+      type: z51.string().describe("\u63D2\u4EF6\u7C7B\u578B\u6807\u8BC6\uFF0C\u5982 'erp'\u3002\u4ECE list_middleware_types \u7684\u8FD4\u56DE\u4E2D\u83B7\u53D6")
     }),
     needUserApprove: false
   },
@@ -44200,10 +44799,10 @@ async function assertSafeUpstreamUrl(raw) {
 }
 
 // src/middlewares/skillMiddleware.ts
-import { createMiddleware as createMiddleware18 } from "langchain";
+import { createMiddleware as createMiddleware19 } from "langchain";
 
 // src/tool_lattice/skill/load_skills.ts
-import z51 from "zod";
+import z52 from "zod";
 import { tool as tool45 } from "langchain";
 var LOAD_SKILLS_DESCRIPTION = `Load all available skills and return their metadata (name, description, license, compatibility, metadata, and subSkills) without the content. This tool returns skill information including hierarchical relationships (subSkills). Use this to discover what skills are available and their structure.`;
 function getSandboxFromExeConfig(_exe_config) {
@@ -44285,7 +44884,7 @@ var createLoadSkillsTool = ({ skills, readAll, pluginSkills, pluginSkillOwners }
     {
       name: "load_skills",
       description: LOAD_SKILLS_DESCRIPTION,
-      schema: z51.object({})
+      schema: z52.object({})
     }
   );
 };
@@ -44295,7 +44894,7 @@ function isSkillAllowed(skillName, staticSkills, staticReadAll) {
 }
 
 // src/tool_lattice/skill/load_skill_content.ts
-import z52 from "zod";
+import z53 from "zod";
 import { tool as tool46 } from "langchain";
 
 // src/sandbox_plugin/pluginSkillResolution.ts
@@ -44445,8 +45044,8 @@ var createLoadSkillContentTool = (pluginSkills, pluginSkillOwnersOrStaticSelecti
     {
       name: "skill",
       description: LOAD_SKILL_CONTENT_DESCRIPTION,
-      schema: z52.object({
-        skill_name: z52.string().describe("The name of the skill to load")
+      schema: z53.object({
+        skill_name: z53.string().describe("The name of the skill to load")
       })
     }
   );
@@ -44465,7 +45064,7 @@ function isSkillAllowed2(skillName, staticSelection) {
 }
 
 // src/tool_lattice/skill/load_skill_resource.ts
-import z53 from "zod";
+import z54 from "zod";
 import { tool as tool47 } from "langchain";
 var LOAD_SKILL_RESOURCE_DESCRIPTION = `Load a specific resource file from a skill's resources directory. Use this tool when you need to access template files, example data, or other resources bundled with a skill. The resource paths are listed in the skill content when using the load_skill_content tool.`;
 function getSandboxFromExeConfig3(_exe_config) {
@@ -44509,16 +45108,16 @@ var createLoadSkillResourceTool = (pluginSkills, pluginSkillOwners) => {
     {
       name: "load_skill_resource",
       description: LOAD_SKILL_RESOURCE_DESCRIPTION,
-      schema: z53.object({
-        skill_name: z53.string().describe("The name of the skill containing the resource"),
-        resource_path: z53.string().describe("The path to the resource relative to the skill's resources/ directory")
+      schema: z54.object({
+        skill_name: z54.string().describe("The name of the skill containing the resource"),
+        resource_path: z54.string().describe("The path to the resource relative to the skill's resources/ directory")
       })
     }
   );
 };
 
 // src/tool_lattice/skill/delete_skill.ts
-import z54 from "zod";
+import z55 from "zod";
 import { tool as tool48 } from "langchain";
 var DELETE_SKILL_DESCRIPTION = `
 Delete a skill by name from the skill system.
@@ -44578,8 +45177,8 @@ var createDeleteSkillTool = (staticSelection = {}) => {
     {
       name: "delete_skill",
       description: DELETE_SKILL_DESCRIPTION,
-      schema: z54.object({
-        skill_name: z54.string().describe("The name of the skill to delete")
+      schema: z55.object({
+        skill_name: z55.string().describe("The name of the skill to delete")
       })
     }
   );
@@ -44603,7 +45202,7 @@ function createSkillMiddleware(params = {}) {
   } = params;
   const skills = params.skills;
   let latestSkills = [];
-  return createMiddleware18({
+  return createMiddleware19({
     name: "skillMiddleware",
     contextSchema,
     tools: [
@@ -44753,10 +45352,10 @@ var skillPlugin = {
 };
 
 // src/middlewares/collectionMiddleware.ts
-import { createMiddleware as createMiddleware19 } from "langchain";
+import { createMiddleware as createMiddleware20 } from "langchain";
 
 // src/tool_lattice/collection/list_collections.ts
-import z55 from "zod";
+import z56 from "zod";
 import { tool as tool49 } from "langchain";
 
 // src/tool_lattice/collection/utils.ts
@@ -44815,20 +45414,21 @@ var createListCollectionsTool = ({
     {
       name: "list_collections",
       description: LIST_COLLECTIONS_DESCRIPTION,
-      schema: z55.object({})
+      schema: z56.object({})
     }
   );
 };
 
 // src/tool_lattice/collection/search_collection.ts
-import z56 from "zod";
+import z57 from "zod";
 import { tool as tool50 } from "langchain";
+import { EMBEDDING_DEFAULT_KEY as EMBEDDING_DEFAULT_KEY3 } from "@axiom-lattice/protocols";
 var SEARCH_COLLECTION_DESCRIPTION = `Search for content within a specific collection using semantic (vector) similarity. Use the 'filter' parameter to narrow results by metadata fields (e.g., {"category": "cardiovascular"}). Returns the most relevant content entries with similarity scores.`;
-var searchSchema = z56.object({
-  collection: z56.string().describe("The collection name to search in"),
-  query: z56.string().describe("The search query text"),
-  filter: z56.record(z56.unknown()).optional().describe("Metadata filter conditions"),
-  top_k: z56.number().optional().default(5).describe("Number of results to return")
+var searchSchema = z57.object({
+  collection: z57.string().describe("The collection name to search in"),
+  query: z57.string().describe("The search query text"),
+  filter: z57.record(z57.unknown()).optional().describe("Metadata filter conditions"),
+  top_k: z57.number().optional().default(5).describe("Number of results to return")
 });
 var createSearchCollectionTool = (scope = { collectionKeys: [], connectAll: true }) => {
   return tool50(
@@ -44842,7 +45442,7 @@ var createSearchCollectionTool = (scope = { collectionKeys: [], connectAll: true
         if (!metadata) {
           return `Collection "${collection}" not found. Use list_collections to see available collections.`;
         }
-        const embeddingKey = metadata.embeddingKey || "default";
+        const embeddingKey = metadata.embeddingKey || EMBEDDING_DEFAULT_KEY3;
         let vectorStore;
         try {
           const storeKey = `${tenantId2}:${collection}`;
@@ -44857,7 +45457,10 @@ var createSearchCollectionTool = (scope = { collectionKeys: [], connectAll: true
         const embeddingsClient = await embeddingsLatticeManager.getEmbeddingsClientWithTenant(
           tenantId2,
           embeddingKey
-        ) ?? await embeddingsLatticeManager.getEmbeddingsClientWithTenant(
+        ) ?? (embeddingKey === EMBEDDING_DEFAULT_KEY3 ? void 0 : await embeddingsLatticeManager.getEmbeddingsClientWithTenant(
+          tenantId2,
+          EMBEDDING_DEFAULT_KEY3
+        )) ?? await embeddingsLatticeManager.getEmbeddingsClientWithTenant(
           tenantId2,
           "default"
         );
@@ -44901,7 +45504,7 @@ var createSearchCollectionTool = (scope = { collectionKeys: [], connectAll: true
 };
 
 // src/tool_lattice/collection/get_collection.ts
-import z57 from "zod";
+import z58 from "zod";
 import { tool as tool51 } from "langchain";
 var GET_COLLECTION_DESCRIPTION = `Get a collection's full definition including its custom fields schema. Use this to discover what metadata fields are available before adding entries.`;
 var createGetCollectionTool = (scope = { collectionKeys: [], connectAll: true }) => tool51(
@@ -44929,21 +45532,21 @@ Embedding: ${c.embeddingKey}${fieldsDesc}`;
       return `Error: ${error.message}`;
     }
   },
-  { name: "get_collection", description: GET_COLLECTION_DESCRIPTION, schema: z57.object({ name: z57.string().describe("Collection name") }) }
+  { name: "get_collection", description: GET_COLLECTION_DESCRIPTION, schema: z58.object({ name: z58.string().describe("Collection name") }) }
 );
 
 // src/tool_lattice/collection/create_collection.ts
-import z58 from "zod";
+import z59 from "zod";
 import { tool as tool52 } from "langchain";
-var createSchema = z58.object({
-  name: z58.string().describe("Collection name (lowercase, underscores only)"),
-  label: z58.string().describe("Display name"),
-  embeddingKey: z58.string().describe("Embedding model key"),
-  fields: z58.array(z58.object({
-    key: z58.string().describe("Field key name"),
-    type: z58.enum(["string", "number", "enum"]).describe("Field data type"),
-    enumValues: z58.array(z58.string()).optional().describe("Valid values for enum type"),
-    required: z58.boolean().optional().default(false).describe("Whether field is required")
+var createSchema = z59.object({
+  name: z59.string().describe("Collection name (lowercase, underscores only)"),
+  label: z59.string().describe("Display name"),
+  embeddingKey: z59.string().describe("Embedding model key"),
+  fields: z59.array(z59.object({
+    key: z59.string().describe("Field key name"),
+    type: z59.enum(["string", "number", "enum"]).describe("Field data type"),
+    enumValues: z59.array(z59.string()).optional().describe("Valid values for enum type"),
+    required: z59.boolean().optional().default(false).describe("Whether field is required")
   })).optional().describe("Custom field definitions for entries in this collection")
 });
 var createCreateCollectionTool = (scope = {}) => tool52(
@@ -44972,17 +45575,17 @@ var createCreateCollectionTool = (scope = {}) => tool52(
 );
 
 // src/tool_lattice/collection/update_collection.ts
-import z59 from "zod";
+import z60 from "zod";
 import { tool as tool53 } from "langchain";
-var schema = z59.object({
-  name: z59.string().describe("Collection name"),
-  label: z59.string().optional().describe("New display name"),
-  embeddingKey: z59.string().optional().describe("New embedding model key"),
-  fields: z59.array(z59.object({
-    key: z59.string().describe("Field key name"),
-    type: z59.enum(["string", "number", "enum"]).describe("Field data type"),
-    enumValues: z59.array(z59.string()).optional().describe("Valid values for enum type"),
-    required: z59.boolean().optional().default(false).describe("Whether field is required")
+var schema = z60.object({
+  name: z60.string().describe("Collection name"),
+  label: z60.string().optional().describe("New display name"),
+  embeddingKey: z60.string().optional().describe("New embedding model key"),
+  fields: z60.array(z60.object({
+    key: z60.string().describe("Field key name"),
+    type: z60.enum(["string", "number", "enum"]).describe("Field data type"),
+    enumValues: z60.array(z60.string()).optional().describe("Valid values for enum type"),
+    required: z60.boolean().optional().default(false).describe("Whether field is required")
   })).optional().describe("Custom field definitions for entries (replaces existing schema)")
 });
 var createUpdateCollectionTool = (scope = { collectionKeys: [], connectAll: true }) => tool53(
@@ -45006,7 +45609,7 @@ var createUpdateCollectionTool = (scope = { collectionKeys: [], connectAll: true
 );
 
 // src/tool_lattice/collection/delete_collection.ts
-import z60 from "zod";
+import z61 from "zod";
 import { tool as tool54 } from "langchain";
 var createDeleteCollectionTool = (scope = { collectionKeys: [], connectAll: true }) => tool54(
   async (input, _exeConfig) => {
@@ -45020,14 +45623,14 @@ var createDeleteCollectionTool = (scope = { collectionKeys: [], connectAll: true
       return `Error: ${e.message}`;
     }
   },
-  { name: "delete_collection", description: `Delete a collection and all its entries. This cannot be undone.`, schema: z60.object({ name: z60.string().describe("Collection name") }) }
+  { name: "delete_collection", description: `Delete a collection and all its entries. This cannot be undone.`, schema: z61.object({ name: z61.string().describe("Collection name") }) }
 );
 
 // src/tool_lattice/collection/list_entries.ts
-import z61 from "zod";
+import z62 from "zod";
 import { tool as tool55 } from "langchain";
-var schema2 = z61.object({
-  collection: z61.string().describe("Collection name")
+var schema2 = z62.object({
+  collection: z62.string().describe("Collection name")
 });
 function buildKey2(tenantId2, name) {
   return `${tenantId2}:${name}`;
@@ -45061,14 +45664,14 @@ var createListEntriesTool = (scope = { collectionKeys: [], connectAll: true }) =
 );
 
 // src/tool_lattice/collection/add_entry.ts
-import z62 from "zod";
+import z63 from "zod";
 import { tool as tool56 } from "langchain";
 import { Document } from "@langchain/core/documents";
 import { v4 as uuidv47 } from "uuid";
-var schema3 = z62.object({
-  collection: z62.string().describe("Collection name"),
-  content: z62.string().describe("Entry content text"),
-  metadata: z62.record(z62.unknown()).optional().describe("Metadata fields matching the collection schema")
+var schema3 = z63.object({
+  collection: z63.string().describe("Collection name"),
+  content: z63.string().describe("Entry content text"),
+  metadata: z63.record(z63.unknown()).optional().describe("Metadata fields matching the collection schema")
 });
 function key2(t, n) {
   return `${t}:${n}`;
@@ -45105,13 +45708,13 @@ var createAddEntryTool = (scope = { collectionKeys: [], connectAll: true }) => t
 );
 
 // src/tool_lattice/collection/update_entry.ts
-import z63 from "zod";
+import z64 from "zod";
 import { tool as tool57 } from "langchain";
-var schema4 = z63.object({
-  collection: z63.string().describe("Collection name"),
-  entryId: z63.string().describe("Entry ID to update"),
-  content: z63.string().optional().describe("New content"),
-  metadata: z63.record(z63.unknown()).optional().describe("New metadata")
+var schema4 = z64.object({
+  collection: z64.string().describe("Collection name"),
+  entryId: z64.string().describe("Entry ID to update"),
+  content: z64.string().optional().describe("New content"),
+  metadata: z64.record(z64.unknown()).optional().describe("New metadata")
 });
 function key3(t, n) {
   return `${t}:${n}`;
@@ -45137,11 +45740,11 @@ var createUpdateEntryTool = (scope = { collectionKeys: [], connectAll: true }) =
 );
 
 // src/tool_lattice/collection/delete_entry.ts
-import z64 from "zod";
+import z65 from "zod";
 import { tool as tool58 } from "langchain";
-var schema5 = z64.object({
-  collection: z64.string().describe("Collection name"),
-  entryId: z64.string().describe("Entry ID to delete")
+var schema5 = z65.object({
+  collection: z65.string().describe("Collection name"),
+  entryId: z65.string().describe("Entry ID to delete")
 });
 function key4(t, n) {
   return `${t}:${n}`;
@@ -45166,7 +45769,7 @@ var createDeleteEntryTool = (scope = { collectionKeys: [], connectAll: true }) =
 function createCollectionMiddleware(params) {
   const { collectionKeys, connectAll, compileStableCandidateTools = false } = params;
   if (!compileStableCandidateTools && !connectAll && (!collectionKeys || collectionKeys.length === 0)) {
-    return createMiddleware19({
+    return createMiddleware20({
       name: "collectionMiddleware",
       contextSchema,
       tools: [
@@ -45176,7 +45779,7 @@ function createCollectionMiddleware(params) {
     });
   }
   const toolParams = { collectionKeys, connectAll };
-  return createMiddleware19({
+  return createMiddleware20({
     name: "collectionMiddleware",
     contextSchema,
     tools: [
@@ -45239,21 +45842,21 @@ var collectionPlugin = {
 };
 
 // src/middlewares/askUserClarifyMiddleware.ts
-import { createMiddleware as createMiddleware20, ToolMessage as ToolMessage9 } from "langchain";
+import { createMiddleware as createMiddleware21, ToolMessage as ToolMessage10 } from "langchain";
 import { interrupt as interrupt3 } from "@langchain/langgraph";
 
 // src/tool_lattice/ask_user_to_clarify/index.ts
 import { tool as tool59 } from "langchain";
-import z65 from "zod";
-var questionSchema = z65.object({
-  question: z65.string().describe("The question text to ask the user. MUST include the specific context, options, or details being clarified \u2014 never use a bare generic label. Good: 'Confirm the plan: use Redis cache + PostgreSQL primary, split microservices as needed?' Bad: 'Confirm the plan?'"),
-  options: z65.array(z65.string()).optional().default([]).describe("List of EXACT, selectable values. Maximum 3 options allowed. DO NOT include placeholder values like 'Other' or 'Enter manually'. For free-text with predefined choices, use allowOther=true (works with 'single' and 'multiple'). For pure free-text without choices, use type='input' instead. For file_upload and input, pass an empty array."),
-  type: z65.enum(["single", "multiple", "file_upload", "input"]).describe("The question format. 'single' = pick one from options (default, see tool description for guidance). 'multiple' = pick several from options. 'input' = free-text field (only when options cannot express the answer). 'file_upload' = file picker."),
-  required: z65.boolean().optional().default(false).describe("Whether this question must be answered"),
-  allowOther: z65.boolean().optional().default(true).describe("Set to true to append an 'Other' checkbox with a free-text input field. Works with 'single' and 'multiple' types. Use for open-ended answers or when the options cannot cover all possibilities. Not applicable for 'input' or 'file_upload' types.")
+import z66 from "zod";
+var questionSchema = z66.object({
+  question: z66.string().describe("The question text to ask the user. MUST include the specific context, options, or details being clarified \u2014 never use a bare generic label. Good: 'Confirm the plan: use Redis cache + PostgreSQL primary, split microservices as needed?' Bad: 'Confirm the plan?'"),
+  options: z66.array(z66.string()).optional().default([]).describe("List of EXACT, selectable values. Maximum 3 options allowed. DO NOT include placeholder values like 'Other' or 'Enter manually'. For free-text with predefined choices, use allowOther=true (works with 'single' and 'multiple'). For pure free-text without choices, use type='input' instead. For file_upload and input, pass an empty array."),
+  type: z66.enum(["single", "multiple", "file_upload", "input"]).describe("The question format. 'single' = pick one from options (default, see tool description for guidance). 'multiple' = pick several from options. 'input' = free-text field (only when options cannot express the answer). 'file_upload' = file picker."),
+  required: z66.boolean().optional().default(false).describe("Whether this question must be answered"),
+  allowOther: z66.boolean().optional().default(true).describe("Set to true to append an 'Other' checkbox with a free-text input field. Works with 'single' and 'multiple' types. Use for open-ended answers or when the options cannot cover all possibilities. Not applicable for 'input' or 'file_upload' types.")
 });
-var inputSchema = z65.object({
-  questions: z65.array(questionSchema).min(1, "At least one question is required").describe("A structured sequence of clarification questions. Use these to gather missing parameters or disambiguate user intent before proceeding.")
+var inputSchema = z66.object({
+  questions: z66.array(questionSchema).min(1, "At least one question is required").describe("A structured sequence of clarification questions. Use these to gather missing parameters or disambiguate user intent before proceeding.")
 });
 function createAskUserToClarifyTool() {
   return tool59(
@@ -45281,7 +45884,7 @@ function isProjectRoomRun(request) {
   return isRecord13(runConfig?.projectRoom);
 }
 function createAskUserClarifyMiddleware() {
-  return createMiddleware20({
+  return createMiddleware21({
     name: "AskUserClarifyMiddleware",
     tools: [createAskUserToClarifyTool()],
     wrapToolCall: async (request, handler) => {
@@ -45291,7 +45894,7 @@ function createAskUserClarifyMiddleware() {
         return handler(request);
       }
       if (isProjectRoomRun(request)) {
-        return new ToolMessage9({
+        return new ToolMessage10({
           content: "You are replying inside a project room, which has no interactive clarification UI. Ask your clarifying questions directly in your reply text and stop; the user's next room message will continue the conversation.",
           tool_call_id: toolCall?.id,
           name: toolName2
@@ -45299,7 +45902,7 @@ function createAskUserClarifyMiddleware() {
       }
       const parsed = inputSchema.safeParse(toolCall?.args);
       if (!parsed.success) {
-        return new ToolMessage9({
+        return new ToolMessage10({
           content: `Invalid clarify tool arguments: ${parsed.error.message}`,
           tool_call_id: toolCall?.id,
           name: toolName2
@@ -45319,7 +45922,7 @@ function createAskUserClarifyMiddleware() {
       const result = await interrupt3(md);
       const response = result.data;
       if (!response?.answers || response.answers.length === 0) {
-        return new ToolMessage9({
+        return new ToolMessage10({
           content: "No clarification questions were answered.",
           tool_call_id: toolCall?.id,
           name: toolName2
@@ -45329,7 +45932,7 @@ function createAskUserClarifyMiddleware() {
         (answer) => (answer.selectedOptions?.length ?? 0) > 0 || answer.otherText && answer.otherText.trim() !== "" || answer.filePath && answer.filePath.trim() !== ""
       );
       if (answeredQuestions.length === 0) {
-        return new ToolMessage9({
+        return new ToolMessage10({
           content: "No clarification questions were answered.",
           tool_call_id: toolCall?.id,
           name: toolName2
@@ -45359,7 +45962,7 @@ function createAskUserClarifyMiddleware() {
         }
         lines.push("");
       }
-      return new ToolMessage9({
+      return new ToolMessage10({
         content: lines.join("\n"),
         tool_call_id: toolCall?.id,
         name: toolName2
@@ -45385,11 +45988,11 @@ var askUserClarifyPlugin = {
 };
 
 // src/middlewares/widgetMiddleware.ts
-import { createMiddleware as createMiddleware21 } from "langchain";
+import { createMiddleware as createMiddleware22 } from "langchain";
 
 // src/tool_lattice/widget/loadGuidelines.ts
 import { tool as tool60 } from "langchain";
-import { z as z66 } from "zod";
+import { z as z67 } from "zod";
 
 // src/middlewares/guidelines/index.ts
 var CORE = `# Imagine \u2014 Visual Creation Suite
@@ -46256,8 +46859,8 @@ function getGuidelines(modules) {
 var AVAILABLE_MODULES = Object.keys(MODULE_SECTIONS);
 
 // src/tool_lattice/widget/loadGuidelines.ts
-var LoadGuidelinesInputSchema = z66.object({
-  modules: z66.array(z66.string()).describe(
+var LoadGuidelinesInputSchema = z67.object({
+  modules: z67.array(z67.string()).describe(
     "Which design modules to load. Choose all that apply. Available modules: [" + AVAILABLE_MODULES.join(",") + "]"
   )
 });
@@ -46277,7 +46880,7 @@ function createLoadGuidelinesTool() {
 
 // src/tool_lattice/widget/showWidget.ts
 import { tool as tool61 } from "langchain";
-import { z as z67 } from "zod";
+import { z as z68 } from "zod";
 function containsForbiddenTags(code) {
   const forbiddenPatterns = [
     /<!DOCTYPE/i,
@@ -46299,15 +46902,15 @@ function validateWidgetCode(code) {
   }
   return { valid: true };
 }
-var ShowWidgetInputSchema = z67.object({
-  i_have_seen_guidelines: z67.boolean().describe(
+var ShowWidgetInputSchema = z68.object({
+  i_have_seen_guidelines: z68.boolean().describe(
     "Must be true. Confirm you have called load_guidelines first."
   ),
-  title: z67.string().describe("Title displayed above the widget"),
-  loading_messages: z67.array(z67.string()).optional().describe(
+  title: z68.string().describe("Title displayed above the widget"),
+  loading_messages: z68.array(z68.string()).optional().describe(
     "1-4 short strings shown while the widget renders"
   ),
-  widget_code: z67.string().describe(
+  widget_code: z68.string().describe(
     "HTML fragment to render. Rules: 1. No DOCTYPE, <html>, <head>, or <body> tags. 2. Order: <style> block first, then HTML content, then <script> last. 3. Use only CSS variables for colors (e.g. var(--color-accent)). 4. No gradients, shadows, or blur effects. For SVG: start directly with <svg> tag."
   )
 });
@@ -46343,7 +46946,7 @@ function createWidgetMiddleware() {
     createLoadGuidelinesTool(),
     createShowWidgetTool()
   ];
-  return createMiddleware21({
+  return createMiddleware22({
     name: "widgetMiddleware",
     contextSchema,
     tools
@@ -46367,8 +46970,8 @@ var widgetPlugin = {
 };
 
 // src/middlewares/taskMiddleware.ts
-import { createMiddleware as createMiddleware22, tool as tool62 } from "langchain";
-import { z as z68 } from "zod";
+import { createMiddleware as createMiddleware23, tool as tool62, ToolMessage as ToolMessage11 } from "langchain";
+import { z as z69 } from "zod";
 import { GraphInterrupt as GraphInterrupt3, interrupt as interrupt4 } from "@langchain/langgraph";
 import { resolveRunScope as resolveRunScope3 } from "@axiom-lattice/protocols";
 
@@ -47253,72 +47856,72 @@ function buildReviewMarkdown(task) {
     result: task.result
   });
 }
-var manageTaskSchema = z68.object({
-  action: z68.enum(["create", "get", "list", "update", "set_status", "add_activity", "delete"]).describe("Action to perform. Available: create, get, list, update, set_status, add_activity, delete. To change status, use set_status. To change content fields, use update."),
-  id: z68.string().optional().describe("Task ID (required for get, update, add_activity; required for delete unless ids is given)"),
-  title: z68.string().optional().describe("Task title (required for create)"),
-  description: z68.string().optional().describe("Task description in Markdown"),
-  priority: z68.enum(["low", "medium", "high"]).optional().describe("Priority level"),
-  status: z68.enum(["pending", "in_progress", "review", "failed", "interrupted", "completed", "cancelled"]).optional().describe("Task status. For status-only changes, prefer set_status action. Set 'in_progress' only for a task THIS run executes (a delegated task is claimed by `task` dispatch); 'completed'/'failed' require the task to be 'in_progress'. Agent summary-only interrupted updates default to missing_input"),
-  dueDate: z68.string().optional().describe("Due date (ISO 8601 format)"),
-  metadata: z68.record(z68.unknown()).optional().describe("Structured metadata (e.g. projectId, module)"),
-  metadataFilter: z68.record(
-    z68.union([z68.string(), z68.number(), z68.boolean()])
+var manageTaskSchema = z69.object({
+  action: z69.enum(["create", "get", "list", "update", "set_status", "add_activity", "delete"]).describe("Action to perform. Available: create, get, list, update, set_status, add_activity, delete. To change status, use set_status. To change content fields, use update."),
+  id: z69.string().optional().describe("Task ID (required for get, update, add_activity; required for delete unless ids is given)"),
+  title: z69.string().optional().describe("Task title (required for create)"),
+  description: z69.string().optional().describe("Task description in Markdown"),
+  priority: z69.enum(["low", "medium", "high"]).optional().describe("Priority level"),
+  status: z69.enum(["pending", "in_progress", "review", "failed", "interrupted", "completed", "cancelled"]).optional().describe("Task status. For status-only changes, prefer set_status action. Set 'in_progress' only for a task THIS run executes (a delegated task is claimed by `task` dispatch); 'completed'/'failed' require the task to be 'in_progress'. Agent summary-only interrupted updates default to missing_input"),
+  dueDate: z69.string().optional().describe("Due date (ISO 8601 format)"),
+  metadata: z69.record(z69.unknown()).optional().describe("Structured metadata (e.g. projectId, module)"),
+  metadataFilter: z69.record(
+    z69.union([z69.string(), z69.number(), z69.boolean()])
   ).optional().describe("List-only filter. Every key must equal the task metadata value, e.g. {projectId:'p1', retries:2}. Multiple keys AND together."),
-  parentId: z68.string().optional().describe("Parent task ID for grouping subtasks"),
-  sourceId: z68.string().optional().describe("Source session/thread ID"),
-  context: z68.record(z68.unknown()).optional().describe("Additional context data"),
-  ownerType: z68.enum(["user", "agent"]).optional().describe("Owner type. Defaults to the runtime actor: agent runtime (no user identity) -> 'agent', user runtime -> 'user'."),
-  ownerId: z68.string().optional().describe("Owner ID. Auto-filled from current user/agent if omitted"),
-  requireReview: z68.boolean().optional().describe("If true, agent completion pauses as interrupted(review_required) for HITL approval"),
-  dependencies: z68.array(z68.string()).optional().describe("List of task IDs that must be completed before this task can start"),
-  result: z68.string().optional().describe("Result summary. Used with set_status status='completed' or update status='completed'"),
-  failureReason: z68.string().optional().describe("Failure reason. Used with set_status status='failed' or update status='failed'"),
-  files: z68.array(z68.object({
-    uri: z68.string().describe("Uniquely locates the resource: http(s):// URL, /s/:token share, or sandbox path"),
-    name: z68.string().optional().describe("Display name"),
-    addedBy: z68.enum(["user", "agent"]).optional().describe("Who attached the file")
+  parentId: z69.string().optional().describe("Parent task ID for grouping subtasks"),
+  sourceId: z69.string().optional().describe("Source session/thread ID"),
+  context: z69.record(z69.unknown()).optional().describe("Additional context data"),
+  ownerType: z69.enum(["user", "agent"]).optional().describe("Owner type. Defaults to the runtime actor: agent runtime (no user identity) -> 'agent', user runtime -> 'user'."),
+  ownerId: z69.string().optional().describe("Owner ID. Auto-filled from current user/agent if omitted"),
+  requireReview: z69.boolean().optional().describe("If true, agent completion pauses as interrupted(review_required) for HITL approval"),
+  dependencies: z69.array(z69.string()).optional().describe("List of task IDs that must be completed before this task can start"),
+  result: z69.string().optional().describe("Result summary. Used with set_status status='completed' or update status='completed'"),
+  failureReason: z69.string().optional().describe("Failure reason. Used with set_status status='failed' or update status='failed'"),
+  files: z69.array(z69.object({
+    uri: z69.string().describe("Uniquely locates the resource: http(s):// URL, /s/:token share, or sandbox path"),
+    name: z69.string().optional().describe("Display name"),
+    addedBy: z69.enum(["user", "agent"]).optional().describe("Who attached the file")
   })).optional().describe("File references attached to this task"),
-  beliefImpact: z68.array(z68.object({
-    key: z68.string().regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/),
-    after: z68.number().int().min(0).max(100),
-    basis: z68.string().trim().min(1).max(1e3),
-    isNew: z68.boolean().optional().describe("Set true only to add a belief key that is absent from the belief owner's Belief State; omit for keys that already exist")
+  beliefImpact: z69.array(z69.object({
+    key: z69.string().regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/),
+    after: z69.number().int().min(0).max(100),
+    basis: z69.string().trim().min(1).max(1e3),
+    isNew: z69.boolean().optional().describe("Set true only to add a belief key that is absent from the belief owner's Belief State; omit for keys that already exist")
   })).optional().describe("Structured belief reports required when an agent-owned task completes; existing keys update the belief owner's table, and a brand-new key must be declared with isNew: true"),
-  content: z68.string().optional().describe("Markdown content required for add_activity"),
-  summary: z68.string().optional().describe("Brief summary of the operation"),
-  executionResultId: z68.string().refine(isExecutionResultEventKey3, {
+  content: z69.string().optional().describe("Markdown content required for add_activity"),
+  summary: z69.string().optional().describe("Brief summary of the operation"),
+  executionResultId: z69.string().refine(isExecutionResultEventKey3, {
     message: "executionResultId must be the execution-result:<threadId> event key returned by task()"
   }).optional().describe(
     "Canonical ASCII `execution-result:<suffix>` event key returned by task(); the nonempty suffix allows only A-Z, a-z, 0-9, period, underscore, colon, and hyphen, and is not a database row ID"
   ),
-  ids: z68.array(z68.string().trim().min(1)).optional().describe("Task IDs to delete in one batch (delete action only). Use with or instead of id.")
+  ids: z69.array(z69.string().trim().min(1)).optional().describe("Task IDs to delete in one batch (delete action only). Use with or instead of id.")
 }).superRefine((input, context) => {
   if (input.executionResultId && input.action !== "update" && input.action !== "set_status" && input.action !== "add_activity") {
     context.addIssue({
-      code: z68.ZodIssueCode.custom,
+      code: z69.ZodIssueCode.custom,
       path: ["executionResultId"],
       message: "executionResultId is valid only for update, set_status, or add_activity"
     });
   }
   if (input.metadataFilter && input.action !== "list") {
     context.addIssue({
-      code: z68.ZodIssueCode.custom,
+      code: z69.ZodIssueCode.custom,
       path: ["metadataFilter"],
       message: "metadataFilter is valid only for list"
     });
   }
   if (input.ids && input.action !== "delete") {
     context.addIssue({
-      code: z68.ZodIssueCode.custom,
+      code: z69.ZodIssueCode.custom,
       path: ["ids"],
       message: "ids is valid only for delete"
     });
   }
 });
-var startTaskSchema = z68.object({
-  taskId: z68.string().trim().min(1).describe("ID of the persisted TaskItem to start"),
-  agentId: z68.string().trim().min(1).describe(
+var startTaskSchema = z69.object({
+  taskId: z69.string().trim().min(1).describe("ID of the persisted TaskItem to start"),
+  agentId: z69.string().trim().min(1).describe(
     `ID of the Agent that should execute the task. Use "general-purpose" to run the caller's own capabilities as an isolated worker.`
   )
 });
@@ -48708,12 +49311,12 @@ function createTaskMiddleware(options = {}) {
       ...trustedCaller ? { callerMembershipId: trustedCaller.membershipId, callerAssistantId: trustedCaller.assistantId } : rc.assistant_id ? { callerAssistantId: rc.assistant_id } : {}
     }));
   };
-  return createMiddleware22({
+  return createMiddleware23({
     name: "TaskMiddleware",
     contextSchema,
     // Persisted between invocations (ADRs: the run↔task binding survives turns).
-    stateSchema: z68.object({
-      taskId: z68.string().default("")
+    stateSchema: z69.object({
+      taskId: z69.string().default("")
     }),
     // CLAIM: a run that holds a task moves it to in_progress (idempotent).
     beforeAgent: async (state, runtime) => {
@@ -48778,6 +49381,26 @@ function createTaskMiddleware(options = {}) {
       taskRunRegistry.unregister(taskId);
       return {};
     },
+    wrapToolCall: async (request, handler) => {
+      if (request.toolCall?.name === "task") {
+        const args = request.toolCall.args;
+        const taskId = typeof args?.taskId === "string" ? args.taskId.trim() : "";
+        const agentId = typeof args?.agentId === "string" ? args.agentId.trim() : "";
+        if (!taskId || !agentId) {
+          return new ToolMessage11({
+            name: "task",
+            tool_call_id: request.toolCall.id ?? "task-dispatch",
+            status: "error",
+            content: JSON.stringify({
+              success: false,
+              code: "TASK_DISPATCH_REQUIRES_TASK_ID",
+              error: '`task` only dispatches an existing TaskItem. Create the task first with `manage_task` action="create" (title + description), then call `task { taskId, agentId }`. Do not pass action/description/title to `task`.'
+            })
+          });
+        }
+      }
+      return handler(request);
+    },
     wrapModelCall: async (request, handler) => {
       const taskPrompt = `## Task Management
 
@@ -48878,7 +49501,7 @@ to an expert \u2014 never re-dispatch the task you are processing.`,
       ),
       tool62(handleStartTask, {
         name: "task",
-        description: `Start a persisted TaskItem with any existing Agent in a fresh isolated thread. Use this to delegate work \u2014 dispatch a subtask you created to the agent that should execute it; never re-dispatch the task you are currently processing (give the expert a child task instead). Pass agentId "general-purpose" for the general-purpose worker \u2014 ${DEFAULT_GENERAL_PURPOSE_DESCRIPTION} It has access to all the caller's tools, model, and middleware, so use it for general-purpose subtasks, to isolate context and token usage, and whenever no specialized agent fits. The target does NOT need task-management tools: it runs and returns an observation, an executionResultId, and the task's taskStatus (re-read after the worker settled). Check taskStatus before completing: if it is already 'completed' the worker finished it \u2014 do NOT complete again (use manage_task add_activity); if it is still 'in_progress' you are the single completer and pass the executionResultId to manage_task set_status completed; if it is 'failed' or 'interrupted', act on that. The caller reconciles via manage_task, which interprets the result and records the outcome. A project task instead returns a managed result (success:true, managed:true) because the project-lifecycle queue owns execution.`,
+        description: `Start a persisted TaskItem with any existing Agent in a fresh isolated thread. This tool CANNOT create a task: create it first with \`manage_task\` action="create" (title + description), then dispatch it with \`task { taskId, agentId }\`. Do not pass action/description/title to this tool. Use this to delegate work \u2014 dispatch a subtask you created to the agent that should execute it; never re-dispatch the task you are currently processing (give the expert a child task instead). Pass agentId "general-purpose" for the general-purpose worker \u2014 ${DEFAULT_GENERAL_PURPOSE_DESCRIPTION} It has access to all the caller's tools, model, and middleware, so use it for general-purpose subtasks, to isolate context and token usage, and whenever no specialized agent fits. The target does NOT need task-management tools: it runs and returns an observation, an executionResultId, and the task's taskStatus (re-read after the worker settled). Check taskStatus before completing: if it is already 'completed' the worker finished it \u2014 do NOT complete again (use manage_task add_activity); if it is still 'in_progress' you are the single completer and pass the executionResultId to manage_task set_status completed; if it is 'failed' or 'interrupted', act on that. The caller reconciles via manage_task, which interprets the result and records the outcome. A project task instead returns a managed result (success:true, managed:true) because the project-lifecycle queue owns execution.`,
         schema: startTaskSchema
       })
     ]
@@ -49020,7 +49643,7 @@ canonical Belief State:
 };
 
 // src/middlewares/documentLearningMiddleware.ts
-import { createMiddleware as createMiddleware23 } from "langchain";
+import { createMiddleware as createMiddleware24 } from "langchain";
 
 // src/middlewares/documentLearningSkills.ts
 var LEARN_CAPABILITY_SKILL = `---
@@ -49259,7 +49882,7 @@ patterns discovered, recommendations. Include validation coverage: user-sample N
 `;
 
 // src/middlewares/documentLearningMiddleware.ts
-var createDocumentLearningMiddleware = () => createMiddleware23({
+var createDocumentLearningMiddleware = () => createMiddleware24({
   name: "DocumentLearningMiddleware",
   contextSchema,
   tools: []
@@ -49282,11 +49905,11 @@ var documentLearningPlugin = {
 };
 
 // src/middlewares/documentParserMiddleware.ts
-import { createMiddleware as createMiddleware24 } from "langchain";
+import { createMiddleware as createMiddleware25 } from "langchain";
 
 // src/tool_lattice/document_parser/index.ts
 import * as path7 from "path";
-import z69 from "zod";
+import z70 from "zod";
 import { tool as tool63 } from "langchain";
 var PARSE_DOCUMENT_DESCRIPTION = `Parse a document file (docx, pdf) into structured Markdown using a remote document parsing service.
 This tool handles the full pipeline internally: file upload \u2192 document parsing \u2192 polling until complete \u2192 download result \u2192 save to filesystem.
@@ -49481,17 +50104,17 @@ function createParseDocumentTool({
     {
       name: "parse_document",
       description: PARSE_DOCUMENT_DESCRIPTION,
-      schema: z69.object({
-        file_path: z69.string().describe(
+      schema: z70.object({
+        file_path: z70.string().describe(
           'Absolute path to the document file. Must point to an existing .docx or .pdf file. Example: "/project/reports/contract.docx". The file must be accessible from the current workspace.'
         ),
-        engine: z69.string().describe(
+        engine: z70.string().describe(
           'Parsing engine to use. Available options: "textin" (recommended, works with local files, supports docx/pdf), "datalab" (alternative engine for docx/pdf), "mineru" (requires public URL, use only if textin/datalab fail), "paddleocr_remote" (PaddleOCR, good for scanned documents), "qwen_ocr" (OCR-focused, best for image-heavy PDFs).'
         ),
-        output_path: z69.string().optional().describe(
+        output_path: z70.string().optional().describe(
           'Path to save the parsed result. If not specified, the input extension is replaced with .md. Example: "/project/report.docx" becomes "/project/report.md". Parent directories are created automatically.'
         ),
-        output_format: z69.enum(["markdown", "json"]).optional().default("markdown").describe(
+        output_format: z70.enum(["markdown", "json"]).optional().default("markdown").describe(
           'Output format. "markdown": structured Markdown with tables, headers, formatting preserved (recommended). "json": raw JSON output from the parsing engine (for programmatic use).'
         )
       })
@@ -49947,7 +50570,7 @@ function createDocumentParserMiddleware(config) {
   const baseUrl = config.baseUrl || "";
   const apiKey = config.apiKey || "";
   const connections = Array.isArray(config.connections) ? config.connections.filter((key5) => typeof key5 === "string") : [];
-  return createMiddleware24({
+  return createMiddleware25({
     name: "DocumentParser",
     contextSchema,
     tools: [createParseDocumentTool({ connectAll, connections, baseUrl, apiKey })]
@@ -50135,8 +50758,8 @@ import {
   snapshotExactArray as snapshotExactArray2,
   snapshotExactRecord as snapshotExactRecord7
 } from "@axiom-lattice/protocols";
-import { createMiddleware as createMiddleware25, tool as tool64 } from "langchain";
-import { z as z70 } from "zod";
+import { createMiddleware as createMiddleware26, tool as tool64 } from "langchain";
+import { z as z71 } from "zod";
 var PROJECT_ROOM_CONTEXT_REQUIRED = "PROJECT_ROOM_CONTEXT_REQUIRED";
 var PROJECT_ROOM_POST_FAILED = "PROJECT_ROOM_POST_FAILED";
 var PROJECT_ROOM_ROSTER_FAILED = "PROJECT_ROOM_ROSTER_FAILED";
@@ -50156,10 +50779,10 @@ var ROSTER_FAILED = JSON.stringify({
   error: PROJECT_ROOM_ROSTER_FAILED,
   message: PROJECT_ROOM_ROSTER_FAILED_MESSAGE
 });
-var postSchema = z70.object({
-  text: z70.string().trim().min(1).max(2e4)
+var postSchema = z71.object({
+  text: z71.string().trim().min(1).max(2e4)
 }).strict();
-var listSchema = z70.object({}).strict();
+var listSchema = z71.object({}).strict();
 function ownDataValue2(record, key5) {
   if (typeof record !== "object" || record === null || Array.isArray(record)) return void 0;
   try {
@@ -50244,7 +50867,7 @@ async function hasActiveCurrentMembership(scope) {
   return true;
 }
 function createProjectRoomMiddleware() {
-  return createMiddleware25({
+  return createMiddleware26({
     name: "ProjectRoomMiddleware",
     tools: [
       tool64(async (input, config) => {
@@ -50339,8 +50962,8 @@ var projectRoomPlugin = {
 };
 
 // src/middlewares/sandboxPluginsMiddleware.ts
-import { createMiddleware as createMiddleware26, tool as tool65 } from "langchain";
-import { z as z71 } from "zod";
+import { createMiddleware as createMiddleware27, tool as tool65 } from "langchain";
+import { z as z72 } from "zod";
 import { AgentType as AgentType10 } from "@axiom-lattice/protocols";
 
 // src/connection/connectionSecretFields.ts
@@ -51583,8 +52206,8 @@ function redactSecretValues(payload, secrets) {
   };
   return walk(payload);
 }
-var managePluginSchema = z71.object({
-  action: z71.enum([
+var managePluginSchema = z72.object({
+  action: z72.enum([
     "list",
     "get",
     "validate",
@@ -51599,15 +52222,15 @@ var managePluginSchema = z71.object({
     "status",
     "deployments"
   ]),
-  type: z71.string().optional(),
-  name: z71.string().optional(),
-  description: z71.string().optional(),
-  mode: z71.enum(["onDemand", "alwaysOn"]).optional(),
-  target: z71.object({
-    kind: z71.enum(["tool", "connection-test", "connection-discover"]),
-    name: z71.string().optional(),
-    input: z71.unknown().optional(),
-    connectionKey: z71.string().optional()
+  type: z72.string().optional(),
+  name: z72.string().optional(),
+  description: z72.string().optional(),
+  mode: z72.enum(["onDemand", "alwaysOn"]).optional(),
+  target: z72.object({
+    kind: z72.enum(["tool", "connection-test", "connection-discover"]),
+    name: z72.string().optional(),
+    input: z72.unknown().optional(),
+    connectionKey: z72.string().optional()
   }).optional()
 });
 var sandboxPluginsPlugin = {
@@ -51702,7 +52325,7 @@ var sandboxPluginsPlugin = {
       ]
     }
   },
-  middleware: () => createMiddleware26({
+  middleware: () => createMiddleware27({
     name: "SandboxPluginsMiddleware",
     tools: [
       tool65(
@@ -51993,8 +52616,8 @@ var sandboxPluginsPlugin = {
 };
 
 // src/middlewares/longTermStoreMiddleware.ts
-import { createMiddleware as createMiddleware27, tool as tool66 } from "langchain";
-import { z as z72 } from "zod";
+import { createMiddleware as createMiddleware28, tool as tool66 } from "langchain";
+import { z as z73 } from "zod";
 import {
   STORE_IDENTITY_SEPARATOR as STORE_IDENTITY_SEPARATOR2,
   StoreValidationError
@@ -52093,34 +52716,34 @@ function store() {
     return void 0;
   }
 }
-var namespaceSchema = z72.array(z72.string()).optional().describe(
+var namespaceSchema = z73.array(z73.string()).optional().describe(
   "Optional relative namespace segments for organization (appended to the scoped prefix)."
 );
-var keySchema = z72.string().min(1).describe("Stable item key within the resolved namespace.");
-var valueSchema = z72.record(z72.unknown()).describe("JSON object value to persist.");
-var putSchema = z72.object({
+var keySchema = z73.string().min(1).describe("Stable item key within the resolved namespace.");
+var valueSchema = z73.record(z73.unknown()).describe("JSON object value to persist.");
+var putSchema = z73.object({
   key: keySchema,
   value: valueSchema,
   namespace: namespaceSchema,
-  ttlMinutes: z72.number().positive().optional().describe("Optional TTL in minutes; omit to use the plugin default.")
+  ttlMinutes: z73.number().positive().optional().describe("Optional TTL in minutes; omit to use the plugin default.")
 });
-var getSchema = z72.object({
+var getSchema = z73.object({
   key: keySchema,
   namespace: namespaceSchema
 });
-var searchSchema2 = z72.object({
-  query: z72.string().optional().describe("Case-insensitive substring match over serialized values."),
-  filter: z72.record(z72.unknown()).optional().describe("Deep partial-equality filter over the value object."),
+var searchSchema2 = z73.object({
+  query: z73.string().optional().describe("Case-insensitive substring match over serialized values."),
+  filter: z73.record(z73.unknown()).optional().describe("Deep partial-equality filter over the value object."),
   namespace: namespaceSchema,
-  limit: z72.number().int().min(1).max(MAX_SEARCH_LIMIT).optional()
+  limit: z73.number().int().min(1).max(MAX_SEARCH_LIMIT).optional()
 });
-var deleteSchema = z72.object({
+var deleteSchema = z73.object({
   key: keySchema,
   namespace: namespaceSchema
 });
-var namespacesSchema = z72.object({
+var namespacesSchema = z73.object({
   namespace: namespaceSchema,
-  limit: z72.number().int().min(1).max(MAX_SEARCH_LIMIT).optional()
+  limit: z73.number().int().min(1).max(MAX_SEARCH_LIMIT).optional()
 });
 var STORE_SKILL_HINT = "Load long_term_store-usage for namespace/TTL guidance.";
 var STORE_DESCRIPTION = [
@@ -52373,7 +52996,7 @@ function createLongTermStoreMiddleware(config = {}) {
       schema: namespacesSchema
     }
   );
-  return createMiddleware27({
+  return createMiddleware28({
     name: "LongTermStoreMiddleware",
     tools: readOnly ? [getTool, searchTool, namespacesTool] : [putTool, getTool, searchTool, deleteTool, namespacesTool]
   });
@@ -53454,11 +54077,14 @@ export {
   CustomMiddlewareRegistry,
   DEFAULT_CALIBRATION_PROBES,
   DEFAULT_CONNECT_TIMEOUT_MS,
+  DEFAULT_CONTENTS_EMBEDDING_PATH,
   DEFAULT_DELAY_MS,
   DEFAULT_HANDLER_TIMEOUT_MS,
   DEFAULT_MAX_ATTEMPTS,
   DEFAULT_MODEL_EXTRA,
   DEFAULT_RESIDENT_INVOKE_TIMEOUT_MS,
+  DEFAULT_SUMMARIZATION_TRIGGER_TOKENS,
+  DEFAULT_TEXTS_EMBEDDING_PATH,
   DaytonaInstance,
   DaytonaProvider,
   DefaultScheduleClient,
@@ -53575,6 +54201,7 @@ export {
   SANDBOX_OPEN_TOKEN_ENV,
   STTModelLattice,
   STTModelLatticeManager,
+  SUMMARIZATION_TRIGGER_RATIO,
   SandboxFilesystem,
   SandboxLatticeManager,
   SandboxPluginExecutor,
@@ -53698,6 +54325,7 @@ export {
   disconnectAllChannels,
   documentLearningPlugin,
   documentParserPlugin,
+  embeddingProbeCandidates,
   embeddingsLatticeManager,
   encodeInput,
   encrypt,
@@ -53835,6 +54463,7 @@ export {
   publishCollectionChanged,
   publishPluginCatalogChanged,
   queueLatticeManager,
+  readContextWindow,
   readLoopBreakerConfig,
   reconcileAllTenantTaskRuns,
   reconcileStaleTaskRuns,
@@ -53864,6 +54493,8 @@ export {
   removeCollectionVectorStore,
   renderTemplate,
   resetReplicaIdForTests,
+  resolveEmbeddingEndpoint,
+  resolveEmbeddingShape,
   resolveEnabledPluginSkill,
   resolveHandlerTimeoutMs,
   resolveJudgeModelKey,
@@ -53873,6 +54504,7 @@ export {
   resolvePluginConnections,
   resolveSandboxPluginConnections,
   resolveStartIndex,
+  resolveSummarizationTriggerTokens,
   resolveTenantPluginSkill,
   roomCoordinatorConfig,
   runAsLeader,