@axiom-lattice/gateway 7.0.0 → 8.0.0

package/dist/index.mjs

@@ -30,7 +30,7 @@ import {
 import {
   PluginToolScopeError,
   invokePluginTool
-} from "./chunk-MWWLJMYN.mjs";
+} from "./chunk-XUWD4VKY.mjs";
 import {
   buildPreviewTokenScript
 } from "./chunk-7CG57LEF.mjs";
@@ -2794,7 +2794,38 @@ async function threadOwnedBy(tenantId, assistantId, threadId) {
   try {
     const ledger = getStoreLattice5("default", "agentRun").store;
     const runs = await ledger.listRuns(tenantId, threadId, { limit: 1 });
-    return runs.some((run2) => run2.assistantId === assistantId);
+    if (runs.some((run2) => run2.assistantId === assistantId)) return true;
+  } catch {
+  }
+  try {
+    const tasks = getStoreLattice5("default", "task").store;
+    const matches = await tasks.list({ tenantId, threadId, limit: 1 });
+    return matches.some((task) => task.ownerType === "agent" && task.ownerId === assistantId);
+  } catch {
+    return false;
+  }
+}
+async function threadIsNewForTenant(tenantId, threadId) {
+  try {
+    const existing = await getStoreLattice5("default", "thread").store.getThreadById(
+      tenantId,
+      threadId
+    );
+    if (existing) return false;
+  } catch {
+    return false;
+  }
+  try {
+    const ledger = getStoreLattice5("default", "agentRun").store;
+    const runs = await ledger.listRuns(tenantId, threadId, { limit: 1 });
+    if (runs.length > 0) return false;
+  } catch {
+    return false;
+  }
+  try {
+    const tasks = getStoreLattice5("default", "task").store;
+    const matches = await tasks.list({ tenantId, threadId, limit: 1 });
+    return matches.length === 0;
   } catch {
     return false;
   }
@@ -2987,6 +3018,12 @@ var RUN_CREATE_UNAVAILABLE2 = "RUN_CREATE_UNAVAILABLE";
 var RUN_CREATE_LOCK_TIMEOUT = "RUN_CREATE_LOCK_TIMEOUT";
 var DEFAULT_WAIT_TIMEOUT_MS = 3e4;
 var DEFAULT_POLL_INTERVAL_MS = 200;
+function getUserId3(request) {
+  const userId = request.user?.id;
+  if (userId) return userId;
+  const header2 = request.headers["x-user-id"];
+  return typeof header2 === "string" && header2.length > 0 ? header2 : void 0;
+}
 var RUN_CREATE_LEASE = {
   ttlMs: 12e4,
   acquireTimeoutMs: 3e4,
@@ -3161,6 +3198,7 @@ function createRunLifecycleHandlers(deps = {}) {
   const resolveRouter = deps.getRunCancelRouter ?? getRunCancelRouter;
   const resolveLeaseStore = deps.getCoordinationLeaseStore ?? getConfiguredCoordinationLeaseStore;
   const ownsThread = deps.threadOwnedBy ?? threadOwnedBy;
+  const isNewThread = deps.threadIsNew ?? threadIsNewForTenant;
   const wake = deps.wakeRunTaskQueue ?? wakeRunTaskQueue;
   const idFactory = deps.idFactory ?? (() => v42());
   const waitTimeoutMs = deps.waitTimeoutMs ?? DEFAULT_WAIT_TIMEOUT_MS;
@@ -3243,7 +3281,9 @@ function createRunLifecycleHandlers(deps = {}) {
     const tenantId = getTenantId4(request);
     const { assistantId, threadId } = request.params;
     if (!await ownsThread(tenantId, assistantId, threadId)) {
-      return notFound2(reply, THREAD_NOT_FOUND2, "Thread not found");
+      if (!await isNewThread(tenantId, threadId)) {
+        return notFound2(reply, THREAD_NOT_FOUND2, "Thread not found");
+      }
     }
     const body = isRecord(request.body) ? request.body : {};
     const mode = body.mode;
@@ -3290,6 +3330,11 @@ function createRunLifecycleHandlers(deps = {}) {
     if (body.metadata !== void 0 && !isRecord(body.metadata)) {
       return invalidRequest(reply, "metadata must be an object");
     }
+    const userId = getUserId3(request);
+    const runConfig = userId ? {
+      ...isRecord(body.config) ? body.config : {},
+      user_id: userId
+    } : isRecord(body.config) ? body.config : void 0;
     const maxActiveRunsForTenant = resolveRunTaskMaxActivePerTenant();
     const createPending = async () => {
       let threadRuns;
@@ -3333,7 +3378,7 @@ function createRunLifecycleHandlers(deps = {}) {
           projectId: resolveAgentScope(request).project_id,
           input: input ?? null,
           command: command ?? null,
-          config: body.config ?? null,
+          config: runConfig ?? null,
           metadata: body.metadata ?? null,
           inputMessageIds: input ? extractAgentRunInputMessageIds2(input) : [],
           ...inheritedRevision === null ? {} : { capabilityRuntimeRevision: inheritedRevision },
@@ -4378,7 +4423,7 @@ async function handleConnection(socket, request) {
       socket.send(JSON.stringify(payload));
       return true;
     };
-    const sendError3 = (code, message, options = {}) => {
+    const sendError4 = (code, message, options = {}) => {
       send({
         type: "error",
         ...options.subscriptionId === void 0 ? {} : { subscription_id: options.subscriptionId },
@@ -4411,7 +4456,7 @@ async function handleConnection(socket, request) {
       } catch (error) {
         if (!subscription.closed && !closed) {
           const frame = mapThreadEventError(error);
-          sendError3(frame.code, frame.message, { subscriptionId: subscription.subscriptionId });
+          sendError4(frame.code, frame.message, { subscriptionId: subscription.subscriptionId });
         }
       } finally {
         await removeSubscription(subscription);
@@ -4419,7 +4464,7 @@ async function handleConnection(socket, request) {
     };
     const subscribe = (requestId, params) => {
       if (subscriptions.size >= MAX_SUBSCRIPTIONS) {
-        sendError3(
+        sendError4(
           "SUBSCRIPTION_LIMIT",
           `at most ${MAX_SUBSCRIPTIONS} subscriptions are allowed`,
           { requestId }
@@ -4428,12 +4473,12 @@ async function handleConnection(socket, request) {
       }
       const normalized = validateThreadEventFilters(params ?? {});
       if (normalized.error || !normalized.filters) {
-        sendError3("INVALID_SUBSCRIPTION", normalized.error ?? "invalid subscription params", { requestId });
+        sendError4("INVALID_SUBSCRIPTION", normalized.error ?? "invalid subscription params", { requestId });
         return;
       }
       const since = parseSinceCursor(isRecord4(params) ? params.since : void 0);
       if (since.error) {
-        sendError3("INVALID_SUBSCRIPTION", since.error, { requestId });
+        sendError4("INVALID_SUBSCRIPTION", since.error, { requestId });
         return;
       }
       const subscriptionId = randomUUID5();
@@ -4464,16 +4509,16 @@ async function handleConnection(socket, request) {
       try {
         message = JSON.parse(String(raw));
       } catch {
-        sendError3("INVALID_REQUEST", "message must be valid JSON");
+        sendError4("INVALID_REQUEST", "message must be valid JSON");
         return;
       }
       if (!isRecord4(message)) {
-        sendError3("INVALID_REQUEST", "message must be an object");
+        sendError4("INVALID_REQUEST", "message must be an object");
         return;
       }
       if (message.type === "subscription.subscribe") {
         if (typeof message.id !== "string" || message.id.length === 0) {
-          sendError3("INVALID_REQUEST", "subscription id is required");
+          sendError4("INVALID_REQUEST", "subscription id is required");
           return;
         }
         subscribe(message.id, message.params);
@@ -4481,13 +4526,13 @@ async function handleConnection(socket, request) {
       }
       if (message.type === "subscription.unsubscribe") {
         if (typeof message.id !== "string" || message.id.length === 0) {
-          sendError3("INVALID_REQUEST", "subscription id is required");
+          sendError4("INVALID_REQUEST", "subscription id is required");
           return;
         }
         unsubscribe(message.id);
         return;
       }
-      sendError3("UNKNOWN_MESSAGE_TYPE", "unknown message type");
+      sendError4("UNKNOWN_MESSAGE_TYPE", "unknown message type");
     };
     cleanup = () => {
       if (closed) return;
@@ -4864,6 +4909,16 @@ function getTenantId7(request) {
   const header2 = request.headers["x-tenant-id"];
   return typeof header2 === "string" && header2.length > 0 ? header2 : "default";
 }
+function getUserId4(request) {
+  const userId = request.user?.id;
+  if (userId) return userId;
+  const header2 = request.headers["x-user-id"];
+  return typeof header2 === "string" && header2.length > 0 ? header2 : void 0;
+}
+function withUserId(config, userId) {
+  if (!userId) return config;
+  return { ...config ?? {}, user_id: userId };
+}
 function headerValue3(request, name) {
   const value = request.headers[name];
   return typeof value === "string" ? value : void 0;
@@ -4937,7 +4992,10 @@ async function executeThreadCommand(request, reply) {
       }
       const mode = parseMode(args.multitask_strategy);
       if (!mode) return badRequest2(reply, "invalid multitask_strategy");
-      const customRunConfig = args.config === void 0 ? void 0 : args.config;
+      const customRunConfig = withUserId(
+        args.config === void 0 ? void 0 : args.config,
+        getUserId4(request)
+      );
       const agent2 = agentInstanceManager6.getAgent({
         assistant_id: thread.assistantId,
         thread_id: threadId,
@@ -4992,6 +5050,10 @@ async function executeThreadCommand(request, reply) {
           );
         }
       };
+      const customRunConfig = withUserId(
+        args.config === void 0 ? void 0 : args.config,
+        getUserId4(request)
+      );
       try {
         const agent2 = agentInstanceManager6.getAgent({
           assistant_id: thread.assistantId,
@@ -4999,7 +5061,7 @@ async function executeThreadCommand(request, reply) {
           tenant_id: tenantId,
           workspace_id: workspaceId,
           project_id: projectId,
-          custom_run_config: args.config
+          custom_run_config: customRunConfig
         });
         let interrupt;
         try {
@@ -5033,7 +5095,7 @@ async function executeThreadCommand(request, reply) {
             input: { id: messageId, message: answerText },
             command: resume.command,
             expected_interrupt_id: interruptId,
-            ...args.config === void 0 ? {} : { custom_run_config: args.config }
+            ...customRunConfig === void 0 ? {} : { custom_run_config: customRunConfig }
           }, QueueMode2.FOLLOWUP);
         } catch (error) {
           await releaseReservation();
@@ -5511,7 +5573,12 @@ function readCronMetadata(metadata) {
   const cron = isRecord7(metadata) && isRecord7(metadata.cron) ? metadata.cron : {};
   const multitaskStrategy = cron.multitaskStrategy === "interrupt" ? "interrupt" : "enqueue";
   const onRunCompleted = cron.onRunCompleted === "delete" ? "delete" : "keep";
-  return { multitaskStrategy, onRunCompleted };
+  return {
+    multitaskStrategy,
+    onRunCompleted,
+    ...typeof cron.workspaceId === "string" && cron.workspaceId.length > 0 ? { workspaceId: cron.workspaceId } : {},
+    ...typeof cron.projectId === "string" && cron.projectId.length > 0 ? { projectId: cron.projectId } : {}
+  };
 }
 function queueModeFor(strategy) {
   return strategy === "interrupt" ? QueueMode3.STEER : QueueMode3.FOLLOWUP;
@@ -5597,6 +5664,10 @@ function createAgentCronHandler(deps) {
     const parts = payloadParts(payload);
     const cron = readCronMetadata(taskInfo.metadata);
     const mode = queueModeFor(cron.multitaskStrategy);
+    const scope = {
+      ...cron.workspaceId === void 0 ? {} : { workspace_id: cron.workspaceId },
+      ...cron.projectId === void 0 ? {} : { project_id: cron.projectId }
+    };
     let threadId = taskInfo.threadId;
     let createdThreadId;
     try {
@@ -5605,18 +5676,25 @@ function createAgentCronHandler(deps) {
         agent = deps.getAgent({
           tenant_id: taskInfo.tenantId,
           assistant_id: assistantId,
-          thread_id: threadId
+          thread_id: threadId,
+          ...scope
         });
       } else {
         createdThreadId = idFactory();
         threadId = createdThreadId;
         await deps.createThread(taskInfo.tenantId, assistantId, threadId, {
-          metadata: { tenantId: taskInfo.tenantId, cronId: taskInfo.taskId }
+          metadata: {
+            tenantId: taskInfo.tenantId,
+            cronId: taskInfo.taskId,
+            ...cron.workspaceId === void 0 ? {} : { workspaceId: cron.workspaceId },
+            ...cron.projectId === void 0 ? {} : { projectId: cron.projectId }
+          }
         });
         agent = deps.getAgent({
           tenant_id: taskInfo.tenantId,
           assistant_id: assistantId,
-          thread_id: threadId
+          thread_id: threadId,
+          ...scope
         });
         if (cron.onRunCompleted === "delete") {
           const cleanupThreadId = threadId;
@@ -5685,6 +5763,8 @@ function toDto(task) {
     cron_id: task.taskId,
     ...task.threadId === void 0 ? {} : { thread_id: task.threadId },
     assistant_id: task.assistantId ?? "",
+    ...cron.workspaceId === void 0 ? {} : { workspace_id: cron.workspaceId },
+    ...cron.projectId === void 0 ? {} : { project_id: cron.projectId },
     schedule: task.cronExpression ?? "",
     timezone: task.timezone ?? "UTC",
     ...task.expiresAt === void 0 ? {} : { end_time: new Date(task.expiresAt).toISOString() },
@@ -5712,6 +5792,70 @@ function failure2(request, reply, error) {
   request.log.error({ err: error }, "agent cron operation failed");
   return reply.status(500).send({ success: false, error: "Agent cron operation failed" });
 }
+function parseScopeId(value) {
+  if (value === void 0 || value === null) return void 0;
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  return trimmed.length === 0 ? void 0 : trimmed;
+}
+async function resolveCronScope(body, tenantId) {
+  const projectId = parseScopeId(body.project_id);
+  if (projectId === null) {
+    return { ok: false, status: 400, error: "project_id must be a string" };
+  }
+  const workspaceId = parseScopeId(body.workspace_id);
+  if (workspaceId === null) {
+    return { ok: false, status: 400, error: "workspace_id must be a string" };
+  }
+  if (projectId !== void 0) {
+    try {
+      const projectStore = getStoreLattice10("default", "project").store;
+      const project = await projectStore.getProjectById(tenantId, projectId);
+      if (!project || project.tenantId !== tenantId) {
+        return { ok: false, status: 404, error: "Project not found" };
+      }
+      if (workspaceId !== void 0 && workspaceId !== project.workspaceId) {
+        return {
+          ok: false,
+          status: 400,
+          error: "project_id does not belong to workspace_id"
+        };
+      }
+      return {
+        ok: true,
+        scope: {
+          projectId,
+          ...project.workspaceId ? { workspaceId: project.workspaceId } : workspaceId === void 0 ? {} : { workspaceId }
+        }
+      };
+    } catch {
+      return { ok: false, status: 404, error: "Project not found" };
+    }
+  }
+  if (workspaceId !== void 0) {
+    try {
+      const workspaceStore = getStoreLattice10("default", "workspace").store;
+      const workspace = await workspaceStore.getWorkspaceById(tenantId, workspaceId);
+      if (!workspace || workspace.tenantId !== tenantId) {
+        return { ok: false, status: 404, error: "Workspace not found" };
+      }
+      return { ok: true, scope: { workspaceId } };
+    } catch {
+      return { ok: false, status: 404, error: "Workspace not found" };
+    }
+  }
+  return { ok: true, scope: {} };
+}
+function cronMetadata(strategy, scope, completion) {
+  return {
+    cron: {
+      multitaskStrategy: strategy,
+      ...completion === void 0 ? {} : { onRunCompleted: completion },
+      ...scope.workspaceId === void 0 ? {} : { workspaceId: scope.workspaceId },
+      ...scope.projectId === void 0 ? {} : { projectId: scope.projectId }
+    }
+  };
+}
 function validCron(value) {
   if (typeof value !== "string" || value.trim() === "") return void 0;
   try {
@@ -5780,6 +5924,13 @@ async function createThreadCron(request, reply) {
     return badRequest4(reply, "enabled must be a boolean");
   }
   const tenantId = getTenantId10(request);
+  const scopeResolution = await resolveCronScope(body, tenantId);
+  if (!scopeResolution.ok) {
+    return reply.status(scopeResolution.status).send({
+      success: false,
+      error: scopeResolution.error
+    });
+  }
   let thread;
   try {
     thread = await getStoreLattice10("default", "thread").store.getThreadById(
@@ -5802,7 +5953,7 @@ async function createThreadCron(request, reply) {
       tenantId,
       assistantId: thread.assistantId,
       threadId: thread.id,
-      metadata: { cron: { multitaskStrategy: strategy } }
+      metadata: cronMetadata(strategy, scopeResolution.scope)
     });
     if (!scheduled) return failure2(request, reply, new Error("scheduleCron rejected the task"));
     if (body.enabled === false) {
@@ -5857,6 +6008,13 @@ async function createStatelessCron(request, reply) {
   } catch (error) {
     return failure2(request, reply, error);
   }
+  const scopeResolution = await resolveCronScope(body, tenantId);
+  if (!scopeResolution.ok) {
+    return reply.status(scopeResolution.status).send({
+      success: false,
+      error: scopeResolution.error
+    });
+  }
   const lattice = schedule();
   if (!lattice || !storageOf(lattice)) return unavailable2(reply);
   const cronId = randomUUID10();
@@ -5868,7 +6026,7 @@ async function createStatelessCron(request, reply) {
       maxRetries: 2,
       tenantId,
       assistantId: body.assistant_id,
-      metadata: { cron: { multitaskStrategy: strategy, onRunCompleted: completion } }
+      metadata: cronMetadata(strategy, scopeResolution.scope, completion)
     });
     if (!scheduled) return failure2(request, reply, new Error("scheduleCron rejected the task"));
     if (body.enabled === false) {
@@ -6376,9 +6534,10 @@ function isSharedStore(kind) {
 }
 function computeMultiReplicaReadiness() {
   const multiReplicaDeclared = isMultiReplicaDeclared();
+  const strict = process.env.AXIOM_READINESS_STRICT === "true";
   const warnings = [];
   if (!multiReplicaDeclared) {
-    return { multiReplicaDeclared, ok: true, warnings };
+    return { multiReplicaDeclared, ok: true, strict, blocking: false, warnings };
   }
   for (const kind of SHARED_STORE_KINDS) {
     const name = storeClassName(kind);
@@ -6424,16 +6583,35 @@ function computeMultiReplicaReadiness() {
       );
     }
   }
-  return { multiReplicaDeclared, ok: warnings.length === 0, warnings };
+  const ok = warnings.length === 0;
+  return {
+    multiReplicaDeclared,
+    ok,
+    strict,
+    blocking: strict && multiReplicaDeclared && !ok,
+    warnings
+  };
 }
-function warnMultiReplicaReadiness(logger8) {
+var MultiReplicaReadinessError = class extends Error {
+  constructor(warnings) {
+    super(`Multi-replica readiness blocked startup: ${warnings.join(" | ")}`);
+    this.warnings = warnings;
+    this.code = "MULTI_REPLICA_READINESS_BLOCKED";
+    this.name = "MultiReplicaReadinessError";
+  }
+};
+function assertMultiReplicaReadiness() {
+  const { blocking, warnings } = computeMultiReplicaReadiness();
+  if (blocking) throw new MultiReplicaReadinessError(warnings);
+}
+function warnMultiReplicaReadiness(logger9) {
   const { multiReplicaDeclared, warnings } = computeMultiReplicaReadiness();
   if (!multiReplicaDeclared) return;
   for (const message of warnings) {
-    logger8.warn(message, { phase: "multi_replica_readiness" });
+    logger9.warn(message, { phase: "multi_replica_readiness" });
   }
   if (process.env.CHUNK_SOURCE?.trim() !== "redis") {
-    logger8.warn(
+    logger9.warn(
       "Multi-replica: CHUNK_SOURCE is not 'redis'; agent run SSE and resume_stream are process-local and require thread affinity/sticky routing (set CHUNK_SOURCE=redis with REDIS_URL to share streams)",
       { phase: "multi_replica_readiness", feature: "agent-run-sse" }
     );
@@ -6527,6 +6705,159 @@ async function getInfo(request, reply) {
   }
 }
 
+// src/controllers/observability.ts
+import {
+  ObservabilityDashboardUnavailableError,
+  ObservabilityDashboardUnsupportedError,
+  ObservabilityLatticeManager
+} from "@axiom-lattice/core";
+
+// src/controllers/tenant-scope.ts
+var TenantScopeError = class extends Error {
+  /** Creates a tenant scope error. */
+  constructor(code, statusCode, message) {
+    super(message);
+    this.code = code;
+    this.statusCode = statusCode;
+    this.name = "TenantScopeError";
+  }
+};
+function resolveTenantScope(request, authRequired2) {
+  const authenticated = request.user?.tenantId;
+  const header2 = request.headers["x-tenant-id"];
+  const requested = Array.isArray(header2) ? header2[0] : header2;
+  if (authenticated) {
+    if (requested && requested !== authenticated) {
+      throw new TenantScopeError(
+        "TENANT_ACCESS_DENIED",
+        403,
+        "Tenant access denied"
+      );
+    }
+    return { tenantId: authenticated, userId: request.user?.id };
+  }
+  if (authRequired2) {
+    throw new TenantScopeError(
+      "UNAUTHENTICATED",
+      401,
+      "Console session required"
+    );
+  }
+  return { tenantId: requested || "default" };
+}
+
+// src/controllers/observability.ts
+var logger = new Logger({ serviceName: "lattice/gateway/observability" });
+var DASHBOARD_RANGES = /* @__PURE__ */ new Set([
+  "1h",
+  "24h",
+  "7d",
+  "30d"
+]);
+function buildObservabilityInfo(manager = ObservabilityLatticeManager.getInstance()) {
+  const provider = manager.getDefault();
+  if (!provider) return { enabled: false, dashboard: false };
+  const url = provider.getTraceListUrl?.();
+  return {
+    enabled: true,
+    dashboard: typeof provider.getDashboard === "function",
+    provider: provider.type,
+    ...url ? { url } : {}
+  };
+}
+async function getObservability(_request, reply) {
+  return reply.send({ success: true, data: buildObservabilityInfo() });
+}
+function sendError(reply, status, code, message) {
+  return reply.status(status).send({
+    success: false,
+    error: { code, message, retryable: false }
+  });
+}
+async function getObservabilityDashboard(request, reply) {
+  const provider = ObservabilityLatticeManager.getInstance().getDefault();
+  if (!provider) {
+    return sendError(
+      reply,
+      404,
+      "OBSERVABILITY_DISABLED",
+      "Observability is not enabled"
+    );
+  }
+  if (typeof provider.getDashboard !== "function") {
+    return sendError(
+      reply,
+      501,
+      "OBSERVABILITY_DASHBOARD_UNSUPPORTED",
+      "Dashboard is not supported by this provider"
+    );
+  }
+  const range = request.query.range ?? "24h";
+  if (!DASHBOARD_RANGES.has(range)) {
+    return sendError(reply, 400, "INVALID_RANGE", "Invalid dashboard range");
+  }
+  let tenantId;
+  try {
+    tenantId = resolveTenantScope(
+      request,
+      process.env.AUTH_REQUIRED === "true"
+    ).tenantId;
+  } catch (error) {
+    if (error instanceof TenantScopeError) {
+      return sendError(reply, error.statusCode, error.code, error.message);
+    }
+    return sendError(
+      reply,
+      401,
+      "UNAUTHENTICATED",
+      "Console session required"
+    );
+  }
+  try {
+    const result = await provider.getDashboard({
+      range,
+      tenantId
+    });
+    return reply.send({
+      success: true,
+      data: {
+        provider: provider.type,
+        range,
+        generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        version: result.version,
+        ...result.warnings ? { warnings: result.warnings } : {},
+        payload: result.payload
+      }
+    });
+  } catch (error) {
+    if (error instanceof ObservabilityDashboardUnsupportedError) {
+      return sendError(
+        reply,
+        501,
+        "OBSERVABILITY_DASHBOARD_UNSUPPORTED",
+        error.message
+      );
+    }
+    if (error instanceof ObservabilityDashboardUnavailableError) {
+      return sendError(
+        reply,
+        502,
+        "OBSERVABILITY_DASHBOARD_UNAVAILABLE",
+        error.message
+      );
+    }
+    logger.warn("observability dashboard failed", {
+      error: error instanceof Error ? error.message : String(error)
+    });
+    return sendError(
+      reply,
+      502,
+      "OBSERVABILITY_DASHBOARD_FAILED",
+      "Failed to load dashboard"
+    );
+  }
+}
+
 // src/controllers/system-metrics.ts
 import {
   getReplicaId as getReplicaId4,
@@ -7874,8 +8205,92 @@ async function executeSqlQuery(client, body, reply) {
 }
 
 // src/controllers/workflow-tracking.ts
-import { getStoreLattice as getStoreLattice14, agentInstanceManager as agentInstanceManager7, ThreadStatus as ThreadStatus2, abortWorkflowRun as signalAbort } from "@axiom-lattice/core";
-import { MessageChunkTypes as MessageChunkTypes3 } from "@axiom-lattice/protocols";
+import {
+  getStoreLattice as getStoreLattice14,
+  agentInstanceManager as agentInstanceManager7,
+  ThreadStatus as ThreadStatus2,
+  abortWorkflowRun as signalAbort
+} from "@axiom-lattice/core";
+
+// src/router/roomInterrupt.ts
+var CLARIFY_FENCE = /^```clarify\n([\s\S]*?)\n```$/;
+function readClarifyValue(value) {
+  if (typeof value !== "string") return void 0;
+  const match = CLARIFY_FENCE.exec(value.trim());
+  if (!match) return void 0;
+  try {
+    const parsed = JSON.parse(match[1]);
+    if (typeof parsed === "object" && parsed !== null && Array.isArray(parsed.questions)) {
+      return parsed;
+    }
+  } catch {
+  }
+  return void 0;
+}
+function rawInterruptId(interrupt, taskId, taskIndex, index) {
+  const record = typeof interrupt === "object" && interrupt !== null ? interrupt : void 0;
+  const rawId = record?.id;
+  if (typeof rawId === "string" || typeof rawId === "number") return String(rawId);
+  return `${taskId ?? `task-${taskIndex}`}:${index}`;
+}
+function pendingInterrupts(state) {
+  if (typeof state !== "object" || state === null) return [];
+  const tasks = state.tasks;
+  if (!Array.isArray(tasks)) return [];
+  const result = [];
+  tasks.forEach((task, taskIndex) => {
+    const record = typeof task === "object" && task !== null ? task : void 0;
+    const rawTaskId = record?.id;
+    const taskId = typeof rawTaskId === "string" || typeof rawTaskId === "number" ? String(rawTaskId) : void 0;
+    const interrupts = record?.interrupts;
+    if (!Array.isArray(interrupts)) return;
+    interrupts.forEach((interrupt, index) => {
+      const value = typeof interrupt === "object" && interrupt !== null ? interrupt.value : void 0;
+      const clarify = readClarifyValue(value);
+      result.push({
+        interruptId: rawInterruptId(interrupt, taskId, taskIndex, index),
+        ...clarify === void 0 ? {} : { clarify }
+      });
+    });
+  });
+  return result;
+}
+function readPendingInterruptTarget(state) {
+  const interrupts = pendingInterrupts(state);
+  if (interrupts.length === 0) return void 0;
+  const ids = new Set(interrupts.map((interrupt) => interrupt.interruptId));
+  if (ids.size !== interrupts.length) return { conflict: true };
+  const clarify = interrupts.find((interrupt) => interrupt.clarify !== void 0);
+  if (clarify !== void 0) {
+    if (!isOfficialInterruptId(clarify.interruptId) && interrupts.length > 1) return { conflict: true };
+    return { target: clarify };
+  }
+  return interrupts.length === 1 ? { target: interrupts[0] } : { conflict: true };
+}
+function readExplicitInterruptTarget(state, interruptId) {
+  const interrupts = pendingInterrupts(state);
+  const matches = interrupts.filter((interrupt) => interrupt.interruptId === interruptId);
+  if (matches.length > 1) return { conflict: true };
+  const target = matches[0];
+  if (target === void 0) return void 0;
+  if (!isOfficialInterruptId(interruptId) && interrupts.length > 1) return { conflict: true };
+  return { target };
+}
+function readClarifyInterruptTarget(state) {
+  const match = readPendingInterruptTarget(state);
+  return match !== void 0 && !("conflict" in match) && match.target.clarify !== void 0 ? match.target : void 0;
+}
+function readClarifyInterrupt(state) {
+  return pendingInterrupts(state).find((interrupt) => interrupt.clarify !== void 0)?.clarify;
+}
+function buildClarifyResumeCommand(text, interruptId) {
+  return resumeMap(interruptId, { data: { answers: [{ questionIndex: 0, otherText: text }] } });
+}
+function buildClarifySkipCommand(interruptId) {
+  return resumeMap(interruptId, { data: { answers: [] } });
+}
+
+// src/controllers/workflow-tracking.ts
 function getTenantId14(request) {
   const userTenantId = request.user?.tenantId;
   if (userTenantId) return userTenantId;
@@ -8202,19 +8617,19 @@ async function deleteWorkflowRun(request, reply) {
       return reply.status(404).send({ success: false, message: "Workflow run not found" });
     }
     if (run2.status === "running") {
-      try {
-        const workspace_id = request.headers["x-workspace-id"];
-        const project_id = request.headers["x-project-id"];
-        const agent = agentInstanceManager7.getAgent({
-          assistant_id: run2.assistantId,
-          thread_id: run2.threadId,
-          tenant_id: tenantId,
-          workspace_id,
-          project_id
+      const result = await requestWorkflowCancel(request, tenantId, run2);
+      if (result === "unavailable") {
+        return reply.status(503).send({
+          success: false,
+          message: "Workflow cancellation is unavailable on this replica"
         });
-        await agent.abort();
-      } catch (err) {
-        request.log.warn({ runId, error: err.message }, "Failed to abort agent, deleting tracking records anyway");
+      }
+      if (result === "accepted" || result === "not_found") {
+        await store2.updateWorkflowRun(runId, {
+          status: "cancelled",
+          errorMessage: "Deleted by user",
+          completedAt: /* @__PURE__ */ new Date()
+        }).catch(() => void 0);
       }
     }
     await store2.deleteWorkflowRun(runId);
@@ -8307,29 +8722,62 @@ async function replyInboxTask(request, reply) {
         data: { runId: run2.id, assistantId: run2.assistantId, threadId: run2.threadId, status: runStatus }
       });
     }
-    agent.addMessage({
-      input: { message: "Clarification answers submitted" },
-      command: {
-        resume: {
-          action: "submit",
-          data: { answers },
-          message: "Clarification answers submitted"
-        }
+    const currentState = await agent.getCurrentState();
+    const interruptMatch = readPendingInterruptTarget(currentState);
+    if (!interruptMatch || "conflict" in interruptMatch) {
+      return reply.status(409).send({
+        success: false,
+        message: "Cannot resume: pending interrupt is missing or ambiguous",
+        data: { runId: run2.id, assistantId: run2.assistantId, threadId: run2.threadId }
+      });
+    }
+    const interruptTarget = interruptMatch.target;
+    const resume = interruptTarget.clarify ? clarifyResume({ answers }, interruptTarget.interruptId) : {
+      command: resumeMap(interruptTarget.interruptId, {
+        action: "submit",
+        data: { answers },
+        message: "Clarification answers submitted"
+      })
+    };
+    if (!resume.command) {
+      return reply.status(400).send({
+        success: false,
+        message: "error" in resume ? resume.error ?? "Invalid resume answers" : "Invalid resume answers"
+      });
+    }
+    let queuedStatus = 200;
+    let runPayload;
+    const syntheticReply = {
+      status(code) {
+        queuedStatus = code;
+        return this;
+      },
+      send(payload) {
+        runPayload = payload;
+        return this;
+      },
+      header() {
+        return this;
       }
-    }).then((result) => {
-      const stream = agent.chunkStream(
-        result.messageId,
-        [MessageChunkTypes3.MESSAGE_COMPLETED]
-      );
-      (async () => {
-        for await (const _ of stream) {
+    };
+    await createRun(
+      {
+        ...request,
+        body: {
+          assistant_id: run2.assistantId,
+          thread_id: run2.threadId,
+          background: true,
+          command: resume.command
         }
-      })().catch((error) => {
-        request.log.error(error, "Background chunk stream error");
+      },
+      syntheticReply
+    );
+    if (queuedStatus >= 400) {
+      return reply.status(queuedStatus).send(runPayload ?? {
+        success: false,
+        message: "Failed to enqueue workflow resume"
       });
-    }).catch((error) => {
-      request.log.error(error, "Background resume failed");
-    });
+    }
     return reply.status(200).send({
       success: true,
       message: "Resume request submitted successfully",
@@ -8348,6 +8796,60 @@ async function replyInboxTask(request, reply) {
     });
   }
 }
+async function requestWorkflowCancel(request, tenantId, run2) {
+  let agentRun;
+  try {
+    const ledger = getStoreLattice14("default", "agentRun").store;
+    agentRun = await ledger.findRunning(tenantId, run2.threadId);
+  } catch {
+  }
+  if (agentRun) {
+    const router = getRunCancelRouter();
+    if (router) {
+      try {
+        const result = await router.requestCancelById({
+          tenantId,
+          assistantId: run2.assistantId,
+          threadId: run2.threadId,
+          runId: agentRun.runId,
+          reason: "abort"
+        });
+        if (result === "not_found") return "not_found";
+        if (result === "terminal") return "terminal";
+        signalAbort(run2.id);
+        return "accepted";
+      } catch {
+        return "unavailable";
+      }
+    }
+    try {
+      const ledger = getStoreLattice14("default", "agentRun").store;
+      const result = await ledger.requestCancel(tenantId, agentRun.runId);
+      if (result === "not_found") return "not_found";
+      if (result === "terminal") return "terminal";
+      signalAbort(run2.id);
+      return "accepted";
+    } catch {
+      return "unavailable";
+    }
+  }
+  try {
+    const workspace_id = request.headers["x-workspace-id"];
+    const project_id = request.headers["x-project-id"];
+    const agent = agentInstanceManager7.getAgent({
+      assistant_id: run2.assistantId,
+      thread_id: run2.threadId,
+      tenant_id: tenantId,
+      workspace_id,
+      project_id
+    });
+    await agent.abort();
+    signalAbort(run2.id);
+    return "accepted";
+  } catch {
+    return "unavailable";
+  }
+}
 async function abortWorkflowRun(request, reply) {
   try {
     const { runId } = request.params;
@@ -8366,23 +8868,24 @@ async function abortWorkflowRun(request, reply) {
         message: "Workflow run not found"
       });
     }
+    const result = await requestWorkflowCancel(request, tenantId, run2);
+    if (result === "not_found" || result === "terminal") {
+      return reply.status(409).send({
+        success: false,
+        message: result === "terminal" ? "Workflow run is already finished" : "Workflow run is not running"
+      });
+    }
+    if (result === "unavailable") {
+      return reply.status(503).send({
+        success: false,
+        message: "Workflow cancellation is unavailable on this replica"
+      });
+    }
     await store2.updateWorkflowRun(runId, {
       status: "cancelled",
       errorMessage: "Aborted by user",
       completedAt: /* @__PURE__ */ new Date()
-    }).catch(() => {
-    });
-    const workspace_id = request.headers["x-workspace-id"];
-    const project_id = request.headers["x-project-id"];
-    const agent = agentInstanceManager7.getAgent({
-      assistant_id: run2.assistantId,
-      thread_id: run2.threadId,
-      tenant_id: tenantId,
-      workspace_id,
-      project_id
-    });
-    await agent.abort();
-    signalAbort(runId);
+    }).catch(() => void 0);
     return reply.status(200).send({
       success: true,
       message: "Workflow aborted",
@@ -8408,7 +8911,7 @@ function getTenantId15(request) {
   if (userTenantId) return userTenantId;
   return request.headers["x-tenant-id"] || "default";
 }
-function getUserId3(request) {
+function getUserId5(request) {
   const userId = request.user?.id || request.headers["x-user-id"];
   if (!userId) throw new Error("User ID is required");
   return userId;
@@ -8431,7 +8934,7 @@ async function updateLinkMeta(userId, tenantId, meta) {
 }
 async function createPersonalAssistant(request, reply) {
   const tenantId = getTenantId15(request);
-  const userId = getUserId3(request);
+  const userId = getUserId5(request);
   const { name, personality } = request.body;
   if (!name || !personality) {
     return reply.status(400).send({ success: false, message: "name and personality are required" });
@@ -8468,7 +8971,7 @@ async function createPersonalAssistant(request, reply) {
 }
 async function getPersonalAssistant(request, reply) {
   const tenantId = getTenantId15(request);
-  const userId = getUserId3(request);
+  const userId = getUserId5(request);
   const store2 = getAssistantStore();
   const assistant = await store2.getByOwner(tenantId, userId);
   if (!assistant) {
@@ -8485,7 +8988,7 @@ async function getPersonalAssistant(request, reply) {
 }
 async function deletePersonalAssistant(request, reply) {
   const tenantId = getTenantId15(request);
-  const userId = getUserId3(request);
+  const userId = getUserId5(request);
   const store2 = getAssistantStore();
   const assistant = await store2.getByOwner(tenantId, userId);
   if (!assistant) {
@@ -9162,7 +9665,7 @@ var ExportImportService = class {
 // src/controllers/export-import.ts
 import { ExportableEntityRegistry as ExportableEntityRegistry2 } from "@axiom-lattice/core";
 var service = new ExportImportService();
-var TenantScopeError = class extends Error {
+var TenantScopeError2 = class extends Error {
   constructor() {
     super(...arguments);
     this.statusCode = 403;
@@ -9174,12 +9677,12 @@ function resolveTenantId(request, routeTenantId) {
   const headerTenantId = Array.isArray(header2) ? header2[0] : header2;
   if (authenticatedTenantId) {
     if (headerTenantId && headerTenantId !== authenticatedTenantId) {
-      throw new TenantScopeError(
+      throw new TenantScopeError2(
         `Tenant scope mismatch: header tenant "${headerTenantId}" does not match authenticated tenant "${authenticatedTenantId}"`
       );
     }
     if (routeTenantId && routeTenantId !== authenticatedTenantId) {
-      throw new TenantScopeError(
+      throw new TenantScopeError2(
         `Tenant scope mismatch: route tenant "${routeTenantId}" does not match authenticated tenant "${authenticatedTenantId}"`
       );
     }
@@ -13033,7 +13536,9 @@ import {
 } from "@axiom-lattice/protocols";
 import {
   getSandboxPluginCatalog as getSandboxPluginCatalog2,
-  mcpManager as mcpManager2
+  mcpManager as mcpManager2,
+  resolvePluginConnections,
+  verifyMcpUiScope
 } from "@axiom-lattice/core";
 
 // src/services/mcp-ui/UiResourceResolver.ts
@@ -13303,6 +13808,22 @@ var PluginMethodNotSupportedError = class extends Error {
     this.name = "PluginMethodNotSupportedError";
   }
 };
+var McpAppScopeError = class extends Error {
+  /**
+   * @param status - HTTP status to return.
+   * @param code - Stable machine-readable denial code.
+   */
+  constructor(status, code) {
+    super(code);
+    this.status = status;
+    this.code = code;
+    this.name = "McpAppScopeError";
+  }
+};
+function denyScope(status, code, detail) {
+  console.warn(JSON.stringify({ event: "mcp-apps:scope-denied", ...detail, code }));
+  return new McpAppScopeError(status, code);
+}
 var ALLOWED_METHODS = /* @__PURE__ */ new Set(["tools/call", "tools/list", "resources/read"]);
 function asRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
@@ -13369,6 +13890,9 @@ function makeMcpAppHandlers(deps) {
         }
         return { status: 200, body: { tools: await deps.listTools(tenantId, ref) } };
       } catch (error) {
+        if (error instanceof McpAppScopeError) {
+          return { status: error.status, body: { error: error.code } };
+        }
         if (error instanceof PluginToolScopeError) {
           return { status: 403, body: { error: "PLUGIN_TOOL_SCOPE" } };
         }
@@ -13412,8 +13936,84 @@ async function fetchPluginUiResource(backend, tenantId, pluginType, resource) {
     prefersBorder: tool.ui.prefersBorder
   };
 }
-async function callPluginTool(backend, tenantId, ref, name, args, context) {
-  return invokePluginTool(backend, tenantId, ref.pluginType, name, args, context);
+async function callPluginTool(backend, tenantId, ref, name, args, context, deps) {
+  const scope = ref.scope ? (deps?.verifyScope ?? verifyMcpUiScope)(ref.scope) : null;
+  if (ref.scope && !scope) {
+    throw denyScope(403, "SCOPE_INVALID", {
+      tenantId,
+      pluginType: ref.pluginType,
+      tool: name
+    });
+  }
+  if (scope) {
+    const mismatched = scope.tid !== tenantId || scope.plugin !== ref.pluginType || scope.resource !== ref.resource;
+    if (mismatched) {
+      throw denyScope(403, "SCOPE_MISMATCH", {
+        tenantId,
+        pluginType: ref.pluginType,
+        tool: name,
+        jti: scope.jti,
+        threadId: scope.thid
+      });
+    }
+  }
+  const manifest = await backend.catalog.getValidatedManifest(tenantId, ref.pluginType);
+  const rawConnectionKey = args.connectionKey;
+  const explicit = typeof rawConnectionKey === "string" ? rawConnectionKey : void 0;
+  const scoped = scope?.ck;
+  const connectionRelevant = Boolean(manifest?.connection) || scoped !== void 0;
+  if (connectionRelevant && (explicit !== void 0 ? explicit !== scoped : rawConnectionKey !== void 0)) {
+    throw denyScope(403, "CONNECTION_NOT_ALLOWED", {
+      tenantId,
+      pluginType: ref.pluginType,
+      tool: name,
+      jti: scope?.jti,
+      threadId: scope?.thid
+    });
+  }
+  let connection;
+  let connectionKey;
+  if (scoped !== void 0) {
+    const resolveConnections = deps?.resolveConnections ?? resolvePluginConnections;
+    const resolved = await resolveConnections(
+      ref.pluginType,
+      { connections: [scoped] },
+      { tenantId }
+    );
+    if (resolved.length === 0) {
+      throw denyScope(403, "CONNECTION_NOT_ALLOWED", {
+        tenantId,
+        pluginType: ref.pluginType,
+        tool: name,
+        jti: scope?.jti,
+        threadId: scope?.thid
+      });
+    }
+    connection = resolved[0].config;
+    connectionKey = resolved[0].key;
+  }
+  if (manifest?.connection && !connectionKey) {
+    throw denyScope(409, "CONNECTION_REQUIRED", {
+      tenantId,
+      pluginType: ref.pluginType,
+      tool: name,
+      jti: scope?.jti,
+      threadId: scope?.thid
+    });
+  }
+  const identity = scope ? {
+    workspaceId: scope.wid,
+    projectId: scope.pid,
+    threadId: scope.thid,
+    assistantId: scope.aid
+  } : {
+    workspaceId: context?.workspaceId,
+    projectId: context?.projectId
+  };
+  return invokePluginTool(backend, tenantId, ref.pluginType, name, args, {
+    ...identity,
+    ...connection === void 0 ? {} : { connection }
+  });
 }
 function createDefaultPluginBackend() {
   return {
@@ -13461,8 +14061,8 @@ function runContextOf(request) {
     projectId: firstHeader(request, "x-project-id")
   };
 }
-function registerMcpAppRoutes(fastify2) {
-  const handlers = makeMcpAppHandlers(resolveMcpAppDeps());
+function registerMcpAppRoutes(fastify2, deps = resolveMcpAppDeps()) {
+  const handlers = makeMcpAppHandlers(deps);
   fastify2.get("/mcp-apps/sandbox.html", async (_request, reply) => {
     return reply.header("content-type", SANDBOX_HTML_CONTENT_TYPE).header("x-content-type-options", "nosniff").header("cache-control", "no-store").send(SANDBOX_HTML);
   });
@@ -13493,6 +14093,7 @@ import { v4 as uuidv43 } from "uuid";
 // src/services/eval-runner.ts
 import { EventEmitter } from "events";
 import {
+  getReplicaId as getReplicaId6,
   getStoreLattice as getStoreLattice20,
   hasModelLatticeForTenant,
   listModelLatticesForTenant,
@@ -13500,6 +14101,8 @@ import {
 } from "@axiom-lattice/core";
 import { v4 as uuidv42 } from "uuid";
 var TERMINAL_PERSIST_ATTEMPTS = 2;
+var EVAL_EXECUTION_LEASE = "eval:execution";
+var EVAL_LEASE_TTL_MS = 6e4;
 function mapLogs(logs) {
   return logs.map((l) => ({
     timestamp: l.ts,
@@ -13534,14 +14137,48 @@ var EvalRunner = class {
     }
     const leaseToken = Symbol(leaseKey);
     this.projectLeases.set(leaseKey, leaseToken);
+    let executionLease;
     try {
-      return await this.startLeasedRun(tenantId, projectId, suiteIds, caseIds, runConfig, taskId, leaseKey, leaseToken);
+      executionLease = await this.acquireExecutionLease();
+      return await this.startLeasedRun(
+        tenantId,
+        projectId,
+        suiteIds,
+        caseIds,
+        runConfig,
+        taskId,
+        leaseKey,
+        leaseToken,
+        executionLease.release
+      );
     } catch (error) {
       this.releaseProjectLease(leaseKey, leaseToken);
+      await executionLease?.release();
       throw error;
     }
   }
-  async startLeasedRun(tenantId, projectId, suiteIds, caseIds, runConfig, taskId, leaseKey, leaseToken) {
+  /** One eval at a time across replicas; the executing worker holds this lease. */
+  async acquireExecutionLease() {
+    const store2 = this.getLeaseStore();
+    const holder = `${getReplicaId6()}#${uuidv42()}`;
+    if (!await store2.tryAcquire(EVAL_EXECUTION_LEASE, holder, EVAL_LEASE_TTL_MS)) {
+      throw new Error("An evaluation run is already in progress");
+    }
+    const heartbeat = setInterval(() => {
+      void store2.renew(EVAL_EXECUTION_LEASE, holder, EVAL_LEASE_TTL_MS).catch(() => void 0);
+    }, Math.max(1e3, Math.floor(EVAL_LEASE_TTL_MS / 3)));
+    heartbeat.unref?.();
+    return {
+      release: async () => {
+        clearInterval(heartbeat);
+        await store2.release(EVAL_EXECUTION_LEASE, holder).catch(() => void 0);
+      }
+    };
+  }
+  getLeaseStore() {
+    return getStoreLattice20("default", "lease").store;
+  }
+  async startLeasedRun(tenantId, projectId, suiteIds, caseIds, runConfig, taskId, leaseKey, leaseToken, releaseExecutionLease) {
     const store2 = this.getEvalStore();
     const project = await store2.getProjectById(tenantId, projectId);
     if (!project) throw new Error("Project not found");
@@ -13719,6 +14356,12 @@ var EvalRunner = class {
       });
     };
     const runPromise = (async () => {
+      const cancelPoll = setInterval(() => {
+        void Promise.resolve(this.getEvalStore().getRunById(tenantId, runId)).then((latest) => {
+          if (latest?.cancelRequested) abortController.abort();
+        }).catch(() => void 0);
+      }, 1e3);
+      cancelPoll.unref?.();
       try {
         const evalProject = new LatticeEvalProject(projectConfig, onCaseComplete);
         const calibration = await evalProject.calibrateJudge();
@@ -13744,10 +14387,11 @@ var EvalRunner = class {
         });
         return { report };
       } catch (err) {
-        const errorMsg = err.message;
+        const latest = await Promise.resolve(this.getEvalStore().getRunById(tenantId, runId)).catch(() => null);
+        const errorMsg = latest?.cancelRequested ? "Run aborted" : err.message;
         try {
           await persistTerminal({
-            status: "failed",
+            status: latest?.cancelRequested ? "aborted" : "failed",
             error: errorMsg,
             completedAt: /* @__PURE__ */ new Date()
           }, {
@@ -13759,11 +14403,13 @@ var EvalRunner = class {
         }
         throw err;
       } finally {
+        clearInterval(cancelPoll);
         terminal.workerSettled = true;
         if (terminal.persisted) {
           this.runs.delete(runId);
           this.releaseProjectLease(leaseKey, leaseToken);
         }
+        await releaseExecutionLease();
       }
     })();
     this.runs.set(runId, { runId, projectId, tenantId, abortController, promise: runPromise, terminal, leaseKey, leaseToken, taskId });
@@ -13773,10 +14419,16 @@ var EvalRunner = class {
   }
   async abortRun(runId, tenantId) {
     const ctx = this.runs.get(runId);
-    if (!ctx || tenantId !== void 0 && ctx.tenantId !== tenantId) return false;
+    if (ctx && tenantId !== void 0 && ctx.tenantId !== tenantId) return false;
+    if (!ctx) {
+      if (!tenantId) return false;
+      const store3 = this.getEvalStore();
+      return store3.requestCancel ? await Promise.resolve(store3.requestCancel(tenantId, runId)).catch(() => false) === true : false;
+    }
     if (ctx.terminal.claiming || ctx.terminal.persisted) return false;
-    ctx.abortController.abort();
     const store2 = this.getEvalStore();
+    void Promise.resolve(store2.requestCancel?.(ctx.tenantId, runId)).catch(() => false);
+    ctx.abortController.abort();
     ctx.terminal.claiming = true;
     try {
       let lastError;
@@ -14253,8 +14905,8 @@ function registerEvalRoutes(app2) {
     const tenantId = getTenantId19(request);
     const { rid } = request.params;
     const store2 = getEvalStore();
-    const ownedRun = await store2.getRunById(tenantId, rid);
-    if (!ownedRun) return reply.status(404).send({ success: false, message: "Run not found" });
+    const initial = await store2.getRunById(tenantId, rid);
+    if (!initial) return reply.status(404).send({ success: false, message: "Run not found" });
     reply.hijack();
     reply.raw.writeHead(200, {
       "Content-Type": "text/event-stream",
@@ -14262,67 +14914,74 @@ function registerEvalRoutes(app2) {
       Connection: "keep-alive",
       "Access-Control-Allow-Origin": "*"
     });
-    const emitter = evalRunner.getEventEmitter();
-    const eventKey = `run:${rid}`;
-    let settled = false;
+    let closed = false;
+    let finished = false;
+    const seen = /* @__PURE__ */ new Set();
+    let timer;
     const cleanup = () => {
-      emitter.off(eventKey, handler);
-      request.raw.off("close", disconnect);
-    };
-    const disconnect = () => {
-      if (settled) return;
-      settled = true;
-      cleanup();
+      if (closed) return;
+      closed = true;
+      if (timer) clearInterval(timer);
+      request.raw.off("close", cleanup);
     };
-    const finish = (type, data) => {
-      if (settled) return;
-      settled = true;
-      cleanup();
-      reply.raw.write(`event: ${type}
+    const write = (event, data) => {
+      if (closed) return;
+      reply.raw.write(`event: ${event}
 data: ${JSON.stringify(data)}
 
 `);
+    };
+    const finish = (event, data) => {
+      if (finished) return;
+      finished = true;
+      write(event, data);
+      cleanup();
       reply.raw.end();
     };
-    const handler = (event) => {
-      if (event.type === "completed" || event.type === "error") {
-        finish(event.type, event.data);
+    const poll = async () => {
+      if (closed || finished) return;
+      let run2;
+      let results;
+      try {
+        run2 = await store2.getRunById(tenantId, rid);
+        if (!run2) {
+          finish("error", { message: "Run not found" });
+          return;
+        }
+        results = await store2.getResultsByRun(tenantId, rid);
+      } catch (error) {
         return;
       }
-      if (!settled) reply.raw.write(`event: ${event.type}
-data: ${JSON.stringify(event.data)}
-
-`);
+      for (const result of results) {
+        if (seen.has(result.id)) continue;
+        seen.add(result.id);
+        write("progress", {
+          suiteName: result.suiteName,
+          caseId: result.caseId,
+          pass: result.pass,
+          score: result.score,
+          interrupted: result.interrupted ?? false,
+          completed: run2.passedCases + run2.failedCases,
+          total: run2.totalCases
+        });
+      }
+      if (run2.status === "completed") {
+        finish("completed", {
+          passed: run2.passedCases,
+          failed: run2.failedCases,
+          avgScore: run2.avgScore
+        });
+      } else if (run2.status === "failed") {
+        finish("error", { message: run2.error ?? "Evaluation failed" });
+      } else if (run2.status === "aborted") {
+        finish("error", { message: "Run aborted" });
+      }
     };
-    emitter.on(eventKey, handler);
-    request.raw.on("close", disconnect);
-    let reconciledRun;
-    try {
-      reconciledRun = await store2.getRunById(tenantId, rid);
-    } catch (error) {
-      finish("error", { message: error.message });
-      return;
-    }
-    if (settled) return;
-    if (!reconciledRun) {
-      cleanup();
-      reply.raw.end();
-      return;
-    }
-    if (reconciledRun.status === "completed") {
-      finish("completed", {
-        passed: reconciledRun.passedCases,
-        failed: reconciledRun.failedCases,
-        avgScore: reconciledRun.avgScore
-      });
-    } else if (reconciledRun.status === "failed") {
-      finish("error", { message: reconciledRun.error ?? "Evaluation failed" });
-    } else if (reconciledRun.status === "aborted") {
-      finish("error", { message: "Run aborted" });
-    } else if (!evalRunner.isRunning(rid, tenantId)) {
-      cleanup();
-      reply.raw.end();
-    }
+    request.raw.on("close", cleanup);
+    await poll();
+    if (!closed && !finished) timer = setInterval(() => {
+      void poll();
+    }, 1e3);
   });
   app2.post("/api/eval/runs/:rid/abort", async (request, reply) => {
     try {
@@ -14332,7 +14991,7 @@ data: ${JSON.stringify(event.data)}
       if (!run2) return reply.status(404).send({ success: false, message: "Run not found" });
       const aborted = await evalRunner.abortRun(rid, tenantId);
       if (!aborted) return reply.status(404).send({ success: false, message: "Run not found or not running" });
-      reply.send({ success: true, message: "Run aborted" });
+      reply.status(202).send({ success: true, message: "Abort requested", data: { runId: rid } });
     } catch (err) {
       reply.status(500).send({ success: false, message: err.message });
     }
@@ -14945,10 +15604,10 @@ function bypassesConsoleAuth(request) {
   const path5 = request.url.split("?")[0];
   const method = request.method;
   if (method === "GET" && /^\/api\/web-apps\/[^/]+\/runtime\/bootstrap$/.test(path5) || (method === "GET" || method === "POST") && /^\/api\/web-apps\/[^/]+\/runtime\/threads$/.test(path5) || (method === "PATCH" || method === "DELETE") && /^\/api\/web-apps\/[^/]+\/runtime\/threads\/[^/]+$/.test(path5) || method === "GET" && /^\/api\/web-apps\/[^/]+\/runtime\/threads\/[^/]+\/messages$/.test(path5) || method === "GET" && /^\/api\/web-apps\/[^/]+\/runtime\/files\/(viewfile|downloadfile)$/.test(path5) || method === "GET" && /^\/api\/web-apps\/[^/]+\/runtime\/api\/assistants\/[^/]+\/threads\/[^/]+\/sandbox\/(viewfile|downloadfile)$/.test(path5) || method === "POST" && /^\/api\/web-apps\/[^/]+\/runtime\/threads\/[^/]+\/(messages\/stream|abort|attachments)$/.test(path5) || method === "POST" && /^\/api\/web-apps\/[^/]+\/runtime\/threads\/[^/]+\/interrupts\/[^/]+\/resume$/.test(path5) || method === "GET" && /^\/api\/web-apps\/[^/]+\/runtime(?:\/api)?\/assistants\/[^/]+\/threads\/[^/]+\/runs$/.test(path5) || method === "POST" && /^\/api\/web-apps\/[^/]+\/runtime(?:\/api)?\/assistants\/[^/]+\/threads\/[^/]+\/runs$/.test(path5) || method === "GET" && /^\/api\/web-apps\/[^/]+\/runtime(?:\/api)?\/assistants\/[^/]+\/threads\/[^/]+\/runs\/[^/]+$/.test(path5) || method === "GET" && /^\/api\/web-apps\/[^/]+\/runtime(?:\/api)?\/assistants\/[^/]+\/threads\/[^/]+\/runs\/[^/]+\/join$/.test(path5) || method === "POST" && /^\/api\/web-apps\/[^/]+\/runtime(?:\/api)?\/assistants\/[^/]+\/threads\/[^/]+\/runs\/[^/]+\/cancel$/.test(path5) || method === "GET" && /^\/api\/web-apps\/[^/]+\/chat$/.test(path5) || method === "GET" && /^\/embed\/[^/]+$/.test(path5) || method === "GET" && path5 === "/mcp-apps/sandbox.html" || (method === "POST" || method === "DELETE") && path5 === "/open/mcp" || (method === "POST" || method === "GET") && (path5 === "/mcp" || path5 === "/mcp/") || method === "POST" && path5 === "/open/session" || (method === "GET" || method === "POST") && path5.startsWith("/open/sandbox/files/")) return true;
-  if (request.method === "GET" && (/^\/api\/a2a\/agents\/[^/]+\/\.well-known\/agent-card\.json$/.test(path5) || /^\/a2a\/[^/]+\/\.well-known\/agent-card\.json$/.test(path5))) {
+  if (request.method === "GET" && (/^\/api\/a2a\/agents\/[^/]+\/\.well-known\/agent-card\.json$/.test(path5) || /^\/a2a\/(?:v1\/)?[^/]+\/\.well-known\/agent-card\.json$/.test(path5))) {
     return true;
   }
-  return request.method === "POST" && /^\/api\/a2a\/agents\/[^/]+\/jsonrpc$/.test(path5) || request.method === "POST" && /^\/a2a\/[^/]+$/.test(path5);
+  return request.method === "POST" && /^\/api\/a2a\/agents\/[^/]+\/jsonrpc$/.test(path5) || request.method === "POST" && /^\/a2a\/(?:v1\/)?[^/]+$/.test(path5);
 }
 function registerConsoleAuthHook(app2, options) {
   app2.addHook("preHandler", async (request, reply) => {
@@ -15053,7 +15712,7 @@ function normalizeChatType(chatType) {
 
 // src/channels/lark/LarkChannelAdapter.ts
 import * as Lark from "@larksuiteoapi/node-sdk";
-var logger = new Logger({ serviceName: "lattice/gateway/lark" });
+var logger2 = new Logger({ serviceName: "lattice/gateway/lark" });
 var activeConnections = /* @__PURE__ */ new Map();
 function parseTextContent(content) {
   if (!content) return null;
@@ -15141,21 +15800,21 @@ var larkChannelAdapter = {
   async connect(installation, deps) {
     const { id: installationId, tenantId, config } = installation;
     if (!config.appId || !config.appSecret) {
-      logger.warn("Lark installation missing credentials, skipping", { installationId });
+      logger2.warn("Lark installation missing credentials, skipping", { installationId });
       return;
     }
     if (activeConnections.has(installationId)) {
-      logger.warn("Lark WS already connected for installation, skipping", { installationId });
+      logger2.warn("Lark WS already connected for installation, skipping", { installationId });
       return;
     }
-    logger.info("Lark WS client starting", { installationId, tenantId });
+    logger2.info("Lark WS client starting", { installationId, tenantId });
     const router = deps?.router;
     const eventDispatcher = new Lark.EventDispatcher({}).register({
       "im.message.receive_v1": async (data) => {
         try {
           const inbound = wsEventToInbound(data, installationId, tenantId);
           if (!inbound) return;
-          logger.info("Lark WS message received", {
+          logger2.info("Lark WS message received", {
             installationId,
             senderId: inbound.sender.id,
             chatId: data.message?.chat_id
@@ -15163,14 +15822,14 @@ var larkChannelAdapter = {
           if (router) {
             const result = await router.dispatch(inbound);
             if (!result.success) {
-              logger.warn("Lark WS dispatch failed", {
+              logger2.warn("Lark WS dispatch failed", {
                 installationId,
                 error: result.error?.message
               });
             }
           }
         } catch (err) {
-          logger.error("Lark WS event handler error", {
+          logger2.error("Lark WS event handler error", {
             installationId,
             error: err instanceof Error ? err.message : String(err)
           });
@@ -15184,25 +15843,25 @@ var larkChannelAdapter = {
     });
     await client.start({ eventDispatcher });
     activeConnections.set(installationId, client);
-    logger.info("Lark WS client connected", { installationId });
+    logger2.info("Lark WS client connected", { installationId });
   },
   async disconnect(installationId) {
     const client = activeConnections.get(installationId);
     if (!client) {
-      logger.warn("Lark WS not connected, nothing to disconnect", { installationId });
+      logger2.warn("Lark WS not connected, nothing to disconnect", { installationId });
       return;
     }
-    logger.info("Lark WS client disconnecting", { installationId });
+    logger2.info("Lark WS client disconnecting", { installationId });
     try {
       client.close({ force: true });
     } catch (err) {
-      logger.error("Lark WS client stop error", {
+      logger2.error("Lark WS client stop error", {
         installationId,
         error: err instanceof Error ? err.message : String(err)
       });
     }
     activeConnections.delete(installationId);
-    logger.info("Lark WS client disconnected", { installationId });
+    logger2.info("Lark WS client disconnected", { installationId });
   }
 };
 
@@ -15267,7 +15926,7 @@ function verifyLarkRequestSignature(request, config) {
 }
 
 // src/channels/lark/controller.ts
-var logger2 = new Logger({ serviceName: "lattice/gateway/lark" });
+var logger3 = new Logger({ serviceName: "lattice/gateway/lark" });
 function createLarkEventHandler(deps) {
   return async function handleLarkEvent(request, reply) {
     const { installationId } = request.params;
@@ -15298,7 +15957,7 @@ function createLarkEventHandler(deps) {
       return;
     }
     deps.router.dispatch(inboundMessage).catch((error) => {
-      logger2.error("Lark message dispatch error", {
+      logger3.error("Lark message dispatch error", {
         error: error instanceof Error ? error.message : String(error)
       });
     });
@@ -15319,21 +15978,9 @@ function registerLarkChannelRoutes(app2, deps) {
 }
 
 // src/channels/wechat/controller.ts
-var qrSessions = /* @__PURE__ */ new Map();
-var SESSION_TTL_MS = 5 * 60 * 1e3;
-function cleanupExpiredSessions() {
-  const now = Date.now();
-  for (const [key, session] of qrSessions) {
-    if (now - session.createdAt > SESSION_TTL_MS) {
-      qrSessions.delete(key);
-    }
-  }
-}
 async function handleGetQrCode(_request, reply) {
   try {
-    cleanupExpiredSessions();
     const { qrcode, qrcodeImgUrl } = await getQrCode();
-    qrSessions.set(qrcode, { qrcode, createdAt: Date.now() });
     reply.send({ success: true, data: { qrcode, qrcodeImgUrl } });
   } catch (err) {
     reply.status(500).send({
@@ -15348,11 +15995,6 @@ async function handleGetQrCodeStatus(request, reply) {
     reply.status(400).send({ success: false, message: "qrcode is required" });
     return;
   }
-  const session = qrSessions.get(qrcode);
-  if (!session) {
-    reply.status(404).send({ success: false, message: "Session not found or expired" });
-    return;
-  }
   try {
     const result = await getQrCodeStatus(qrcode);
     reply.send({ success: true, data: result });
@@ -15390,9 +16032,19 @@ import {
 import { getStoreLattice as getStoreLattice25 } from "@axiom-lattice/core";
 var _adapterRegistry;
 var _router;
+var _onInstallationChanged;
 function setChannelControllerDeps(deps) {
   _adapterRegistry = deps.adapterRegistry;
   _router = deps.router;
+  _onInstallationChanged = deps.onInstallationChanged;
+}
+async function notifyInstallationChanged(tenantId, installationId) {
+  if (!_onInstallationChanged) return;
+  try {
+    await _onInstallationChanged({ tenantId, installationId });
+  } catch (error) {
+    console.error("Failed to notify channel installation change:", error);
+  }
 }
 function getTenantId20(request) {
   const userTenantId = request.user?.tenantId;
@@ -15608,7 +16260,9 @@ async function createChannelInstallation(request, reply) {
       installationId,
       createInput
     );
-    if (body.enabled !== false && _adapterRegistry) {
+    if (_onInstallationChanged) {
+      await notifyInstallationChanged(tenantId, installationId);
+    } else if (body.enabled !== false && _adapterRegistry) {
       const adapter = _adapterRegistry.get(body.channel);
       if (adapter?.connect) {
         try {
@@ -15663,6 +16317,19 @@ async function updateChannelInstallation(request, reply) {
       reply.code(400);
       return { success: false, message: "Invalid request body" };
     }
+    if (_onInstallationChanged) {
+      const installation2 = await store2.updateInstallation(tenantId, installationId, body);
+      if (!installation2) {
+        reply.code(404);
+        return { success: false, message: "Channel installation not found" };
+      }
+      await notifyInstallationChanged(tenantId, installationId);
+      return {
+        success: true,
+        message: "Channel installation updated successfully",
+        data: installation2
+      };
+    }
     const adapter = _adapterRegistry?.get(existing.channel);
     const disconnect = adapter?.disconnect;
     const connect = adapter?.connect;
@@ -15782,7 +16449,7 @@ async function deleteChannelInstallation(request, reply) {
         message: "Access denied"
       };
     }
-    if (_adapterRegistry) {
+    if (!_onInstallationChanged && _adapterRegistry) {
       const adapter = _adapterRegistry.get(existing.channel);
       if (adapter?.disconnect) {
         try {
@@ -15800,6 +16467,7 @@ async function deleteChannelInstallation(request, reply) {
         message: "Channel installation not found"
       };
     }
+    await notifyInstallationChanged(tenantId, installationId);
     return {
       success: true,
       message: "Channel installation deleted successfully"
@@ -16318,42 +16986,6 @@ function registerA2ABridgeRoutes(app2) {
 
 // src/routes/stt.ts
 import { sttModelLatticeManager } from "@axiom-lattice/core";
-
-// src/controllers/tenant-scope.ts
-var TenantScopeError2 = class extends Error {
-  /** Creates a tenant scope error. */
-  constructor(code, statusCode, message) {
-    super(message);
-    this.code = code;
-    this.statusCode = statusCode;
-    this.name = "TenantScopeError";
-  }
-};
-function resolveTenantScope(request, authRequired2) {
-  const authenticated = request.user?.tenantId;
-  const header2 = request.headers["x-tenant-id"];
-  const requested = Array.isArray(header2) ? header2[0] : header2;
-  if (authenticated) {
-    if (requested && requested !== authenticated) {
-      throw new TenantScopeError2(
-        "TENANT_ACCESS_DENIED",
-        403,
-        "Tenant access denied"
-      );
-    }
-    return { tenantId: authenticated, userId: request.user?.id };
-  }
-  if (authRequired2) {
-    throw new TenantScopeError2(
-      "UNAUTHENTICATED",
-      401,
-      "Console session required"
-    );
-  }
-  return { tenantId: requested || "default" };
-}
-
-// src/routes/stt.ts
 function tenantIdOf(request) {
   try {
     return resolveTenantScope(request, false).tenantId;
@@ -16719,7 +17351,7 @@ import {
   createTaskLifecycleService,
   createTrustedAgentMessageDispatcher,
   executionAuthorityRegistry,
-  getReplicaId as getReplicaId9,
+  getReplicaId as getReplicaId10,
   getStoreLattice as getStoreLattice28,
   hasModelLatticeForTenant as hasModelLatticeForTenant3,
   ManagedTaskStartError,
@@ -17393,6 +18025,8 @@ var ProjectTaskRunPlanner = class {
       throw asPlanError(error);
     }
     const inputId = (this.deps.idFactory ?? randomUUID20)();
+    const actor3 = input.actor ?? SYSTEM_ACTOR;
+    const userId = actor3.startsWith("user:") && actor3.length > "user:".length ? actor3.slice("user:".length) : void 0;
     const trustedContext = {
       projectTask: buildTrustedTaskContext(task, thread, inputId, rosterExempt)
     };
@@ -17404,12 +18038,16 @@ var ProjectTaskRunPlanner = class {
       projectId: task.projectId,
       assistantId: task.ownerId,
       threadId: thread.id,
-      config: { taskId: task.id, execution: { taskId: task.id } },
+      config: {
+        taskId: task.id,
+        execution: { taskId: task.id },
+        ...userId ? { user_id: userId } : {}
+      },
       metadata: {
         taskId: task.id,
         projectId: task.projectId,
         workspaceId: task.workspaceId,
-        actor: input.actor ?? SYSTEM_ACTOR,
+        actor: actor3,
         mode: input.mode
       }
     };
@@ -18375,7 +19013,7 @@ function getTenantId24(request) {
   if (typeof value !== "string" || !value) throw new HttpTaskError(400, "INVALID_TASK_INPUT");
   return value;
 }
-function getUserId4(request) {
+function getUserId6(request) {
   const user = request.user;
   const value = user?.id ?? request.headers["x-user-id"];
   if (typeof value !== "string" || !value) throw new HttpTaskError(400, "INVALID_TASK_INPUT", "User ID is required");
@@ -18541,7 +19179,7 @@ function withErrors(handler) {
 }
 async function authorizeRead(request, task, authorize) {
   if (!task.projectId || task.projectId === "default") {
-    if (task.ownerType !== "user" || task.ownerId !== getUserId4(request)) throw notFound6();
+    if (task.ownerType !== "user" || task.ownerId !== getUserId6(request)) throw notFound6();
     return;
   }
   let project;
@@ -18555,7 +19193,7 @@ async function authorizeRead(request, task, authorize) {
 }
 async function authorizeCommand(request, task, authorize, capability2) {
   if (!task.projectId || task.projectId === "default") {
-    if (task.ownerType !== "user" || task.ownerId !== getUserId4(request)) throw notFound6();
+    if (task.ownerType !== "user" || task.ownerId !== getUserId6(request)) throw notFound6();
     return;
   }
   let project;
@@ -18568,7 +19206,7 @@ async function authorizeCommand(request, task, authorize, capability2) {
   if (task.workspaceId !== project.workspaceId) throw new HttpTaskError(404, "TASK_NOT_FOUND");
 }
 async function authorizeMutation(request, task, authorize) {
-  const capability2 = task.ownerType === "agent" || task.ownerId !== getUserId4(request) ? "manage" : "send";
+  const capability2 = task.ownerType === "agent" || task.ownerId !== getUserId6(request) ? "manage" : "send";
   return authorizeCommand(request, task, authorize, capability2);
 }
 async function preauthorizeExplicitProject(request, authorize) {
@@ -18612,7 +19250,7 @@ function createTaskController(deps) {
   const mutationMutex = deps.projectMutationMutex ?? projectMutationMutex;
   const authorize = async (request, projectId, capability2) => deps.access.requireProjectAccess({
     tenantId: getTenantId24(request),
-    userId: getUserId4(request),
+    userId: getUserId6(request),
     projectId,
     capability: capability2
   });
@@ -18630,7 +19268,7 @@ function createTaskController(deps) {
   };
   const list = withErrors(async (request) => {
     const tenantId = getTenantId24(request);
-    const userId = getUserId4(request);
+    const userId = getUserId6(request);
     const query = exactObject(request.query, ["projectId", "status", "priority", "limit", "offset", "ownerType", "ownerId", "parentId", "metadata"]);
     const projectId = typeof query.projectId === "string" ? query.projectId : void 0;
     const limit = integer(query.limit, 1);
@@ -18709,7 +19347,7 @@ function createTaskController(deps) {
   const create = withErrors(async (request, reply) => {
     const body = snapshotCreate(request.body);
     const tenantId = getTenantId24(request);
-    const userId = getUserId4(request);
+    const userId = getUserId6(request);
     const governed = governedCreate(body);
     if (governed) return reply.code(409).send({ success: false, code: governed });
     if (!body.projectId || body.projectId === "default") {
@@ -18785,7 +19423,7 @@ function createTaskController(deps) {
     await authorizeMutation(request, current3, authorize);
     return lockedTask(request, current3, async (locked) => {
       if (deps.commands) {
-        const actor3 = `user:${getUserId4(request)}`;
+        const actor3 = `user:${getUserId6(request)}`;
         await deps.commands.run(locked, { type: "delete", actor: actor3 });
         return { success: true, message: "Task deleted" };
       }
@@ -18826,7 +19464,7 @@ function createTaskController(deps) {
       if (body.expectedUpdatedAt && body.expectedUpdatedAt !== locked.updatedAt.toISOString()) {
         throw new HttpTaskError(409, "TASK_STATUS_CONFLICT");
       }
-      const result = await deps.commands.run(locked, { ...body, actor: `user:${getUserId4(request)}` });
+      const result = await deps.commands.run(locked, { ...body, actor: `user:${getUserId6(request)}` });
       return { success: true, data: result.task, warnings: result.warnings };
     }, capability2);
   });
@@ -19172,8 +19810,8 @@ import { z as z5, ZodError as ZodError2 } from "zod";
 
 // src/services/agent-web-app/AgentWebAppRuntimeService.ts
 import { createHash as createHash5, randomUUID as randomUUID22 } from "crypto";
-import { MessageChunkTypes as MessageChunkTypes4, parseAgentWebAppGenUIBlock, buildAffinityMissChunk as buildAffinityMissChunk2 } from "@axiom-lattice/protocols";
-import { getReplicaId as getReplicaId6, getThreadRunOwner as getThreadRunOwner2, normalizeAgentInterrupts as normalizeAgentInterrupts2 } from "@axiom-lattice/core";
+import { MessageChunkTypes as MessageChunkTypes3, parseAgentWebAppGenUIBlock, buildAffinityMissChunk as buildAffinityMissChunk2 } from "@axiom-lattice/protocols";
+import { getReplicaId as getReplicaId7, getThreadRunOwner as getThreadRunOwner2, normalizeAgentInterrupts as normalizeAgentInterrupts2 } from "@axiom-lattice/core";
 function isRecord9(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -19353,7 +19991,7 @@ var AgentWebAppRuntimeService = class {
   async enqueueMessage(webAppId, userId, threadId, content, selection) {
     const runtime = await this.resolveOwnedRuntime(webAppId, userId, threadId, selection);
     const agent = this.resolveAgent(runtime, threadId);
-    const execution = await this.execute(agent, runtime, { input: { message: content } });
+    const execution = await this.execute(agent, runtime, userId, { input: { message: content } });
     return { messageId: execution.messageId };
   }
   async removePendingMessage(webAppId, userId, threadId, messageId, selection) {
@@ -19372,7 +20010,7 @@ var AgentWebAppRuntimeService = class {
         assistantId: runtime.webApp.assistantId,
         threadId
       });
-      if (owner && owner !== getReplicaId6()) {
+      if (owner && owner !== getReplicaId7()) {
         return {
           stream: (async function* () {
             yield buildAffinityMissChunk2(owner, threadId);
@@ -19400,7 +20038,7 @@ var AgentWebAppRuntimeService = class {
     const content = refs.length ? `${input.content}
 
 ${formatFileRefsSection(refs)}` : input.content;
-    const execution = await this.execute(agent, runtime, { input: { message: content } });
+    const execution = await this.execute(agent, runtime, userId, { input: { message: content } });
     return { ...execution, allowInterrupts: runtime.webApp.features.hitl, allowGenUI: runtime.webApp.features.genUI };
   }
   async abort(webAppId, userId, threadId, selection) {
@@ -19503,17 +20141,21 @@ ${formatFileRefsSection(refs)}` : input.content;
     );
     if (matched.conflict) this.fail("INVALID_REQUEST", 409, "Interrupt is ambiguous");
     if (!matched.interrupt) this.fail("INVALID_REQUEST", 400, "Interrupt not found");
-    const execution = await this.execute(agent, runtime, {
+    const execution = await this.execute(agent, runtime, userId, {
       input: { message: input.message },
       command: resumeMap(interruptId, input.response)
     });
     return { ...execution, allowInterrupts: true, allowGenUI: runtime.webApp.features.genUI };
   }
-  execute(agent, runtime, request) {
+  execute(agent, runtime, userId, request) {
+    const customRunConfig = {
+      ...runtime.modelKey ? { modelConfig: { modelKey: runtime.modelKey } } : {},
+      ...userId ? { user_id: userId } : {}
+    };
     return executeScopedAgentMessage(agent, {
       ...request,
-      ...runtime.modelKey ? { custom_run_config: { modelConfig: { modelKey: runtime.modelKey } } } : {}
-    }, [MessageChunkTypes4.MESSAGE_COMPLETED, MessageChunkTypes4.INTERRUPT, MessageChunkTypes4.MESSAGE_FAILED]);
+      ...Object.keys(customRunConfig).length > 0 ? { custom_run_config: customRunConfig } : {}
+    }, [MessageChunkTypes3.MESSAGE_COMPLETED, MessageChunkTypes3.INTERRUPT, MessageChunkTypes3.MESSAGE_FAILED]);
   }
   async resolveRuntime(webAppId, selection) {
     const webApp = await this.deps.webAppStore.findById(webAppId);
@@ -19778,7 +20420,7 @@ async function verifyWebAppToken(token, issuer, options = {}) {
 
 // src/routes/agent-web-app-runtime.ts
 import { createAgentWebAppStreamProjectionContext, projectAgentWebAppChunk, AGENT_AFFINITY_HEADER as AGENT_AFFINITY_HEADER2, AFFINITY_ECHO_HEADER as AFFINITY_ECHO_HEADER2, affinityEchoHeaders as affinityEchoHeaders2, REPLICA_HEADER as REPLICA_HEADER2 } from "@axiom-lattice/protocols";
-import { getReplicaId as getReplicaId7 } from "@axiom-lattice/core";
+import { getReplicaId as getReplicaId8 } from "@axiom-lattice/core";
 var idSchema = z5.string().min(1).max(128);
 var paramsSchema = z5.object({ webAppId: idSchema }).strict();
 var threadParamsSchema = z5.object({ webAppId: idSchema, threadId: idSchema }).strict();
@@ -19804,7 +20446,7 @@ var resumeBodySchema = z5.object({
     z5.object({ approved: z5.boolean(), feedback: z5.string().max(4096).optional() }).strict()
   ])
 }).strict();
-var MAX_ATTACHMENT_BYTES = 10 * 1024 * 1024;
+var MAX_ATTACHMENT_BYTES = 500 * 1024 * 1024;
 var stateQuerySchema = z5.object({
   threadId: idSchema,
   projectId: idSchema.optional(),
@@ -20355,7 +20997,7 @@ function registerAgentWebAppRuntimeRoutes(app2, deps) {
           if (!threadId) throw new AgentWebAppRuntimeError("INVALID_REQUEST", 400, "thread_id is required");
           const content = body.messages.map((message) => message.content).join("\n");
           const { messageId } = await deps.service.enqueueMessage(webAppId, identity.userId, threadId, content, { projectId: body.projectId, modelKey: body.modelKey });
-          reply.header(REPLICA_HEADER2, getReplicaId7());
+          reply.header(REPLICA_HEADER2, getReplicaId8());
           for (const [name, value] of Object.entries(affinityEchoHeaders2(request.headers[AGENT_AFFINITY_HEADER2]))) {
             reply.header(name, value);
           }
@@ -20441,7 +21083,7 @@ function beginSse(reply, request) {
     "X-Accel-Buffering": "no",
     "Access-Control-Allow-Origin": "*",
     "Access-Control-Expose-Headers": `${REPLICA_HEADER2}, ${AFFINITY_ECHO_HEADER2}`,
-    [REPLICA_HEADER2]: getReplicaId7(),
+    [REPLICA_HEADER2]: getReplicaId8(),
     ...affinityEchoHeaders2(request.headers[AGENT_AFFINITY_HEADER2])
   });
 }
@@ -20886,7 +21528,7 @@ var CapabilityBundleService = class {
 };
 
 // src/controllers/capability-bundles.ts
-var logger3 = new Logger({ serviceName: "lattice/gateway/capability-bundles" });
+var logger4 = new Logger({ serviceName: "lattice/gateway/capability-bundles" });
 var capability = z8.unknown();
 var createSchema = z8.object({ name: z8.string(), description: z8.string().optional(), capabilities: z8.array(capability) }).strict();
 var updateSchema = createSchema.partial().extend({ expectedUpdatedAt: z8.string().optional() });
@@ -20904,14 +21546,14 @@ function tenant(request, authRequired2) {
   if (authRequired2) throw new CapabilityBundleServiceError("INVALID_INPUT", "Unauthorized", 401);
   return requested || "default";
 }
-function sendError(reply, error) {
+function sendError2(reply, error) {
   if (error instanceof CapabilityBundleServiceError) return reply.status(error.statusCode).send({ success: false, code: error.code, message: error.message });
   if (error instanceof Error && error.name === "CapabilityBundleValidationError") {
     const validationError = error;
     const code = validationError.code === "CAPABILITY_BUNDLE_INELIGIBLE_CAPABILITY" ? "BUNDLE_PLUGIN_NOT_ELIGIBLE" : validationError.code === "CAPABILITY_BUNDLE_CREDENTIALS_FORBIDDEN" || validationError.code === "CAPABILITY_BUNDLE_INVALID_CONFIG" ? "INVALID_BUNDLE_CONFIG" : validationError.code;
     return reply.status(400).send({ success: false, code, message: error.message, capabilityType: validationError.capabilityType, fieldPath: validationError.fieldPath });
   }
-  logger3.error("Capability bundle controller error", { error: error instanceof Error ? error : new Error(String(error)) });
+  logger4.error("Capability bundle controller error", { error: error instanceof Error ? error : new Error(String(error)) });
   return reply.status(500).send({ success: false, code: "INTERNAL_ERROR", message: "Internal server error" });
 }
 var CapabilityBundleController = class {
@@ -20924,7 +21566,7 @@ var CapabilityBundleController = class {
       const result = await this.service.list(tenant(request, this.authRequired));
       return reply.send({ success: true, data: result.bundles, errors: result.errors });
     } catch (error) {
-      return sendError(reply, error);
+      return sendError2(reply, error);
     }
   }
   async getBundle(request, reply) {
@@ -20934,7 +21576,7 @@ var CapabilityBundleController = class {
       if (!parsed.success) return reply.status(400).send({ success: false, code: "INVALID_INPUT", message: "Invalid capability bundle ID" });
       return reply.send({ success: true, data: await this.service.get(tenantId, parsed.data.bundleId) });
     } catch (error) {
-      return sendError(reply, error);
+      return sendError2(reply, error);
     }
   }
   async createBundle(request, reply) {
@@ -20944,7 +21586,7 @@ var CapabilityBundleController = class {
       if (!parsed.success) return reply.status(400).send({ success: false, code: "INVALID_INPUT", message: "Invalid capability bundle body" });
       return reply.status(201).send({ success: true, data: await this.service.create(tenantId, parsed.data) });
     } catch (error) {
-      return sendError(reply, error);
+      return sendError2(reply, error);
     }
   }
   async updateBundle(request, reply) {
@@ -20955,7 +21597,7 @@ var CapabilityBundleController = class {
       if (!params.success || !parsed.success) return reply.status(400).send({ success: false, code: "INVALID_INPUT", message: "Invalid capability bundle request" });
       return reply.send({ success: true, data: await this.service.update(tenantId, params.data.bundleId, parsed.data) });
     } catch (error) {
-      return sendError(reply, error);
+      return sendError2(reply, error);
     }
   }
   async deleteBundle(request, reply) {
@@ -20966,7 +21608,7 @@ var CapabilityBundleController = class {
       await this.service.remove(tenantId, parsed.data.bundleId);
       return reply.send({ success: true, data: null });
     } catch (error) {
-      return sendError(reply, error);
+      return sendError2(reply, error);
     }
   }
   async updateProjectBundles(request, reply) {
@@ -20977,7 +21619,7 @@ var CapabilityBundleController = class {
       const result = await this.service.project(tenantId, request.params.projectId, parsed.data.bundleIds, true, parsed.data.expectedRevisions);
       return reply.send({ success: true, data: { project: result.project, persistedBundleIds: result.persistedBundleIds, bundles: result.bundles, preview: result.preview } });
     } catch (error) {
-      return sendError(reply, error);
+      return sendError2(reply, error);
     }
   }
   async getProjectBundles(request, reply) {
@@ -20986,7 +21628,7 @@ var CapabilityBundleController = class {
       if (result.preview.errors.some((issue2) => issue2.code === "CAPABILITY_BUNDLE_CREDENTIALS_FORBIDDEN")) return reply.status(400).send({ success: false, code: "INVALID_BUNDLE_CONFIG", message: "Capability bundle record is invalid" });
       return reply.send({ success: true, data: { project: result.project, persistedBundleIds: result.persistedBundleIds, bundles: result.bundles, preview: result.preview } });
     } catch (error) {
-      return sendError(reply, error);
+      return sendError2(reply, error);
     }
   }
   async getProjectPreview(request, reply) {
@@ -20994,7 +21636,7 @@ var CapabilityBundleController = class {
       const preview = await this.service.previewProject(tenant(request, this.authRequired), request.params.projectId);
       return reply.send({ success: true, data: preview });
     } catch (error) {
-      return sendError(reply, error);
+      return sendError2(reply, error);
     }
   }
   async postProjectPreview(request, reply) {
@@ -21005,7 +21647,7 @@ var CapabilityBundleController = class {
       const result = await this.service.project(tenantId, request.params.projectId, parsed.data.bundleIds, false);
       return reply.send({ success: true, data: result.preview });
     } catch (error) {
-      return sendError(reply, error);
+      return sendError2(reply, error);
     }
   }
 };
@@ -22151,8 +22793,8 @@ var probeProviderSchema = z9.object({
 }).strict();
 
 // src/controllers/model-providers.ts
-var logger4 = new Logger({ serviceName: "lattice/gateway/model-providers" });
-function sendError2(reply, error) {
+var logger5 = new Logger({ serviceName: "lattice/gateway/model-providers" });
+function sendError3(reply, error) {
   if (error instanceof ModelProviderServiceError) {
     return reply.status(error.statusCode).send({
       success: false,
@@ -22163,7 +22805,7 @@ function sendError2(reply, error) {
       }
     });
   }
-  if (error instanceof TenantScopeError2) {
+  if (error instanceof TenantScopeError) {
     return reply.status(error.statusCode).send({
       success: false,
       error: {
@@ -22183,7 +22825,7 @@ function sendError2(reply, error) {
       }
     });
   }
-  logger4.error("Model provider controller error", {
+  logger5.error("Model provider controller error", {
     error: error instanceof Error ? error : new Error(String(error))
   });
   return reply.status(500).send({
@@ -22207,7 +22849,7 @@ var ModelProviderController = class {
       const catalog = await this.service.catalog(scope.userId, scope.tenantId);
       return reply.send({ success: true, data: catalog });
     } catch (error) {
-      return sendError2(reply, error);
+      return sendError3(reply, error);
     }
   }
   /** Hydrates the runtime model registry from persisted providers (startup). */
@@ -22228,7 +22870,7 @@ var ModelProviderController = class {
         data: { records, total: records.length }
       });
     } catch (error) {
-      return sendError2(reply, error);
+      return sendError3(reply, error);
     }
   }
   /** GET /api/model-providers/:providerId */
@@ -22241,7 +22883,7 @@ var ModelProviderController = class {
         data: await this.service.get(scope.userId, scope.tenantId, providerId2)
       });
     } catch (error) {
-      return sendError2(reply, error);
+      return sendError3(reply, error);
     }
   }
   /** POST /api/model-providers */
@@ -22254,7 +22896,7 @@ var ModelProviderController = class {
         data: await this.service.create(scope.userId, scope.tenantId, input)
       });
     } catch (error) {
-      return sendError2(reply, error);
+      return sendError3(reply, error);
     }
   }
   /** PUT /api/model-providers/:providerId */
@@ -22273,7 +22915,7 @@ var ModelProviderController = class {
         )
       });
     } catch (error) {
-      return sendError2(reply, error);
+      return sendError3(reply, error);
     }
   }
   /** DELETE /api/model-providers/:providerId */
@@ -22284,7 +22926,7 @@ var ModelProviderController = class {
       await this.service.remove(scope.userId, scope.tenantId, providerId2);
       return reply.send({ success: true, data: null });
     } catch (error) {
-      return sendError2(reply, error);
+      return sendError3(reply, error);
     }
   }
   /** POST /api/model-providers/probe */
@@ -22297,7 +22939,7 @@ var ModelProviderController = class {
         data: await this.service.probe(scope.userId, scope.tenantId, input)
       });
     } catch (error) {
-      return sendError2(reply, error);
+      return sendError3(reply, error);
     }
   }
   /** PUT /api/model-providers/:providerId/models */
@@ -22316,7 +22958,7 @@ var ModelProviderController = class {
         )
       });
     } catch (error) {
-      return sendError2(reply, error);
+      return sendError3(reply, error);
     }
   }
   /** POST /api/model-providers/:providerId/discover */
@@ -22334,7 +22976,7 @@ var ModelProviderController = class {
         )
       });
     } catch (error) {
-      return sendError2(reply, error);
+      return sendError3(reply, error);
     }
   }
   /** POST /api/model-providers/:providerId/models/enabled */
@@ -22354,7 +22996,7 @@ var ModelProviderController = class {
         )
       });
     } catch (error) {
-      return sendError2(reply, error);
+      return sendError3(reply, error);
     }
   }
 };
@@ -23472,86 +24114,6 @@ import { toProjectRoomPublicMessage } from "@axiom-lattice/protocols";
 
 // src/services/collaboration/RoomInterruptService.ts
 import { randomUUID as randomUUID28 } from "crypto";
-
-// src/router/roomInterrupt.ts
-var CLARIFY_FENCE = /^```clarify\n([\s\S]*?)\n```$/;
-function readClarifyValue(value) {
-  if (typeof value !== "string") return void 0;
-  const match = CLARIFY_FENCE.exec(value.trim());
-  if (!match) return void 0;
-  try {
-    const parsed = JSON.parse(match[1]);
-    if (typeof parsed === "object" && parsed !== null && Array.isArray(parsed.questions)) {
-      return parsed;
-    }
-  } catch {
-  }
-  return void 0;
-}
-function rawInterruptId(interrupt, taskId, taskIndex, index) {
-  const record = typeof interrupt === "object" && interrupt !== null ? interrupt : void 0;
-  const rawId = record?.id;
-  if (typeof rawId === "string" || typeof rawId === "number") return String(rawId);
-  return `${taskId ?? `task-${taskIndex}`}:${index}`;
-}
-function pendingInterrupts(state) {
-  if (typeof state !== "object" || state === null) return [];
-  const tasks = state.tasks;
-  if (!Array.isArray(tasks)) return [];
-  const result = [];
-  tasks.forEach((task, taskIndex) => {
-    const record = typeof task === "object" && task !== null ? task : void 0;
-    const rawTaskId = record?.id;
-    const taskId = typeof rawTaskId === "string" || typeof rawTaskId === "number" ? String(rawTaskId) : void 0;
-    const interrupts = record?.interrupts;
-    if (!Array.isArray(interrupts)) return;
-    interrupts.forEach((interrupt, index) => {
-      const value = typeof interrupt === "object" && interrupt !== null ? interrupt.value : void 0;
-      const clarify = readClarifyValue(value);
-      result.push({
-        interruptId: rawInterruptId(interrupt, taskId, taskIndex, index),
-        ...clarify === void 0 ? {} : { clarify }
-      });
-    });
-  });
-  return result;
-}
-function readPendingInterruptTarget(state) {
-  const interrupts = pendingInterrupts(state);
-  if (interrupts.length === 0) return void 0;
-  const ids = new Set(interrupts.map((interrupt) => interrupt.interruptId));
-  if (ids.size !== interrupts.length) return { conflict: true };
-  const clarify = interrupts.find((interrupt) => interrupt.clarify !== void 0);
-  if (clarify !== void 0) {
-    if (!isOfficialInterruptId(clarify.interruptId) && interrupts.length > 1) return { conflict: true };
-    return { target: clarify };
-  }
-  return interrupts.length === 1 ? { target: interrupts[0] } : { conflict: true };
-}
-function readExplicitInterruptTarget(state, interruptId) {
-  const interrupts = pendingInterrupts(state);
-  const matches = interrupts.filter((interrupt) => interrupt.interruptId === interruptId);
-  if (matches.length > 1) return { conflict: true };
-  const target = matches[0];
-  if (target === void 0) return void 0;
-  if (!isOfficialInterruptId(interruptId) && interrupts.length > 1) return { conflict: true };
-  return { target };
-}
-function readClarifyInterruptTarget(state) {
-  const match = readPendingInterruptTarget(state);
-  return match !== void 0 && !("conflict" in match) && match.target.clarify !== void 0 ? match.target : void 0;
-}
-function readClarifyInterrupt(state) {
-  return pendingInterrupts(state).find((interrupt) => interrupt.clarify !== void 0)?.clarify;
-}
-function buildClarifyResumeCommand(text, interruptId) {
-  return resumeMap(interruptId, { data: { answers: [{ questionIndex: 0, otherText: text }] } });
-}
-function buildClarifySkipCommand(interruptId) {
-  return resumeMap(interruptId, { data: { answers: [] } });
-}
-
-// src/services/collaboration/RoomInterruptService.ts
 var RESUMABLE_TASK_INTERRUPT_CODES = /* @__PURE__ */ new Set([
   "PROJECT_TASK_NOT_RESUMABLE",
   "PROJECT_TASK_NOT_READY",
@@ -25247,7 +25809,7 @@ function createRoomMessageRetentionJob(input) {
 
 // src/services/collaboration/ProjectTaskExecutionMutex.ts
 import { snapshotExactRecord as snapshotExactRecord8 } from "@axiom-lattice/protocols";
-import { getCoordinationLeaseStore, getReplicaId as getReplicaId8, withLease as withLease2 } from "@axiom-lattice/core";
+import { getCoordinationLeaseStore, getReplicaId as getReplicaId9, withLease as withLease2 } from "@axiom-lattice/core";
 var MACHINE_LEASE_OPTIONS = { ttlMs: 6e4, acquireTimeoutMs: 9e4, retryDelayMs: 100 };
 function machineKey(scope) {
   const snapshot = snapshotExactRecord8(scope, ["tenantId", "assistantId", "projectId"]);
@@ -25277,7 +25839,7 @@ var ProjectTaskExecutionMutex = class {
     try {
       const store2 = getCoordinationLeaseStore();
       if (!store2) return await operation();
-      return await withLease2(store2, leaseKey, getReplicaId8(), operation, MACHINE_LEASE_OPTIONS);
+      return await withLease2(store2, leaseKey, getReplicaId9(), operation, MACHINE_LEASE_OPTIONS);
     } finally {
       this.release(key);
     }
@@ -28556,7 +29118,7 @@ function broadcastModelProviderChanged(tenantId, providerId2) {
   if (!tenantId) return;
   try {
     const outbox = getStoreLattice28("default", "outbox").store;
-    void publishModelProviderChanged(outbox, getReplicaId9(), tenantId, providerId2);
+    void publishModelProviderChanged(outbox, getReplicaId10(), tenantId, providerId2);
   } catch {
   }
 }
@@ -29173,6 +29735,11 @@ var registerLatticeRoutes = (app2, channelDeps, options = {}) => {
     getHealth
   );
   app2.get("/info", getInfo);
+  app2.get("/api/observability", getObservability);
+  app2.get(
+    "/api/observability/dashboard",
+    getObservabilityDashboard
+  );
   app2.get("/metrics", getSystemMetrics);
   app2.get(
     "/api/assistants/:assistantId/threads/:threadId/schedules",
@@ -30872,6 +31439,50 @@ var ChannelAdapterRegistry = class {
   }
 };
 
+// src/router/middlewares/channelSharedState.ts
+import { createClient as createClient2 } from "redis";
+var clientPromise;
+async function redis() {
+  const url = process.env.REDIS_URL?.trim();
+  if (!url) return void 0;
+  if (!clientPromise) {
+    clientPromise = (async () => {
+      const client = createClient2({ url });
+      client.on("error", () => void 0);
+      await client.connect();
+      return client;
+    })();
+  }
+  try {
+    const client = await clientPromise;
+    return client.isOpen ? client : void 0;
+  } catch {
+    clientPromise = void 0;
+    return void 0;
+  }
+}
+async function claimDedupKey(key, ttlMs) {
+  try {
+    const client = await redis();
+    if (!client) return void 0;
+    const result = await client.set(key, "1", { NX: true, PX: ttlMs });
+    return result === "OK";
+  } catch {
+    return void 0;
+  }
+}
+async function incrementRateCounter(key, windowMs) {
+  try {
+    const client = await redis();
+    if (!client) return void 0;
+    const count = await client.incr(key);
+    if (count === 1) await client.pExpire(key, windowMs);
+    return count;
+  } catch {
+    return void 0;
+  }
+}
+
 // src/router/middlewares/deduplication.ts
 var processedMessages = /* @__PURE__ */ new Map();
 function createDeduplicationMiddleware(ttlMs = 5 * 60 * 1e3) {
@@ -30891,6 +31502,16 @@ function createDeduplicationMiddleware(ttlMs = 5 * 60 * 1e3) {
         }, "Duplicate message blocked by deduplication");
         return;
       }
+      const sharedClaim = await claimDedupKey(`axiom:channel:dedup:${key}`, ttlMs);
+      if (sharedClaim === false) {
+        console.warn({
+          event: "dedup:blocked",
+          channel: msg.channel,
+          senderId: msg.sender.id,
+          messageId: msgId
+        }, "Duplicate message blocked by deduplication");
+        return;
+      }
       processedMessages.set(key, now);
     }
     if (processedMessages.size > 1e4) {
@@ -30913,11 +31534,12 @@ function createRateLimitMiddleware(maxRequests = 10, windowMs = 60 * 1e3, maxEnt
   return async (ctx, next) => {
     const senderKey = `${ctx.inboundMessage.channel}:${ctx.inboundMessage.sender.id}`;
     const now = Date.now();
+    const sharedCount = await incrementRateCounter(`axiom:channel:rate:${senderKey}`, windowMs);
     let counter = rateCounters.get(senderKey);
     if (!counter || now > counter.resetAt) {
       counter = { count: 0, resetAt: now + windowMs };
     }
-    counter.count++;
+    counter.count = sharedCount ?? counter.count + 1;
     rateCounters.set(senderKey, counter);
     if (rateCounters.size > maxEntries) {
       const oldest = Array.from(rateCounters.entries()).sort((a, b) => a[1].resetAt - b[1].resetAt)[0];
@@ -30938,13 +31560,13 @@ function createRateLimitMiddleware(maxRequests = 10, windowMs = 60 * 1e3, maxEnt
 }
 
 // src/router/middlewares/auditLogger.ts
-var logger5 = new Logger({ serviceName: "lattice/gateway/audit" });
+var logger6 = new Logger({ serviceName: "lattice/gateway/audit" });
 function createAuditLoggerMiddleware() {
   return async (ctx, next) => {
     const start2 = Date.now();
     try {
       await next();
-      logger5.info("message routed", {
+      logger6.info("message routed", {
         event: "message:routed",
         channel: ctx.inboundMessage.channel,
         senderId: ctx.inboundMessage.sender.id,
@@ -30954,7 +31576,7 @@ function createAuditLoggerMiddleware() {
         status: "success"
       });
     } catch (error) {
-      logger5.error(
+      logger6.error(
         error instanceof Error ? error.message : String(error),
         {
           event: "message:error",
@@ -31000,9 +31622,59 @@ function parseWecomTextFrame(frame) {
 }
 
 // src/channels/wecom/cardTool.ts
-import { getToolLattice, registerToolLattice } from "@axiom-lattice/core";
+import { getStoreLattice as getStoreLattice38, getToolLattice, registerToolLattice } from "@axiom-lattice/core";
 import { z as z12 } from "zod";
 var CARD_TTL_MS = 10 * 6e4;
+var SHARED_NAMESPACE = ["channel-runtime", "wecom-card"];
+var SHARED_TTL_MINUTES = 10;
+function sharedStore() {
+  try {
+    return getStoreLattice38("default", "store").store;
+  } catch {
+    return null;
+  }
+}
+async function putWecomCardForTenant(tenantId, key, card) {
+  const accepted = putWecomCard(key, card);
+  if (!accepted) return false;
+  const store2 = sharedStore();
+  if (!store2) return true;
+  try {
+    await store2.put(tenantId, {
+      namespace: SHARED_NAMESPACE,
+      key,
+      value: { card },
+      ttlMinutes: SHARED_TTL_MINUTES
+    });
+  } catch {
+  }
+  return true;
+}
+async function takeWecomCardForTenant(tenantId, key) {
+  const store2 = sharedStore();
+  if (store2) {
+    try {
+      const item = await store2.get(tenantId, SHARED_NAMESPACE, key);
+      const card = item?.value?.card;
+      if (card) {
+        await store2.delete(tenantId, SHARED_NAMESPACE, key);
+        takeWecomCard(key);
+        return card;
+      }
+    } catch {
+    }
+  }
+  return takeWecomCard(key);
+}
+async function discardWecomCardForTenant(tenantId, key) {
+  discardWecomCard(key);
+  const store2 = sharedStore();
+  if (!store2) return;
+  try {
+    await store2.delete(tenantId, SHARED_NAMESPACE, key);
+  } catch {
+  }
+}
 var MAX_CARD_ENTRIES = 1e3;
 var cardEntries = /* @__PURE__ */ new Map();
 function pruneCards(now) {
@@ -31216,6 +31888,11 @@ function readReplyKey(exeConfig) {
   const key = configurable?.runConfig?.wecomReplyKey;
   return typeof key === "string" && key.length > 0 ? key : void 0;
 }
+function readTenantId(exeConfig) {
+  const configurable = exeConfig?.configurable;
+  const tenantId = configurable?.runConfig?.tenantId;
+  return typeof tenantId === "string" && tenantId.length > 0 ? tenantId : "default";
+}
 function registerWecomCardTool() {
   if (getToolLattice("wecom_card")) return;
   registerToolLattice(
@@ -31232,7 +31909,7 @@ function registerWecomCardTool() {
       }
       try {
         const card = buildTemplateCard(input);
-        if (!putWecomCard(replyKey, card)) {
+        if (!await putWecomCardForTenant(readTenantId(exeConfig), replyKey, card)) {
           return "ERROR: \u672C\u6761\u56DE\u590D\u5DF2\u7ED3\u675F\uFF0C\u65E0\u6CD5\u518D\u9644\u5E26\u5361\u7247\u3002\u8BF7\u628A\u7ED3\u679C\u5199\u5165\u6B63\u6587\u3002";
         }
         const title = card.main_title?.title;
@@ -31246,7 +31923,7 @@ function registerWecomCardTool() {
 }
 
 // src/channels/wecom/WecomChannelAdapter.ts
-var logger6 = new Logger({ serviceName: "lattice/gateway/wecom" });
+var logger7 = new Logger({ serviceName: "lattice/gateway/wecom" });
 var wecomConfigSchema = z13.object({
   botId: z13.string(),
   secret: z13.string()
@@ -31338,12 +32015,12 @@ async function sendStreamFrame(connection, replyTarget, input) {
   }
   const frame = replyTarget.rawTarget?.frame;
   if (!frame) {
-    logger6.warn("WeCom reply target has no inbound frame, skipping", {
+    logger7.warn("WeCom reply target has no inbound frame, skipping", {
       installationId: replyTarget.channelInstallationId
     });
     return;
   }
-  const report = (message, error) => logger6.warn(message, {
+  const report = (message, error) => logger7.warn(message, {
     installationId: replyTarget.channelInstallationId,
     error: error instanceof Error ? error.message : String(error)
   });
@@ -31364,7 +32041,7 @@ async function sendStreamFrame(connection, replyTarget, input) {
         template_card: input.card
       }));
       rememberSentCard(input.card);
-      logger6.info("WeCom card sent", {
+      logger7.info("WeCom card sent", {
         installationId: replyTarget.channelInstallationId,
         cardType: input.card.card_type
       });
@@ -31377,19 +32054,19 @@ async function sendEventReply(connection, replyTarget, input) {
   if (!input.done) return;
   const chatId = eventChatId(replyTarget);
   if (!chatId) {
-    logger6.warn("WeCom card event has no chat id, cannot reply", {
+    logger7.warn("WeCom card event has no chat id, cannot reply", {
       installationId: replyTarget.channelInstallationId
     });
     return;
   }
   const sendMessage = connection.client.sendMessage;
   if (!sendMessage) {
-    logger6.warn("WeCom client does not support sendMessage, cannot reply to card event", {
+    logger7.warn("WeCom client does not support sendMessage, cannot reply to card event", {
       installationId: replyTarget.channelInstallationId
     });
     return;
   }
-  const report = (message, error) => logger6.warn(message, {
+  const report = (message, error) => logger7.warn(message, {
     installationId: replyTarget.channelInstallationId,
     error: error instanceof Error ? error.message : String(error)
   });
@@ -31400,7 +32077,7 @@ async function sendEventReply(connection, replyTarget, input) {
         template_card: input.card
       }));
       rememberSentCard(input.card);
-      logger6.info("WeCom card sent", {
+      logger7.info("WeCom card sent", {
         installationId: replyTarget.channelInstallationId,
         cardType: input.card.card_type
       });
@@ -31496,14 +32173,14 @@ function handleTemplateCardEvent(rawFrame, installation, client, router) {
   const userId = body.from?.userid;
   const chatId = typeof body.chatid === "string" && body.chatid ? body.chatid : userId;
   if (!userId || !chatId) {
-    logger6.warn("WeCom card event missing user/chat id, skipping", {
+    logger7.warn("WeCom card event missing user/chat id, skipping", {
       installationId: installation.id
     });
     return;
   }
   const { taskId, eventKey } = cardEventFields(event);
   if (!claimCardEvent(taskId, eventKey)) {
-    logger6.info("WeCom duplicate card event ignored", {
+    logger7.info("WeCom duplicate card event ignored", {
       installationId: installation.id,
       taskId,
       eventKey
@@ -31515,24 +32192,24 @@ function handleTemplateCardEvent(rawFrame, installation, client, router) {
     const updated = acknowledgedCard(taskId, eventKey);
     try {
       void Promise.resolve(updateTemplateCard.call(client, rawFrame, updated)).catch((error) => {
-        logger6.warn("WeCom template card update failed", {
+        logger7.warn("WeCom template card update failed", {
           installationId: installation.id,
           error: describeError(error)
         });
       });
     } catch (error) {
-      logger6.warn("WeCom template card update failed", {
+      logger7.warn("WeCom template card update failed", {
         installationId: installation.id,
         error: describeError(error)
       });
     }
   } else {
-    logger6.warn("WeCom client does not support updateTemplateCard", {
+    logger7.warn("WeCom client does not support updateTemplateCard", {
       installationId: installation.id
     });
   }
   if (!router) return;
-  logger6.info("WeCom card event dispatched", {
+  logger7.info("WeCom card event dispatched", {
     installationId: installation.id,
     taskId,
     eventKey,
@@ -31540,13 +32217,13 @@ function handleTemplateCardEvent(rawFrame, installation, client, router) {
   });
   try {
     void router.dispatch(cardEventInbound(frame, installation, { chatId, userId })).catch((error) => {
-      logger6.error("WeCom card event dispatch error", {
+      logger7.error("WeCom card event dispatch error", {
         installationId: installation.id,
         error: describeError(error)
       });
     });
   } catch (error) {
-    logger6.error("WeCom card event dispatch error", {
+    logger7.error("WeCom card event dispatch error", {
       installationId: installation.id,
       error: describeError(error)
     });
@@ -31590,13 +32267,13 @@ var wecomChannelAdapter = {
   async sendReply(replyTarget, message, installation) {
     const connection = activeConnections2.get(installation.id);
     if (!connection) {
-      logger6.warn("WeCom bot not connected, cannot reply", {
+      logger7.warn("WeCom bot not connected, cannot reply", {
         installationId: installation.id
       });
       return;
     }
     const key = replyKeyForTarget(replyTarget);
-    const card = takeWecomCard(key);
+    const card = await takeWecomCardForTenant(installation.tenantId, key);
     await sendStreamFrame(connection, replyTarget, {
       text: message.text,
       done: true,
@@ -31614,7 +32291,7 @@ var wecomChannelAdapter = {
   async sendStreamChunk(replyTarget, chunk, installation) {
     const connection = activeConnections2.get(installation.id);
     if (!connection) {
-      logger6.warn("WeCom bot not connected, cannot stream reply", {
+      logger7.warn("WeCom bot not connected, cannot stream reply", {
         installationId: installation.id
       });
       return;
@@ -31623,9 +32300,9 @@ var wecomChannelAdapter = {
     let card;
     if (chunk.done) {
       if (chunk.reason !== void 0 && chunk.reason !== "completed") {
-        discardWecomCard(key);
+        await discardWecomCardForTenant(installation.tenantId, key);
       } else {
-        card = takeWecomCard(key);
+        card = await takeWecomCardForTenant(installation.tenantId, key);
       }
     }
     await sendStreamFrame(connection, replyTarget, {
@@ -31646,11 +32323,11 @@ var wecomChannelAdapter = {
   async connect(installation, deps) {
     const { id: installationId, tenantId, config } = installation;
     if (!config.botId || !config.secret) {
-      logger6.warn("WeCom installation missing botId/secret, skipping", { installationId });
+      logger7.warn("WeCom installation missing botId/secret, skipping", { installationId });
       return;
     }
     if (activeConnections2.has(installationId)) {
-      logger6.warn("WeCom long connection already running, skipping", { installationId });
+      logger7.warn("WeCom long connection already running, skipping", { installationId });
       return;
     }
     const { router, wsClientFactory } = deps ?? {};
@@ -31661,7 +32338,7 @@ var wecomChannelAdapter = {
         if (!inbound || !router) return void 0;
         return router.dispatch(inbound);
       }).catch((error) => {
-        logger6.error("WeCom message dispatch error", {
+        logger7.error("WeCom message dispatch error", {
           installationId,
           error: error instanceof Error ? error.message : String(error)
         });
@@ -31674,19 +32351,19 @@ var wecomChannelAdapter = {
       connection.attempts = 0;
     });
     client.on("event.disconnected_event", () => {
-      logger6.warn("WeCom connection kicked by a newer connection; will reconnect", {
+      logger7.warn("WeCom connection kicked by a newer connection; will reconnect", {
         installationId
       });
       scheduleReconnect(installationId, connection);
     });
     activeConnections2.set(installationId, connection);
     client.connect();
-    logger6.info("WeCom long connection starting", { installationId, tenantId });
+    logger7.info("WeCom long connection starting", { installationId, tenantId });
   },
   async disconnect(installationId) {
     const connection = activeConnections2.get(installationId);
     if (!connection) {
-      logger6.warn("WeCom long connection not running, nothing to disconnect", { installationId });
+      logger7.warn("WeCom long connection not running, nothing to disconnect", { installationId });
       return;
     }
     connection.intentional = true;
@@ -31697,20 +32374,20 @@ var wecomChannelAdapter = {
     try {
       connection.client.disconnect();
     } catch (error) {
-      logger6.error("WeCom long connection stop error", {
+      logger7.error("WeCom long connection stop error", {
         installationId,
         error: error instanceof Error ? error.message : String(error)
       });
     }
     activeConnections2.delete(installationId);
-    logger6.info("WeCom long connection disconnected", { installationId });
+    logger7.info("WeCom long connection disconnected", { installationId });
   }
 };
 function scheduleReconnect(installationId, connection) {
   if (connection.intentional || connection.timer) return;
   const delay3 = Math.min(RECONNECT_BASE_MS * 2 ** connection.attempts, RECONNECT_MAX_MS);
   connection.attempts += 1;
-  logger6.info("WeCom reconnect scheduled", {
+  logger7.info("WeCom reconnect scheduled", {
     installationId,
     delayMs: delay3,
     attempt: connection.attempts
@@ -31723,7 +32400,7 @@ function scheduleReconnect(installationId, connection) {
     try {
       connection.client.connect();
     } catch (error) {
-      logger6.error("WeCom reconnect failed", {
+      logger7.error("WeCom reconnect failed", {
         installationId,
         error: error instanceof Error ? error.message : String(error)
       });
@@ -31870,19 +32547,17 @@ import {
   getLoggerLattice,
   loggerLatticeManager,
   sandboxLatticeManager as sandboxLatticeManager2,
-  getStoreLattice as getStoreLattice41,
+  getStoreLattice as getStoreLattice42,
   agentInstanceManager as agentInstanceManager13,
   createSandboxProvider,
   TokenCache,
   mcpManager as mcpManager3,
   convertToConnection as convertToConnection2,
   createTrustedAgentMessageDispatcher as createTrustedAgentMessageDispatcher2,
-  connectAllChannels,
-  disconnectAllChannels,
   ChannelConnectionLeader,
   runAsLeader,
   configureCoordinationLeaseStore,
-  getReplicaId as getReplicaId11,
+  getReplicaId as getReplicaId12,
   tryAcquireThreadRun as tryAcquireThreadRun5,
   taskLifecycleNotifier as taskLifecycleNotifier3,
   projectTaskAdmissionNotifier as projectTaskAdmissionNotifier2,
@@ -31895,6 +32570,7 @@ import {
   configureCollectionSync,
   COLLECTION_CHANGED_TOPIC,
   vectorStoreLatticeManager as vectorStoreLatticeManager2,
+  observabilityLatticeManager,
   getSandboxPluginCatalog as getSandboxPluginCatalog3,
   getSandBoxManager as getSandBoxManager4,
   installPluginHost,
@@ -31906,7 +32582,7 @@ import {
 } from "@axiom-lattice/core";
 
 // src/services/chunk/redisAppendLog.ts
-import { createClient as createClient2 } from "redis";
+import { createClient as createClient3 } from "redis";
 var VALUE_FIELD = "v";
 var START_ID = "0-0";
 var ChunkLogCorruptionError = class extends Error {
@@ -31923,7 +32599,7 @@ var ChunkLogCorruptionError = class extends Error {
   }
 };
 async function createRedisAppendLog(url, options = {}) {
-  const client = createClient2({
+  const client = createClient3({
     url,
     disableOfflineQueue: true,
     socket: {
@@ -32113,7 +32789,7 @@ function readField(fields, name) {
 }
 
 // src/services/run-cancel/RedisRunCancelNotifier.ts
-import { createClient as createClient3 } from "redis";
+import { createClient as createClient4 } from "redis";
 import {
   runCancelSignalSchema as runCancelSignalSchema2
 } from "@axiom-lattice/protocols";
@@ -32514,7 +33190,7 @@ function createRedisRunCancelNotifier(options) {
   });
 }
 function createNodeRedisClient2(url) {
-  const client = createClient3({
+  const client = createClient4({
     url,
     disableOfflineQueue: true,
     socket: {
@@ -32570,13 +33246,13 @@ import { RoomAgentMessageService } from "@axiom-lattice/core";
 
 // src/router/MessageRouter.ts
 import {
-  getStoreLattice as getStoreLattice38,
+  getStoreLattice as getStoreLattice39,
   agentInstanceManager as agentInstanceManager10
 } from "@axiom-lattice/core";
 import {
   snapshotExactArray as snapshotExactArray3,
   snapshotExactRecord as snapshotExactRecord15,
-  MessageChunkTypes as MessageChunkTypes5
+  MessageChunkTypes as MessageChunkTypes4
 } from "@axiom-lattice/protocols";
 import { randomUUID as randomUUID35 } from "crypto";
 
@@ -32895,7 +33571,7 @@ var _MessageRouter = class _MessageRouter {
             channel: message.channel,
             adapterChannel: adapter.channel
           }, "Thread resolved by adapter strategy");
-          const threadStore = getStoreLattice38("default", "thread").store;
+          const threadStore = getStoreLattice39("default", "thread").store;
           try {
             await threadStore.createThread(
               tenantId,
@@ -32932,7 +33608,7 @@ var _MessageRouter = class _MessageRouter {
           }
         }
         if (!threadId) {
-          const threadStore = getStoreLattice38("default", "thread").store;
+          const threadStore = getStoreLattice39("default", "thread").store;
           const newThreadId = randomUUID35();
           console.log({
             event: "dispatch:thread:create",
@@ -33167,8 +33843,8 @@ var _MessageRouter = class _MessageRouter {
       ...metadata && typeof metadata === "object" && !Array.isArray(metadata) ? metadata : {},
       channelRun: true
     };
-    const runLedger = getStoreLattice38("default", "agentRun").store;
-    const jobStore = getStoreLattice38("default", "channelReplyJob").store;
+    const runLedger = getStoreLattice39("default", "agentRun").store;
+    const jobStore = getStoreLattice39("default", "channelReplyJob").store;
     const runId = randomUUID35();
     await jobStore.create({
       runId,
@@ -33266,13 +33942,13 @@ var _MessageRouter = class _MessageRouter {
       for await (const chunk of stream) {
         if (state.finished) break;
         if (!started) {
-          if (chunk?.type === MessageChunkTypes5.HUMAN && chunk?.data?.id === inputMessageId) {
+          if (chunk?.type === MessageChunkTypes4.HUMAN && chunk?.data?.id === inputMessageId) {
             started = true;
           }
           continue;
         }
-        if (chunk?.type === MessageChunkTypes5.MESSAGE_COMPLETED || chunk?.type === MessageChunkTypes5.MESSAGE_FAILED || chunk?.type === MessageChunkTypes5.INTERRUPT) {
-          if (chunk.type === MessageChunkTypes5.MESSAGE_COMPLETED) {
+        if (chunk?.type === MessageChunkTypes4.MESSAGE_COMPLETED || chunk?.type === MessageChunkTypes4.MESSAGE_FAILED || chunk?.type === MessageChunkTypes4.INTERRUPT) {
+          if (chunk.type === MessageChunkTypes4.MESSAGE_COMPLETED) {
             normalEnd = true;
             const grace = setTimeout(
               () => {
@@ -33281,14 +33957,14 @@ var _MessageRouter = class _MessageRouter {
               _MessageRouter.COMPLETION_GRACE_MS
             );
             grace.unref?.();
-          } else if (chunk.type === MessageChunkTypes5.MESSAGE_FAILED) {
+          } else if (chunk.type === MessageChunkTypes4.MESSAGE_FAILED) {
             await closeWith("failed");
           } else {
             await closeWith("interrupted");
           }
           break;
         }
-        if (chunk?.type !== MessageChunkTypes5.AI) continue;
+        if (chunk?.type !== MessageChunkTypes4.AI) continue;
         const text = typeof chunk.data?.content === "string" ? chunk.data.content : void 0;
         if (!text) continue;
         accumulated += text;
@@ -34589,11 +35265,11 @@ function readPluginDeploymentLimits(env = process.env) {
   };
 }
 function startPluginDeploymentRuntime(options) {
-  const { lease, holder, logger: logger8 } = options;
+  const { lease, holder, logger: logger9 } = options;
   const forcedOn = process.env[PLUGIN_DEPLOYMENT_RUNTIME_FLAG] === "true" || process.env[PLUGIN_DEPLOYMENT_RUNTIME_FLAG] === "1";
   const effectiveServiceBaseUrl = options.wiring.serviceBaseUrl ?? process.env.MICROSANDBOX_SERVICE_BASE_URL;
   if (forcedOn && !effectiveServiceBaseUrl) {
-    logger8.warn(
+    logger9.warn(
       `${PLUGIN_DEPLOYMENT_RUNTIME_FLAG} is enabled but MICROSANDBOX_SERVICE_BASE_URL is empty; skipping plugin deployment runtime`,
       { holder }
     );
@@ -34612,8 +35288,8 @@ function startPluginDeploymentRuntime(options) {
   };
   const service2 = createService(deps);
   register(service2);
-  logger8.info("plugin deployment runtime started", { holder });
-  const reconcile = runStartupReconcile(service2, reconcileDeadlineMs, logger8, holder);
+  logger9.info("plugin deployment runtime started", { holder });
+  const reconcile = runStartupReconcile(service2, reconcileDeadlineMs, logger9, holder);
   let held = false;
   let inFlight = false;
   const tick = async () => {
@@ -34621,18 +35297,18 @@ function startPluginDeploymentRuntime(options) {
     inFlight = true;
     try {
       if (held) {
-        held = await renewLease(lease, holder, logger8);
+        held = await renewLease(lease, holder, logger9);
         if (!held) {
-          logger8.warn("plugin deployment lease lost; watchdog paused", { holder });
+          logger9.warn("plugin deployment lease lost; watchdog paused", { holder });
         }
       } else {
-        held = await acquireLease(lease, holder, logger8);
+        held = await acquireLease(lease, holder, logger9);
         if (held) {
-          logger8.info("plugin deployment lease acquired", { holder });
+          logger9.info("plugin deployment lease acquired", { holder });
         }
       }
       if (!held) return;
-      await runWatchdog(service2, holder, logger8);
+      await runWatchdog(service2, holder, logger9);
     } finally {
       inFlight = false;
     }
@@ -34648,7 +35324,7 @@ function startPluginDeploymentRuntime(options) {
         try {
           await lease.release(PLUGIN_DEPLOYMENT_LEASE_KEY, holder);
         } catch (error) {
-          logger8.warn("plugin deployment lease release failed", {
+          logger9.warn("plugin deployment lease release failed", {
             holder,
             error: errorMessage8(error)
           });
@@ -34656,16 +35332,16 @@ function startPluginDeploymentRuntime(options) {
         held = false;
       }
       register(void 0);
-      logger8.info("plugin deployment runtime stopped", { holder });
+      logger9.info("plugin deployment runtime stopped", { holder });
     }
   };
 }
-async function runStartupReconcile(service2, deadlineMs, logger8, holder) {
+async function runStartupReconcile(service2, deadlineMs, logger9, holder) {
   try {
     await withDeadline(service2.startupReconcile(), deadlineMs);
-    logger8.info("plugin deployment startup reconcile complete", { holder });
+    logger9.info("plugin deployment startup reconcile complete", { holder });
   } catch (error) {
-    logger8.warn("plugin deployment startup reconcile failed", {
+    logger9.warn("plugin deployment startup reconcile failed", {
       holder,
       error: errorMessage8(error)
     });
@@ -34688,7 +35364,7 @@ async function withDeadline(work, deadlineMs) {
     if (timer !== void 0) clearTimeout(timer);
   }
 }
-async function acquireLease(lease, holder, logger8) {
+async function acquireLease(lease, holder, logger9) {
   try {
     return await lease.tryAcquire(
       PLUGIN_DEPLOYMENT_LEASE_KEY,
@@ -34696,14 +35372,14 @@ async function acquireLease(lease, holder, logger8) {
       PLUGIN_DEPLOYMENT_LEASE_TTL_MS
     );
   } catch (error) {
-    logger8.warn("plugin deployment lease acquire failed", {
+    logger9.warn("plugin deployment lease acquire failed", {
       holder,
       error: errorMessage8(error)
     });
     return false;
   }
 }
-async function renewLease(lease, holder, logger8) {
+async function renewLease(lease, holder, logger9) {
   try {
     return await lease.renew(
       PLUGIN_DEPLOYMENT_LEASE_KEY,
@@ -34711,18 +35387,18 @@ async function renewLease(lease, holder, logger8) {
       PLUGIN_DEPLOYMENT_LEASE_TTL_MS
     );
   } catch (error) {
-    logger8.warn("plugin deployment lease renew failed", {
+    logger9.warn("plugin deployment lease renew failed", {
       holder,
       error: errorMessage8(error)
     });
     return false;
   }
 }
-async function runWatchdog(service2, holder, logger8) {
+async function runWatchdog(service2, holder, logger9) {
   try {
     await service2.healthWatchdog();
   } catch (error) {
-    logger8.warn("plugin deployment health watchdog failed", {
+    logger9.warn("plugin deployment health watchdog failed", {
       holder,
       error: errorMessage8(error)
     });
@@ -34822,8 +35498,8 @@ function resolveRetentionMs(value) {
 
 // src/services/execution/threadTtlSweeper.ts
 import {
-  getReplicaId as getReplicaId10,
-  getStoreLattice as getStoreLattice39,
+  getReplicaId as getReplicaId11,
+  getStoreLattice as getStoreLattice40,
   tryAcquireThreadRun as tryAcquireThreadRun2
 } from "@axiom-lattice/core";
 function createThreadTtlSweeper(options) {
@@ -34841,7 +35517,7 @@ function createThreadTtlSweeper(options) {
     const result = { scanned: 0, pruned: 0, skipped: 0, errors: 0 };
     let expired;
     try {
-      expired = await getStoreLattice39("default", "thread").store.listExpiredThreads(now(), batchSize);
+      expired = await getStoreLattice40("default", "thread").store.listExpiredThreads(now(), batchSize);
     } catch (error) {
       result.errors += 1;
       log2.warn("Thread TTL sweep failed to list expired threads", {
@@ -34854,11 +35530,11 @@ function createThreadTtlSweeper(options) {
       let lease;
       try {
         lease = await tryAcquireThreadRun2({
-          store: getStoreLattice39("default", "lease").store,
+          store: getStoreLattice40("default", "lease").store,
           tenantId: thread.tenantId,
           assistantId: thread.assistantId,
           threadId: thread.id,
-          owner: getReplicaId10(),
+          owner: getReplicaId11(),
           ttlMs: 6e4
         });
       } catch (error) {
@@ -34874,7 +35550,7 @@ function createThreadTtlSweeper(options) {
         continue;
       }
       try {
-        const queueStore = getStoreLattice39("default", "threadMessageQueue").store;
+        const queueStore = getStoreLattice40("default", "threadMessageQueue").store;
         const pending2 = await queueStore.getPendingMessages(thread.id, queueScopeFromThread(thread));
         if (pending2.length > 0) {
           result.skipped += 1;
@@ -34951,7 +35627,7 @@ function createThreadTtlSweeper(options) {
 }
 
 // src/services/execution/storeTtlSweeper.ts
-import { getStoreLattice as getStoreLattice40 } from "@axiom-lattice/core";
+import { getStoreLattice as getStoreLattice41 } from "@axiom-lattice/core";
 function parsePositiveInteger(value, fallback) {
   const parsed = Number(value);
   return Number.isSafeInteger(parsed) && parsed >= 1 ? parsed : fallback;
@@ -34974,7 +35650,7 @@ function createStoreTtlSweeper(options) {
   const performSweep = async () => {
     let store2;
     try {
-      store2 = getStoreLattice40("default", "store").store;
+      store2 = getStoreLattice41("default", "store").store;
     } catch (error) {
       if (!warnedMissingStore) {
         warnedMissingStore = true;
@@ -36415,7 +37091,7 @@ function createAgentRunRetentionJob(input) {
 }
 
 // src/services/run-task/RedisRunTaskWake.ts
-import { createClient as createClient4 } from "redis";
+import { createClient as createClient5 } from "redis";
 var RUN_TASK_WAKE_CHANNEL = "run-task:wake";
 var DEFAULT_OPERATION_TIMEOUT_MS = 2e3;
 var DEFAULT_RETRY_DELAYS_MS = [500, 2e3, 5e3, 1e4];
@@ -36808,7 +37484,7 @@ function createConfiguredRedisRunTaskWake(options) {
   return createRedisRunTaskWake({ ...options, url });
 }
 function createNodeRedisClient3(url) {
-  const client = createClient4({
+  const client = createClient5({
     url,
     disableOfflineQueue: true,
     socket: {
@@ -36916,6 +37592,19 @@ function ingestRoomEvent(payload, broker) {
   return broker.ingestForeignEvent(serialized);
 }
 
+// src/services/channelInstallationSync.ts
+var CHANNEL_INSTALLATION_CHANGED_TOPIC = "channel-installation-changed";
+async function publishChannelInstallationChanged(outbox, owner, payload) {
+  try {
+    await outbox.append({
+      topic: CHANNEL_INSTALLATION_CHANGED_TOPIC,
+      payload,
+      originReplicaId: owner
+    });
+  } catch {
+  }
+}
+
 // src/services/assistantRegistrySync.ts
 var ASSISTANT_CHANGE_EVENTS = ["assistant:created", "assistant:updated", "assistant:deleted"];
 var ASSISTANT_CHANGED_TOPIC = "assistant-changed";
@@ -37000,6 +37689,743 @@ import {
   REPLICA_HEADER as REPLICA_HEADER3,
   AFFINITY_ECHO_HEADER as AFFINITY_ECHO_HEADER3
 } from "@axiom-lattice/protocols";
+
+// src/services/observability/LangfuseObservabilityProvider.ts
+import { Buffer as Buffer2 } from "buffer";
+import { NodeTracerProvider } from "@opentelemetry/sdk-trace-node";
+import { LangfuseSpanProcessor } from "@langfuse/otel";
+import { CallbackHandler } from "@langfuse/langchain";
+import {
+  ObservabilityDashboardUnavailableError as ObservabilityDashboardUnavailableError2,
+  ObservabilityDashboardUnsupportedError as ObservabilityDashboardUnsupportedError2
+} from "@axiom-lattice/core";
+import {
+  LANGFUSE_OBSERVABILITY_DASHBOARD_VERSION
+} from "@axiom-lattice/protocols";
+
+// src/services/observability/LangfuseDashboardQueries.ts
+var DASHBOARD_SECTIONS = [
+  "traces",
+  "agentTraces",
+  "costTokens",
+  "latency",
+  "errors",
+  "agents",
+  "models",
+  "tools",
+  "toolCalls"
+];
+var V1_METRICS_SECTIONS = /* @__PURE__ */ new Set([
+  "traces",
+  "agentTraces"
+]);
+var RANGE_MS = {
+  "1h": 60 * 60 * 1e3,
+  "24h": 24 * 60 * 60 * 1e3,
+  "7d": 7 * 24 * 60 * 60 * 1e3,
+  "30d": 30 * 24 * 60 * 60 * 1e3
+};
+var GRANULARITY = {
+  "1h": "minute",
+  "24h": "hour",
+  "7d": "hour",
+  "30d": "day"
+};
+var ROOT_FILTER = {
+  column: "isRootObservation",
+  operator: "=",
+  value: true,
+  type: "boolean"
+};
+function typeFilter(value) {
+  return {
+    column: "type",
+    operator: "any of",
+    value: [value],
+    type: "stringOptions"
+  };
+}
+function buildDashboardQueries(input) {
+  const now = input.now ?? /* @__PURE__ */ new Date();
+  const fromTimestamp = new Date(
+    now.getTime() - RANGE_MS[input.range]
+  ).toISOString();
+  const toTimestamp = now.toISOString();
+  const filters = [
+    {
+      column: "metadata",
+      operator: "=",
+      value: input.tenantId,
+      type: "stringObject",
+      key: "x-tenant-id"
+    }
+  ];
+  if (input.environment) {
+    filters.push({
+      column: "environment",
+      operator: "=",
+      value: input.environment,
+      type: "string"
+    });
+  }
+  const timeDimension = { granularity: GRANULARITY[input.range] };
+  const window = { fromTimestamp, toTimestamp };
+  return {
+    traces: {
+      view: "traces",
+      metrics: [{ measure: "count", aggregation: "count" }],
+      filters,
+      timeDimension,
+      ...window,
+      config: { row_limit: 1e3 }
+    },
+    agentTraces: {
+      view: "traces",
+      metrics: [{ measure: "count", aggregation: "count" }],
+      dimensions: [{ field: "tags" }, { field: "name" }],
+      filters,
+      orderBy: [{ field: "count_count", direction: "desc" }],
+      ...window,
+      config: { row_limit: 1e3 }
+    },
+    costTokens: {
+      view: "observations",
+      metrics: [
+        { measure: "totalCost", aggregation: "sum" },
+        { measure: "inputTokens", aggregation: "sum" },
+        { measure: "outputTokens", aggregation: "sum" }
+      ],
+      dimensions: [{ field: "providedModelName" }],
+      filters: [...filters, typeFilter("GENERATION")],
+      timeDimension,
+      ...window,
+      config: { row_limit: 1e3 }
+    },
+    latency: {
+      view: "observations",
+      metrics: [
+        { measure: "latency", aggregation: "p50" },
+        { measure: "latency", aggregation: "p95" },
+        { measure: "latency", aggregation: "p99" }
+      ],
+      filters: [...filters, ROOT_FILTER],
+      timeDimension,
+      ...window,
+      config: { row_limit: 1e3 }
+    },
+    errors: {
+      view: "observations",
+      metrics: [{ measure: "count", aggregation: "count" }],
+      dimensions: [{ field: "level" }],
+      filters,
+      timeDimension,
+      ...window,
+      config: { row_limit: 1e3 }
+    },
+    agents: {
+      view: "observations",
+      metrics: [
+        { measure: "count", aggregation: "count" },
+        { measure: "totalCost", aggregation: "sum" },
+        { measure: "inputTokens", aggregation: "sum" },
+        { measure: "outputTokens", aggregation: "sum" }
+      ],
+      dimensions: [{ field: "tags" }, { field: "level" }],
+      filters,
+      orderBy: [{ field: "count_count", direction: "desc" }],
+      ...window,
+      config: { row_limit: 1e3 }
+    },
+    models: {
+      view: "observations",
+      metrics: [
+        { measure: "count", aggregation: "count" },
+        { measure: "totalCost", aggregation: "sum" },
+        { measure: "inputTokens", aggregation: "sum" },
+        { measure: "outputTokens", aggregation: "sum" },
+        { measure: "latency", aggregation: "p95" }
+      ],
+      dimensions: [{ field: "providedModelName" }],
+      filters: [...filters, typeFilter("GENERATION")],
+      orderBy: [{ field: "count_count", direction: "desc" }],
+      ...window,
+      config: { row_limit: 20 }
+    },
+    tools: {
+      view: "observations",
+      metrics: [{ measure: "count", aggregation: "count" }],
+      dimensions: [{ field: "name" }],
+      filters: [...filters, typeFilter("TOOL")],
+      orderBy: [{ field: "count_count", direction: "desc" }],
+      ...window,
+      config: { row_limit: 20 }
+    },
+    toolCalls: {
+      view: "observations",
+      metrics: [{ measure: "count", aggregation: "count" }],
+      filters: [...filters, typeFilter("TOOL")],
+      timeDimension,
+      ...window,
+      config: { row_limit: 1e3 }
+    }
+  };
+}
+function rowsOf(data) {
+  if (!data || typeof data !== "object") return [];
+  const rows = data.data;
+  if (!Array.isArray(rows)) return [];
+  return rows.filter(
+    (row) => row !== null && typeof row === "object" && !Array.isArray(row)
+  );
+}
+function numberOf(row, key) {
+  const value = row[key];
+  return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+function nullableNumber(row, key) {
+  const value = row[key];
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function isoBucket(row) {
+  const raw = row.time_dimension ?? row.timestamp;
+  if (typeof raw !== "string" || raw.length === 0) return null;
+  const parsed = new Date(raw);
+  return Number.isFinite(parsed.getTime()) ? parsed.toISOString() : null;
+}
+function toSeries(data, key) {
+  const points = [];
+  for (const row of rowsOf(data)) {
+    const bucket = isoBucket(row);
+    if (!bucket) continue;
+    points.push({ bucket, value: nullableNumber(row, key) });
+  }
+  return points.sort((a, b) => a.bucket.localeCompare(b.bucket));
+}
+function sumSeries(points) {
+  return points.reduce((total, point) => total + (point.value ?? 0), 0);
+}
+function toAggregatedSeries(data, key) {
+  const buckets = /* @__PURE__ */ new Map();
+  for (const row of rowsOf(data)) {
+    const bucket = isoBucket(row);
+    if (!bucket) continue;
+    buckets.set(bucket, (buckets.get(bucket) ?? 0) + (nullableNumber(row, key) ?? 0));
+  }
+  return [...buckets.entries()].sort(([a], [b]) => a.localeCompare(b)).map(([bucket, value]) => ({ bucket, value }));
+}
+function parseCostByModel(data) {
+  const byModel = /* @__PURE__ */ new Map();
+  for (const row of rowsOf(data)) {
+    const bucket = isoBucket(row);
+    if (!bucket) continue;
+    const model = typeof row.providedModelName === "string" && row.providedModelName ? row.providedModelName : "unknown";
+    const points = byModel.get(model) ?? [];
+    points.push({ bucket, value: nullableNumber(row, "sum_totalCost") });
+    byModel.set(model, points);
+  }
+  return [...byModel.entries()].map(([model, points]) => ({
+    model,
+    points: points.sort((a, b) => a.bucket.localeCompare(b.bucket))
+  })).filter((series) => sumSeries(series.points) !== 0).sort((a, b) => sumSeries(b.points) - sumSeries(a.points));
+}
+function parseLevelSeries(data) {
+  const buckets = /* @__PURE__ */ new Map();
+  for (const row of rowsOf(data)) {
+    const bucket = isoBucket(row);
+    if (!bucket) continue;
+    const current3 = buckets.get(bucket) ?? { total: 0, errors: 0 };
+    const count = numberOf(row, "count_count");
+    current3.total += count;
+    if (row.level === "ERROR") current3.errors += count;
+    buckets.set(bucket, current3);
+  }
+  return [...buckets.entries()].sort(([a], [b]) => a.localeCompare(b)).map(([bucket, value]) => ({
+    bucket,
+    value: value.total > 0 ? value.errors / value.total : 0
+  }));
+}
+function parseModels(data) {
+  return rowsOf(data).map((row) => ({
+    model: typeof row.providedModelName === "string" && row.providedModelName ? row.providedModelName : "unknown",
+    count: numberOf(row, "count_count"),
+    costUsd: numberOf(row, "sum_totalCost"),
+    inputTokens: numberOf(row, "sum_inputTokens"),
+    outputTokens: numberOf(row, "sum_outputTokens"),
+    p95LatencyMs: nullableNumber(row, "p95_latency")
+  })).filter((row) => row.count > 0).sort((a, b) => b.count - a.count);
+}
+function assistantIdFromTags(tags) {
+  if (!Array.isArray(tags)) return "unattributed";
+  const assistantTag = tags.find(
+    (tag) => typeof tag === "string" && tag.startsWith("assistant:")
+  );
+  if (!assistantTag) return "unattributed";
+  const assistantId = assistantTag.slice("assistant:".length);
+  return assistantId.length > 0 ? assistantId : "unattributed";
+}
+function parseAgentTraces(data) {
+  const byAgent = /* @__PURE__ */ new Map();
+  for (const row of rowsOf(data)) {
+    const assistantId = assistantIdFromTags(row.tags);
+    const current3 = byAgent.get(assistantId) ?? {
+      calls: 0,
+      names: /* @__PURE__ */ new Map()
+    };
+    const count = numberOf(row, "count_count");
+    current3.calls += count;
+    const name = typeof row.name === "string" ? row.name.trim() : "";
+    if (name) {
+      current3.names.set(name, (current3.names.get(name) ?? 0) + count);
+    }
+    byAgent.set(assistantId, current3);
+  }
+  return byAgent;
+}
+function parseAgents(observationData, traceData) {
+  const observations = /* @__PURE__ */ new Map();
+  for (const row of rowsOf(observationData)) {
+    const assistantId = assistantIdFromTags(row.tags);
+    const current3 = observations.get(assistantId) ?? {
+      observations: 0,
+      costUsd: 0,
+      inputTokens: 0,
+      outputTokens: 0,
+      errorCount: 0
+    };
+    const count = numberOf(row, "count_count");
+    current3.observations += count;
+    current3.costUsd += numberOf(row, "sum_totalCost");
+    current3.inputTokens += numberOf(row, "sum_inputTokens");
+    current3.outputTokens += numberOf(row, "sum_outputTokens");
+    if (row.level === "ERROR") current3.errorCount += count;
+    observations.set(assistantId, current3);
+  }
+  const traces = parseAgentTraces(traceData);
+  const ids = /* @__PURE__ */ new Set([...observations.keys(), ...traces.keys()]);
+  return [...ids].map((assistantId) => {
+    const observation = observations.get(assistantId) ?? {
+      observations: 0,
+      costUsd: 0,
+      inputTokens: 0,
+      outputTokens: 0,
+      errorCount: 0
+    };
+    const trace = traces.get(assistantId);
+    const bestName = trace ? [...trace.names.entries()].sort((a, b) => b[1] - a[1])[0]?.[0] : void 0;
+    return {
+      assistantId,
+      ...bestName ? { name: bestName } : {},
+      calls: trace?.calls ?? 0,
+      observations: observation.observations,
+      costUsd: observation.costUsd,
+      inputTokens: observation.inputTokens,
+      outputTokens: observation.outputTokens,
+      errorCount: observation.errorCount,
+      errorRate: observation.observations > 0 ? observation.errorCount / observation.observations : 0
+    };
+  }).sort(
+    (a, b) => b.calls - a.calls || b.observations - a.observations
+  );
+}
+function parseTools(data) {
+  return rowsOf(data).map((row) => ({
+    tool: typeof row.name === "string" && row.name ? row.name : "unknown",
+    count: numberOf(row, "count_count")
+  })).filter((row) => row.count > 0);
+}
+function assembleLangfuseDashboard(input) {
+  const warnings = DASHBOARD_SECTIONS.filter(
+    (section) => input.responses[section] === void 0
+  );
+  const tracesSeries = toSeries(input.responses.traces, "count_count");
+  const costSeries = toAggregatedSeries(
+    input.responses.costTokens,
+    "sum_totalCost"
+  );
+  const inputTokenSeries = toAggregatedSeries(
+    input.responses.costTokens,
+    "sum_inputTokens"
+  );
+  const outputTokenSeries = toAggregatedSeries(
+    input.responses.costTokens,
+    "sum_outputTokens"
+  );
+  const latencyP50 = toSeries(input.responses.latency, "p50_latency");
+  const latencyP95 = toSeries(input.responses.latency, "p95_latency");
+  const latencyP99 = toSeries(input.responses.latency, "p99_latency");
+  const errorRateSeries = parseLevelSeries(input.responses.errors);
+  const errorRows = rowsOf(input.responses.errors);
+  const totalObservationCount = errorRows.reduce(
+    (total, row) => total + numberOf(row, "count_count"),
+    0
+  );
+  const totalErrors = errorRows.filter((row) => row.level === "ERROR").reduce((total, row) => total + numberOf(row, "count_count"), 0);
+  const traces = sumSeries(tracesSeries);
+  return {
+    warnings,
+    payload: {
+      samplingRate: input.samplingRate,
+      kpis: {
+        traces,
+        costUsd: sumSeries(costSeries),
+        inputTokens: sumSeries(inputTokenSeries),
+        outputTokens: sumSeries(outputTokenSeries),
+        errorRate: totalObservationCount > 0 ? totalErrors / totalObservationCount : 0
+      },
+      series: {
+        traces: tracesSeries,
+        cost: costSeries,
+        tokens: {
+          input: inputTokenSeries,
+          output: outputTokenSeries
+        },
+        latency: {
+          p50: latencyP50,
+          p95: latencyP95,
+          p99: latencyP99
+        },
+        errorRate: errorRateSeries,
+        toolCalls: toSeries(input.responses.toolCalls, "count_count"),
+        costByModel: parseCostByModel(input.responses.costTokens)
+      },
+      agents: parseAgents(
+        input.responses.agents,
+        input.responses.agentTraces
+      ),
+      models: parseModels(input.responses.models),
+      tools: parseTools(input.responses.tools)
+    }
+  };
+}
+
+// src/services/observability/LangfuseObservabilityProvider.ts
+function parseSampleRate(raw) {
+  const trimmed = raw?.trim();
+  if (!trimmed) return 1;
+  const value = Number(trimmed);
+  if (!Number.isFinite(value)) return 1;
+  return Math.min(1, Math.max(0, value));
+}
+function readLangfuseConfig(env = process.env) {
+  if (env.LANGFUSE_ENABLED?.trim() !== "true") return void 0;
+  const publicKey = env.LANGFUSE_PUBLIC_KEY?.trim();
+  const secretKey = env.LANGFUSE_SECRET_KEY?.trim();
+  const baseUrl = env.LANGFUSE_BASE_URL?.trim();
+  if (!publicKey || !secretKey || !baseUrl) return void 0;
+  return {
+    publicKey,
+    secretKey,
+    baseUrl,
+    uiUrl: env.LANGFUSE_UI_URL?.trim() || baseUrl,
+    ...env.LANGFUSE_RELEASE?.trim() ? { release: env.LANGFUSE_RELEASE.trim() } : {},
+    ...env.LANGFUSE_TRACING_ENVIRONMENT?.trim() ? { environment: env.LANGFUSE_TRACING_ENVIRONMENT.trim() } : {},
+    sampleRate: parseSampleRate(env.LANGFUSE_SAMPLE_RATE)
+  };
+}
+var USAGE_KEYS = /* @__PURE__ */ new Set([
+  "max_tokens",
+  "input_tokens",
+  "output_tokens",
+  "token_usage"
+]);
+var STRONG_SECRET_SUBSTRINGS = [
+  "apikey",
+  "authorization",
+  "secret",
+  "password",
+  "passwd",
+  "privatekey",
+  "credential",
+  "clientkey"
+];
+var SECRET_SUBSTRINGS = [...STRONG_SECRET_SUBSTRINGS, "token"];
+function keyWords(key) {
+  return key.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").split(/[^A-Za-z0-9]+/).filter(Boolean).map((word) => word.toLowerCase());
+}
+function isSecretKey(key) {
+  const words = keyWords(key);
+  const snake = words.join("_");
+  const compact2 = words.join("");
+  const components = new Set(words);
+  const strongSecret = STRONG_SECRET_SUBSTRINGS.some(
+    (substring) => compact2.includes(substring)
+  ) || components.has("private") && components.has("key") || components.has("api") && components.has("key");
+  if (strongSecret) return true;
+  const tokenUsage = components.has("token") && (components.has("count") || components.has("usage") || components.has("details"));
+  if (USAGE_KEYS.has(snake) || snake.endsWith("_tokens") || snake.endsWith("token_usage") || tokenUsage) {
+    return false;
+  }
+  return SECRET_SUBSTRINGS.some((substring) => compact2.includes(substring));
+}
+function redactText(value) {
+  return value.replace(/Bearer\s+[A-Za-z0-9._~+/=-]+/gi, "Bearer [redacted]").replace(/sk-[A-Za-z0-9_-]{8,}/g, "[redacted]");
+}
+function redactString(value) {
+  const first = value.trimStart()[0];
+  if (first === "{" || first === "[" || first === '"') {
+    try {
+      const redacted = JSON.stringify(redactLangfuseValue(JSON.parse(value)));
+      return redacted ?? "null";
+    } catch {
+    }
+  }
+  return redactText(value);
+}
+function redactLangfuseValue(value) {
+  if (typeof value === "string") return redactString(value);
+  if (Array.isArray(value)) return value.map(redactLangfuseValue);
+  if (typeof value === "object" && value !== null) {
+    return Object.fromEntries(
+      Object.entries(value).map(([key, nested]) => [
+        key,
+        isSecretKey(key) ? "[redacted]" : redactLangfuseValue(nested)
+      ])
+    );
+  }
+  return value;
+}
+function tagsFor(context) {
+  return [
+    `tenant:${context.tenantId}`,
+    ...context.projectId ? [`project:${context.projectId}`] : [],
+    `assistant:${context.assistantId}`,
+    ...context.source ? [`source:${context.source}`] : []
+  ];
+}
+function traceMetadataFor(context) {
+  return {
+    tenant_id: context.tenantId,
+    ...context.projectId ? { project_id: context.projectId } : {},
+    ...context.workspaceId ? { workspace_id: context.workspaceId } : {},
+    assistant_id: context.assistantId,
+    thread_id: context.threadId,
+    run_id: context.runId,
+    ...context.taskId ? { task_id: context.taskId } : {},
+    ...context.source ? { source: context.source } : {}
+  };
+}
+function createLangfuseProviderFromEnv(env = process.env, logger9) {
+  const config = readLangfuseConfig(env);
+  return config ? new LangfuseObservabilityProvider(config, logger9) : void 0;
+}
+var LangfuseMetricsHttpError = class extends Error {
+  /**
+   * @param status - HTTP status returned by Langfuse.
+   */
+  constructor(status) {
+    super(`Langfuse metrics request failed with ${status}`);
+    this.status = status;
+    this.name = "LangfuseMetricsHttpError";
+  }
+};
+var LangfuseObservabilityProvider = class {
+  /**
+   * @param config - Parsed Langfuse configuration.
+   * @param logger - Optional best-effort lifecycle logger.
+   */
+  constructor(config, logger9) {
+    this.config = config;
+    this.logger = logger9;
+    this.type = "langfuse";
+    this.capabilities = {
+      autoCallbacks: true,
+      customObservations: false,
+      scores: false,
+      sessions: true,
+      promptManagement: false
+    };
+  }
+  warn(message, error) {
+    try {
+      this.logger?.warn(message, error);
+    } catch {
+    }
+  }
+  /**
+   * Start the OpenTelemetry tracer provider exporting to Langfuse.
+   *
+   * @remarks
+   * Never throws. If construction or registration fails, the provider is
+   * marked not started and any constructed tracer provider is shut down
+   * best-effort.
+   */
+  async start() {
+    if (this.tracerProvider) return;
+    let provider;
+    let processor;
+    try {
+      processor = new LangfuseSpanProcessor({
+        publicKey: this.config.publicKey,
+        secretKey: this.config.secretKey,
+        baseUrl: this.config.baseUrl,
+        ...this.config.release ? { release: this.config.release } : {},
+        ...this.config.environment ? { environment: this.config.environment } : {},
+        mask: ({ data }) => redactLangfuseValue(data)
+      });
+      provider = new NodeTracerProvider({ spanProcessors: [processor] });
+      provider.register();
+      this.tracerProvider = provider;
+    } catch (error) {
+      if (provider) {
+        try {
+          await provider.shutdown();
+        } catch (shutdownError) {
+          this.warn(
+            "langfuse observability start cleanup failed",
+            shutdownError
+          );
+        }
+      } else if (processor) {
+        try {
+          await processor.shutdown();
+        } catch (shutdownError) {
+          this.warn(
+            "langfuse observability start cleanup failed",
+            shutdownError
+          );
+        }
+      }
+      this.warn("langfuse observability start failed", error);
+    }
+  }
+  /**
+   * Flush pending spans and shut down the tracer provider.
+   *
+   * @remarks
+   * Never throws and is idempotent. OpenTelemetry has no process-wide
+   * unregister API, so the host must install exactly one provider instance per
+   * process; stopping flushes spans but does not remove the global registration.
+   */
+  async stop() {
+    const provider = this.tracerProvider;
+    this.tracerProvider = void 0;
+    if (!provider) return;
+    try {
+      await provider.shutdown();
+    } catch (error) {
+      this.warn("langfuse observability stop failed", error);
+    }
+  }
+  /**
+   * Fetches the Langfuse metrics dashboard for one tenant.
+   *
+   * @param input - Time range and server-resolved tenant scope.
+   * @returns The normalized Langfuse payload.
+   * @throws ObservabilityDashboardUnsupportedError for Langfuse < v4.
+   * @throws ObservabilityDashboardUnavailableError when every query fails.
+   */
+  async getDashboard(input) {
+    const queries = buildDashboardQueries({
+      range: input.range,
+      tenantId: input.tenantId,
+      ...this.config.environment ? { environment: this.config.environment } : {}
+    });
+    const settled = await Promise.all(
+      DASHBOARD_SECTIONS.map(async (section) => {
+        try {
+          const data = await this.fetchMetrics(queries[section], section);
+          return { section, data, ok: true };
+        } catch (error) {
+          return { section, error, ok: false };
+        }
+      })
+    );
+    const failures = settled.filter((item) => !item.ok);
+    if (failures.length === settled.length) {
+      if (failures.some(
+        (item) => !item.ok && item.error instanceof LangfuseMetricsHttpError && item.error.status === 404
+      )) {
+        throw new ObservabilityDashboardUnsupportedError2(
+          "Langfuse metrics dashboard requires Langfuse v4+"
+        );
+      }
+      throw new ObservabilityDashboardUnavailableError2(
+        "Langfuse metrics dashboard is unavailable"
+      );
+    }
+    const responses = {};
+    for (const item of settled) {
+      if (item.ok) responses[item.section] = item.data;
+    }
+    const assembled = assembleLangfuseDashboard({
+      responses,
+      samplingRate: this.config.sampleRate
+    });
+    return {
+      version: LANGFUSE_OBSERVABILITY_DASHBOARD_VERSION,
+      ...assembled.warnings.length > 0 ? { warnings: assembled.warnings } : {},
+      payload: {
+        ...assembled.payload,
+        ...this.config.environment ? { environment: this.config.environment } : {}
+      }
+    };
+  }
+  async fetchMetrics(query, section) {
+    const base = this.config.baseUrl.replace(/\/+$/, "");
+    const path5 = V1_METRICS_SECTIONS.has(section) ? "/api/public/metrics" : "/api/public/v2/metrics";
+    let url = new URL(`${base}${path5}`);
+    url.searchParams.set("query", JSON.stringify(query));
+    const auth = Buffer2.from(
+      `${this.config.publicKey}:${this.config.secretKey}`
+    ).toString("base64");
+    const headers = {
+      Authorization: `Basic ${auth}`,
+      Accept: "application/json"
+    };
+    const signal = AbortSignal.timeout(1e4);
+    for (let attempt = 0; attempt < 3; attempt++) {
+      const response = await fetch(url, {
+        headers,
+        redirect: "manual",
+        signal
+      });
+      if (response.status >= 300 && response.status < 400) {
+        const location = response.headers.get("location");
+        if (!location) throw new LangfuseMetricsHttpError(response.status);
+        const next = new URL(location, url);
+        if (next.protocol !== "http:" && next.protocol !== "https:") {
+          throw new LangfuseMetricsHttpError(response.status);
+        }
+        url = next;
+        continue;
+      }
+      if (!response.ok) throw new LangfuseMetricsHttpError(response.status);
+      return response.json();
+    }
+    throw new LangfuseMetricsHttpError(508);
+  }
+  /**
+   * Create a Langfuse callback handler for one invocation.
+   *
+   * @param context - Correlation fields for the running Agent invocation.
+   * @returns One callback handler, or an empty list before start or when
+   * sampled out.
+   */
+  createCallbacks(context) {
+    if (!this.tracerProvider) return [];
+    if (this.config.sampleRate <= 0) return [];
+    if (this.config.sampleRate < 1 && Math.random() >= this.config.sampleRate) {
+      return [];
+    }
+    return [
+      new CallbackHandler({
+        sessionId: context.threadId,
+        userId: context.userId,
+        tags: tagsFor(context),
+        traceMetadata: traceMetadataFor(context),
+        ...this.config.release ? { version: this.config.release } : {}
+      })
+    ];
+  }
+  /**
+   * @returns The configured Langfuse UI trace-list URL.
+   */
+  getTraceListUrl() {
+    return this.config.uiUrl;
+  }
+};
+
+// src/index.ts
 process.on("unhandledRejection", (reason, promise) => {
   console.error("\u672A\u5904\u7406\u7684Promise\u62D2\u7EDD:", reason);
 });
@@ -37011,7 +38437,7 @@ var DEFAULT_LOGGER_CONFIG = {
   loggerName: "lattice/gateway"
 };
 var loggerLattice = initializeLogger(DEFAULT_LOGGER_CONFIG);
-var logger7 = loggerLattice.client;
+var logger8 = loggerLattice.client;
 function initializeLogger(config) {
   if (loggerLatticeManager.hasLattice("default")) {
     loggerLatticeManager.removeLattice("default");
@@ -37021,7 +38447,7 @@ function initializeLogger(config) {
 }
 var app = fastify({
   logger: false,
-  bodyLimit: Number(process.env.BODY_LIMIT) || 100 * 1024 * 1024,
+  bodyLimit: Number(process.env.BODY_LIMIT) || 500 * 1024 * 1024,
   // Composite subagent thread IDs ({mainThread}____{assistant}-general-purpose_{toolCallId})
   // can exceed the 100-char default, which makes the router 404 before any
   // handler runs. Allow the longest IDs the conventions can produce.
@@ -37081,6 +38507,7 @@ app.register(cors, {
   exposedHeaders: [
     "Content-Type",
     "Content-Disposition",
+    "A2A-Version",
     REPLICA_HEADER3,
     AFFINITY_ECHO_HEADER3
   ],
@@ -37089,7 +38516,7 @@ app.register(cors, {
 app.register(sensible);
 app.register(multipart, {
   limits: {
-    fileSize: Number(process.env.BODY_LIMIT) || 100 * 1024 * 1024
+    fileSize: Number(process.env.BODY_LIMIT) || 500 * 1024 * 1024
   }
 });
 app.register(staticPlugin, {
@@ -37102,7 +38529,7 @@ app.setErrorHandler((error, request, reply) => {
     "x-request-id": getHeaderValue(request.headers["x-request-id"]),
     "x-user-id": getHeaderValue(request.headers["x-user-id"])
   };
-  logger7.error(
+  logger8.error(
     `\u8BF7\u6C42\u9519\u8BEF: ${request.method} ${request.url} error:${error.message}`,
     {
       ...context,
@@ -37135,17 +38562,17 @@ function getConfiguredSandboxProvider() {
 }
 async function restoreMcpConnections() {
   try {
-    const storeLattice = getStoreLattice41("default", "mcp");
+    const storeLattice = getStoreLattice42("default", "mcp");
     const store2 = storeLattice.store;
     if (!store2) {
-      logger7.info("MCP store not configured, skipping connection restoration");
+      logger8.info("MCP store not configured, skipping connection restoration");
       return;
     }
     const configs = (await store2.getAllConfigsWithoutTenant()).filter(
       (c2) => c2.status === "connected"
     );
     if (configs.length === 0) return;
-    logger7.info(`Restoring ${configs.length} MCP server connections...`);
+    logger8.info(`Restoring ${configs.length} MCP server connections...`);
     const deps = {
       store: store2,
       manager: mcpManager3,
@@ -37162,15 +38589,15 @@ async function restoreMcpConnections() {
     results.forEach((result, index) => {
       if (result.status === "rejected") {
         const config = configs[index];
-        logger7.warn(
+        logger8.warn(
           `Failed to restore MCP server "${config.tenantId}/${config.key}"`,
           { error: result.reason }
         );
       }
     });
-    logger7.info(`MCP connection restoration complete: ${configs.length} servers`);
+    logger8.info(`MCP connection restoration complete: ${configs.length} servers`);
   } catch (err) {
-    logger7.error("MCP connection restoration failed", { error: err });
+    logger8.error("MCP connection restoration failed", { error: err });
   }
 }
 var start = async (config) => {
@@ -37183,16 +38610,37 @@ var start = async (config) => {
         file: config.loggerConfig.file || DEFAULT_LOGGER_CONFIG.file
       };
       loggerLattice = initializeLogger(loggerConfig);
-      logger7 = loggerLattice.client;
+      logger8 = loggerLattice.client;
     }
     app.decorate("loggerLattice", loggerLattice);
+    const observabilityProvider = observabilityLatticeManager.getDefault();
+    if (observabilityProvider) {
+      try {
+        await observabilityProvider.start?.();
+      } catch (error) {
+        logger8.warn("Observability provider failed to start", {
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+      app.addHook("onClose", async () => {
+        try {
+          await observabilityProvider.stop?.();
+        } catch (error) {
+          logger8.warn("Observability provider failed to stop", {
+            error: error instanceof Error ? error.message : String(error)
+          });
+        }
+      });
+    }
     let executionSupervisor;
     let runTaskRuntime;
     let runTaskWake;
     let agentRunRetentionJob;
+    let scheduleReconcileTimer;
+    const channelLeaders = [];
     let runLedger;
     try {
-      runLedger = getStoreLattice41("default", "agentRun").store;
+      runLedger = getStoreLattice42("default", "agentRun").store;
     } catch {
     }
     if (runLedger) agentInstanceManager13.setRunLedger(runLedger);
@@ -37220,7 +38668,7 @@ var start = async (config) => {
       chunkSourceHandle = await createRedisAppendLog(redisUrl, {
         keyPrefix: chunkKeyPrefix,
         logger: {
-          warn: (message, context) => logger7.warn(message, context)
+          warn: (message, context) => logger8.warn(message, context)
         }
       });
       const sharedBuffer = new SharedChunkBuffer2({
@@ -37234,7 +38682,7 @@ var start = async (config) => {
         chunkBufferManager.remove("default");
       }
       registerChunkBuffer("default", sharedBuffer);
-      logger7.info("Shared Redis chunk source enabled", {
+      logger8.info("Shared Redis chunk source enabled", {
         phase: "chunk_source",
         ttlMs,
         maxLen
@@ -37246,7 +38694,7 @@ var start = async (config) => {
       if (runLedger) {
         runCancelNotifier = createRedisRunCancelNotifier({
           url: runCancelRedisUrl,
-          owner: getReplicaId11(),
+          owner: getReplicaId12(),
           ledger: runLedger,
           resolveAgent: (params) => (
             // Never use getAgent() here: creating an idle instance lets its
@@ -37254,14 +38702,14 @@ var start = async (config) => {
             resolveManagedRunCancelAgent(agentInstanceManager13, params)
           ),
           logger: {
-            warn: (message, context) => logger7.warn(message, context),
-            info: (message, context) => logger7.info(message, context)
+            warn: (message, context) => logger8.warn(message, context),
+            info: (message, context) => logger8.info(message, context)
           }
         });
         try {
           await runCancelNotifier.start();
         } catch (error) {
-          logger7.warn("Run cancel subscriber failed to start", {
+          logger8.warn("Run cancel subscriber failed to start", {
             error: error instanceof Error ? error.message : String(error)
           });
         }
@@ -37269,13 +38717,13 @@ var start = async (config) => {
           ledger: runLedger,
           notifier: runCancelNotifier,
           logger: {
-            warn: (message, context) => logger7.warn(message, context)
+            warn: (message, context) => logger8.warn(message, context)
           }
         }));
       } else {
-        logger7.warn(
+        logger8.warn(
           "Run cancel subscription disabled: the agent run ledger is not configured",
-          { owner: getReplicaId11() }
+          { owner: getReplicaId12() }
         );
       }
     }
@@ -37287,7 +38735,7 @@ var start = async (config) => {
       ),
       keyPrefix: chunkKeyPrefix,
       logger: {
-        warn: (message, context) => logger7.warn(message, context)
+        warn: (message, context) => logger8.warn(message, context)
       }
     });
     setInterruptAnswerRegistry(interruptAnswerRegistry);
@@ -37295,10 +38743,10 @@ var start = async (config) => {
     let projectRoomRealtimeRuntime;
     if (projectRoomRealtimeMode === "single-gateway") {
       projectRoomRealtimeRuntime = createProjectRoomRealtimeRuntime({
-        tasks: getStoreLattice41("default", "task").store,
-        rooms: getStoreLattice41("default", "projectRoom").store,
-        memberships: getStoreLattice41("default", "projectBotMembership").store,
-        log: { warn: (message, context) => logger7.warn(message, context) }
+        tasks: getStoreLattice42("default", "task").store,
+        rooms: getStoreLattice42("default", "projectRoom").store,
+        memberships: getStoreLattice42("default", "projectBotMembership").store,
+        log: { warn: (message, context) => logger8.warn(message, context) }
       });
     }
     let channelDeps;
@@ -37306,14 +38754,14 @@ var start = async (config) => {
     adapterRegistry.register(larkChannelAdapter);
     adapterRegistry.register(wecomChannelAdapter);
     registerWecomCardTool();
-    const { wechatChannelAdapter } = await import("./WechatChannelAdapter-7WHE5UGY.mjs");
+    const { wechatChannelAdapter } = await import("./WechatChannelAdapter-QLPJJD6S.mjs");
     adapterRegistry.register(wechatChannelAdapter);
     const durableChannelRuns = process.env.CHANNEL_DURABLE_RUNS !== "false";
     let channelReplyDispatcher;
     try {
       const infrastructure = createChannelInfrastructure({
         adapterRegistry,
-        getStore: ((kind) => getStoreLattice41("default", kind).store),
+        getStore: ((kind) => getStoreLattice42("default", kind).store),
         trustedDispatcher: createTrustedAgentMessageDispatcher2((scope) => agentInstanceManager13.getAgent(scope)),
         middlewares: [
           createDeduplicationMiddleware(),
@@ -37321,7 +38769,7 @@ var start = async (config) => {
           createAuditLoggerMiddleware()
         ],
         durableChannelRuns,
-        warn: (message, context) => logger7.warn(message, context),
+        warn: (message, context) => logger8.warn(message, context),
         realtime: projectRoomRealtimeRuntime?.publisher
       });
       const bindingStore = infrastructure.bindingRegistry;
@@ -37335,25 +38783,25 @@ var start = async (config) => {
         installationStore,
         bindingRegistry: bindingStore,
         realtime: projectRoomRealtimeRuntime?.publisher,
-        warn: (message, context) => logger7.warn(message, context)
+        warn: (message, context) => logger8.warn(message, context)
       };
     } catch (err) {
-      logger7.warn("Channel infrastructure unavailable", {
+      logger8.warn("Channel infrastructure unavailable", {
         error: err instanceof Error ? err.message : String(err)
       });
     }
     if (channelDeps && durableChannelRuns) {
       try {
         channelReplyDispatcher = new ChannelReplyDispatcher({
-          jobStore: getStoreLattice41("default", "channelReplyJob").store,
-          runLedger: getStoreLattice41("default", "agentRun").store,
+          jobStore: getStoreLattice42("default", "channelReplyJob").store,
+          runLedger: getStoreLattice42("default", "agentRun").store,
           loadFinalReplyText: createCheckpointFinalReplyLoader(),
           adapterRegistry: channelDeps.adapterRegistry,
           installationStore: channelDeps.installationStore,
-          owner: getReplicaId11(),
+          owner: getReplicaId12(),
           logger: {
-            info: (message, context) => logger7.info(message, context),
-            warn: (message, context) => logger7.warn(message, context)
+            info: (message, context) => logger8.info(message, context),
+            warn: (message, context) => logger8.warn(message, context)
           }
         });
         const dispatcher = channelReplyDispatcher;
@@ -37363,38 +38811,54 @@ var start = async (config) => {
           await dispatcher.stop();
         });
         dispatcher.start();
-        logger7.info("Durable channel replies enabled", { owner: getReplicaId11() });
+        logger8.info("Durable channel replies enabled", { owner: getReplicaId12() });
       } catch (err) {
-        logger7.warn("Durable channel replies unavailable", {
+        logger8.warn("Durable channel replies unavailable", {
           error: err instanceof Error ? err.message : String(err)
         });
       }
     }
     setEvalRunService(evalRunner);
     try {
-      const menuStore = getStoreLattice41("default", "menu").store;
+      const menuStore = getStoreLattice42("default", "menu").store;
       setMenuRegistry(menuStore);
-      logger7.info("Menu registry initialized");
+      logger8.info("Menu registry initialized");
     } catch {
     }
     registerAllBuiltinEntities();
     if (channelDeps?.router) {
-      setChannelControllerDeps({ adapterRegistry, router: channelDeps.router });
+      setChannelControllerDeps({
+        adapterRegistry,
+        router: channelDeps.router,
+        onInstallationChanged: async ({ tenantId, installationId }) => {
+          try {
+            const outbox = getStoreLattice42("default", "outbox").store;
+            await publishChannelInstallationChanged(outbox, getReplicaId12(), {
+              tenantId,
+              installationId
+            });
+          } catch (err) {
+            logger8.warn("Channel installation change wake failed", {
+              error: err instanceof Error ? err.message : String(err)
+            });
+          }
+        }
+      });
     }
     await app.register(websocket);
     const routes = registerLatticeRoutes(app, channelDeps, {
       projectTaskEnabled: process.env.AXIOM_PROJECT_TASK_EXECUTION_ENABLED !== "false",
-      projectTaskLog: { warn: (message, context) => logger7.warn(message, context) },
+      projectTaskLog: { warn: (message, context) => logger8.warn(message, context) },
       projectRoomRealtimeRuntime
     });
     try {
       const { A2AAuthService: A2AAuthService2, parseEnvKeys: parseEnvKeys2 } = await import("./A2AAuthService-7UGQ7GMW.mjs");
-      const { registerA2AStandardRoutes } = await import("./a2a-standard-DP53K7RC.mjs");
+      const { registerA2AStandardRoutes } = await import("./a2a-standard-VL5I7B4W.mjs");
       const a2a = await import("./a2a-BHBLACJV.mjs");
-      const a2aKeyStore = getStoreLattice41("default", "a2aApiKey").store;
-      const assistantStore = getStoreLattice41("default", "assistant").store;
-      const projectStore = getStoreLattice41("default", "project").store;
-      const taskStore = getStoreLattice41("default", "task").store;
+      const a2aKeyStore = getStoreLattice42("default", "a2aApiKey").store;
+      const assistantStore = getStoreLattice42("default", "assistant").store;
+      const projectStore = getStoreLattice42("default", "project").store;
+      const taskStore = getStoreLattice42("default", "task").store;
       const authService = new A2AAuthService2({
         keyStore: a2aKeyStore,
         assistantStore,
@@ -37412,19 +38876,19 @@ var start = async (config) => {
         getProjectStore: () => projectStore
       });
       a2a.registerA2ARoutes(app);
-      logger7.info("A2A standard routes registered");
+      logger8.info("A2A standard routes registered");
     } catch (err) {
-      logger7.warn("A2A standard routes unavailable", {
+      logger8.warn("A2A standard routes unavailable", {
         error: err instanceof Error ? err.message : String(err)
       });
     }
     try {
-      const { registerOpenRoutes } = await import("./open-NTH7AGD3.mjs");
+      const { registerOpenRoutes } = await import("./open-7ED27I5B.mjs");
       const { registerOpenSessionRoutes } = await import("./open-session-2Y7XJJW2.mjs");
       const { registerOpenCatalogRoutes } = await import("./open-catalog-SZQ435AY.mjs");
       const { registerOpenFilesRoutes } = await import("./open-files-V3R2BFTV.mjs");
       const { registerOpenAuditRoutes } = await import("./open-audit-UJ3NXCGW.mjs");
-      const { registerOpenExposureRoutes } = await import("./open-exposure-AGNG4MC3.mjs");
+      const { registerOpenExposureRoutes } = await import("./open-exposure-I3DN2X4E.mjs");
       const { openLattice } = await import("./openLattice-Q6M5S6CY.mjs");
       const { OpenRateLimiter } = await import("./openRateLimiter-XEOL3A5G.mjs");
       const { createKbProvider } = await import("./kbProvider-2D6DZ34N.mjs");
@@ -37434,8 +38898,8 @@ var start = async (config) => {
       const { CollectionService: CollectionService2 } = await import("./collection_service-RTRJEQFL.mjs");
       openLattice.register(createKbProvider(new CollectionService2()));
       openLattice.register(createOpenSandboxProvider());
-      const threadStore = getStoreLattice41("default", "thread").store;
-      const assistantStore = getStoreLattice41("default", "assistant").store;
+      const threadStore = getStoreLattice42("default", "thread").store;
+      const assistantStore = getStoreLattice42("default", "assistant").store;
       openLattice.register(
         createAgentProvider({
           threadStore,
@@ -37463,32 +38927,32 @@ var start = async (config) => {
       registerOpenFilesRoutes(app);
       registerOpenAuditRoutes(app);
       registerOpenExposureRoutes(app);
-      logger7.info("Open API routes registered (kb + sandbox providers, session exchange)");
+      logger8.info("Open API routes registered (kb + sandbox providers, session exchange)");
     } catch (err) {
-      logger7.warn("Open API routes unavailable", {
+      logger8.warn("Open API routes unavailable", {
         error: err instanceof Error ? err.message : String(err)
       });
     }
     try {
       const { registerGatewaySandboxOpenCredentialProvider } = await import("./sandboxOpenCredentialProvider-AT227D4N.mjs");
       registerGatewaySandboxOpenCredentialProvider((error) => {
-        logger7.warn("sandbox open-credential provider failed", { error });
+        logger8.warn("sandbox open-credential provider failed", { error });
       });
-      logger7.info("Sandbox open-credential provider registered");
+      logger8.info("Sandbox open-credential provider registered");
     } catch (err) {
-      logger7.warn("Sandbox open-credential provider unavailable", {
+      logger8.warn("Sandbox open-credential provider unavailable", {
         error: err instanceof Error ? err.message : String(err)
       });
     }
     if (!sandboxLatticeManager2.hasLattice("default")) {
       sandboxLatticeManager2.registerLattice("default", getConfiguredSandboxProvider());
-      logger7.info("Registered sandbox manager from env configuration");
+      logger8.info("Registered sandbox manager from env configuration");
     }
     if (isPluginDeploymentRuntimeEnabled()) {
       try {
-        const pluginDeploymentStore = getStoreLattice41("default", "pluginDeployment").store;
-        const tenantStore = getStoreLattice41("default", "tenant").store;
-        const leaseStore2 = getStoreLattice41("default", "lease").store;
+        const pluginDeploymentStore = getStoreLattice42("default", "pluginDeployment").store;
+        const tenantStore = getStoreLattice42("default", "tenant").store;
+        const leaseStore2 = getStoreLattice42("default", "lease").store;
         const listAllDeployments = async () => {
           const tenants = await tenantStore.getAllTenants();
           const lists = await Promise.all(
@@ -37509,90 +38973,112 @@ var start = async (config) => {
             listAllDeployments,
             // The service logs fields-first; the gateway logger is message-first.
             logger: {
-              info: (fields, message) => logger7.info(message ?? "plugin deployment", fields),
-              warn: (fields, message) => logger7.warn(message ?? "plugin deployment", fields),
-              error: (fields, message) => logger7.error(message ?? "plugin deployment", fields)
+              info: (fields, message) => logger8.info(message ?? "plugin deployment", fields),
+              warn: (fields, message) => logger8.warn(message ?? "plugin deployment", fields),
+              error: (fields, message) => logger8.error(message ?? "plugin deployment", fields)
             }
           },
           lease: leaseStore2,
-          holder: getReplicaId11(),
-          logger: logger7
+          holder: getReplicaId12(),
+          logger: logger8
         });
         app.addHook("onClose", async () => {
           await pluginDeploymentRuntime.dispose();
         });
-        logger7.info("Plugin deployment runtime started");
+        logger8.info("Plugin deployment runtime started");
       } catch (err) {
-        logger7.warn("Plugin deployment runtime unavailable", {
+        logger8.warn("Plugin deployment runtime unavailable", {
           error: err instanceof Error ? err.message : String(err)
         });
       }
     }
     try {
       const { ResourceController } = await import("./resources-DAU5ZIPB.mjs");
-      const sharedResourceStore = getStoreLattice41("default", "sharedResource").store;
+      const sharedResourceStore = getStoreLattice42("default", "sharedResource").store;
       const cache = new TokenCache();
       const resourceController = new ResourceController({
         store: sharedResourceStore,
         sandboxManager: sandboxLatticeManager2,
         cache,
-        logger: logger7
+        logger: logger8
       });
       registerResourceRoutes(app, resourceController);
-      logger7.info("Resource share routes registered");
+      logger8.info("Resource share routes registered");
     } catch (err) {
-      logger7.warn("Resource share infrastructure unavailable", {
+      logger8.warn("Resource share infrastructure unavailable", {
         error: err instanceof Error ? err.message : String(err)
       });
     }
     if (channelDeps && process.env.CHANNELS_ENABLED !== "false") {
       try {
-        const channelLeader = new ChannelConnectionLeader({
-          leaseStore: getStoreLattice41("default", "lease").store,
-          owner: getReplicaId11(),
-          connect: () => connectAllChannels((channel) => adapterRegistry.get(channel), {
-            deps: { router: channelDeps.router }
-          }),
-          disconnect: () => disconnectAllChannels((channel) => adapterRegistry.get(channel)),
-          log: { warn: (message, context) => logger7.warn(message, context) }
-        });
+        const shardCount = parsePositiveInteger2(process.env.CHANNEL_SHARDS, 1);
+        const leaseStore2 = getStoreLattice42("default", "lease").store;
+        const installationStore = getStoreLattice42("default", "channelInstallation").store;
+        for (let shard = 0; shard < shardCount; shard += 1) {
+          const leader = new ChannelConnectionLeader({
+            leaseStore: leaseStore2,
+            owner: getReplicaId12(),
+            shard,
+            shardCount,
+            loadDesired: () => installationStore.getAllInstallations(),
+            connectInstallation: async (installation) => {
+              const adapter = adapterRegistry.get(installation.channel);
+              await adapter?.connect?.(installation, { router: channelDeps.router });
+            },
+            disconnectInstallation: async (installation) => {
+              const adapter = adapterRegistry.get(installation.channel);
+              await adapter?.disconnect?.(installation.id);
+            },
+            fingerprint: (installation) => JSON.stringify({
+              channel: installation.channel,
+              config: installation.config,
+              fallbackAgentId: installation.fallbackAgentId,
+              rejectWhenNoBinding: installation.rejectWhenNoBinding
+            }),
+            log: { warn: (message, context) => logger8.warn(message, context) }
+          });
+          channelLeaders.push(leader);
+          leader.start();
+        }
         app.addHook("onClose", async () => {
-          await channelLeader.stop();
+          await Promise.all(channelLeaders.map((leader) => leader.stop()));
         });
-        channelLeader.start();
       } catch (err) {
-        logger7.error("Failed to start channel connections", {
+        logger8.error("Failed to start channel connections", {
           error: err instanceof Error ? err.message : String(err)
         });
       }
     }
     const target_port = config?.port || Number(process.env.PORT) || 4001;
-    configureCoordinationLeaseStore(getStoreLattice41("default", "lease").store);
-    const outboxStore = getStoreLattice41("default", "outbox").store;
+    configureCoordinationLeaseStore(getStoreLattice42("default", "lease").store);
+    const outboxStore = getStoreLattice42("default", "outbox").store;
     taskLifecycleNotifier3.setOutbox(outboxStore);
     projectTaskAdmissionNotifier2.setOutbox(outboxStore);
-    configurePluginCatalogSync({ outbox: outboxStore, owner: getReplicaId11() });
-    configureCollectionSync({ outbox: outboxStore, owner: getReplicaId11() });
+    configurePluginCatalogSync({ outbox: outboxStore, owner: getReplicaId12() });
+    configureCollectionSync({ outbox: outboxStore, owner: getReplicaId12() });
     bridgeAssistantEvents(
       (event, cb) => eventBus3.subscribe(event, cb),
       outboxStore,
-      getReplicaId11()
+      getReplicaId12()
     );
-    installAgentLifecycleSync({ outbox: outboxStore, owner: getReplicaId11() });
+    installAgentLifecycleSync({ outbox: outboxStore, owner: getReplicaId12() });
     if (projectRoomRealtimeRuntime) {
       projectRoomRealtimeRuntime.broker.setBroadcastHook((scope, serialized, sourceKey) => {
-        void publishRoomEvent(outboxStore, getReplicaId11(), scope, serialized, sourceKey);
+        void publishRoomEvent(outboxStore, getReplicaId12(), scope, serialized, sourceKey);
       });
     }
     const outboxPoller = new OutboxPoller({
       store: outboxStore,
-      owner: getReplicaId11(),
+      owner: getReplicaId12(),
       handlers: {
         "task-lifecycle": (payload) => taskLifecycleNotifier3.deliverFromOutbox(payload),
         "project-task-admission": (payload) => projectTaskAdmissionNotifier2.deliverFromOutbox(payload),
         [ROOM_EVENT_TOPIC]: async (payload) => {
           if (projectRoomRealtimeRuntime) ingestRoomEvent(payload, projectRoomRealtimeRuntime.broker);
         },
+        [CHANNEL_INSTALLATION_CHANGED_TOPIC]: async () => {
+          for (const leader of channelLeaders) leader.wake();
+        },
         "assistant-changed": (payload) => handleAssistantChanged(payload, async (tenantId) => {
           await agentLatticeManager6.initializeStoredAssistantsForTenant(tenantId);
           invalidateAgentReflectionCache(tenantId);
@@ -37603,7 +39089,7 @@ var start = async (config) => {
         },
         [A2A_KEY_CHANGED_TOPIC]: (payload) => handleA2AKeyChanged(payload, () => refreshStoreKeyMap()),
         [MCP_CONFIG_CHANGED_TOPIC]: (payload) => reconcileMcpConfigChange(payload, {
-          store: getStoreLattice41("default", "mcp").store,
+          store: getStoreLattice42("default", "mcp").store,
           manager: mcpManager3,
           convertToConnection: convertToConnection2
         }),
@@ -37628,31 +39114,32 @@ var start = async (config) => {
           await handleModelProviderChanged(payload, (tenantId, providerId2) => controller.reconcileProvider(tenantId, providerId2));
         }
       },
-      log: logger7
+      log: logger8
     });
     try {
       await outboxPoller.start();
     } catch (err) {
-      logger7.warn("Outbox poller failed to start", { error: err instanceof Error ? err.message : String(err) });
+      logger8.warn("Outbox poller failed to start", { error: err instanceof Error ? err.message : String(err) });
     }
-    const leaseStore = getStoreLattice41("default", "lease").store;
+    const leaseStore = getStoreLattice42("default", "lease").store;
     if (leaseStore.constructor?.name === "InMemoryLeaseStore") {
-      logger7.warn(
+      logger8.warn(
         "Startup recovery leader gate uses a non-distributed lease store (per-process only); configure a shared 'lease' store for multi-replica deployments",
         { phase: "startup_recovery" }
       );
     }
-    warnMultiReplicaReadiness(logger7);
+    warnMultiReplicaReadiness(logger8);
+    assertMultiReplicaReadiness();
     if (scheduleLatticeManager3.hasLattice("default")) {
       registerAgentCronHandler(scheduleLatticeManager3.getScheduleLattice("default"), {
         getAgent: (params) => agentInstanceManager13.getAgent(params),
-        createThread: (tenantId, assistantId, threadId, data) => getStoreLattice41("default", "thread").store.createThread(tenantId, assistantId, threadId, data),
+        createThread: (tenantId, assistantId, threadId, data) => getStoreLattice42("default", "thread").store.createThread(tenantId, assistantId, threadId, data),
         acquireThreadRun: (tenantId, assistantId, threadId) => tryAcquireThreadRun5({
-          store: getStoreLattice41("default", "lease").store,
+          store: getStoreLattice42("default", "lease").store,
           tenantId,
           assistantId,
           threadId,
-          owner: getReplicaId11(),
+          owner: getReplicaId12(),
           ttlMs: 6e4
         }),
         getMaintenanceStore: getCheckpointMaintenanceStore,
@@ -37660,63 +39147,73 @@ var start = async (config) => {
         removeAgent: (params) => {
           agentInstanceManager13.removeAgent(params);
         },
-        log: { warn: (message, context) => logger7.warn(message, context) }
+        log: { warn: (message, context) => logger8.warn(message, context) }
       });
     }
     const startup = await runAsLeader(leaseStore, "startup-recovery", async () => {
       if (routes.projectTaskRuntime) {
-        await prepareProjectTaskRuntime(routes.projectTaskRuntime, logger7);
+        await prepareProjectTaskRuntime(routes.projectTaskRuntime, logger8);
       }
       if (process.env.AXIOM_TASK_ORPHAN_RECOVERY === "true") {
         try {
           const { createOrphanRecoveryRuntime: createOrphanRecoveryRuntime2 } = await import("./OrphanRecoveryRuntime-T4T5NOZU.mjs");
           const { createRecoveryCallerDeps: createRecoveryCallerDeps2 } = await import("./RecoveryCallerDeps-6SJUYJ5S.mjs");
           const runtime = createOrphanRecoveryRuntime2({
-            taskStore: getStoreLattice41("default", "task").store,
-            workItemStore: getStoreLattice41("default", "taskWorkItem").store,
-            tenantStore: getStoreLattice41("default", "tenant").store,
+            taskStore: getStoreLattice42("default", "task").store,
+            workItemStore: getStoreLattice42("default", "taskWorkItem").store,
+            tenantStore: getStoreLattice42("default", "tenant").store,
             ...createRecoveryCallerDeps2(),
-            log: logger7
+            log: logger8
           });
           await runtime.recoverAll();
         } catch (err) {
-          logger7.warn("Task orphan recovery failed", { error: err instanceof Error ? err.message : String(err) });
-        }
-      }
-      if (scheduleLatticeManager3.hasLattice("default")) {
-        try {
-          const restored = await scheduleLatticeManager3.getScheduleLattice("default").restore();
-          logger7.info("Scheduled tasks restored", { phase: "startup_recovery", restored });
-        } catch (err) {
-          logger7.warn("Scheduled task restore failed", {
-            phase: "startup_recovery",
-            error: err instanceof Error ? err.message : String(err)
-          });
+          logger8.warn("Task orphan recovery failed", { error: err instanceof Error ? err.message : String(err) });
         }
       }
     }, { hold: true, ttlMs: 5 * 6e4 });
     if (!startup.ran) {
-      logger7.info("Startup recovery skipped (another replica leads)", { phase: "startup_recovery" });
+      logger8.info("Startup recovery skipped (another replica leads)", { phase: "startup_recovery" });
+    }
+    if (scheduleLatticeManager3.hasLattice("default")) {
+      const schedule2 = scheduleLatticeManager3.getScheduleLattice("default");
+      try {
+        const restored = await schedule2.restore();
+        logger8.info("Scheduled tasks restored", { phase: "startup_recovery", restored });
+      } catch (err) {
+        logger8.warn("Scheduled task restore failed", {
+          phase: "startup_recovery",
+          error: err instanceof Error ? err.message : String(err)
+        });
+      }
+      const intervalMs = parsePositiveInteger2(process.env.SCHEDULE_RECONCILE_MS, 3e4);
+      scheduleReconcileTimer = setInterval(() => {
+        void Promise.resolve(schedule2.reconcile?.()).catch((err) => {
+          logger8.warn("Scheduled task reconcile failed", {
+            error: err instanceof Error ? err.message : String(err)
+          });
+        });
+      }, intervalMs);
+      scheduleReconcileTimer.unref?.();
     }
     if (process.env.EXECUTION_WORKER_ENABLED === "true") {
       try {
-        const queueStore = getStoreLattice41("default", "threadMessageQueue").store;
+        const queueStore = getStoreLattice42("default", "threadMessageQueue").store;
         executionSupervisor = new ThreadExecutionSupervisor({
           queueStore,
           runLedger,
           scanIntervalMs: Number(process.env.EXECUTION_SCAN_MS ?? "1000"),
           maxConcurrentThreads: Number(process.env.EXECUTION_MAX_THREADS ?? "20"),
-          log: { warn: (message, context) => logger7.warn(message, context) }
+          log: { warn: (message, context) => logger8.warn(message, context) }
         });
         executionSupervisor.start();
         setExecutionSupervisor(executionSupervisor);
-        logger7.info("Execution worker supervisor started", {
+        logger8.info("Execution worker supervisor started", {
           scanIntervalMs: process.env.EXECUTION_SCAN_MS ?? "1000",
           maxConcurrentThreads: process.env.EXECUTION_MAX_THREADS ?? "20",
           runLedger: runLedger ? "enabled" : "disabled"
         });
       } catch (err) {
-        logger7.warn("Execution worker supervisor unavailable", {
+        logger8.warn("Execution worker supervisor unavailable", {
           error: err instanceof Error ? err.message : String(err)
         });
       }
@@ -37730,23 +39227,23 @@ var start = async (config) => {
       );
       runTaskWake = createConfiguredRedisRunTaskWake({
         url: process.env.REDIS_URL,
-        owner: getReplicaId11(),
+        owner: getReplicaId12(),
         wake: () => runTaskRuntime?.wake() ?? Promise.resolve(),
         logger: {
-          warn: (message, context) => logger7.warn(message, context),
-          info: (message, context) => logger7.info(message, context)
+          warn: (message, context) => logger8.warn(message, context),
+          info: (message, context) => logger8.info(message, context)
         }
       });
       setRunTaskWakeStatsSource(runTaskWake);
       if (runTaskWake) setRunTaskWakePublisher(runTaskWake);
       try {
         const projectTaskRunHooks = createProjectTaskRunHooks({
-          tasks: getStoreLattice41("default", "task").store,
-          workItems: getStoreLattice41("default", "taskWorkItem").store,
-          projects: getStoreLattice41("default", "project").store,
-          rooms: getStoreLattice41("default", "projectRoom").store,
-          bots: getStoreLattice41("default", "projectBotMembership").store,
-          threads: getStoreLattice41("default", "thread").store,
+          tasks: getStoreLattice42("default", "task").store,
+          workItems: getStoreLattice42("default", "taskWorkItem").store,
+          projects: getStoreLattice42("default", "project").store,
+          rooms: getStoreLattice42("default", "projectRoom").store,
+          bots: getStoreLattice42("default", "projectBotMembership").store,
+          threads: getStoreLattice42("default", "thread").store,
           getThreadState: async ({ task, thread }) => agentInstanceManager13.getAgent({
             tenant_id: task.tenantId,
             assistant_id: task.ownerId,
@@ -37755,15 +39252,17 @@ var start = async (config) => {
             project_id: task.projectId
           }).getCurrentState(),
           onTaskInterrupted: (input) => projectTaskInterrupt(input),
-          logger: { warn: (message, context) => logger7.warn(message, context) }
+          logger: { warn: (message, context) => logger8.warn(message, context) }
         });
         runTaskRuntime = new RunTaskRuntime({
           ledger: runLedger,
           leaseStore,
-          getAgent: (params) => agentInstanceManager13.getAgent(params),
+          // The worker holds the thread-run lease, so it can make the run's
+          // scope authoritative on the shared per-thread instance.
+          getAgent: (params) => agentInstanceManager13.getAgentForExecution(params),
           ...projectTaskRunRuntimeOptions(projectTaskRunHooks),
           resolveRollbackStore: getCheckpointRollbackStore,
-          owner: getReplicaId11(),
+          owner: getReplicaId12(),
           executeEnabled: runTaskWorkerEnabled,
           maxConcurrentJobs: parsePositiveInteger2(process.env.N_JOBS_PER_WORKER, 10),
           maxRunningPerTenant: resolveRunTaskMaxRunningPerTenant(process.env),
@@ -37779,30 +39278,30 @@ var start = async (config) => {
           rollbackBackoffBaseMs: parsePositiveInteger2(process.env.RUN_TASK_ROLLBACK_BACKOFF_MS, 1e3),
           shutdownTimeoutMs: runTaskShutdownTimeoutMs,
           logger: {
-            info: (message, context) => logger7.info(message, context),
-            warn: (message, context) => logger7.warn(message, context)
+            info: (message, context) => logger8.info(message, context),
+            warn: (message, context) => logger8.warn(message, context)
           }
         });
         runTaskRuntime.start();
         setRunTaskRuntime(runTaskRuntime);
-        logger7.info("Run task runtime started", {
+        logger8.info("Run task runtime started", {
           executeEnabled: runTaskWorkerEnabled,
           maxConcurrentJobs: parsePositiveInteger2(process.env.N_JOBS_PER_WORKER, 10),
           worker: runTaskRuntime.worker ? "enabled" : "disabled",
           recovery: "enabled"
         });
       } catch (err) {
-        logger7.warn("Run task runtime unavailable", {
+        logger8.warn("Run task runtime unavailable", {
           error: err instanceof Error ? err.message : String(err)
         });
       }
       if (runTaskWake && runTaskRuntime?.worker) {
         void runTaskWake.start().catch((err) => {
-          logger7.warn("Run task wake subscriber failed to start", {
+          logger8.warn("Run task wake subscriber failed to start", {
             error: err instanceof Error ? err.message : String(err)
           });
         });
-        logger7.info("Run task Redis wake started in background", {
+        logger8.info("Run task Redis wake started in background", {
           subscriber: "enabled"
         });
       }
@@ -37810,17 +39309,17 @@ var start = async (config) => {
         ledger: runLedger,
         days: process.env.AGENT_RUN_RETENTION_DAYS,
         log: {
-          info: (message, context) => logger7.info(message, context),
-          warn: (message, context) => logger7.warn(message, context)
+          info: (message, context) => logger8.info(message, context),
+          warn: (message, context) => logger8.warn(message, context)
         }
       });
       if (agentRunRetentionJob) {
         agentRunRetentionJob.start();
-        logger7.info("Agent run retention job started", {
+        logger8.info("Agent run retention job started", {
           days: parseAgentRunRetentionDays(process.env.AGENT_RUN_RETENTION_DAYS)
         });
       } else {
-        logger7.warn("Agent run retention disabled", {
+        logger8.warn("Agent run retention disabled", {
           env: "AGENT_RUN_RETENTION_DAYS"
         });
       }
@@ -37829,8 +39328,8 @@ var start = async (config) => {
       intervalMs: parsePositiveInteger2(process.env.THREAD_TTL_SWEEP_MS, 6e4),
       batchSize: parsePositiveInteger2(process.env.THREAD_TTL_SWEEP_BATCH, 100),
       log: {
-        info: (message, context) => logger7.info(message, context),
-        warn: (message, context) => logger7.warn(message, context)
+        info: (message, context) => logger8.info(message, context),
+        warn: (message, context) => logger8.warn(message, context)
       }
     });
     if (threadTtlSweeper) {
@@ -37838,7 +39337,7 @@ var start = async (config) => {
         await threadTtlSweeper.stop();
       });
       threadTtlSweeper.start();
-      logger7.info("Thread TTL sweeper started", {
+      logger8.info("Thread TTL sweeper started", {
         intervalMs: parsePositiveInteger2(process.env.THREAD_TTL_SWEEP_MS, 6e4),
         batchSize: parsePositiveInteger2(process.env.THREAD_TTL_SWEEP_BATCH, 100)
       });
@@ -37848,8 +39347,8 @@ var start = async (config) => {
       intervalMs: storeTtlConfig.intervalMs,
       batchSize: storeTtlConfig.batchSize,
       log: {
-        info: (message, context) => logger7.info(message, context),
-        warn: (message, context) => logger7.warn(message, context)
+        info: (message, context) => logger8.info(message, context),
+        warn: (message, context) => logger8.warn(message, context)
       }
     }) : void 0;
     if (storeTtlSweeper) {
@@ -37857,31 +39356,31 @@ var start = async (config) => {
         await storeTtlSweeper.stop();
       });
       storeTtlSweeper.start();
-      logger7.info("Store TTL sweeper started", {
+      logger8.info("Store TTL sweeper started", {
         intervalMs: storeTtlConfig.intervalMs,
         batchSize: storeTtlConfig.batchSize
       });
     }
     installLifespanHooks(app, config?.lifespans, {
-      warn: (message, context) => logger7.warn(message, context)
+      warn: (message, context) => logger8.warn(message, context)
     });
     await app.listen({ port: target_port, host: "0.0.0.0" });
-    logger7.info(`Lattice Gateway is running on port: ${target_port}`);
+    logger8.info(`Lattice Gateway is running on port: ${target_port}`);
     const outboxRetention = createOutboxRetentionJob({
       outbox: outboxStore,
-      log: logger7
+      log: logger8
     });
     outboxRetention.start();
     restoreMcpConnections().catch((error) => {
-      logger7.error("MCP connection restoration failed", { error });
+      logger8.error("MCP connection restoration failed", { error });
     });
     if (config?.gracefulShutdown !== false && !shutdownHandlersInstalled) {
       shutdownHandlersInstalled = true;
       const gracefulShutdown = createGracefulShutdown({
         timeoutMs: config?.gracefulShutdownTimeoutMs ?? 1e4,
         log: {
-          info: (message, context) => logger7.info(message, context),
-          warn: (message, context) => logger7.warn(message, context)
+          info: (message, context) => logger8.info(message, context),
+          warn: (message, context) => logger8.warn(message, context)
         },
         steps: [
           async () => {
@@ -37908,6 +39407,10 @@ var start = async (config) => {
           },
           () => outboxPoller.stop(),
           () => outboxRetention.stop(),
+          () => {
+            if (scheduleReconcileTimer) clearInterval(scheduleReconcileTimer);
+            scheduleReconcileTimer = void 0;
+          },
           () => threadTtlSweeper?.stop(),
           () => storeTtlSweeper?.stop(),
           () => chunkSourceHandle?.close(),
@@ -37921,7 +39424,7 @@ var start = async (config) => {
       process.once("SIGINT", () => void gracefulShutdown("SIGINT"));
     }
   } catch (err) {
-    logger7.error("Server start failed", { error: err });
+    logger8.error("Server start failed", { error: err });
     process.exit(1);
   }
 };
@@ -37945,6 +39448,7 @@ export {
   DEFAULT_RUN_TASK_MAX_ATTEMPTS,
   DEFAULT_RUN_TASK_SCAN_MS,
   DEFAULT_THREAD_RUN_LEASE_TTL_MS,
+  LangfuseObservabilityProvider,
   LatticeGateway,
   MIRRORED_AGENT_EVENTS,
   MODEL_PROVIDER_CHANGED_TOPIC,
@@ -37958,6 +39462,7 @@ export {
   RunTaskRuntime,
   RunTaskWorker,
   createConfiguredRedisRunTaskWake,
+  createLangfuseProviderFromEnv,
   createOrphanRecoveryRuntime,
   createRecoveryCallerDeps,
   createRedisAppendLog,
@@ -37976,8 +39481,10 @@ export {
   publishAgentLifecycle,
   publishModelProviderChanged,
   publishRoomEvent,
+  readLangfuseConfig,
   recoverTask,
   recoverTopCaller,
+  redactLangfuseValue,
   resolveTopCaller,
   runOrphanRecovery,
   setRunTaskRuntime,