@axiom-lattice/core 9.0.0 → 10.0.0

package/dist/index.js

@@ -734,6 +734,11 @@ var init_parse_yaml = __esm({
 });
 
 // src/workflow/utils.ts
+function workflowAbortSignal(runId, parentSignal) {
+  const signals = [parentSignal, runId ? getWorkflowSignal(runId) : void 0].filter((signal) => signal !== void 0);
+  if (signals.length === 0) return void 0;
+  return signals.length === 1 ? signals[0] : AbortSignal.any(signals);
+}
 function buildStateAnnotation(fields) {
   const annotations = {};
   if (fields) {
@@ -1079,7 +1084,7 @@ ${renderedInput}
 === END INPUT ===`);
       const subConfig = {
         ...config,
-        signal: getWorkflowSignal(runId),
+        signal: workflowAbortSignal(runId, config?.signal),
         configurable: {
           ...config?.configurable ?? {},
           thread_id: `${config?.configurable?.thread_id ?? "default"}:${node.id}`
@@ -1299,7 +1304,7 @@ function createMapNode(node, resolveAgent, trackingStore) {
           const input = buildInput(node.node.input, state, itemCtx);
           const subConfig = {
             ...config,
-            signal: getWorkflowSignal(runId),
+            signal: workflowAbortSignal(runId, config?.signal),
             configurable: {
               ...config?.configurable ?? {},
               thread_id: `${config?.configurable?.thread_id ?? "default"}:${node.id}:item:${globalIdx}`
@@ -1517,12 +1522,12 @@ __export(compile_exports, {
   compileWorkflow: () => compileWorkflow,
   validateDSL: () => validateDSL
 });
-function compileWorkflow(yamlStr, resolveAgent, checkpointer, trackingStore) {
+function compileWorkflow(yamlStr, resolveAgent, checkpointer, trackingStore, options = {}) {
   console.log(`[WF COMPILE] compiling YAML workflow`);
   const ir = parseYaml(yamlStr);
-  return compileInternal(ir, resolveAgent, checkpointer, trackingStore);
+  return compileInternal(ir, resolveAgent, checkpointer, trackingStore, options);
 }
-function compileInternal(ir, resolveAgent, checkpointer, trackingStore) {
+function compileInternal(ir, resolveAgent, checkpointer, trackingStore, options = {}) {
   validateAndThrow(ir);
   console.log(`[WF COMPILE] validation passed`);
   const StateAnnotation = buildStateAnnotation(ir.state?.fields);
@@ -1544,7 +1549,7 @@ function compileInternal(ir, resolveAgent, checkpointer, trackingStore) {
       builder.addEdge(from, to === "END" ? import_langgraph11.END : to);
     }
   }
-  const graph = builder.compile({ checkpointer, name: ir.name });
+  const graph = builder.compile({ checkpointer, name: options.name || ir.name });
   console.log(`[WF COMPILE] graph compiled successfully`);
   return graph;
 }
@@ -1723,6 +1728,9 @@ __export(index_exports, {
   MicrosandboxServiceClient: () => MicrosandboxServiceClient,
   ModelLatticeManager: () => ModelLatticeManager,
   MysqlDatabase: () => MysqlDatabase,
+  ObservabilityDashboardUnavailableError: () => ObservabilityDashboardUnavailableError,
+  ObservabilityDashboardUnsupportedError: () => ObservabilityDashboardUnsupportedError,
+  ObservabilityLatticeManager: () => ObservabilityLatticeManager,
   OutboxPoller: () => OutboxPoller,
   PACK_DIRECTORY_TIMEOUT_MS: () => PACK_DIRECTORY_TIMEOUT_MS,
   PLATFORM_SECRET_ENV_VARS: () => PLATFORM_SECRET_ENV_VARS,
@@ -1816,6 +1824,7 @@ __export(index_exports, {
   buildTaskMutationFallback: () => buildTaskMutationFallback,
   buildTaskNormalizationFallback: () => buildTaskNormalizationFallback,
   canConvergeOrphan: () => canConvergeOrphan,
+  channelShardForInstallation: () => channelShardForInstallation,
   checkEmptyContent: () => checkEmptyContent,
   chunkBufferStreamKey: () => chunkBufferStreamKey,
   clearEncryptionKeyCache: () => clearEncryptionKeyCache,
@@ -1920,6 +1929,7 @@ __export(index_exports, {
   getEncryptionKey: () => getEncryptionKey,
   getEvalRunService: () => getEvalRunService,
   getLoggerLattice: () => getLoggerLattice,
+  getMcpUiScopeSecret: () => getMcpUiScopeSecret,
   getMenuRegistry: () => getMenuRegistry,
   getModelLattice: () => getModelLattice,
   getNextCronTime: () => getNextCronTime,
@@ -1988,6 +1998,7 @@ __export(index_exports, {
   normalizeAgentInterrupts: () => normalizeAgentInterrupts,
   normalizeAgentRunMessageIds: () => normalizeAgentRunMessageIds,
   normalizeSandboxName: () => normalizeSandboxName,
+  observabilityLatticeManager: () => observabilityLatticeManager,
   ownTaskResponseField: () => ownTaskResponseField,
   parallelLimit: () => parallelLimit,
   parseCronExpression: () => parseCronExpression,
@@ -2028,6 +2039,7 @@ __export(index_exports, {
   registerLoggerLattice: () => registerLoggerLattice,
   registerModelLattice: () => registerModelLattice,
   registerModelLatticeForTenant: () => registerModelLatticeForTenant,
+  registerObservabilityLattice: () => registerObservabilityLattice,
   registerQueueLattice: () => registerQueueLattice,
   registerSTTModelLattice: () => registerSTTModelLattice,
   registerSandboxOpenCredentialProvider: () => registerSandboxOpenCredentialProvider,
@@ -2045,6 +2057,7 @@ __export(index_exports, {
   resolveHandlerTimeoutMs: () => resolveHandlerTimeoutMs,
   resolveJudgeModelKey: () => resolveJudgeModelKey,
   resolveModelLatticeForTenant: () => resolveModelLatticeForTenant,
+  resolveObservabilityCallbacks: () => resolveObservabilityCallbacks,
   resolvePath: () => resolvePath,
   resolvePluginConnections: () => resolvePluginConnections,
   resolveSandboxPluginConnections: () => resolveSandboxPluginConnections,
@@ -2065,11 +2078,13 @@ __export(index_exports, {
   serializeTaskReadResponse: () => serializeTaskReadResponse,
   setAgentLifecycleTap: () => setAgentLifecycleTap,
   setBindingRegistry: () => setBindingRegistry,
+  setDefaultObservabilityLattice: () => setDefaultObservabilityLattice,
   setEvalRunService: () => setEvalRunService,
   setMenuRegistry: () => setMenuRegistry,
   setPluginDeploymentService: () => setPluginDeploymentService,
   setRunCancelHeartbeatFallbackObserver: () => setRunCancelHeartbeatFallbackObserver,
   setSandboxPluginCatalog: () => setSandboxPluginCatalog,
+  signMcpUiScope: () => signMcpUiScope,
   skillLatticeManager: () => skillLatticeManager,
   sqlDatabaseManager: () => sqlDatabaseManager,
   storeLatticeManager: () => storeLatticeManager,
@@ -2098,6 +2113,7 @@ __export(index_exports, {
   validateToolInput: () => validateToolInput,
   vectorStoreLatticeManager: () => vectorStoreLatticeManager,
   vectorStoreProviderManager: () => vectorStoreProviderManager,
+  verifyMcpUiScope: () => verifyMcpUiScope,
   withLease: () => withLease,
   withTimeout: () => withTimeout2,
   wrapMcpToolWithUi: () => wrapMcpToolWithUi
@@ -6340,6 +6356,7 @@ var InMemoryTaskStore = class {
     if (filter2.ownerId) results = results.filter((t) => t.ownerId === filter2.ownerId);
     if (filter2.status) results = results.filter((t) => t.status === filter2.status);
     if (filter2.priority) results = results.filter((t) => t.priority === filter2.priority);
+    if (filter2.threadId) results = results.filter((t) => t.context?.thread_id === filter2.threadId);
     if (filter2.workspaceId) results = results.filter((t) => t.workspaceId === filter2.workspaceId);
     if (filter2.projectId === null) results = results.filter((task) => !task.projectId || task.projectId === "default");
     else if (filter2.projectId !== void 0) results = results.filter((task) => task.projectId === filter2.projectId);
@@ -7771,6 +7788,7 @@ var _DefaultScheduleClient = class _DefaultScheduleClient {
   }
   // ===== Recovery =====
   async restore() {
+    this.clearAllTimers();
     try {
       const requeued = await this.storage.requeueStaleRunning(STALE_RUNNING_MS);
       if (requeued > 0) {
@@ -7784,41 +7802,89 @@ var _DefaultScheduleClient = class _DefaultScheduleClient {
         error
       );
     }
+    const restored = await this.reconcileTimers(true);
+    console.log(`[Scheduler] Restored ${restored} tasks`);
+    return restored;
+  }
+  /**
+   * Reconcile this replica's timers with the shared schedule store.
+   *
+   * @remarks Safe to call periodically and on every replica. Execution still
+   * goes through `claimScheduledRun`, so duplicate timer fires execute once.
+   */
+  async reconcile() {
+    try {
+      await this.storage.requeueStaleRunning(STALE_RUNNING_MS);
+    } catch (error) {
+      console.error(
+        "[Scheduler] Failed to requeue stale running tasks during reconcile:",
+        error
+      );
+    }
+    return this.reconcileTimers(false);
+  }
+  clearTimer(taskId) {
+    const timer = this.timers.get(taskId);
+    if (!timer) return;
+    clearTimeout(timer.timerId);
+    this.timers.delete(taskId);
+  }
+  clearAllTimers() {
+    for (const timer of this.timers.values()) clearTimeout(timer.timerId);
+    this.timers.clear();
+  }
+  async reconcileTimers(recomputeCronNextRun) {
     const activeTasks = await this.storage.getActiveTasks();
-    let restored = 0;
+    const activeById = new Map(activeTasks.map((task) => [task.taskId, task]));
+    for (const taskId of [...this.timers.keys()]) {
+      const task = activeById.get(taskId);
+      if (!task || task.status === import_protocols8.ScheduledTaskStatus.PAUSED) {
+        this.clearTimer(taskId);
+      }
+    }
+    let reconciled = 0;
     for (const task of activeTasks) {
       if (!this.handlers.has(task.taskType)) {
         console.warn(
-          `[Scheduler] No handler for task type ${task.taskType}, skipping restore for task ${task.taskId}`
+          `[Scheduler] No handler for task type ${task.taskType}, skipping reconcile for task ${task.taskId}`
         );
+        this.clearTimer(task.taskId);
         continue;
       }
       if (task.status === import_protocols8.ScheduledTaskStatus.PAUSED) {
+        this.clearTimer(task.taskId);
         continue;
       }
       if (task.executionType === import_protocols8.ScheduleExecutionType.ONCE) {
-        if (task.executeAt && task.executeAt <= Date.now()) {
-          console.log(
-            `[Scheduler] Executing overdue one-time task: ${task.taskId}`
-          );
-          this.executeTask(task);
-        } else {
+        if (task.executeAt !== void 0 && task.executeAt <= Date.now()) {
+          this.clearTimer(task.taskId);
+          void this.executeTask(task);
+        } else if (task.executeAt !== void 0) {
           this.scheduleTimer(task);
         }
       } else if (task.executionType === import_protocols8.ScheduleExecutionType.CRON) {
-        const nextRunAt = getNextCronTime(task.cronExpression, /* @__PURE__ */ new Date(), task.timezone);
-        await this.storage.update(task.taskId, {
-          nextRunAt: nextRunAt.getTime()
-        });
-        const updatedTask = await this.storage.get(task.taskId);
-        if (updatedTask) {
-          this.scheduleTimer(updatedTask);
+        let nextRunAt = task.nextRunAt;
+        if (recomputeCronNextRun || nextRunAt === void 0) {
+          nextRunAt = getNextCronTime(task.cronExpression, /* @__PURE__ */ new Date(), task.timezone).getTime();
+          await this.storage.update(task.taskId, { nextRunAt });
+          const updated = await this.storage.get(task.taskId);
+          if (!updated) continue;
+          if (updated.nextRunAt !== void 0 && updated.nextRunAt <= Date.now()) {
+            this.clearTimer(updated.taskId);
+            void this.executeTask(updated);
+          } else {
+            this.scheduleTimer(updated);
+          }
+        } else if (nextRunAt <= Date.now()) {
+          this.clearTimer(task.taskId);
+          void this.executeTask(task);
+        } else {
+          this.scheduleTimer(task);
         }
       }
-      restored++;
+      reconciled++;
     }
-    console.log(`[Scheduler] Restored ${restored} tasks`);
-    return restored;
+    return reconciled;
   }
   // ===== Storage =====
   setStorage(storage) {
@@ -7829,6 +7895,7 @@ var _DefaultScheduleClient = class _DefaultScheduleClient {
   }
   // ===== Private Methods =====
   scheduleTimer(task) {
+    this.clearTimer(task.taskId);
     const targetTime = task.executionType === import_protocols8.ScheduleExecutionType.CRON ? task.nextRunAt : task.executeAt;
     if (targetTime === void 0) {
       console.error(`[Scheduler] No execution time for task: ${task.taskId}`);
@@ -8097,6 +8164,9 @@ var ScheduleLatticeManager = class _ScheduleLatticeManager extends BaseLatticeMa
       // Recovery
       restore: async () => {
         return scheduleClient.restore();
+      },
+      reconcile: async () => {
+        return scheduleClient.reconcile?.() ?? 0;
       }
     };
     this.register(key5, scheduleLattice);
@@ -22347,7 +22417,7 @@ function getPluginDeploymentService() {
 }
 
 // src/sandbox_plugin/TenantPluginCatalog.ts
-var import_node_crypto3 = require("crypto");
+var import_node_crypto4 = require("crypto");
 
 // src/sandbox_plugin/jsonSchemaToZod.ts
 var import_zod47 = require("zod");
@@ -22713,6 +22783,19 @@ async function resolveSandboxPluginConnections(type, config, runConfig) {
   return { connection: connections[0]?.config, connections };
 }
 
+// src/sandbox_plugin/sandboxRunConfig.ts
+function sandboxRunConfigFrom(exeConfig) {
+  const config = exeConfig;
+  const raw = config?.configurable?.runConfig ?? {};
+  return {
+    tenantId: typeof raw.tenantId === "string" && raw.tenantId.length > 0 ? raw.tenantId : void 0,
+    assistantId: typeof raw.assistant_id === "string" && raw.assistant_id.length > 0 ? raw.assistant_id : void 0,
+    threadId: typeof raw.thread_id === "string" && raw.thread_id.length > 0 ? raw.thread_id : void 0,
+    workspaceId: typeof raw.workspaceId === "string" && raw.workspaceId.length > 0 ? raw.workspaceId : void 0,
+    projectId: typeof raw.projectId === "string" && raw.projectId.length > 0 ? raw.projectId : void 0
+  };
+}
+
 // src/mcp_lattice/mcpUi.ts
 var import_tools2 = require("@langchain/core/tools");
 var isObj = (v) => typeof v === "object" && v !== null;
@@ -22793,6 +22876,145 @@ function wrapMcpToolWithUi(raw, ref) {
   });
 }
 
+// src/mcp_lattice/mcpUiScope.ts
+var import_node_crypto3 = require("crypto");
+var MIN_SECRET_LENGTH = 32;
+var MAX_PAYLOAD_BYTES = 2048;
+var MAX_TOKEN_LENGTH = 4096;
+var SCOPE_KEY_INFO = "mcp-ui-scope";
+var warnedMessages = /* @__PURE__ */ new Set();
+function getMcpUiScopeSecret() {
+  const explicit = process.env.MCP_UI_SCOPE_SECRET;
+  if (explicit) {
+    return explicit.length >= MIN_SECRET_LENGTH ? explicit : void 0;
+  }
+  const encryptionKey = process.env.LATTICE_ENCRYPTION_KEY;
+  if (!encryptionKey) return void 0;
+  return Buffer.from(
+    (0, import_node_crypto3.hkdfSync)("sha256", encryptionKey, "", SCOPE_KEY_INFO, 32)
+  ).toString("base64url");
+}
+function warnOnce(message) {
+  if (warnedMessages.has(message)) return;
+  warnedMessages.add(message);
+  console.warn(JSON.stringify({ event: "mcp-ui-scope:warning", message }));
+}
+function isRecord8(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function signMcpUiScope(input, secret = getMcpUiScopeSecret()) {
+  if (!secret || secret.length < MIN_SECRET_LENGTH) {
+    warnOnce(
+      "no usable MCP UI scope signing secret (set MCP_UI_SCOPE_SECRET or LATTICE_ENCRYPTION_KEY)"
+    );
+    return void 0;
+  }
+  if (typeof input.tid !== "string" || input.tid === "" || typeof input.plugin !== "string" || input.plugin === "" || typeof input.resource !== "string" || input.resource === "") {
+    warnOnce("scope identity is missing tid/plugin/resource");
+    return void 0;
+  }
+  const optionalStrings = [input.thid, input.aid, input.wid, input.pid, input.ck];
+  if (optionalStrings.some(
+    (value) => value !== void 0 && typeof value !== "string"
+  )) {
+    warnOnce("scope optional identity fields must be strings");
+    return void 0;
+  }
+  if (input.iat !== void 0 && (typeof input.iat !== "number" || !Number.isFinite(input.iat))) {
+    warnOnce("scope iat must be a finite number");
+    return void 0;
+  }
+  if (input.jti !== void 0 && typeof input.jti !== "string") {
+    warnOnce("scope jti must be a string");
+    return void 0;
+  }
+  const payload = {
+    v: 1,
+    tid: input.tid,
+    thid: input.thid,
+    aid: input.aid,
+    wid: input.wid,
+    pid: input.pid,
+    plugin: input.plugin,
+    resource: input.resource,
+    ck: input.ck === "" ? void 0 : input.ck,
+    iat: input.iat ?? Math.floor(Date.now() / 1e3),
+    jti: input.jti ?? (0, import_node_crypto3.randomUUID)()
+  };
+  const json = JSON.stringify(payload);
+  if (Buffer.byteLength(json, "utf8") > MAX_PAYLOAD_BYTES) {
+    warnOnce("scope payload exceeds 2048 bytes");
+    return void 0;
+  }
+  const body = Buffer.from(json, "utf8").toString("base64url");
+  const sig = (0, import_node_crypto3.createHmac)("sha256", secret).update(body).digest("base64url");
+  const token = `${body}.${sig}`;
+  if (token.length > MAX_TOKEN_LENGTH) {
+    warnOnce("signed scope token exceeds 4096 characters");
+    return void 0;
+  }
+  return token;
+}
+function verifyMcpUiScope(token, secret = getMcpUiScopeSecret()) {
+  if (!token || token.length > MAX_TOKEN_LENGTH || !secret || secret.length < MIN_SECRET_LENGTH) {
+    return null;
+  }
+  const parts = token.split(".");
+  if (parts.length !== 2) return null;
+  const [body, sig] = parts;
+  if (!body || !sig) return null;
+  try {
+    const expected = (0, import_node_crypto3.createHmac)("sha256", secret).update(body).digest("base64url");
+    const expectedBuf = Buffer.from(expected, "utf8");
+    const sigBuf = Buffer.from(sig, "utf8");
+    if (expectedBuf.length !== sigBuf.length || !(0, import_node_crypto3.timingSafeEqual)(expectedBuf, sigBuf)) {
+      return null;
+    }
+  } catch {
+    return null;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(Buffer.from(body, "base64url").toString("utf8"));
+  } catch {
+    return null;
+  }
+  if (!isRecord8(parsed) || parsed.v !== 1) return null;
+  const tid = parsed.tid;
+  const plugin = parsed.plugin;
+  const resource = parsed.resource;
+  const thid = parsed.thid;
+  const aid = parsed.aid;
+  const wid = parsed.wid;
+  const pid = parsed.pid;
+  const ck = parsed.ck;
+  const iat = parsed.iat;
+  const jti = parsed.jti;
+  if (typeof tid !== "string" || tid === "") return null;
+  if (typeof plugin !== "string" || plugin === "") return null;
+  if (typeof resource !== "string" || resource === "") return null;
+  if (thid !== void 0 && typeof thid !== "string") return null;
+  if (aid !== void 0 && typeof aid !== "string") return null;
+  if (wid !== void 0 && typeof wid !== "string") return null;
+  if (pid !== void 0 && typeof pid !== "string") return null;
+  if (ck !== void 0 && (typeof ck !== "string" || ck === "")) return null;
+  if (typeof iat !== "number" || !Number.isFinite(iat)) return null;
+  if (typeof jti !== "string") return null;
+  return {
+    v: 1,
+    tid,
+    ...thid === void 0 ? {} : { thid },
+    ...aid === void 0 ? {} : { aid },
+    ...wid === void 0 ? {} : { wid },
+    ...pid === void 0 ? {} : { pid },
+    plugin,
+    resource,
+    ...ck === void 0 ? {} : { ck },
+    iat,
+    jti
+  };
+}
+
 // src/sandbox_plugin/SandboxPluginCompiler.ts
 var EMPTY_CONFIG_SCHEMA = Object.freeze({ type: "object", properties: Object.freeze({}) });
 var STANDARD_CONNECTION_SCHEMA = Object.freeze({
@@ -22807,20 +23029,9 @@ var STANDARD_CONNECTION_DEFAULT_CONFIG = Object.freeze({
   connectAll: false
 });
 var EMPTY_DEFAULT_CONFIG = Object.freeze({});
-function isRecord8(value) {
+function isRecord9(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function runConfigFrom(exeConfig) {
-  const c = exeConfig;
-  const r = c?.configurable?.runConfig ?? {};
-  return {
-    tenantId: typeof r.tenantId === "string" ? r.tenantId : void 0,
-    assistantId: typeof r.assistant_id === "string" ? r.assistant_id : void 0,
-    threadId: typeof r.thread_id === "string" ? r.thread_id : void 0,
-    workspaceId: typeof r.workspaceId === "string" ? r.workspaceId : void 0,
-    projectId: typeof r.projectId === "string" ? r.projectId : void 0
-  };
-}
 function compileSandboxPlugin(args) {
   const { manifest, executor, tenantId: tenantId2 } = args;
   const plugin = {
@@ -22837,11 +23048,10 @@ function compileSandboxPlugin(args) {
       defaultConfig: manifest.defaultConfig ?? (manifest.connection ? STANDARD_CONNECTION_DEFAULT_CONFIG : EMPTY_DEFAULT_CONFIG)
     },
     middleware: (config) => {
-      const runConfigFor = (exeConfig) => runConfigFrom(exeConfig);
       const tools = manifest.tools.map(
         (t) => (0, import_langchain48.tool)(
           async (input, exeConfig) => {
-            const runConfig = runConfigFor(exeConfig);
+            const runConfig = sandboxRunConfigFrom(exeConfig);
             const resolution = await resolveConnection(manifest.type, config, runConfig);
             const result = await executor.invoke({
               manifest,
@@ -22860,7 +23070,24 @@ function compileSandboxPlugin(args) {
             });
             if (!result.ok) return result.error ?? "sandbox plugin execution failed";
             const text = handlerResultText(result);
-            const ref = t.ui ? { kind: "plugin", pluginType: manifest.type, resource: t.ui.resource, displayMode: t.ui.displayMode ?? "inline" } : null;
+            const ui = t.ui;
+            const scope = ui ? signMcpUiScope({
+              tid: runConfig.tenantId || tenantId2,
+              thid: runConfig.threadId,
+              aid: runConfig.assistantId,
+              wid: runConfig.workspaceId,
+              pid: runConfig.projectId,
+              plugin: manifest.type,
+              resource: ui.resource,
+              ck: resolution.connections?.[0]?.key
+            }) : void 0;
+            const ref = ui ? {
+              kind: "plugin",
+              pluginType: manifest.type,
+              resource: ui.resource,
+              displayMode: ui.displayMode ?? "inline",
+              ...scope ? { scope } : {}
+            } : null;
             return ref ? appendUiFence(text, ref) : text;
           },
           { name: t.name, description: t.description, schema: jsonSchemaToZod(t.schema) }
@@ -22897,11 +23124,11 @@ async function runConnectionHandler(executor, manifest, handler, config, tenantI
     return { ok: false, message: result.error ?? "connection test failed" };
   }
   const value = result.result;
-  if (isRecord8(value) && typeof value.ok === "boolean" && typeof value.message === "string") {
+  if (isRecord9(value) && typeof value.ok === "boolean" && typeof value.message === "string") {
     return {
       ok: value.ok,
       message: value.message,
-      details: isRecord8(value.details) ? value.details : void 0
+      details: isRecord9(value.details) ? value.details : void 0
     };
   }
   return { ok: false, message: result.error ?? "connection test returned an invalid result" };
@@ -23397,7 +23624,7 @@ var TenantPluginCatalog = class {
       hashParts.push(`${type}:${manifestJson}:${relPaths.join(",")}`);
       candidates.push({ type, dirPath: dir.path, raw, manifestJson, files: dirFiles });
     }
-    const hash = (0, import_node_crypto3.createHash)("sha256").update(hashParts.sort().join("\n")).digest("hex").slice(0, 16);
+    const hash = (0, import_node_crypto4.createHash)("sha256").update(hashParts.sort().join("\n")).digest("hex").slice(0, 16);
     const cached2 = this.cache.get(tenantId2)?.value;
     if (cached2 && cached2.hash === hash) {
       this.cache.set(tenantId2, { value: cached2, checkedAt: this.now() });
@@ -23636,23 +23863,23 @@ function toolName(tool67) {
   return typeof tool67.name === "string" ? tool67.name : void 0;
 }
 function schemaHasConnectionKey(schema6) {
-  const definition = isRecord9(schema6._def) ? schema6._def : void 0;
+  const definition = isRecord10(schema6._def) ? schema6._def : void 0;
   const shape = definition?.shape;
   const fields = typeof shape === "function" ? shape() : shape;
-  return isRecord9(fields) && Object.prototype.hasOwnProperty.call(fields, "connectionKey");
+  return isRecord10(fields) && Object.prototype.hasOwnProperty.call(fields, "connectionKey");
 }
 function hasConnectionKeySchema(tool67) {
-  if (!isRecord9(tool67) || !isRecord9(tool67.schema)) return false;
+  if (!isRecord10(tool67) || !isRecord10(tool67.schema)) return false;
   if (schemaHasConnectionKey(tool67.schema)) return true;
-  const definition = isRecord9(tool67.schema._def) ? tool67.schema._def : void 0;
+  const definition = isRecord10(tool67.schema._def) ? tool67.schema._def : void 0;
   if (Array.isArray(definition?.options) && definition.options.length > 0) {
     return definition.options.every(
-      (option) => isRecord9(option) && schemaHasConnectionKey(option)
+      (option) => isRecord10(option) && schemaHasConnectionKey(option)
     );
   }
   return false;
 }
-function isRecord9(value) {
+function isRecord10(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 var CapabilityToolRegistry = class {
@@ -23744,17 +23971,17 @@ var CapabilityToolRegistry = class {
 // src/middlewares/capabilityGuardMiddleware.ts
 var import_messages4 = require("@langchain/core/messages");
 var import_langchain49 = require("langchain");
-function isRecord10(value) {
+function isRecord11(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function capabilityRuntimeFromRequest(request) {
-  if (!isRecord10(request) || !isRecord10(request.runtime)) return void 0;
+  if (!isRecord11(request) || !isRecord11(request.runtime)) return void 0;
   const configurable = request.runtime.configurable;
   const context = request.runtime.context;
-  const runConfig = isRecord10(configurable) && isRecord10(configurable.runConfig) ? configurable.runConfig : isRecord10(context) && isRecord10(context.runConfig) ? context.runConfig : void 0;
+  const runConfig = isRecord11(configurable) && isRecord11(configurable.runConfig) ? configurable.runConfig : isRecord11(context) && isRecord11(context.runConfig) ? context.runConfig : void 0;
   if (!runConfig) return void 0;
   const value = runConfig.capabilityRuntime;
-  if (!isRecord10(value) || typeof value.revision !== "string" || !isRecord10(value.middleware)) {
+  if (!isRecord11(value) || typeof value.revision !== "string" || !isRecord11(value.middleware)) {
     return void 0;
   }
   return value;
@@ -23766,10 +23993,10 @@ function hasActiveRuntimePolicy(runtime) {
   return Object.keys(runtime.middleware).length > 0;
 }
 function tenantIdFromRequest(request) {
-  if (!isRecord10(request) || !isRecord10(request.runtime)) return void 0;
+  if (!isRecord11(request) || !isRecord11(request.runtime)) return void 0;
   const configurable = request.runtime.configurable;
   const context = request.runtime.context;
-  const runConfig = isRecord10(configurable) && isRecord10(configurable.runConfig) ? configurable.runConfig : isRecord10(context) && isRecord10(context.runConfig) ? context.runConfig : void 0;
+  const runConfig = isRecord11(configurable) && isRecord11(configurable.runConfig) ? configurable.runConfig : isRecord11(context) && isRecord11(context.runConfig) ? context.runConfig : void 0;
   return runConfig && typeof runConfig.tenantId === "string" ? runConfig.tenantId : void 0;
 }
 async function standardConnectionAllowed(request, capabilityType, config) {
@@ -23777,8 +24004,8 @@ async function standardConnectionAllowed(request, capabilityType, config) {
   const hasConnectAll = Object.prototype.hasOwnProperty.call(config, "connectAll");
   if (!hasConnections && (!hasConnectAll || config.connectAll !== true)) return false;
   const tenantId2 = tenantIdFromRequest(request);
-  const resource = isRecord10(request.toolCall) && isRecord10(request.toolCall.args) ? request.toolCall.args.connectionKey : void 0;
-  const hasConnectionKey = isRecord10(request.toolCall) && isRecord10(request.toolCall.args) && Object.prototype.hasOwnProperty.call(
+  const resource = isRecord11(request.toolCall) && isRecord11(request.toolCall.args) ? request.toolCall.args.connectionKey : void 0;
+  const hasConnectionKey = isRecord11(request.toolCall) && isRecord11(request.toolCall.args) && Object.prototype.hasOwnProperty.call(
     request.toolCall.args,
     "connectionKey"
   );
@@ -23844,10 +24071,10 @@ function createCapabilityGuardMiddleware(registry4) {
           toolName: toolName2
         });
       }
-      const standardConfig = isRecord10(policy.config) ? policy.config : {};
+      const standardConfig = isRecord11(policy.config) ? policy.config : {};
       if (registry4.isStandardConnectionTool(toolName2) && !await standardConnectionAllowed(request, metadata.capabilityType, standardConfig)) {
         const args2 = request.toolCall.args;
-        const resource = isRecord10(args2) && typeof args2.connectionKey === "string" ? args2.connectionKey : void 0;
+        const resource = isRecord11(args2) && typeof args2.connectionKey === "string" ? args2.connectionKey : void 0;
         return denialMessage(request.toolCall, {
           code: "RESOURCE_NOT_ALLOWED",
           message: typeof resource === "string" ? `Resource '${resource}' is not allowed by the capability policy` : "Resource selector 'connectionKey' must be a permitted string",
@@ -23860,8 +24087,8 @@ function createCapabilityGuardMiddleware(registry4) {
       const selector = metadata.resourceSelector;
       const args = request.toolCall.args;
       if (selector) {
-        const resource = isRecord10(args) ? args[selector.argumentField] : void 0;
-        const config = isRecord10(policy.config) ? policy.config : {};
+        const resource = isRecord11(args) ? args[selector.argumentField] : void 0;
+        const config = isRecord11(policy.config) ? policy.config : {};
         const hasExplicitResources = Object.prototype.hasOwnProperty.call(config, selector.configField);
         const allowsAll = !hasExplicitResources && selector.allowAllField !== void 0 && config[selector.allowAllField] === true;
         const allowedResources = config[selector.configField];
@@ -24438,7 +24665,17 @@ var import_langgraph6 = require("@langchain/langgraph");
 var import_protocols17 = require("@axiom-lattice/protocols");
 
 // src/services/Agent.ts
-var import_node_crypto6 = require("crypto");
+var import_node_crypto7 = require("crypto");
+
+// src/services/agentRecursionLimit.ts
+var DEFAULT_AGENT_RECURSION_LIMIT = 500;
+function readAgentRecursionLimit(env = process.env) {
+  const raw = env.AGENT_RECURSION_LIMIT;
+  if (raw === void 0 || raw.trim() === "") return DEFAULT_AGENT_RECURSION_LIMIT;
+  const parsed = Number(raw);
+  if (!Number.isFinite(parsed) || parsed < 1) return DEFAULT_AGENT_RECURSION_LIMIT;
+  return Math.floor(parsed);
+}
 
 // src/services/DelegationCancellation.ts
 var DelegationCancellationRegistry = class {
@@ -25045,7 +25282,7 @@ var import_langgraph5 = require("@langchain/langgraph");
 
 // src/services/agentInterrupts.ts
 var FENCE = /^```([A-Za-z0-9_-]+)\n([\s\S]*?)\n```$/;
-function isRecord11(value) {
+function isRecord12(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function parseFence(value) {
@@ -25059,7 +25296,7 @@ function parseFence(value) {
   }
 }
 function isTaskReview(value) {
-  return isRecord11(value) && (value.type === "task_review" || value.kind === "task_review" || "task_review" in value);
+  return isRecord12(value) && (value.type === "task_review" || value.kind === "task_review" || "task_review" in value);
 }
 function isOfficialInterruptId(interruptId) {
   return /^[a-f0-9]{32}$/i.test(interruptId);
@@ -25074,28 +25311,28 @@ function hasExpectedInterrupt(interrupts, expectedInterruptId) {
   ).length === 1;
 }
 function normalizeAgentInterrupts(state, threadId) {
-  if (!isRecord11(state) || !Array.isArray(state.tasks)) return [];
+  if (!isRecord12(state) || !Array.isArray(state.tasks)) return [];
   const result = [];
   state.tasks.forEach((task, taskIndex) => {
-    if (!isRecord11(task) || !Array.isArray(task.interrupts)) return;
+    if (!isRecord12(task) || !Array.isArray(task.interrupts)) return;
     const rawTaskId = task.id;
     const taskId = typeof rawTaskId === "string" || typeof rawTaskId === "number" ? String(rawTaskId) : void 0;
     task.interrupts.forEach((interrupt5, index) => {
-      const record = isRecord11(interrupt5) ? interrupt5 : {};
+      const record = isRecord12(interrupt5) ? interrupt5 : {};
       const rawId = record.id;
       const interruptId = typeof rawId === "string" || typeof rawId === "number" ? String(rawId) : `${taskId ?? `task-${taskIndex}`}:${index}`;
-      const rawValue = isRecord11(interrupt5) ? record.value : interrupt5;
+      const rawValue = isRecord12(interrupt5) ? record.value : interrupt5;
       const fenced = parseFence(rawValue);
       const value = fenced ? fenced.payload : rawValue;
       let type;
-      if (fenced?.type === "clarify" || isRecord11(value) && Array.isArray(value.questions)) {
+      if (fenced?.type === "clarify" || isRecord12(value) && Array.isArray(value.questions)) {
         type = "clarify";
       } else if (fenced?.type === "task_review" || isTaskReview(value)) {
         type = "task_review";
       } else {
         type = "custom";
       }
-      const payload = type === "clarify" && isRecord11(value) && Array.isArray(value.questions) ? { questions: value.questions } : value;
+      const payload = type === "clarify" && isRecord12(value) && Array.isArray(value.questions) ? { questions: value.questions } : value;
       result.push({
         interruptId,
         type,
@@ -26103,7 +26340,7 @@ var import_uuid5 = require("uuid");
 var import_zod48 = require("zod");
 
 // src/capability/CapabilityBundleMerger.ts
-var import_node_crypto4 = require("crypto");
+var import_node_crypto5 = require("crypto");
 var import_node_util = require("util");
 
 // src/capability/CredentialFieldPolicy.ts
@@ -26539,7 +26776,7 @@ function createCapabilityRevision(bundles, effectivePolicy) {
     bundles: bundles.map(({ id, updatedAt }) => [id, updatedAt]),
     effectivePolicy
   };
-  return (0, import_node_crypto4.createHash)("sha256").update(JSON.stringify(canonicalize(revisionInput))).digest("hex");
+  return (0, import_node_crypto5.createHash)("sha256").update(JSON.stringify(canonicalize(revisionInput))).digest("hex");
 }
 var LEGACY_UNION_CONFIG_FIELDS = new Set(
   Object.values(LEGACY_PLUGIN_CONNECTION_FIELDS).map(({ selectorField }) => selectorField)
@@ -27057,6 +27294,114 @@ var CapabilityRuntimeResolver = class {
   }
 };
 
+// src/observability_lattice/ObservabilityProvider.ts
+var ObservabilityDashboardUnsupportedError = class extends Error {
+  /**
+   * @param message - Stable diagnostic message.
+   */
+  constructor(message = "Observability dashboard is not supported") {
+    super(message);
+    this.name = "ObservabilityDashboardUnsupportedError";
+  }
+};
+var ObservabilityDashboardUnavailableError = class extends Error {
+  /**
+   * @param message - Stable diagnostic message.
+   */
+  constructor(message = "Observability dashboard is unavailable") {
+    super(message);
+    this.name = "ObservabilityDashboardUnavailableError";
+  }
+};
+
+// src/observability_lattice/ObservabilityLatticeManager.ts
+init_BaseLatticeManager();
+var ObservabilityLatticeManager = class _ObservabilityLatticeManager extends BaseLatticeManager {
+  constructor() {
+    super(...arguments);
+    this.defaultKey = "default";
+  }
+  /** Returns the process-wide singleton manager. */
+  static getInstance() {
+    if (!_ObservabilityLatticeManager.instance) {
+      _ObservabilityLatticeManager.instance = new _ObservabilityLatticeManager();
+    }
+    return _ObservabilityLatticeManager.instance;
+  }
+  getLatticeType() {
+    return "observability";
+  }
+  /** Registers a provider under a caller-chosen key. */
+  registerLattice(key5, provider2) {
+    this.register(key5, provider2);
+  }
+  /**
+   * Returns the provider registered under `key`.
+   *
+   * @throws Error when no provider is registered under `key`.
+   */
+  getObservabilityLattice(key5) {
+    const provider2 = this.get(key5);
+    if (!provider2) throw new Error(`Observability lattice "${key5}" not registered`);
+    return provider2;
+  }
+  /** Returns whether a provider is registered under `key`. */
+  hasLattice(key5) {
+    return this.has(key5);
+  }
+  /**
+   * Removes the provider under `key`.
+   *
+   * @returns `true` when a provider was removed. Removing the active default
+   * falls back to the `"default"` key.
+   */
+  removeLattice(key5) {
+    const removed = this.remove(key5);
+    if (removed && this.defaultKey === key5) this.defaultKey = "default";
+    return removed;
+  }
+  /** Removes all providers and resets the active default. */
+  clear() {
+    super.clear();
+    this.defaultKey = "default";
+  }
+  /**
+   * Selects the provider used for new invocations.
+   *
+   * @throws Error when no provider is registered under `key`.
+   */
+  setDefault(key5) {
+    if (!this.has(key5)) {
+      throw new Error(`Observability lattice "${key5}" is not registered`);
+    }
+    this.defaultKey = key5;
+  }
+  /** Returns the key of the active default provider. */
+  getDefaultKey() {
+    return this.defaultKey;
+  }
+  /** Returns the active default provider, if registered. */
+  getDefault() {
+    return this.get(this.defaultKey);
+  }
+};
+var observabilityLatticeManager = ObservabilityLatticeManager.getInstance();
+function registerObservabilityLattice(key5, provider2) {
+  observabilityLatticeManager.registerLattice(key5, provider2);
+}
+function setDefaultObservabilityLattice(key5) {
+  observabilityLatticeManager.setDefault(key5);
+}
+function resolveObservabilityCallbacks(context) {
+  const provider2 = observabilityLatticeManager.getDefault();
+  if (!provider2?.createCallbacks) return [];
+  try {
+    return [...provider2.createCallbacks(context) ?? []];
+  } catch {
+    return [];
+  }
+}
+
 // src/services/TaskExecutionContext.ts
 var DELEGATED_WORKER_SCOPE_TOKEN = Symbol("delegated-worker-scope");
 var delegatedWorkerScopeSecret = Object.freeze({});
@@ -27147,13 +27492,13 @@ function preserveDelegationContext(source, target) {
 var TRUSTED_AGENT_DISPATCH = Symbol("axiom.trustedAgentDispatch");
 
 // src/services/threadRunLease.ts
-var import_node_crypto5 = require("crypto");
+var import_node_crypto6 = require("crypto");
 function threadRunLeaseKey(tenantId2, assistantId, threadId) {
   return `thread-run:${tenantId2}:${assistantId}:${threadId}`;
 }
 async function tryAcquireThreadRun(input) {
   const key5 = threadRunLeaseKey(input.tenantId, input.assistantId, input.threadId);
-  const holder = `${input.owner}#${(0, import_node_crypto5.randomUUID)()}`;
+  const holder = `${input.owner}#${(0, import_node_crypto6.randomUUID)()}`;
   if (!await input.store.tryAcquire(key5, holder, input.ttlMs)) return null;
   const heartbeatMs = input.heartbeatMs ?? Math.max(1e3, Math.floor(input.ttlMs / 3));
   let released = false;
@@ -27874,7 +28219,6 @@ function checkpointCapabilityRevision(state) {
 }
 var QUEUE_PROCESSOR_RETRY_BASE_MS = 100;
 var QUEUE_PROCESSOR_MAX_RETRIES = 3;
-var AGENT_RECURSION_LIMIT = 1e3;
 var THREAD_RUN_LEASE_TTL_MS = 6e4;
 var THREAD_RUN_LEASE_RETRY_BASE_MS = 150;
 var THREAD_RUN_LEASE_RETRY_CAP_MS = 1500;
@@ -27925,7 +28269,7 @@ var Agent = class {
      */
     this.threadRunLease = null;
     this.threadRunLeaseRetryAttempt = 0;
-    this.runIdFactory = import_node_crypto6.randomUUID;
+    this.runIdFactory = import_node_crypto7.randomUUID;
     this.ledgerChain = Promise.resolve();
     this.agentExecutor = async ({ input, command, custom_run_config, expected_capability_revision, trusted_run_context }, signal) => {
       const { runnable_agent, runConfig } = await this.getLatticeClientAndRuntimeConfig(
@@ -27939,6 +28283,8 @@ var Agent = class {
         throw new Error("Agent execution was aborted");
       }
       try {
+        const runId = (0, import_uuid5.v4)();
+        const callbacks = this.observabilityCallbacks(executionRunConfig, runId, "agent-executor");
         const result = await runnable_agent.invoke(
           command ? new import_langgraph5.Command(command) : { ...stateInput, "x-tenant-id": this.tenant_id },
           {
@@ -27946,11 +28292,12 @@ var Agent = class {
               runConfig: executionRunConfig
             },
             configurable: {
-              run_id: (0, import_uuid5.v4)(),
               ...executionRunConfig,
+              run_id: runId,
               runConfig: executionRunConfig
             },
-            recursionLimit: AGENT_RECURSION_LIMIT,
+            ...callbacks ? { callbacks } : {},
+            recursionLimit: readAgentRecursionLimit(),
             signal
           }
         );
@@ -28016,6 +28363,8 @@ var Agent = class {
             data: { id: message.id, content: message.content }
           });
         });
+        const runId = execution_run_id ?? (0, import_uuid5.v4)();
+        const callbacks = this.observabilityCallbacks(executionRunConfig, runId, "stream");
         const agentStream = await runnable_agent.stream(
           command ? new import_langgraph5.Command(command) : {
             ...stateInput,
@@ -28026,15 +28375,16 @@ var Agent = class {
               runConfig: executionRunConfig
             },
             configurable: {
-              run_id: execution_run_id ?? (0, import_uuid5.v4)(),
               ...executionRunConfig,
+              run_id: runId,
               runConfig: executionRunConfig
               // Inject runConfig for tools to access
             },
+            ...callbacks ? { callbacks } : {},
             ...execution_run_id === void 0 ? {} : { metadata: { run_id: execution_run_id } },
             streamMode: ["updates", "messages"],
             subgraphs: false,
-            recursionLimit: AGENT_RECURSION_LIMIT,
+            recursionLimit: readAgentRecursionLimit(),
             signal
           }
         );
@@ -28442,6 +28792,28 @@ var Agent = class {
     this.queue_project_id = project_id == null || project_id === "" ? null : this.project_id;
     this.custom_run_config = custom_run_config;
   }
+  /**
+   * Re-pins the workspace/project scope used by the next execution.
+   *
+   * @param params - Concrete scope of the run about to execute; absent or
+   * `null`/empty values keep the run unscoped.
+   * @throws {Error} When this Agent is actively executing.
+   * @remarks `AgentInstanceManager` is keyed by
+   * `(tenant_id, assistant_id, thread_id)` only, so a control-plane caller can
+   * create the instance before the durable run worker does. The worker calls
+   * this method while holding the thread-run lease (no other execution can be
+   * active) so the run's authoritative scope cannot inherit a stale default and
+   * fail capability resolution with `Project 'default' was not found`.
+   */
+  applyExecutionScope(params) {
+    if (this.activeExecutionPromise !== void 0) {
+      throw new Error("Cannot re-pin execution scope while the agent is executing");
+    }
+    this.workspace_id = params.workspace_id || "default";
+    this.project_id = params.project_id || "default";
+    this.queue_workspace_id = params.workspace_id === null ? null : this.workspace_id;
+    this.queue_project_id = params.project_id == null || params.project_id === "" ? null : this.project_id;
+  }
   /**
    * Accepts host-authenticated queue metadata through the package-private symbol capability.
    *
@@ -28568,6 +28940,22 @@ var Agent = class {
     }
     return base;
   }
+  observabilityCallbacks(runConfig, runId, source) {
+    const execution = isPlainRecord(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,
+      ...this.queue_project_id ? { projectId: this.queue_project_id } : {},
+      ...this.workspace_id ? { workspaceId: this.workspace_id } : {},
+      assistantId: this.assistant_id,
+      threadId: this.thread_id,
+      runId,
+      ...taskId ? { taskId } : {},
+      ...typeof runConfig.user_id === "string" ? { userId: runConfig.user_id } : {},
+      source: typeof runConfig.source === "string" ? runConfig.source : source
+    });
+    return callbacks.length > 0 ? callbacks : void 0;
+  }
   getHumanPendingContent(message) {
     if (typeof message.content === "string" || !message.content || !("id" in message.content) || !("message" in message.content)) {
       throw new Error(`Expected human pending message content for message ${message.id}`);
@@ -28798,16 +29186,19 @@ var Agent = class {
       if (combinedSignal.aborted) {
         throw new Error("Agent execution was aborted");
       }
+      const runId = (0, import_uuid5.v4)();
+      const callbacks = this.observabilityCallbacks(executionRunConfig, runId, "invoke");
       const result = await runnable_agent.invoke(
         inputMessage.command ? new import_langgraph5.Command(inputMessage.command) : { ...rest, messages, "x-tenant-id": this.tenant_id },
         {
           context: { runConfig: executionRunConfig },
           configurable: {
-            run_id: (0, import_uuid5.v4)(),
             ...executionRunConfig,
+            run_id: runId,
             runConfig: executionRunConfig
           },
-          recursionLimit: AGENT_RECURSION_LIMIT,
+          ...callbacks ? { callbacks } : {},
+          recursionLimit: readAgentRecursionLimit(),
           signal: combinedSignal
         }
       );
@@ -29207,6 +29598,8 @@ var Agent = class {
       capabilityRuntimeRevision
     );
     const executionRunConfig = this.executionRunConfig(runConfig, trustedRunContext);
+    const runId = executionRunId ?? (0, import_uuid5.v4)();
+    const callbacks = this.observabilityCallbacks(executionRunConfig, runId, "stream");
     const agentStream = await runnable_agent.stream(
       null,
       {
@@ -29215,13 +29608,14 @@ var Agent = class {
         },
         configurable: {
           ...executionRunConfig,
-          ...executionRunId === void 0 ? {} : { run_id: executionRunId },
+          run_id: runId,
           runConfig: executionRunConfig
         },
+        ...callbacks ? { callbacks } : {},
         ...executionRunId === void 0 ? {} : { metadata: { run_id: executionRunId } },
         streamMode: ["updates", "messages"],
         subgraphs: false,
-        recursionLimit: AGENT_RECURSION_LIMIT,
+        recursionLimit: readAgentRecursionLimit(),
         signal
       }
     );
@@ -30571,6 +30965,25 @@ var AgentInstanceManager = class _AgentInstanceManager {
     }
     return this.agents.get(key5);
   }
+  /**
+   * Get the managed Agent for an exclusive execution and re-pin its scope.
+   *
+   * @param params - Thread identity plus the authoritative run scope.
+   * @returns The singleton Agent whose next execution uses `params` scope.
+   * @throws {Error} When the resolved Agent is actively executing.
+   * @remarks Callers must already hold the thread-run lease (the durable run
+   * worker does), so no execution can be in flight. This keeps the one-instance
+   * identity while preventing a control-plane caller's default scope from
+   * deciding how the durable run resolves Projects.
+   */
+  getAgentForExecution(params) {
+    const agent = this.getAgent(params);
+    agent.applyExecutionScope({
+      workspace_id: params.workspace_id,
+      project_id: params.project_id
+    });
+    return agent;
+  }
   /**
    * Get the managed Agent for a thread WITHOUT creating or registering one.
    *
@@ -30700,8 +31113,13 @@ var DelegationService = class {
       if (!agent) {
         throw new Error(`Delegated agent ${request.assistant_id} not found`);
       }
+      let childAbort;
+      const abortChild = () => {
+        childAbort ?? (childAbort = agent.abort().catch(() => void 0));
+        return childAbort;
+      };
       const onCancel = () => {
-        void agent.abort().catch(() => void 0);
+        void abortChild();
       };
       if (cancellation) {
         if (cancellation.signal.aborted) onCancel();
@@ -30722,7 +31140,14 @@ var DelegationService = class {
         });
         try {
           await Promise.race([invocation, aborted]);
+          if (signal.aborted) {
+            await abortChild();
+            throw new Error("Delegated child aborted");
+          }
           return await agent.getCurrentState();
+        } catch (error) {
+          if (signal.aborted) await abortChild();
+          throw error;
         } finally {
           signal.removeEventListener("abort", onAbort);
         }
@@ -30892,7 +31317,15 @@ var agentWorkerGraph = createAgentWorkerGraph();
 // src/deep_agent_new/middleware/subagents.ts
 init_MemoryLatticeManager();
 var DEFAULT_SUBAGENT_PROMPT = "In order to complete the objective that the user asks of you, you have access to a number of standard tools.";
-var EXCLUDED_STATE_KEYS = ["messages", "todos", "jumpTo"];
+var EXCLUDED_STATE_KEYS = [
+  "messages",
+  "todos",
+  "jumpTo",
+  "repeatedToolCallSignature",
+  "repeatedToolCallCount",
+  "repeatedToolCallRunMarker",
+  "repeatedToolCallMemberSignatures"
+];
 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];
@@ -31488,8 +31921,12 @@ function registerAgentAddMessageHandler() {
         tenant_id: taskInfo.tenantId,
         assistant_id: taskInfo.assistantId ?? "",
         thread_id: taskInfo.threadId ?? "",
-        workspace_id: runConfigFromMetadata?.workspaceId ?? "default",
-        project_id: runConfigFromMetadata?.projectId ?? "default"
+        // An absent scope must stay unscoped: defaulting the project to
+        // `"default"` pinned the shared thread Agent to a project that may not
+        // exist, so later runs on the same thread failed capability resolution
+        // with `Project 'default' was not found`.
+        workspace_id: runConfigFromMetadata?.workspaceId ?? "",
+        project_id: runConfigFromMetadata?.projectId ?? ""
       });
       await agent.addMessage({
         input: {
@@ -33321,6 +33758,7 @@ var DeepAgentGraphBuilder = class {
     const deepAgent = createDeepAgent({
       tools,
       model: params.model,
+      name: agentLattice.config.name,
       contextSchema: params.stateSchema,
       systemPrompt: params.prompt,
       subagents,
@@ -33790,6 +34228,7 @@ var WorkflowAgentGraphBuilder = class {
     }
     const config = agentLattice.config;
     const yaml2 = config.workflowYaml;
+    const agentName = config.name?.trim() || config.key;
     const tenantId2 = agentLattice.config.tenantId ?? "default";
     const checkpointer = getCheckpointSaver("default");
     const tools = params.tools.map((t) => t.executor).filter(Boolean);
@@ -33812,6 +34251,7 @@ var WorkflowAgentGraphBuilder = class {
       model: params.model,
       tools,
       systemPrompt: buildStepSystemPrompt(false, params.prompt),
+      name: agentName,
       checkpointer,
       middleware: middlewares,
       stateSchema: withToolCallLimitStateSchema()
@@ -33833,6 +34273,7 @@ var WorkflowAgentGraphBuilder = class {
             model: params.model,
             tools,
             systemPrompt: buildStepSystemPrompt(isAsk, params.prompt),
+            name: agentName,
             checkpointer,
             middleware: isAsk ? noWrapAskMiddlewares : noWrapMiddlewares,
             stateSchema: withToolCallLimitStateSchema(),
@@ -33850,6 +34291,7 @@ var WorkflowAgentGraphBuilder = class {
             model: params.model,
             tools,
             systemPrompt: buildStepSystemPrompt(true, params.prompt),
+            name: agentName,
             checkpointer,
             middleware: askMiddlewares
           });
@@ -33868,7 +34310,13 @@ var WorkflowAgentGraphBuilder = class {
     } catch {
       console.warn(`[WF BUILDER] no trackingStore registered`);
     }
-    const graph = compileWorkflow(yaml2, resolveAgent, checkpointer, trackingStore);
+    const graph = compileWorkflow(
+      yaml2,
+      resolveAgent,
+      checkpointer,
+      trackingStore,
+      { name: agentName }
+    );
     return graph;
   }
 };
@@ -37338,7 +37786,7 @@ function parseRecursiveGrepOutput(output) {
 }
 
 // src/sandbox_lattice/packDirectory.ts
-var import_node_crypto7 = require("crypto");
+var import_node_crypto8 = require("crypto");
 var posix2 = __toESM(require("path/posix"));
 var MAX_PACK_ENTRIES = 1e4;
 var MAX_PACK_FILE_BYTES = 100 * 1024 * 1024;
@@ -37364,7 +37812,7 @@ function buildRemotePackDirectoryCommand(parentDir, sourceName, archiveName) {
   const parent = quotePosixShellArg(parentDir);
   const name = quotePosixShellArg(sourceName);
   const lock = quotePosixShellArg(`.${archiveName}.lock`);
-  const tempDir = quotePosixShellArg(`.${archiveName}.tmp-${(0, import_node_crypto7.randomBytes)(16).toString("hex")}`);
+  const tempDir = quotePosixShellArg(`.${archiveName}.tmp-${(0, import_node_crypto8.randomBytes)(16).toString("hex")}`);
   const archivePath = joinPhysicalPath(parentDir, archiveName);
   const archive = quotePosixShellArg(archivePath);
   return [
@@ -37843,7 +38291,7 @@ function getDefaultMicrosandboxRemoteConfig() {
     image: process.env.MICROSANDBOX_IMAGE ?? "kioko12520/sandbox:0.1.0",
     //"daytonaio/sandbox:0.6.0",
     cpus: parseOptionalNumberEnv("MICROSANDBOX_CPUS", 1),
-    memoryMib: parseOptionalNumberEnv("MICROSANDBOX_MEMORY", 512),
+    memoryMib: parseOptionalNumberEnv("MICROSANDBOX_MEMORY", 1024),
     user: "root"
   };
 }
@@ -38948,7 +39396,7 @@ var fs4 = __toESM(require("fs/promises"));
 
 // src/sandbox_lattice/LocalSandboxInstance.ts
 var import_node_child_process = require("child_process");
-var import_node_crypto8 = require("crypto");
+var import_node_crypto9 = require("crypto");
 var fs3 = __toESM(require("fs/promises"));
 var path5 = __toESM(require("path"));
 var posix5 = __toESM(require("path/posix"));
@@ -38987,7 +39435,8 @@ var PLATFORM_SECRET_ENV_VARS = [
   "TAVILY_API_KEY",
   "VAPID_PRIVATE_KEY",
   "SUPABASE_KEY",
-  "A2A_API_KEYS"
+  "A2A_API_KEYS",
+  "MCP_UI_SCOPE_SECRET"
 ];
 function stripPlatformSecrets(env) {
   const rest = { ...env };
@@ -39294,7 +39743,7 @@ ${errOut}`.trim() : out.trim();
       };
       await preflight(sourceHost);
       const lockName = `.${filename}.lock`;
-      const tempDirectoryName = `.${filename}.tmp-${(0, import_node_crypto8.randomBytes)(16).toString("hex")}`;
+      const tempDirectoryName = `.${filename}.tmp-${(0, import_node_crypto9.randomBytes)(16).toString("hex")}`;
       const sourceOperand = `./${rootName}`;
       tempDirectoryHost = path5.join(realArchiveDirectory, tempDirectoryName);
       tempHost = path5.join(tempDirectoryHost, "archive.zip");
@@ -39674,11 +40123,20 @@ async function disconnectAllChannels(getAdapter) {
 }
 
 // src/channel/ChannelConnectionLeader.ts
-var import_node_crypto9 = require("crypto");
+var import_node_crypto10 = require("crypto");
 var LEASE_KEY = "leader:channel-connections";
+function channelShardForInstallation(installationId, shardCount) {
+  if (!Number.isSafeInteger(shardCount) || shardCount < 1) {
+    throw new RangeError("shardCount must be a positive integer");
+  }
+  if (shardCount === 1) return 0;
+  return (0, import_node_crypto10.createHash)("sha256").update(installationId).digest().readUInt32BE(0) % shardCount;
+}
 var ChannelConnectionLeader = class {
   constructor(deps) {
+    this.active = /* @__PURE__ */ new Map();
     this.holder = null;
+    this.renewFailures = 0;
     this.connected = false;
     this.attempted = false;
     this.inFlight = null;
@@ -39688,6 +40146,33 @@ var ChannelConnectionLeader = class {
     this.deps = deps;
     this.ttlMs = deps.ttlMs ?? 6e4;
     this.retryMs = deps.retryMs ?? Math.max(5e3, Math.floor(this.ttlMs / 3));
+    this.shardCount = deps.shardCount ?? 1;
+    this.shard = deps.shard ?? 0;
+    if (!Number.isSafeInteger(this.shardCount) || this.shardCount < 1) {
+      throw new RangeError("ChannelConnectionLeader shardCount must be a positive integer");
+    }
+    if (!Number.isSafeInteger(this.shard) || this.shard < 0 || this.shard >= this.shardCount) {
+      throw new RangeError("ChannelConnectionLeader shard must be within shardCount");
+    }
+    this.leaseKey = deps.leaseKey ?? (this.shardCount === 1 ? LEASE_KEY : `${LEASE_KEY}:${this.shard}`);
+    this.reconciler = deps.loadDesired !== void 0;
+    if (this.reconciler && (!deps.connectInstallation || !deps.disconnectInstallation)) {
+      throw new Error("ChannelConnectionLeader reconcile mode requires connectInstallation and disconnectInstallation");
+    }
+  }
+  /** Whether this shard owns an installation id. */
+  owns(installationId) {
+    return channelShardForInstallation(installationId, this.shardCount) === this.shard;
+  }
+  /** Wake the current leader so it reconciles the shared desired state. */
+  wake() {
+    if (this.stopped) return;
+    void this.tickOnce();
+  }
+  /** Reconcile now when this instance currently holds the lease. */
+  async reconcile() {
+    if (!this.reconciler || !this.holder || this.stopped) return;
+    await this.reconcileChannels();
   }
   /** Starts the ownership loop (immediate tick, then every `retryMs`). */
   start() {
@@ -39714,13 +40199,17 @@ var ChannelConnectionLeader = class {
     if (this.holder) {
       const holder = this.holder;
       this.holder = null;
-      await this.deps.leaseStore.release(LEASE_KEY, holder).catch((error) => {
+      await this.deps.leaseStore.release(this.leaseKey, holder).catch((error) => {
         this.deps.log?.warn("Channel leader lease release failed", {
           error: error instanceof Error ? error.message : String(error)
         });
       });
     }
-    await this.disconnectChannels();
+    if (this.reconciler) {
+      await this.disconnectTracked();
+    } else {
+      await this.disconnectChannels();
+    }
   }
   /**
    * Runs one ownership/health step. Public for deterministic tests.
@@ -39751,39 +40240,64 @@ var ChannelConnectionLeader = class {
       let renewed = false;
       let renewFailed = false;
       try {
-        renewed = await this.deps.leaseStore.renew(LEASE_KEY, this.holder, this.ttlMs);
+        renewed = await this.deps.leaseStore.renew(this.leaseKey, this.holder, this.ttlMs);
       } catch (error) {
         renewFailed = true;
         this.deps.log?.warn("Channel leader lease renew failed", {
           error: error instanceof Error ? error.message : String(error)
         });
       }
-      if (renewFailed) return;
+      if (renewFailed) {
+        this.renewFailures += 1;
+        if (this.renewFailures * this.retryMs < this.ttlMs) return;
+        await this.loseLeadership();
+        return;
+      }
+      this.renewFailures = 0;
       if (renewed) {
-        if (!this.connected) await this.connectChannels();
+        if (this.reconciler) {
+          await this.reconcileChannels();
+        } else if (!this.connected) {
+          await this.connectChannels();
+        }
         return;
       }
       await this.loseLeadership();
     }
+    if (this.reconciler && this.active.size > 0) {
+      await this.disconnectTracked();
+      if (this.active.size > 0) return;
+    }
     await this.tryAcquire();
   }
   async tryAcquire() {
-    const holder = `${this.deps.owner}#${(0, import_node_crypto9.randomUUID)()}`;
-    const acquired = await this.deps.leaseStore.tryAcquire(LEASE_KEY, holder, this.ttlMs).catch((error) => {
+    const holder = `${this.deps.owner}#${(0, import_node_crypto10.randomUUID)()}`;
+    const acquired = await this.deps.leaseStore.tryAcquire(this.leaseKey, holder, this.ttlMs).catch((error) => {
       this.deps.log?.warn("Channel leader lease acquire failed", {
         error: error instanceof Error ? error.message : String(error)
       });
       return false;
     });
     if (!acquired) return;
+    this.renewFailures = 0;
     this.holder = holder;
-    await this.connectChannels();
+    if (this.reconciler) {
+      await this.reconcileChannels();
+    } else {
+      await this.connectChannels();
+    }
   }
   async loseLeadership() {
     this.holder = null;
-    await this.disconnectChannels();
+    this.renewFailures = 0;
+    if (this.reconciler) {
+      await this.disconnectTracked();
+    } else {
+      await this.disconnectChannels();
+    }
   }
   async connectChannels() {
+    if (!this.deps.connect) return;
     this.attempted = true;
     try {
       await this.deps.connect();
@@ -39796,7 +40310,7 @@ var ChannelConnectionLeader = class {
     }
   }
   async disconnectChannels() {
-    if (!this.attempted) return;
+    if (!this.attempted || !this.deps.disconnect) return;
     this.attempted = false;
     this.connected = false;
     try {
@@ -39807,6 +40321,74 @@ var ChannelConnectionLeader = class {
       });
     }
   }
+  /** Reconcile desired installations against the connections this shard holds. */
+  async reconcileChannels() {
+    if (!this.reconciler || !this.holder || this.stopped) return;
+    let desired;
+    try {
+      desired = (await this.deps.loadDesired()).filter(
+        (installation) => installation.enabled && this.owns(installation.id)
+      );
+    } catch (error) {
+      this.deps.log?.warn("Channel leader desired-state read failed", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+      return;
+    }
+    const desiredById = new Map(desired.map((installation) => [installation.id, installation]));
+    for (const [id, active] of [...this.active]) {
+      const next = desiredById.get(id);
+      if (next && this.fingerprint(next) === active.fingerprint) continue;
+      if (await this.safeDisconnect(active.installation)) this.active.delete(id);
+    }
+    for (const installation of desired) {
+      if (this.active.has(installation.id)) continue;
+      if (await this.safeConnect(installation)) {
+        this.active.set(installation.id, {
+          installation,
+          fingerprint: this.fingerprint(installation)
+        });
+      }
+    }
+  }
+  fingerprint(installation) {
+    if (this.deps.fingerprint) return this.deps.fingerprint(installation);
+    return JSON.stringify({
+      channel: installation.channel,
+      config: installation.config,
+      fallbackAgentId: installation.fallbackAgentId,
+      rejectWhenNoBinding: installation.rejectWhenNoBinding
+    });
+  }
+  async safeConnect(installation) {
+    try {
+      await this.deps.connectInstallation(installation);
+      return true;
+    } catch (error) {
+      this.deps.log?.warn("Channel installation connect failed", {
+        installationId: installation.id,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      return false;
+    }
+  }
+  async safeDisconnect(installation) {
+    try {
+      await this.deps.disconnectInstallation(installation);
+      return true;
+    } catch (error) {
+      this.deps.log?.warn("Channel installation disconnect failed", {
+        installationId: installation.id,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      return false;
+    }
+  }
+  async disconnectTracked() {
+    for (const [id, active] of [...this.active]) {
+      if (await this.safeDisconnect(active.installation)) this.active.delete(id);
+    }
+  }
 };
 
 // src/eval_lattice/LatticeEval.ts
@@ -41270,7 +41852,7 @@ function getCoordinationLeaseStore() {
 }
 
 // src/services/withLease.ts
-var import_node_crypto10 = require("crypto");
+var import_node_crypto11 = require("crypto");
 var LeaseAcquisitionTimeoutError = class extends Error {
   /**
    * @param key Lease key that could not be acquired.
@@ -41295,7 +41877,7 @@ async function withLease(store2, key5, ownerLabel, fn, options = {}) {
   const acquireTimeoutMs = options.acquireTimeoutMs ?? 1e4;
   const retryDelayMs = options.retryDelayMs ?? 50;
   const heartbeatMs = options.heartbeatMs ?? Math.max(1e3, Math.floor(ttlMs / 3));
-  const holder = `${ownerLabel}#${(0, import_node_crypto10.randomUUID)()}`;
+  const holder = `${ownerLabel}#${(0, import_node_crypto11.randomUUID)()}`;
   const deadline = Date.now() + acquireTimeoutMs;
   for (; ; ) {
     if (await store2.tryAcquire(key5, holder, ttlMs)) break;
@@ -42127,11 +42709,11 @@ function describe(error) {
 }
 
 // src/services/TaskLifecycleService.ts
-var import_node_crypto12 = require("crypto");
+var import_node_crypto13 = require("crypto");
 var import_protocols35 = require("@axiom-lattice/protocols");
 
 // src/middlewares/taskBelief.ts
-var import_node_crypto11 = require("crypto");
+var import_node_crypto12 = require("crypto");
 function buildBeliefCompletionEventKey(taskId, result, impacts) {
   const canonical = JSON.stringify({
     beliefImpact: impacts.map((impact) => ({
@@ -42142,7 +42724,7 @@ function buildBeliefCompletionEventKey(taskId, result, impacts) {
     })),
     result: result.trim()
   });
-  return (0, import_node_crypto11.createHash)("sha256").update(canonical).digest("hex");
+  return (0, import_node_crypto12.createHash)("sha256").update(canonical).digest("hex");
 }
 function buildCompletionEvidenceDetail(result, impacts, eventKey) {
   return { result, beliefImpact: impacts, eventKey };
@@ -42345,7 +42927,7 @@ function canonicalJson(value) {
   return JSON.stringify(value);
 }
 function sha256(value) {
-  return (0, import_node_crypto12.createHash)("sha256").update(canonicalJson(value)).digest("hex");
+  return (0, import_node_crypto13.createHash)("sha256").update(canonicalJson(value)).digest("hex");
 }
 function sameEvidenceDetail(detail, taskId, result, impacts, eventKey, beliefOwner) {
   const storedOwner = detail.beliefOwner;
@@ -44427,7 +45009,7 @@ function createTaskLifecycleService(deps) {
 }
 
 // src/services/TaskExecutionService.ts
-var import_node_crypto14 = require("crypto");
+var import_node_crypto15 = require("crypto");
 var import_node_util3 = require("util");
 var import_protocols36 = require("@axiom-lattice/protocols");
 
@@ -44783,13 +45365,13 @@ async function reconcileAllTenantTaskRuns(input) {
 }
 
 // src/services/taskRunLease.ts
-var import_node_crypto13 = require("crypto");
+var import_node_crypto14 = require("crypto");
 function taskRunLeaseKey(taskId) {
   return `task-run:${taskId}`;
 }
 async function tryAcquireTaskRun(input) {
   const key5 = taskRunLeaseKey(input.taskId);
-  const holder = `${input.owner}#${(0, import_node_crypto13.randomUUID)()}`;
+  const holder = `${input.owner}#${(0, import_node_crypto14.randomUUID)()}`;
   if (!await input.store.tryAcquire(key5, holder, input.ttlMs)) return null;
   const heartbeatMs = input.heartbeatMs ?? Math.max(1e3, Math.floor(input.ttlMs / 3));
   let released = false;
@@ -45209,11 +45791,11 @@ function createTaskExecutionService(deps) {
     let threadId;
     let runId;
     try {
-      threadId = storedThreadId ?? (deps.createThreadId ?? import_node_crypto14.randomUUID)();
+      threadId = storedThreadId ?? (deps.createThreadId ?? import_node_crypto15.randomUUID)();
       if (task.status === "interrupted" && reuseCurrentRun) {
         runId = storedRunId;
       } else if (task.status === "interrupted" || task.status === "failed") {
-        runId = (deps.createRunId ?? import_node_crypto14.randomUUID)();
+        runId = (deps.createRunId ?? import_node_crypto15.randomUUID)();
       }
     } catch (error) {
       return {
@@ -45493,11 +46075,11 @@ function createTaskExecutionService(deps) {
 }
 
 // src/services/leadership.ts
-var import_node_crypto15 = require("crypto");
+var import_node_crypto16 = require("crypto");
 async function runAsLeader(store2, name, fn, options = {}) {
   const key5 = `leader:${name}`;
   const owner3 = options.owner ?? getReplicaId();
-  const holder = `${owner3}#${(0, import_node_crypto15.randomUUID)()}`;
+  const holder = `${owner3}#${(0, import_node_crypto16.randomUUID)()}`;
   const ttlMs = options.ttlMs ?? 6e4;
   if (!await store2.tryAcquire(key5, holder, ttlMs)) return { ran: false };
   const heartbeat = setInterval(() => {
@@ -46746,16 +47328,16 @@ function createAskUserToClarifyTool() {
 }
 
 // src/middlewares/askUserClarifyMiddleware.ts
-function isRecord12(value) {
+function isRecord13(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function isProjectRoomRun(request) {
-  if (!isRecord12(request) || !isRecord12(request.runtime)) return false;
+  if (!isRecord13(request) || !isRecord13(request.runtime)) return false;
   const runtime = request.runtime;
-  const configurable = isRecord12(runtime.configurable) ? runtime.configurable.runConfig : void 0;
-  const context = isRecord12(runtime.context) ? runtime.context.runConfig : void 0;
-  const runConfig = isRecord12(configurable) ? configurable : isRecord12(context) ? context : void 0;
-  return isRecord12(runConfig?.projectRoom);
+  const configurable = isRecord13(runtime.configurable) ? runtime.configurable.runConfig : void 0;
+  const context = isRecord13(runtime.context) ? runtime.context.runConfig : void 0;
+  const runConfig = isRecord13(configurable) ? configurable : isRecord13(context) ? context : void 0;
+  return isRecord13(runConfig?.projectRoom);
 }
 function createAskUserClarifyMiddleware() {
   return (0, import_langchain76.createMiddleware)({
@@ -53339,11 +53921,14 @@ var sandboxPluginsPlugin = {
               }
               const toolDef = (parsedManifest.tools ?? []).find((t) => t.name === input.target?.name);
               if (!toolDef) return `tool "${input.target.name ?? ""}" not found`;
-              const runCfg = exeConfig?.configurable?.runConfig ?? {};
+              const runConfig = {
+                ...sandboxRunConfigFrom(exeConfig),
+                tenantId: tenantId2
+              };
               const resolved = input.target.connectionKey ? await resolveSandboxPluginConnections(
                 input.type,
                 { connections: [input.target.connectionKey] },
-                { tenantId: tenantId2 }
+                runConfig
               ) : {};
               const secrets = collectSecretValues(resolved.connection, connectionSecretFields(plugin));
               try {
@@ -53354,19 +53939,27 @@ var sandboxPluginsPlugin = {
                   connection: resolved.connection,
                   connections: resolved.connections,
                   context: { tenantId: tenantId2, pluginType: input.type, tool: toolDef.name },
-                  runConfig: {
-                    tenantId: tenantId2,
-                    assistantId: typeof runCfg.assistant_id === "string" ? runCfg.assistant_id : void 0
-                  }
+                  runConfig
                 });
                 const text = handlerResultText(redactSecretValues(result, secrets));
                 const ui = toolDef.ui;
                 if (!ui?.resource) return text;
+                const scope = result.ok && ui?.resource ? signMcpUiScope({
+                  tid: runConfig.tenantId || tenantId2,
+                  thid: runConfig.threadId,
+                  aid: runConfig.assistantId,
+                  wid: runConfig.workspaceId,
+                  pid: runConfig.projectId,
+                  plugin: input.type,
+                  resource: ui.resource,
+                  ck: resolved.connections?.[0]?.key
+                }) : void 0;
                 const uiRef = {
                   kind: "plugin",
                   pluginType: input.type,
                   resource: ui.resource,
-                  displayMode: ui.displayMode ?? "inline"
+                  displayMode: ui.displayMode ?? "inline",
+                  ...scope ? { scope } : {}
                 };
                 return appendUiFence(text, uiRef);
               } catch (err) {
@@ -54064,11 +54657,11 @@ var INLINE_INPUT_LIMIT_BYTES2 = 48 * 1024;
 var DEFAULT_HANDLER_TIMEOUT_MS = 6e4;
 var MIN_HANDLER_TIMEOUT_MS = 1e3;
 var MAX_HANDLER_TIMEOUT_MS = 3e5;
-function isRecord13(value) {
+function isRecord14(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function isEnvelope3(value) {
-  return isRecord13(value) && typeof value.ok === "boolean";
+  return isRecord14(value) && typeof value.ok === "boolean";
 }
 function parseHostArgs(argv) {
   let type;
@@ -54150,7 +54743,7 @@ function normalizeEnvelope(parsed) {
 }
 
 // src/sandbox_plugin/host/pluginHostSource.ts
-var import_node_crypto16 = require("crypto");
+var import_node_crypto17 = require("crypto");
 var PLUGIN_HOST_VERSION = "1.1.0";
 var PLUGIN_HOST_SERVER_SOURCE = String.raw`#!/usr/bin/env node
 "use strict";
@@ -54352,6 +54945,8 @@ async function runHandler(body) {
   var needsTempDir = inputIsLarge || connectionPayload !== null;
   var tempDir = null;
   var env = Object.assign({}, process.env);
+  // Handler processes must never inherit scope signing secrets.
+  delete env.MCP_UI_SCOPE_SECRET;
   try {
     if (needsTempDir) {
       tempDir = path.join(os.tmpdir(), "plugin-run-" + Date.now() + "-" + Math.random().toString(36).slice(2));
@@ -54443,7 +55038,7 @@ server.listen(config.port, "0.0.0.0", function () {
 });
 `;
 function pluginHostContentHash() {
-  return (0, import_node_crypto16.createHash)("sha256").update(`${PLUGIN_HOST_VERSION}:${PLUGIN_HOST_SERVER_SOURCE}`).digest("hex").slice(0, 16);
+  return (0, import_node_crypto17.createHash)("sha256").update(`${PLUGIN_HOST_VERSION}:${PLUGIN_HOST_SERVER_SOURCE}`).digest("hex").slice(0, 16);
 }
 
 // src/sandbox_plugin/host/pluginHostInstaller.ts
@@ -54857,16 +55452,16 @@ var IdRemapper = class {
 };
 
 // src/util/directRoomId.ts
-var import_node_crypto17 = require("crypto");
+var import_node_crypto18 = require("crypto");
 function generateDirectHumanProjectId(tenantId2, workspaceId, userId1, userId2) {
   const sortedUserIds = [userId1, userId2].sort();
   const parts = [tenantId2, workspaceId, ...sortedUserIds];
-  const hash = (0, import_node_crypto17.createHash)("sha256").update(parts.join(":")).digest("hex");
+  const hash = (0, import_node_crypto18.createHash)("sha256").update(parts.join(":")).digest("hex");
   return `direct_human_${hash}`;
 }
 function generateDirectBotProjectId(tenantId2, workspaceId, userId, assistantId) {
   const parts = [tenantId2, workspaceId, userId, assistantId];
-  const hash = (0, import_node_crypto17.createHash)("sha256").update(parts.join(":")).digest("hex");
+  const hash = (0, import_node_crypto18.createHash)("sha256").update(parts.join(":")).digest("hex");
   return `direct_bot_${hash}`;
 }
 function parseDirectRoomType(projectId) {
@@ -54998,6 +55593,9 @@ registerBuiltinPlugins();
   MicrosandboxServiceClient,
   ModelLatticeManager,
   MysqlDatabase,
+  ObservabilityDashboardUnavailableError,
+  ObservabilityDashboardUnsupportedError,
+  ObservabilityLatticeManager,
   OutboxPoller,
   PACK_DIRECTORY_TIMEOUT_MS,
   PLATFORM_SECRET_ENV_VARS,
@@ -55091,6 +55689,7 @@ registerBuiltinPlugins();
   buildTaskMutationFallback,
   buildTaskNormalizationFallback,
   canConvergeOrphan,
+  channelShardForInstallation,
   checkEmptyContent,
   chunkBufferStreamKey,
   clearEncryptionKeyCache,
@@ -55195,6 +55794,7 @@ registerBuiltinPlugins();
   getEncryptionKey,
   getEvalRunService,
   getLoggerLattice,
+  getMcpUiScopeSecret,
   getMenuRegistry,
   getModelLattice,
   getNextCronTime,
@@ -55263,6 +55863,7 @@ registerBuiltinPlugins();
   normalizeAgentInterrupts,
   normalizeAgentRunMessageIds,
   normalizeSandboxName,
+  observabilityLatticeManager,
   ownTaskResponseField,
   parallelLimit,
   parseCronExpression,
@@ -55303,6 +55904,7 @@ registerBuiltinPlugins();
   registerLoggerLattice,
   registerModelLattice,
   registerModelLatticeForTenant,
+  registerObservabilityLattice,
   registerQueueLattice,
   registerSTTModelLattice,
   registerSandboxOpenCredentialProvider,
@@ -55320,6 +55922,7 @@ registerBuiltinPlugins();
   resolveHandlerTimeoutMs,
   resolveJudgeModelKey,
   resolveModelLatticeForTenant,
+  resolveObservabilityCallbacks,
   resolvePath,
   resolvePluginConnections,
   resolveSandboxPluginConnections,
@@ -55340,11 +55943,13 @@ registerBuiltinPlugins();
   serializeTaskReadResponse,
   setAgentLifecycleTap,
   setBindingRegistry,
+  setDefaultObservabilityLattice,
   setEvalRunService,
   setMenuRegistry,
   setPluginDeploymentService,
   setRunCancelHeartbeatFallbackObserver,
   setSandboxPluginCatalog,
+  signMcpUiScope,
   skillLatticeManager,
   sqlDatabaseManager,
   storeLatticeManager,
@@ -55373,6 +55978,7 @@ registerBuiltinPlugins();
   validateToolInput,
   vectorStoreLatticeManager,
   vectorStoreProviderManager,
+  verifyMcpUiScope,
   withLease,
   withTimeout,
   wrapMcpToolWithUi