@axiom-lattice/gateway 4.8.1 → 4.8.3

package/dist/index.js

@@ -966,7 +966,7 @@ function outcome(task) {
   });
 }
 async function backfillTopCallerGroup(tasks, top, deps) {
-  const registry = deps.registry ?? import_core70.taskRunRegistry;
+  const registry = deps.registry ?? import_core71.taskRunRegistry;
   const results = [];
   const eligible = [];
   for (const task of tasks) {
@@ -1020,11 +1020,11 @@ async function recoverTask(task, deps) {
   if (task.status !== "in_progress") {
     return { kind: "skipped", reason: "not_in_progress" };
   }
-  const registry = deps.registry ?? import_core70.taskRunRegistry;
+  const registry = deps.registry ?? import_core71.taskRunRegistry;
   if (registry.isLive(task.id) || deps.isTaskLive && await deps.isTaskLive(task)) {
     return { kind: "skipped", reason: "live" };
   }
-  const { convergedTasks } = await (0, import_core70.reconcileStaleTaskRuns)({
+  const { convergedTasks } = await (0, import_core71.reconcileStaleTaskRuns)({
     tasks: [task],
     actor: "system:on-demand-recovery",
     lifecycle: deps.lifecycle,
@@ -1120,29 +1120,29 @@ async function runOrphanRecovery(deps) {
   deps.log.info("Task orphan recovery complete", { recovered, skipped });
   return { recovered, skipped };
 }
-var import_messages, import_core70;
+var import_messages, import_core71;
 var init_TopCallerRecovery = __esm({
   "src/services/collaboration/TopCallerRecovery.ts"() {
     "use strict";
     import_messages = require("@langchain/core/messages");
-    import_core70 = require("@axiom-lattice/core");
+    import_core71 = require("@axiom-lattice/core");
   }
 });
 
 // src/services/collaboration/taskRunLiveness.ts
 function createTaskRunLiveness() {
   try {
-    import_core71.storeLatticeManager.getStoreLattice("default", "lease");
+    import_core72.storeLatticeManager.getStoreLattice("default", "lease");
   } catch {
     return void 0;
   }
   return async (task) => {
     try {
-      const store2 = import_core71.storeLatticeManager.getStoreLattice("default", "lease").store;
-      if (await store2.get((0, import_core71.taskRunLeaseKey)(task.id))) return true;
+      const store2 = import_core72.storeLatticeManager.getStoreLattice("default", "lease").store;
+      if (await store2.get((0, import_core72.taskRunLeaseKey)(task.id))) return true;
       const threadId = typeof task.context?.thread_id === "string" ? task.context.thread_id : void 0;
       if (threadId && task.ownerId) {
-        if (await store2.get((0, import_core71.threadRunLeaseKey)(task.tenantId, task.ownerId, threadId))) return true;
+        if (await store2.get((0, import_core72.threadRunLeaseKey)(task.tenantId, task.ownerId, threadId))) return true;
       }
       return false;
     } catch {
@@ -1150,11 +1150,11 @@ function createTaskRunLiveness() {
     }
   };
 }
-var import_core71;
+var import_core72;
 var init_taskRunLiveness = __esm({
   "src/services/collaboration/taskRunLiveness.ts"() {
     "use strict";
-    import_core71 = require("@axiom-lattice/core");
+    import_core72 = require("@axiom-lattice/core");
   }
 });
 
@@ -1164,7 +1164,7 @@ __export(OrphanRecoveryRuntime_exports, {
   createOrphanRecoveryRuntime: () => createOrphanRecoveryRuntime
 });
 function createOrphanRecoveryRuntime(deps) {
-  const lifecycle = deps.lifecycle ?? (0, import_core72.createTaskLifecycleService)({
+  const lifecycle = deps.lifecycle ?? (0, import_core73.createTaskLifecycleService)({
     taskStore: deps.taskStore,
     workItemStore: deps.workItemStore
   });
@@ -1172,7 +1172,7 @@ function createOrphanRecoveryRuntime(deps) {
     async recoverAll() {
       const isTaskLive = deps.isTaskLive ?? createTaskRunLiveness();
       return runOrphanRecovery({
-        reconcile: () => (0, import_core72.reconcileAllTenantTaskRuns)({
+        reconcile: () => (0, import_core73.reconcileAllTenantTaskRuns)({
           actor: "system:orphan-recovery",
           tenantStore: {
             listTenants: async () => (await deps.tenantStore.getAllTenants()).map((tenant2) => ({ id: tenant2.id }))
@@ -1198,7 +1198,7 @@ function createOrphanRecoveryRuntime(deps) {
       const isTaskLive = deps.isTaskLive ?? createTaskRunLiveness();
       return recoverTask(task, {
         lifecycle,
-        registry: import_core72.taskRunRegistry,
+        registry: import_core73.taskRunRegistry,
         orphans,
         callerFor: deps.callerFor,
         resume: deps.resume,
@@ -1207,11 +1207,11 @@ function createOrphanRecoveryRuntime(deps) {
     }
   };
 }
-var import_core72;
+var import_core73;
 var init_OrphanRecoveryRuntime = __esm({
   "src/services/collaboration/OrphanRecoveryRuntime.ts"() {
     "use strict";
-    import_core72 = require("@axiom-lattice/core");
+    import_core73 = require("@axiom-lattice/core");
     init_TopCallerRecovery();
     init_projectTaskScope();
     init_taskRunLiveness();
@@ -1227,12 +1227,12 @@ function createRecoveryCallerDeps() {
   return {
     callerFor: async (top, tenantId) => {
       if (!top.assistantId) return void 0;
-      const load = import_core73.getAgentClientAsync ?? import_core73.getAgentClient;
+      const load = import_core74.getAgentClientAsync ?? import_core74.getAgentClient;
       const client = await load(tenantId, top.assistantId);
       const config = { configurable: { thread_id: top.threadId, runConfig: { tenantId, assistant_id: top.assistantId } } };
       let agent;
       try {
-        agent = import_core73.agentInstanceManager.getAgent({ assistant_id: top.assistantId, thread_id: top.threadId, tenant_id: tenantId });
+        agent = import_core74.agentInstanceManager.getAgent({ assistant_id: top.assistantId, thread_id: top.threadId, tenant_id: tenantId });
       } catch {
       }
       return agent ? { client, config, agent } : { client, config };
@@ -1249,11 +1249,11 @@ function createRecoveryCallerDeps() {
     }
   };
 }
-var import_core73;
+var import_core74;
 var init_RecoveryCallerDeps = __esm({
   "src/services/collaboration/RecoveryCallerDeps.ts"() {
     "use strict";
-    import_core73 = require("@axiom-lattice/core");
+    import_core74 = require("@axiom-lattice/core");
   }
 });
 
@@ -1843,13 +1843,13 @@ function isA2ATaskSnapshot(value) {
 function snapshotSequence(value) {
   return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : void 0;
 }
-var import_node_crypto28, import_node_util, import_core74, TASK_STATUS_TO_A2A_STATE, TITLE_MAX_LENGTH, A2ATaskScopeConflictError, A2ATaskStoreAdapter;
+var import_node_crypto28, import_node_util, import_core75, TASK_STATUS_TO_A2A_STATE, TITLE_MAX_LENGTH, A2ATaskScopeConflictError, A2ATaskStoreAdapter;
 var init_A2ATaskStoreAdapter = __esm({
   "src/services/a2a/A2ATaskStoreAdapter.ts"() {
     "use strict";
     import_node_crypto28 = require("crypto");
     import_node_util = require("util");
-    import_core74 = require("@axiom-lattice/core");
+    import_core75 = require("@axiom-lattice/core");
     TASK_STATUS_TO_A2A_STATE = {
       pending: "submitted",
       in_progress: "working",
@@ -1875,7 +1875,7 @@ var init_A2ATaskStoreAdapter = __esm({
         this.workItemStore = options.workItemStore;
         this.lifecycle = options.lifecycle;
         this.scope = options.scope;
-        this.runBridge = (0, import_core74.createTaskRunBridge)({
+        this.runBridge = (0, import_core75.createTaskRunBridge)({
           lifecycle: this.lifecycle,
           taskStore: this.taskStore,
           workItemStore: this.workItemStore
@@ -2226,12 +2226,12 @@ function assistantHasGovernedTask(assistant) {
   const allowedTools = taskMiddleware?.allowedTools;
   return !!taskMiddleware && (allowedTools === void 0 || Array.isArray(allowedTools) && (allowedTools.length === 0 || allowedTools.includes("manage_task")));
 }
-var import_uuid11, import_core75, import_protocols35, _AxiomAgentExecutor, AxiomAgentExecutor;
+var import_uuid11, import_core76, import_protocols35, _AxiomAgentExecutor, AxiomAgentExecutor;
 var init_AxiomAgentExecutor = __esm({
   "src/services/a2a/AxiomAgentExecutor.ts"() {
     "use strict";
     import_uuid11 = require("uuid");
-    import_core75 = require("@axiom-lattice/core");
+    import_core76 = require("@axiom-lattice/core");
     import_protocols35 = require("@axiom-lattice/protocols");
     init_a2aFileRefs();
     init_task_file_refs();
@@ -2328,7 +2328,7 @@ var init_AxiomAgentExecutor = __esm({
           await this.taskStore.save(initialTask);
           bus.publish(initialTask);
           try {
-            const agent = import_core75.agentInstanceManager.getAgent(this.agentParams(threadId));
+            const agent = import_core76.agentInstanceManager.getAgent(this.agentParams(threadId));
             const requestText = inputFiles.length > 0 ? `${text}
 
 ${formatFileRefsSection(inputFiles)}` : text;
@@ -2516,7 +2516,7 @@ ${formatFileRefsSection(inputFiles)}` : text;
         const threadId = task ? asString2(task.metadata?.threadId) : void 0;
         if (threadId) {
           try {
-            const agent = import_core75.agentInstanceManager.getAgent(this.agentParams(threadId));
+            const agent = import_core76.agentInstanceManager.getAgent(this.agentParams(threadId));
             await agent.abort();
           } catch (err) {
             console.warn({
@@ -2890,10 +2890,10 @@ function isAsyncGenerator(value) {
 }
 function registerA2AStandardRoutes(app2, deps) {
   const authService = deps.authService;
-  const resolveTasks = deps.getTaskStoreLattice ?? (() => (0, import_core76.getStoreLattice)("default", "task").store);
-  const resolveTaskWorkItems = deps.getTaskWorkItemStore ?? (() => (0, import_core76.getStoreLattice)("default", "taskWorkItem").store);
-  const getAssistantStore2 = deps.getAssistantStore ?? (() => (0, import_core76.getStoreLattice)("default", "assistant").store);
-  const getProjectStore2 = deps.getProjectStore ?? (() => (0, import_core76.getStoreLattice)("default", "project").store);
+  const resolveTasks = deps.getTaskStoreLattice ?? (() => (0, import_core77.getStoreLattice)("default", "task").store);
+  const resolveTaskWorkItems = deps.getTaskWorkItemStore ?? (() => (0, import_core77.getStoreLattice)("default", "taskWorkItem").store);
+  const getAssistantStore2 = deps.getAssistantStore ?? (() => (0, import_core77.getStoreLattice)("default", "assistant").store);
+  const getProjectStore2 = deps.getProjectStore ?? (() => (0, import_core77.getStoreLattice)("default", "project").store);
   const runtimeRegistry = deps.runtimeRegistry ?? new A2ARuntimeRegistry();
   app2.addHook("onClose", async () => {
     runtimeRegistry.close();
@@ -2976,7 +2976,7 @@ function registerA2AStandardRoutes(app2, deps) {
       const taskStore = assistantHasGovernedTask(assistant) ? new A2ATaskStoreAdapter({
         taskStore: internalTasks,
         workItemStore: workItems,
-        lifecycle: (0, import_core76.createTaskLifecycleService)({
+        lifecycle: (0, import_core77.createTaskLifecycleService)({
           taskStore: internalTasks,
           workItemStore: workItems
         }),
@@ -3095,7 +3095,7 @@ data: ${JSON.stringify(errorResponse)}
       const taskStore = assistantHasGovernedTask(assistant) ? new A2ATaskStoreAdapter({
         taskStore: internalTasks,
         workItemStore: workItems,
-        lifecycle: (0, import_core76.createTaskLifecycleService)({
+        lifecycle: (0, import_core77.createTaskLifecycleService)({
           taskStore: internalTasks,
           workItemStore: workItems
         }),
@@ -3150,13 +3150,13 @@ data: ${JSON.stringify(data)}
     }
   );
 }
-var import_uuid12, import_server2, import_core76, SSE_HEADERS;
+var import_uuid12, import_server2, import_core77, SSE_HEADERS;
 var init_a2a_standard = __esm({
   "src/routes/a2a-standard.ts"() {
     "use strict";
     import_uuid12 = require("uuid");
     import_server2 = require("@a2a-js/sdk/server");
-    import_core76 = require("@axiom-lattice/core");
+    import_core77 = require("@axiom-lattice/core");
     init_A2AAuthService();
     init_A2AAgentCardBuilder();
     init_A2ATaskStoreAdapter();
@@ -3908,8 +3908,8 @@ function exposedDeclarations(plugin) {
   return (plugin.meta.tools ?? []).filter((t2) => t2.expose);
 }
 async function registerExposedPluginTools() {
-  for (const key of import_core77.PluginRegistry.list()) {
-    const plugin = import_core77.PluginRegistry.get(key);
+  for (const key of import_core78.PluginRegistry.list()) {
+    const plugin = import_core78.PluginRegistry.get(key);
     if (!plugin?.middleware) continue;
     const exposed = exposedDeclarations(plugin);
     if (exposed.length === 0) continue;
@@ -3944,8 +3944,8 @@ async function registerExposedPluginTools() {
 }
 function collectExposedPluginUiResources(grants) {
   const resources = /* @__PURE__ */ new Map();
-  for (const type of import_core77.PluginRegistry.list()) {
-    const plugin = import_core77.PluginRegistry.get(type);
+  for (const type of import_core78.PluginRegistry.list()) {
+    const plugin = import_core78.PluginRegistry.get(type);
     if (!plugin?.middleware) continue;
     const exposedNames = new Set(exposedDeclarations(plugin).map((d) => d.name));
     if (exposedNames.size === 0) continue;
@@ -3969,11 +3969,11 @@ function collectExposedPluginUiResources(grants) {
   }
   return resources;
 }
-var import_core77;
+var import_core78;
 var init_registerExposedPlugins = __esm({
   "src/services/open/registerExposedPlugins.ts"() {
     "use strict";
-    import_core77 = require("@axiom-lattice/core");
+    import_core78 = require("@axiom-lattice/core");
     init_openLattice();
     init_pluginExposeAdapter();
   }
@@ -3988,14 +3988,14 @@ function toText(result) {
 }
 function defaultCatalog() {
   return {
-    getValidatedManifest: (tenantId, type) => (0, import_core78.getSandboxPluginCatalog)().getValidatedManifest(tenantId, type),
-    getExecutor: () => (0, import_core78.getSandboxPluginCatalog)().getExecutor(),
-    readPluginFile: (tenantId, type, relPath) => (0, import_core78.getSandboxPluginCatalog)().readPluginFile(tenantId, type, relPath)
+    getValidatedManifest: (tenantId, type) => (0, import_core79.getSandboxPluginCatalog)().getValidatedManifest(tenantId, type),
+    getExecutor: () => (0, import_core79.getSandboxPluginCatalog)().getExecutor(),
+    readPluginFile: (tenantId, type, relPath) => (0, import_core79.getSandboxPluginCatalog)().readPluginFile(tenantId, type, relPath)
   };
 }
 async function defaultResolveConnections(pluginType, ctx) {
   try {
-    return await (0, import_core78.resolveSandboxPluginConnections)(
+    return await (0, import_core79.resolveSandboxPluginConnections)(
       pluginType,
       { connectAll: true },
       {
@@ -4024,7 +4024,7 @@ function mergeOpenCatalog(globalCatalog, tenantTools) {
 async function buildTenantOpenPlugins(tenantId, grants, deps = {}) {
   const catalog = deps.catalog ?? defaultCatalog();
   const listPlugins = deps.listPlugins ?? (async (tenant2) => {
-    const snapshot = await (0, import_core78.getSandboxPluginCatalog)().ensureLoaded(tenant2);
+    const snapshot = await (0, import_core79.getSandboxPluginCatalog)().ensureLoaded(tenant2);
     return { plugins: snapshot.plugins, diagnostics: snapshot.diagnostics };
   });
   const resolveConnections = deps.resolveConnections ?? defaultResolveConnections;
@@ -4066,7 +4066,7 @@ async function buildTenantOpenPlugins(tenantId, grants, deps = {}) {
         domain,
         action: tool.name,
         description: tool.description,
-        schema: (0, import_core78.jsonSchemaToZod)(tool.schema),
+        schema: (0, import_core79.jsonSchemaToZod)(tool.schema),
         annotations: {
           readOnlyHint: tool.readOnly ?? false,
           destructiveHint: tool.destructive ?? false
@@ -4117,11 +4117,11 @@ async function buildTenantOpenPlugins(tenantId, grants, deps = {}) {
     }
   };
 }
-var import_core78;
+var import_core79;
 var init_tenantOpenPlugins = __esm({
   "src/services/open/tenantOpenPlugins.ts"() {
     "use strict";
-    import_core78 = require("@axiom-lattice/core");
+    import_core79 = require("@axiom-lattice/core");
     init_openLattice();
     init_pluginToolExecution();
   }
@@ -4158,13 +4158,13 @@ function emptyTenantPlugins() {
 }
 function registerOpenRoutes(app2, deps = {}) {
   const openAuth = deps.openAuth ?? new OpenCredentialService(
-    (0, import_core79.getStoreLattice)("default", "a2aApiKey").store,
-    (0, import_core79.getStoreLattice)("default", "project").store
+    (0, import_core80.getStoreLattice)("default", "a2aApiKey").store,
+    (0, import_core80.getStoreLattice)("default", "project").store
   );
   const grantsSource = deps.grantsSource ?? ((ctx) => ctx.grants);
   const audit = deps.audit ?? (() => {
     try {
-      const store2 = (0, import_core79.getStoreLattice)("default", "openAudit").store;
+      const store2 = (0, import_core80.getStoreLattice)("default", "openAudit").store;
       return new OpenAuditService(store2);
     } catch {
       return void 0;
@@ -4319,12 +4319,12 @@ function registerOpenRoutes(app2, deps = {}) {
     }
   );
 }
-var import_types, import_core79, RPC_ERROR;
+var import_types, import_core80, RPC_ERROR;
 var init_open = __esm({
   "src/routes/open.ts"() {
     "use strict";
     import_types = require("@modelcontextprotocol/sdk/types.js");
-    import_core79 = require("@axiom-lattice/core");
+    import_core80 = require("@axiom-lattice/core");
     init_openCredentialService();
     init_openAuditService();
     init_openRateLimiter();
@@ -4357,7 +4357,7 @@ function registerOpenSessionRoutes(app2) {
       if (typeof shareToken !== "string" || shareToken.length === 0) {
         return reply.status(400).send({ error: "SHARE_TOKEN_REQUIRED" });
       }
-      const store2 = (0, import_core80.getStoreLattice)("default", "sharedResource").store;
+      const store2 = (0, import_core81.getStoreLattice)("default", "sharedResource").store;
       const record = await store2.findByToken(shareToken);
       if (!record || record.revoked) {
         return reply.status(404).send({ error: "SHARE_NOT_FOUND" });
@@ -4382,11 +4382,11 @@ function registerOpenSessionRoutes(app2) {
     }
   );
 }
-var import_core80;
+var import_core81;
 var init_open_session = __esm({
   "src/routes/open-session.ts"() {
     "use strict";
-    import_core80 = require("@axiom-lattice/core");
+    import_core81 = require("@axiom-lattice/core");
     init_openToken();
     init_previewToken();
     init_openLattice();
@@ -4395,13 +4395,13 @@ var init_open_session = __esm({
 
 // src/services/open/openCatalogService.ts
 async function defaultListTenantPlugins(tenantId) {
-  return (await (0, import_core81.getSandboxPluginCatalog)().ensureLoaded(tenantId)).plugins;
+  return (await (0, import_core82.getSandboxPluginCatalog)().ensureLoaded(tenantId)).plugins;
 }
-var import_core81, OpenCatalogService;
+var import_core82, OpenCatalogService;
 var init_openCatalogService = __esm({
   "src/services/open/openCatalogService.ts"() {
     "use strict";
-    import_core81 = require("@axiom-lattice/core");
+    import_core82 = require("@axiom-lattice/core");
     init_openLattice();
     OpenCatalogService = class {
       constructor(assistantStore, lattice = openLattice, listTenantPlugins2 = defaultListTenantPlugins) {
@@ -4476,17 +4476,17 @@ function registerOpenCatalogRoutes(app2) {
     if (!tenantId) {
       return reply.status(401).send({ success: false, error: "Unauthorized" });
     }
-    const assistantStore = (0, import_core82.getStoreLattice)("default", "assistant").store;
+    const assistantStore = (0, import_core83.getStoreLattice)("default", "assistant").store;
     const service2 = new OpenCatalogService(assistantStore);
     const catalog = await service2.buildForTenant(tenantId);
     return reply.status(200).send({ success: true, data: catalog });
   });
 }
-var import_core82;
+var import_core83;
 var init_open_catalog = __esm({
   "src/routes/open-catalog.ts"() {
     "use strict";
-    import_core82 = require("@axiom-lattice/core");
+    import_core83 = require("@axiom-lattice/core");
     init_openCatalogService();
   }
 });
@@ -4501,11 +4501,11 @@ async function resolveContextSandbox(ctx) {
   const sandboxName = ctx.runConfig?.sandboxName;
   if (typeof sandboxName === "string" && sandboxName.length > 0) {
     try {
-      return await import_core83.sandboxLatticeManager.getSandbox(sandboxName);
+      return await import_core84.sandboxLatticeManager.getSandbox(sandboxName);
     } catch {
     }
   }
-  return import_core83.sandboxLatticeManager.getSandboxFromConfig({
+  return import_core84.sandboxLatticeManager.getSandboxFromConfig({
     assistant_id: "",
     thread_id: "",
     tenantId: ctx.tenantId,
@@ -4603,12 +4603,12 @@ ${truncated}`
     }
   };
 }
-var import_zod21, import_core83, MAX_OUTPUT_BYTES;
+var import_zod21, import_core84, MAX_OUTPUT_BYTES;
 var init_sandboxProvider = __esm({
   "src/services/open/providers/sandboxProvider.ts"() {
     "use strict";
     import_zod21 = require("zod");
-    import_core83 = require("@axiom-lattice/core");
+    import_core84 = require("@axiom-lattice/core");
     MAX_OUTPUT_BYTES = 64e3;
   }
 });
@@ -4630,12 +4630,12 @@ function safePath(raw) {
 }
 function registerOpenFilesRoutes(app2, deps = {}) {
   const openAuth = deps.openAuth ?? new OpenCredentialService(
-    (0, import_core84.getStoreLattice)("default", "a2aApiKey").store,
-    (0, import_core84.getStoreLattice)("default", "project").store
+    (0, import_core85.getStoreLattice)("default", "a2aApiKey").store,
+    (0, import_core85.getStoreLattice)("default", "project").store
   );
   const audit = deps.audit ?? (() => {
     try {
-      const store2 = (0, import_core84.getStoreLattice)("default", "openAudit").store;
+      const store2 = (0, import_core85.getStoreLattice)("default", "openAudit").store;
       return new OpenAuditService(store2);
     } catch {
       return void 0;
@@ -4745,11 +4745,11 @@ function registerOpenFilesRoutes(app2, deps = {}) {
     }
   });
 }
-var import_core84;
+var import_core85;
 var init_open_files = __esm({
   "src/routes/open-files.ts"() {
     "use strict";
-    import_core84 = require("@axiom-lattice/core");
+    import_core85 = require("@axiom-lattice/core");
     init_openCredentialService();
     init_openLattice();
     init_sandboxProvider();
@@ -4771,7 +4771,7 @@ function registerOpenAuditRoutes(app2) {
         return reply.status(401).send({ success: false, error: "Unauthorized" });
       }
       const status = request.query.status === "ok" || request.query.status === "error" ? request.query.status : void 0;
-      const store2 = (0, import_core85.getStoreLattice)("default", "openAudit").store;
+      const store2 = (0, import_core86.getStoreLattice)("default", "openAudit").store;
       const records = await store2.query({
         tenantId,
         credentialId: request.query.credentialId,
@@ -4786,11 +4786,11 @@ function registerOpenAuditRoutes(app2) {
     }
   );
 }
-var import_core85;
+var import_core86;
 var init_open_audit = __esm({
   "src/routes/open-audit.ts"() {
     "use strict";
-    import_core85 = require("@axiom-lattice/core");
+    import_core86 = require("@axiom-lattice/core");
   }
 });
 
@@ -4807,7 +4807,7 @@ function registerOpenExposureRoutes(app2, deps = {}) {
       if (!tenantId) {
         return reply.status(401).send({ success: false, error: "Unauthorized" });
       }
-      const keyStore = (0, import_core86.getStoreLattice)("default", "a2aApiKey").store;
+      const keyStore = (0, import_core87.getStoreLattice)("default", "a2aApiKey").store;
       const record = await keyStore.findById(request.params.id);
       if (!record || record.tenantId !== tenantId) {
         return reply.status(404).send({ success: false, error: "Key not found" });
@@ -4841,7 +4841,7 @@ function registerOpenExposureRoutes(app2, deps = {}) {
         hasUi: Boolean(t2.ui)
       }));
       const agentGrant = grants.find((g) => g.domain === "agent");
-      const assistantStore = (0, import_core86.getStoreLattice)("default", "assistant").store;
+      const assistantStore = (0, import_core87.getStoreLattice)("default", "assistant").store;
       const agents = [];
       for (const assistantId of agentGrant?.items ?? []) {
         const assistant = await assistantStore.getAssistantById(
@@ -4876,11 +4876,11 @@ function registerOpenExposureRoutes(app2, deps = {}) {
     }
   );
 }
-var import_core86, import_protocols38;
+var import_core87, import_protocols38;
 var init_open_exposure = __esm({
   "src/routes/open-exposure.ts"() {
     "use strict";
-    import_core86 = require("@axiom-lattice/core");
+    import_core87 = require("@axiom-lattice/core");
     import_protocols38 = require("@axiom-lattice/protocols");
     init_openLattice();
     init_tenantOpenPlugins();
@@ -5000,7 +5000,7 @@ function createAgentProvider(deps = {}) {
         } catch {
         }
       }
-      const agent = import_core87.agentInstanceManager.getAgent({
+      const agent = import_core88.agentInstanceManager.getAgent({
         tenant_id: ctx.tenantId,
         assistant_id: assistantId,
         thread_id: threadId,
@@ -5025,12 +5025,12 @@ function createAgentProvider(deps = {}) {
     }
   };
 }
-var import_zod23, import_core87, import_protocols39, STOP_TYPES;
+var import_zod23, import_core88, import_protocols39, STOP_TYPES;
 var init_agentProvider = __esm({
   "src/services/open/providers/agentProvider.ts"() {
     "use strict";
     import_zod23 = require("zod");
-    import_core87 = require("@axiom-lattice/core");
+    import_core88 = require("@axiom-lattice/core");
     import_protocols39 = require("@axiom-lattice/protocols");
     STOP_TYPES = [import_protocols39.MessageChunkTypes.MESSAGE_COMPLETED];
   }
@@ -5133,11 +5133,11 @@ async function resolveAgentOpenGrants(tenantId, assistantId, deps) {
   }
 }
 function createDefaultAgentReflectionDeps(tenantId) {
-  (0, import_core88.ensureBuiltinAgentsForTenant)(tenantId);
+  (0, import_core89.ensureBuiltinAgentsForTenant)(tenantId);
   return {
-    ensure: (t2) => import_core88.agentLatticeManager.initializeStoredAssistantsForTenant(t2),
+    ensure: (t2) => import_core89.agentLatticeManager.initializeStoredAssistantsForTenant(t2),
     getAgentConfig: (t2, assistantId) => {
-      const config = import_core88.agentLatticeManager.getAgentConfigWithTenant(t2, assistantId);
+      const config = import_core89.agentLatticeManager.getAgentConfigWithTenant(t2, assistantId);
       if (!config) return void 0;
       return {
         middleware: extractMiddleware(config),
@@ -5145,16 +5145,16 @@ function createDefaultAgentReflectionDeps(tenantId) {
       };
     },
     getAssistantMiddleware: async (t2, assistantId) => {
-      const store2 = (0, import_core88.getStoreLattice)("default", "assistant").store;
+      const store2 = (0, import_core89.getStoreLattice)("default", "assistant").store;
       const assistant = await store2.getAssistantById(t2, assistantId);
       return extractMiddleware(assistant?.graphDefinition);
     },
     exposedActionsByType: (type) => {
-      const plugin = import_core88.PluginRegistry.get(type);
+      const plugin = import_core89.PluginRegistry.get(type);
       return plugin ? normalizeOpenExpose(plugin.meta.openExpose) : [];
     },
     resolvableAssistants: async (t2) => new Set(
-      import_core88.agentLatticeManager.getAllAgentLatticesByTenant(t2).map((lattice) => lattice.config.key)
+      import_core89.agentLatticeManager.getAllAgentLatticesByTenant(t2).map((lattice) => lattice.config.key)
     )
   };
 }
@@ -5219,30 +5219,30 @@ function buildTenantExposedGrants(manifests) {
 }
 function createDefaultPluginReflectionDeps() {
   return {
-    ensure: (tenantId) => import_core88.agentLatticeManager.initializeStoredAssistantsForTenant(tenantId),
+    ensure: (tenantId) => import_core89.agentLatticeManager.initializeStoredAssistantsForTenant(tenantId),
     globalExposedDomains: () => {
       const grants = [];
-      for (const type of import_core88.PluginRegistry.list()) {
-        const plugin = import_core88.PluginRegistry.get(type);
+      for (const type of import_core89.PluginRegistry.list()) {
+        const plugin = import_core89.PluginRegistry.get(type);
         const items = normalizeOpenExpose(plugin?.meta.openExpose);
         if (items.length > 0) grants.push({ domain: type, items });
       }
       return grants;
     },
     tenantExposedDomains: async (tenantId) => {
-      const { manifests } = await (0, import_core88.getSandboxPluginCatalog)().ensureLoaded(tenantId);
+      const { manifests } = await (0, import_core89.getSandboxPluginCatalog)().ensureLoaded(tenantId);
       return buildTenantExposedGrants(Object.values(manifests));
     },
     resolvableAssistants: async (tenantId) => new Set(
-      import_core88.agentLatticeManager.getAllAgentLatticesByTenant(tenantId).map((lattice) => lattice.config.key)
+      import_core89.agentLatticeManager.getAllAgentLatticesByTenant(tenantId).map((lattice) => lattice.config.key)
     )
   };
 }
-var import_core88, AGENT_REFLECTION_CACHE_TTL_MS, cache, PLUGIN_REFLECTION_CACHE_TTL_MS, pluginCache;
+var import_core89, AGENT_REFLECTION_CACHE_TTL_MS, cache, PLUGIN_REFLECTION_CACHE_TTL_MS, pluginCache;
 var init_sandboxOpenReflection = __esm({
   "src/services/open/sandboxOpenReflection.ts"() {
     "use strict";
-    import_core88 = require("@axiom-lattice/core");
+    import_core89 = require("@axiom-lattice/core");
     AGENT_REFLECTION_CACHE_TTL_MS = 6e4;
     cache = /* @__PURE__ */ new Map();
     PLUGIN_REFLECTION_CACHE_TTL_MS = 6e4;
@@ -5288,7 +5288,7 @@ function createSandboxOpenCredentialProvider(options) {
   };
 }
 function registerGatewaySandboxOpenCredentialProvider(onError) {
-  return (0, import_core89.registerSandboxOpenCredentialProvider)(
+  return (0, import_core90.registerSandboxOpenCredentialProvider)(
     createSandboxOpenCredentialProvider({
       gatewayUrl: process.env.PUBLIC_GATEWAY_URL?.trim() || void 0,
       onError
@@ -5296,11 +5296,11 @@ function registerGatewaySandboxOpenCredentialProvider(onError) {
     { onError }
   );
 }
-var import_core89, DEFAULT_SANDBOX_OPEN_GRANTS, MAX_SANDBOX_OPEN_DEPTH;
+var import_core90, DEFAULT_SANDBOX_OPEN_GRANTS, MAX_SANDBOX_OPEN_DEPTH;
 var init_sandboxOpenCredentialProvider = __esm({
   "src/services/open/sandboxOpenCredentialProvider.ts"() {
     "use strict";
-    import_core89 = require("@axiom-lattice/core");
+    import_core90 = require("@axiom-lattice/core");
     init_openToken();
     init_sandboxOpenReflection();
     DEFAULT_SANDBOX_OPEN_GRANTS = [
@@ -5337,12 +5337,12 @@ var resources_exports = {};
 __export(resources_exports, {
   ResourceController: () => ResourceController
 });
-var import_bcryptjs, import_core90, ResourceController;
+var import_bcryptjs, import_core91, ResourceController;
 var init_resources = __esm({
   "src/controllers/resources.ts"() {
     "use strict";
     import_bcryptjs = __toESM(require("bcryptjs"));
-    import_core90 = require("@axiom-lattice/core");
+    import_core91 = require("@axiom-lattice/core");
     init_mime();
     init_http_range();
     init_sandboxGrants();
@@ -5359,14 +5359,14 @@ var init_resources = __esm({
         if (!workspaceId || !projectId) {
           return reply.status(400).send({ error: "x-workspace-id and x-project-id headers required" });
         }
-        const payload = (0, import_core90.createSharePayload)(
+        const payload = (0, import_core91.createSharePayload)(
           tenantId,
           workspaceId,
           projectId,
           userId,
           body
         );
-        const token = (0, import_core90.generateToken)();
+        const token = (0, import_core91.generateToken)();
         try {
           await this.deps.store.create({ ...payload, token });
           this.deps.logger.info(
@@ -5518,7 +5518,7 @@ var init_resources = __esm({
             resourcePath: subPath
           }, subPath, ext, request, reply);
         }
-        const volume = (0, import_core90.buildNamedVolumeName)("p", "project", tenantId, workspaceId, projectId);
+        const volume = (0, import_core91.buildNamedVolumeName)("p", "project", tenantId, workspaceId, projectId);
         return this._resolveAndServe(
           volume,
           subPath,
@@ -10178,23 +10178,13 @@ var import_core20 = require("@axiom-lattice/core");
 
 // src/services/plugins/tenantPluginResolver.ts
 var import_core19 = require("@axiom-lattice/core");
-async function listTenantPlugins(tenantId) {
-  let tenantPlugins = [];
-  try {
-    tenantPlugins = (await (0, import_core19.getSandboxPluginCatalog)().ensureLoaded(tenantId)).plugins;
-  } catch {
-    tenantPlugins = [];
-  }
-  const globalPlugins = import_core19.PluginRegistry.list().map((type) => import_core19.PluginRegistry.get(type)).filter((p) => Boolean(p));
-  return (0, import_core19.mergePluginSources)(globalPlugins, tenantPlugins);
-}
 async function resolveTenantPluginByType(tenantId, type) {
-  return (await listTenantPlugins(tenantId)).find((p) => p.meta.type === type);
+  return (await (0, import_core19.listTenantPlugins)(tenantId)).find((p) => p.meta.type === type);
 }
 
 // src/controllers/middleware-types.ts
 async function collectMiddlewareMetas(tenantId) {
-  return (await listTenantPlugins(tenantId)).map(import_core20.serializePluginMeta);
+  return (await (0, import_core19.listTenantPlugins)(tenantId)).map(import_core20.serializePluginMeta);
 }
 function middlewareTypesRoutes(fastify2) {
   fastify2.get("/api/middleware-types", async (request, reply) => {
@@ -13329,8 +13319,17 @@ function registerMetricsServerConfigRoutes(app2) {
 }
 
 // src/controllers/connections.ts
-var import_core32 = require("@axiom-lattice/core");
+var import_core33 = require("@axiom-lattice/core");
 var import_zod2 = require("zod");
+
+// src/services/plugins/connectionSecretFields.ts
+var import_core32 = require("@axiom-lattice/core");
+function secretFieldsForConnection(plugin) {
+  const keys2 = (0, import_core32.connectionSecretFields)(plugin);
+  return keys2.length > 0 ? keys2 : void 0;
+}
+
+// src/controllers/connections.ts
 var createBody = import_zod2.z.object({
   type: import_zod2.z.string().min(1),
   key: import_zod2.z.string().min(1),
@@ -13352,28 +13351,9 @@ function getTenant(request) {
 async function getTenantPlugin(request, type) {
   return resolveTenantPluginByType(getTenant(request), type);
 }
-function maskSecrets(config) {
-  const sensitive = /* @__PURE__ */ new Set([
-    "password",
-    "secret",
-    "token",
-    "apikey",
-    "api_key",
-    "session",
-    "privatekey",
-    "private_key",
-    "accesskey",
-    "access_key"
-  ]);
-  const out = {};
-  for (const [k, v] of Object.entries(config)) {
-    out[k] = sensitive.has(k.toLowerCase()) ? "********" : v;
-  }
-  return out;
-}
 async function resolveConfig(type, body, tenantId) {
   if (body.key) {
-    const entry = await import_core32.ConnectionRegistry.get(type, body.key, tenantId);
+    const entry = await import_core33.ConnectionRegistry.get(type, body.key, tenantId);
     if (!entry) throw { status: 404, error: `Connection "${body.key}" not found` };
     return entry.config;
   }
@@ -13384,25 +13364,27 @@ function connectionRoutes(fastify2) {
   fastify2.get("/api/connections", async (request, reply) => {
     const { type } = request.query;
     if (!type) return reply.status(400).send({ error: "query 'type' required" });
-    const entries = await import_core32.ConnectionRegistry.list(type, getTenant(request));
+    const entries = await import_core33.ConnectionRegistry.list(type, getTenant(request));
     return reply.send({
       success: true,
-      data: { records: entries.map((e) => ({ ...e, config: maskSecrets(e.config) })), total: entries.length }
+      data: { records: entries, total: entries.length }
     });
   });
   fastify2.post("/api/connections", async (request, reply) => {
     const parsed = createBody.parse(request.body);
-    const entry = await import_core32.ConnectionRegistry.create({
+    const plugin = await getTenantPlugin(request, parsed.type);
+    const entry = await import_core33.ConnectionRegistry.create({
       tenantId: getTenant(request),
       type: parsed.type,
       key: parsed.key,
       name: parsed.name,
       description: parsed.description,
-      config: parsed.config
+      config: parsed.config,
+      secretFields: secretFieldsForConnection(plugin)
     });
     return reply.status(201).send({
       success: true,
-      data: { ...entry, config: maskSecrets(entry.config) }
+      data: entry
     });
   });
   fastify2.put("/api/connections/:key", async (request, reply) => {
@@ -13411,25 +13393,27 @@ function connectionRoutes(fastify2) {
     const { key } = request.params;
     const body = request.body;
     const tenantId = getTenant(request);
-    const existing = await import_core32.ConnectionRegistry.get(type, key, tenantId);
+    const existing = await import_core33.ConnectionRegistry.get(type, key, tenantId);
     if (!existing) return reply.status(404).send({ error: "not found" });
+    const plugin = await getTenantPlugin(request, type);
     const updates = {};
     if (body.name !== void 0) updates.name = body.name;
     if (body.description !== void 0) updates.description = body.description;
     if (body.config) {
       updates.config = { ...existing.config, ...body.config };
+      updates.secretFields = secretFieldsForConnection(plugin);
     }
-    const entry = await import_core32.ConnectionRegistry.update(tenantId, type, key, updates);
+    const entry = await import_core33.ConnectionRegistry.update(tenantId, type, key, updates);
     return reply.send({
       success: true,
-      data: { ...entry, config: maskSecrets(entry?.config ?? {}) }
+      data: entry
     });
   });
   fastify2.delete("/api/connections/:key", async (request, reply) => {
     const { type } = request.query;
     if (!type) return reply.status(400).send({ error: "query 'type' required" });
     const { key } = request.params;
-    const ok = await import_core32.ConnectionRegistry.delete(getTenant(request), type, key);
+    const ok = await import_core33.ConnectionRegistry.delete(getTenant(request), type, key);
     return reply.send({ success: ok });
   });
   fastify2.post("/api/connections/test", async (request, reply) => {
@@ -13490,7 +13474,7 @@ function connectionRoutes(fastify2) {
 }
 
 // src/controllers/mcp-configs.ts
-var import_core33 = require("@axiom-lattice/core");
+var import_core34 = require("@axiom-lattice/core");
 var import_crypto8 = require("crypto");
 
 // src/services/mcpConfigSync.ts
@@ -13539,15 +13523,15 @@ function getTenantId11(request) {
 function broadcastMcpConfigChanged(tenantId, serverKey) {
   if (!tenantId || !serverKey) return;
   try {
-    const outbox = (0, import_core33.getStoreLattice)("default", "outbox").store;
-    void publishMcpConfigChanged(outbox, (0, import_core33.getReplicaId)(), tenantId, serverKey);
+    const outbox = (0, import_core34.getStoreLattice)("default", "outbox").store;
+    void publishMcpConfigChanged(outbox, (0, import_core34.getReplicaId)(), tenantId, serverKey);
   } catch {
   }
 }
 async function getMcpServerConfigList(request, reply) {
   const tenantId = getTenantId11(request);
   try {
-    const storeLattice = (0, import_core33.getStoreLattice)("default", "mcp");
+    const storeLattice = (0, import_core34.getStoreLattice)("default", "mcp");
     const store2 = storeLattice.store;
     const configs = await store2.getAllConfigs(tenantId);
     return {
@@ -13574,7 +13558,7 @@ async function getMcpServerConfig(request, reply) {
   const tenantId = getTenantId11(request);
   const { key } = request.params;
   try {
-    const storeLattice = (0, import_core33.getStoreLattice)("default", "mcp");
+    const storeLattice = (0, import_core34.getStoreLattice)("default", "mcp");
     const store2 = storeLattice.store;
     const config = await store2.getConfigByKey(tenantId, key);
     if (!config) {
@@ -13600,7 +13584,7 @@ async function createMcpServerConfig(request, reply) {
   const tenantId = getTenantId11(request);
   const body = request.body;
   try {
-    const storeLattice = (0, import_core33.getStoreLattice)("default", "mcp");
+    const storeLattice = (0, import_core34.getStoreLattice)("default", "mcp");
     const store2 = storeLattice.store;
     const existing = await store2.getConfigByKey(tenantId, body.key);
     if (existing) {
@@ -13641,7 +13625,7 @@ async function updateMcpServerConfig(request, reply) {
   const { key } = request.params;
   const updates = request.body;
   try {
-    const storeLattice = (0, import_core33.getStoreLattice)("default", "mcp");
+    const storeLattice = (0, import_core34.getStoreLattice)("default", "mcp");
     const store2 = storeLattice.store;
     const existing = await store2.getConfigByKey(tenantId, key);
     if (!existing) {
@@ -13663,13 +13647,13 @@ async function updateMcpServerConfig(request, reply) {
     }
     if (configChanged) {
       try {
-        const connection = (0, import_core33.convertToConnection)(updated.config);
-        import_core33.mcpManager.registerServer(tenantId, key, connection, {
+        const connection = (0, import_core34.convertToConnection)(updated.config);
+        import_core34.mcpManager.registerServer(tenantId, key, connection, {
           timeoutMs: updated.config.timeout,
           maxAttempts: updated.config.retryAttempts
         });
-        await import_core33.mcpManager.ensureConnected(tenantId, key);
-        await import_core33.mcpManager.registerToolsToToolLattice(tenantId, key, updated.selectedTools);
+        await import_core34.mcpManager.ensureConnected(tenantId, key);
+        await import_core34.mcpManager.registerToolsToToolLattice(tenantId, key, updated.selectedTools);
         await store2.updateConfig(tenantId, existing.id, { status: "connected" });
         updated.status = "connected";
       } catch (error) {
@@ -13677,16 +13661,16 @@ async function updateMcpServerConfig(request, reply) {
         await store2.updateConfig(tenantId, existing.id, { status: "error" });
         updated.status = "error";
       }
-    } else if (toolsChanged && import_core33.mcpManager.hasServer(tenantId, key)) {
+    } else if (toolsChanged && import_core34.mcpManager.hasServer(tenantId, key)) {
       try {
-        await import_core33.mcpManager.registerToolsToToolLattice(tenantId, key, updated.selectedTools);
+        await import_core34.mcpManager.registerToolsToToolLattice(tenantId, key, updated.selectedTools);
       } catch (error) {
         console.warn("Failed to re-register MCP tools:", error);
       }
     }
-    if (statusChanged && updated.status !== "connected" && import_core33.mcpManager.hasServer(tenantId, key)) {
+    if (statusChanged && updated.status !== "connected" && import_core34.mcpManager.hasServer(tenantId, key)) {
       try {
-        await import_core33.mcpManager.removeServer(tenantId, key);
+        await import_core34.mcpManager.removeServer(tenantId, key);
       } catch (error) {
         console.warn("Failed to remove MCP server:", error);
       }
@@ -13711,7 +13695,7 @@ async function deleteMcpServerConfig(request, reply) {
   const tenantId = getTenantId11(request);
   const { keyOrId } = request.params;
   try {
-    const storeLattice = (0, import_core33.getStoreLattice)("default", "mcp");
+    const storeLattice = (0, import_core34.getStoreLattice)("default", "mcp");
     const store2 = storeLattice.store;
     let config = await store2.getConfigByKey(tenantId, keyOrId);
     let configKey = keyOrId;
@@ -13729,8 +13713,8 @@ async function deleteMcpServerConfig(request, reply) {
       };
     }
     try {
-      if (import_core33.mcpManager.hasServer(tenantId, configKey)) {
-        await import_core33.mcpManager.removeServer(tenantId, configKey);
+      if (import_core34.mcpManager.hasServer(tenantId, configKey)) {
+        await import_core34.mcpManager.removeServer(tenantId, configKey);
       }
     } catch (error) {
       console.warn("Failed to remove from MCP manager:", error);
@@ -13759,7 +13743,7 @@ async function testMcpServerConnection(request, reply) {
   const tenantId = getTenantId11(request);
   const { key } = request.params;
   try {
-    const storeLattice = (0, import_core33.getStoreLattice)("default", "mcp");
+    const storeLattice = (0, import_core34.getStoreLattice)("default", "mcp");
     const store2 = storeLattice.store;
     const config = await store2.getConfigByKey(tenantId, key);
     if (!config) {
@@ -13771,8 +13755,8 @@ async function testMcpServerConnection(request, reply) {
     }
     try {
       const testKey = `__test_${key}_${Date.now()}`;
-      const connection = (0, import_core33.convertToConnection)(config.config);
-      const { latency } = await import_core33.McpLatticeManager.testConnection(testKey, connection);
+      const connection = (0, import_core34.convertToConnection)(config.config);
+      const { latency } = await import_core34.McpLatticeManager.testConnection(testKey, connection);
       return {
         success: true,
         message: "Connection test successful",
@@ -13807,7 +13791,7 @@ async function listMcpServerTools(request, reply) {
   const tenantId = getTenantId11(request);
   const { key } = request.params;
   try {
-    const storeLattice = (0, import_core33.getStoreLattice)("default", "mcp");
+    const storeLattice = (0, import_core34.getStoreLattice)("default", "mcp");
     const store2 = storeLattice.store;
     const config = await store2.getConfigByKey(tenantId, key);
     if (!config) {
@@ -13817,7 +13801,7 @@ async function listMcpServerTools(request, reply) {
         message: "MCP server configuration not found"
       };
     }
-    const wasConnected = import_core33.mcpManager.isServerConnected(tenantId, key);
+    const wasConnected = import_core34.mcpManager.isServerConnected(tenantId, key);
     if (!wasConnected) {
       await connectAndRegisterTools(config);
     }
@@ -13828,7 +13812,7 @@ async function listMcpServerTools(request, reply) {
     if (!wasConnected || statusStale) {
       broadcastMcpConfigChanged(tenantId, key);
     }
-    const tools = await import_core33.mcpManager.getServerTools(tenantId, key);
+    const tools = await import_core34.mcpManager.getServerTools(tenantId, key);
     return {
       success: true,
       message: "Tools retrieved successfully",
@@ -13848,7 +13832,7 @@ async function connectMcpServer(request, reply) {
   const tenantId = getTenantId11(request);
   const { key } = request.params;
   try {
-    const storeLattice = (0, import_core33.getStoreLattice)("default", "mcp");
+    const storeLattice = (0, import_core34.getStoreLattice)("default", "mcp");
     const store2 = storeLattice.store;
     const config = await store2.getConfigByKey(tenantId, key);
     if (!config) {
@@ -13870,7 +13854,7 @@ async function connectMcpServer(request, reply) {
     };
   } catch (error) {
     console.error("Failed to connect MCP server:", error);
-    const storeLattice = (0, import_core33.getStoreLattice)("default", "mcp");
+    const storeLattice = (0, import_core34.getStoreLattice)("default", "mcp");
     const store2 = storeLattice.store;
     const config = await store2.getConfigByKey(tenantId, key);
     if (config) {
@@ -13887,7 +13871,7 @@ async function disconnectMcpServer(request, reply) {
   const tenantId = getTenantId11(request);
   const { key } = request.params;
   try {
-    const storeLattice = (0, import_core33.getStoreLattice)("default", "mcp");
+    const storeLattice = (0, import_core34.getStoreLattice)("default", "mcp");
     const store2 = storeLattice.store;
     const config = await store2.getConfigByKey(tenantId, key);
     if (!config) {
@@ -13897,8 +13881,8 @@ async function disconnectMcpServer(request, reply) {
         message: "MCP server configuration not found"
       };
     }
-    if (import_core33.mcpManager.hasServer(tenantId, key)) {
-      await import_core33.mcpManager.removeServer(tenantId, key);
+    if (import_core34.mcpManager.hasServer(tenantId, key)) {
+      await import_core34.mcpManager.removeServer(tenantId, key);
     }
     const updated = await store2.updateConfig(tenantId, config.id, {
       status: "disconnected"
@@ -13928,8 +13912,8 @@ async function testMcpServerTools(request, reply) {
       };
     }
     const testKey = `__test_${Date.now()}`;
-    const connection = (0, import_core33.convertToConnection)(body.config);
-    const { tools } = await import_core33.McpLatticeManager.testConnection(testKey, connection);
+    const connection = (0, import_core34.convertToConnection)(body.config);
+    const { tools } = await import_core34.McpLatticeManager.testConnection(testKey, connection);
     return {
       success: true,
       message: "Tools retrieved successfully",
@@ -13946,14 +13930,14 @@ async function testMcpServerTools(request, reply) {
   }
 }
 async function connectAndRegisterTools(config) {
-  const connection = (0, import_core33.convertToConnection)(config.config);
-  import_core33.mcpManager.registerServer(config.tenantId, config.key, connection, {
+  const connection = (0, import_core34.convertToConnection)(config.config);
+  import_core34.mcpManager.registerServer(config.tenantId, config.key, connection, {
     timeoutMs: config.config.timeout,
     maxAttempts: config.config.retryAttempts,
     selectedTools: config.selectedTools
   });
-  await import_core33.mcpManager.ensureConnected(config.tenantId, config.key);
-  await import_core33.mcpManager.registerToolsToToolLattice(
+  await import_core34.mcpManager.ensureConnected(config.tenantId, config.key);
+  await import_core34.mcpManager.registerToolsToToolLattice(
     config.tenantId,
     config.key,
     config.selectedTools
@@ -13974,7 +13958,7 @@ function registerMcpServerConfigRoutes(app2) {
 
 // src/routes/mcp-apps.ts
 var import_protocols6 = require("@axiom-lattice/protocols");
-var import_core34 = require("@axiom-lattice/core");
+var import_core35 = require("@axiom-lattice/core");
 
 // src/services/mcp-ui/UiResourceResolver.ts
 var import_node_crypto5 = require("crypto");
@@ -14339,26 +14323,26 @@ function createDefaultPluginBackend() {
   return {
     resolvePlugin: (tenantId, type) => resolveTenantPluginByType(tenantId, type),
     catalog: {
-      readPluginFile: (tenantId, pluginType, relPath) => (0, import_core34.getSandboxPluginCatalog)().readPluginFile(tenantId, pluginType, relPath),
-      getValidatedManifest: (tenantId, pluginType) => (0, import_core34.getSandboxPluginCatalog)().getValidatedManifest(tenantId, pluginType),
-      getExecutor: () => (0, import_core34.getSandboxPluginCatalog)().getExecutor()
+      readPluginFile: (tenantId, pluginType, relPath) => (0, import_core35.getSandboxPluginCatalog)().readPluginFile(tenantId, pluginType, relPath),
+      getValidatedManifest: (tenantId, pluginType) => (0, import_core35.getSandboxPluginCatalog)().getValidatedManifest(tenantId, pluginType),
+      getExecutor: () => (0, import_core35.getSandboxPluginCatalog)().getExecutor()
     }
   };
 }
 function resolveMcpAppDeps(pluginBackend = createDefaultPluginBackend()) {
   const uiResourceResolver = new UiResourceResolver({
     store: new InMemoryMcpUiResourceCacheStore(),
-    fetchMcp: (tenantId, serverKey, resourceUri) => import_core34.mcpManager.readUiResource(tenantId, serverKey, resourceUri),
+    fetchMcp: (tenantId, serverKey, resourceUri) => import_core35.mcpManager.readUiResource(tenantId, serverKey, resourceUri),
     fetchPlugin: (tenantId, pluginType, resource) => fetchPluginUiResource(pluginBackend, tenantId, pluginType, resource)
   });
   return {
     resolveUiResource: (tenantId, ref) => uiResourceResolver.resolve(tenantId, ref),
-    callTool: (tenantId, ref, name, args, context) => ref.kind === "mcp" ? import_core34.mcpManager.callServerTool(tenantId, ref.serverKey, name, args) : callPluginTool(pluginBackend, tenantId, ref, name, args, context),
+    callTool: (tenantId, ref, name, args, context) => ref.kind === "mcp" ? import_core35.mcpManager.callServerTool(tenantId, ref.serverKey, name, args) : callPluginTool(pluginBackend, tenantId, ref, name, args, context),
     // Plugin refs reach these only after `tools/call`; the handler treats the
     // rejection as an unsupported method (403). The branches are live because
     // the pure handler deliberately delegates method policy to the deps.
-    readResource: (tenantId, ref, uri) => ref.kind === "mcp" ? import_core34.mcpManager.readServerResource(tenantId, ref.serverKey, uri) : Promise.reject(new PluginMethodNotSupportedError("resources/read")),
-    listTools: (tenantId, ref) => ref.kind === "mcp" ? import_core34.mcpManager.getAvailableTools(tenantId, ref.serverKey) : Promise.reject(new PluginMethodNotSupportedError("tools/list"))
+    readResource: (tenantId, ref, uri) => ref.kind === "mcp" ? import_core35.mcpManager.readServerResource(tenantId, ref.serverKey, uri) : Promise.reject(new PluginMethodNotSupportedError("resources/read")),
+    listTools: (tenantId, ref) => ref.kind === "mcp" ? import_core35.mcpManager.getAvailableTools(tenantId, ref.serverKey) : Promise.reject(new PluginMethodNotSupportedError("tools/list"))
   };
 }
 function firstHeader(request, name) {
@@ -14402,12 +14386,12 @@ function registerMcpAppRoutes(fastify2) {
 }
 
 // src/controllers/eval.ts
-var import_core36 = require("@axiom-lattice/core");
+var import_core37 = require("@axiom-lattice/core");
 var import_uuid5 = require("uuid");
 
 // src/services/eval-runner.ts
 var import_events = require("events");
-var import_core35 = require("@axiom-lattice/core");
+var import_core36 = require("@axiom-lattice/core");
 var import_uuid4 = require("uuid");
 var TERMINAL_PERSIST_ATTEMPTS = 2;
 function mapLogs(logs) {
@@ -14517,12 +14501,12 @@ var EvalRunner = class {
     const judgeModelKey = judgeCfg.modelKey || "";
     let resolvedJudgeModelKey;
     if (judgeModelKey) {
-      if (!import_core35.modelLatticeManager.hasLattice(judgeModelKey)) {
+      if (!import_core36.modelLatticeManager.hasLattice(judgeModelKey)) {
         throw new Error(`Judge model "${judgeModelKey}" is not registered`);
       }
       resolvedJudgeModelKey = judgeModelKey;
     } else {
-      const models = import_core35.modelLatticeManager.getAllLattices();
+      const models = import_core36.modelLatticeManager.getAllLattices();
       const defaultModel = models.find((m) => m.key === "default");
       resolvedJudgeModelKey = defaultModel?.key ?? models[0]?.key ?? "";
       if (!resolvedJudgeModelKey) {
@@ -14630,7 +14614,7 @@ var EvalRunner = class {
     };
     const runPromise = (async () => {
       try {
-        const evalProject = new import_core35.LatticeEvalProject(projectConfig, onCaseComplete);
+        const evalProject = new import_core36.LatticeEvalProject(projectConfig, onCaseComplete);
         const calibration = await evalProject.calibrateJudge();
         if (!calibration.ok && !calibration.bypassed) {
           throw new Error(`Judge calibration failed: ${calibration.reason}`);
@@ -14734,7 +14718,7 @@ var EvalRunner = class {
     return ctx !== void 0 && !ctx.terminal.workerSettled && (tenantId === void 0 || ctx.tenantId === tenantId);
   }
   getEvalStore() {
-    return (0, import_core35.getStoreLattice)("default", "eval").store;
+    return (0, import_core36.getStoreLattice)("default", "eval").store;
   }
   releaseProjectLease(leaseKey, leaseToken) {
     if (this.projectLeases.get(leaseKey) === leaseToken) this.projectLeases.delete(leaseKey);
@@ -14751,7 +14735,7 @@ function getTenantId12(request) {
   return request.headers["x-tenant-id"] || "default";
 }
 function getEvalStore() {
-  return (0, import_core36.getStoreLattice)("default", "eval").store;
+  return (0, import_core37.getStoreLattice)("default", "eval").store;
 }
 async function getOwnedSuite(store2, tenantId, projectId, suiteId) {
   const project = await store2.getProjectById(tenantId, projectId);
@@ -15281,11 +15265,11 @@ data: ${JSON.stringify(event.data)}
 }
 
 // src/controllers/users.ts
-var import_core37 = require("@axiom-lattice/core");
+var import_core38 = require("@axiom-lattice/core");
 var import_uuid6 = require("uuid");
 var UsersController = class {
   constructor() {
-    this.userStore = (0, import_core37.getStoreLattice)("default", "user").store;
+    this.userStore = (0, import_core38.getStoreLattice)("default", "user").store;
   }
   async listUsers(request, reply) {
     const { email } = request.query;
@@ -15363,11 +15347,11 @@ function registerUserRoutes(app2) {
 }
 
 // src/controllers/tenants.ts
-var import_core38 = require("@axiom-lattice/core");
+var import_core39 = require("@axiom-lattice/core");
 var import_uuid7 = require("uuid");
 var TenantsController = class {
   constructor() {
-    this.tenantStore = (0, import_core38.getStoreLattice)("default", "tenant").store;
+    this.tenantStore = (0, import_core39.getStoreLattice)("default", "tenant").store;
   }
   // ==================== Tenant CRUD ====================
   async listTenants(request, reply) {
@@ -15431,7 +15415,7 @@ function registerTenantRoutes(app2) {
 }
 
 // src/controllers/auth.ts
-var import_core39 = require("@axiom-lattice/core");
+var import_core40 = require("@axiom-lattice/core");
 var import_uuid8 = require("uuid");
 var import_node_crypto6 = require("crypto");
 var defaultAuthConfig = {
@@ -15441,9 +15425,9 @@ var defaultAuthConfig = {
 };
 var AuthController = class {
   constructor(config = {}) {
-    this.userStore = (0, import_core39.getStoreLattice)("default", "user").store;
-    this.tenantStore = (0, import_core39.getStoreLattice)("default", "tenant").store;
-    this.userTenantLinkStore = (0, import_core39.getStoreLattice)("default", "userTenantLink").store;
+    this.userStore = (0, import_core40.getStoreLattice)("default", "user").store;
+    this.tenantStore = (0, import_core40.getStoreLattice)("default", "tenant").store;
+    this.userTenantLinkStore = (0, import_core40.getStoreLattice)("default", "userTenantLink").store;
     this.config = { ...defaultAuthConfig, ...config };
   }
   async register(request, reply) {
@@ -15602,7 +15586,7 @@ var AuthController = class {
       const linkMeta = link?.metadata || {};
       let personalAssistant = null;
       if (linkMeta.personalAssistantId) {
-        const assistantStore = (0, import_core39.getStoreLattice)("default", "assistant").store;
+        const assistantStore = (0, import_core40.getStoreLattice)("default", "assistant").store;
         const exists = await assistantStore.hasAssistant(tenantId, linkMeta.personalAssistantId);
         if (exists) {
           personalAssistant = {
@@ -16739,7 +16723,7 @@ function registerChannelInstallationRoutes(app2) {
 
 // src/controllers/channel-bindings.ts
 var import_protocols8 = require("@axiom-lattice/protocols");
-var import_core40 = require("@axiom-lattice/core");
+var import_core41 = require("@axiom-lattice/core");
 function getTenantId14(request) {
   const userTenantId = request.user?.tenantId;
   if (typeof userTenantId === "string" && userTenantId) return userTenantId;
@@ -16797,7 +16781,7 @@ function snapshotPublicUpdate(value) {
   return body;
 }
 function getInstallationStore2() {
-  return (0, import_core40.getStoreLattice)("default", "channelInstallation").store;
+  return (0, import_core41.getStoreLattice)("default", "channelInstallation").store;
 }
 async function isValidPublicInstallation(tenantId, channelInstallationId, channel) {
   const installation = await getInstallationStore2().getInstallationById(channelInstallationId);
@@ -16816,7 +16800,7 @@ async function getBindingList(request, _reply) {
   const tenantId = getTenantId14(request);
   const { channel, agentId, channelInstallationId, limit, offset } = request.query;
   try {
-    const registry = (0, import_core40.getBindingRegistry)();
+    const registry = (0, import_core41.getBindingRegistry)();
     const bindings = await registry.list({
       channel,
       agentId,
@@ -16835,7 +16819,7 @@ async function getBindingList(request, _reply) {
 async function getBinding(request, reply) {
   const tenantId = getTenantId14(request);
   try {
-    const registry = (0, import_core40.getBindingRegistry)();
+    const registry = (0, import_core41.getBindingRegistry)();
     const binding = await registry.findById(tenantId, request.params.id);
     if (!binding || isInternalBinding(binding)) {
       reply.status(404);
@@ -16857,7 +16841,7 @@ async function createBinding(request, reply) {
       input.channelInstallationId,
       input.channel
     )) return invalidPublicInstallation(reply);
-    const registry = (0, import_core40.getBindingRegistry)();
+    const registry = (0, import_core41.getBindingRegistry)();
     const binding = await registry.create({ ...input, tenantId });
     reply.status(201);
     return { success: true, message: "Binding created", data: binding };
@@ -16874,7 +16858,7 @@ async function createBinding(request, reply) {
 async function updateBinding(request, reply) {
   try {
     const tenantId = getTenantId14(request);
-    const registry = (0, import_core40.getBindingRegistry)();
+    const registry = (0, import_core41.getBindingRegistry)();
     const existing = await registry.findById(tenantId, request.params.id);
     if (!existing || isInternalBinding(existing)) {
       reply.status(404);
@@ -16901,7 +16885,7 @@ async function updateBinding(request, reply) {
 async function deleteBinding(request, reply) {
   try {
     const tenantId = getTenantId14(request);
-    const registry = (0, import_core40.getBindingRegistry)();
+    const registry = (0, import_core41.getBindingRegistry)();
     const existing = await registry.findById(tenantId, request.params.id);
     if (!existing || isInternalBinding(existing)) {
       reply.status(404);
@@ -16923,7 +16907,7 @@ async function resolveBinding(request, _reply) {
     return { success: false, message: "No binding found", data: null };
   }
   try {
-    const registry = (0, import_core40.getBindingRegistry)();
+    const registry = (0, import_core41.getBindingRegistry)();
     const binding = await registry.resolve({ channel, senderId, channelInstallationId, tenantId });
     if (!binding) {
       return { success: false, message: "No binding found", data: null };
@@ -16946,7 +16930,7 @@ function registerChannelBindingRoutes(app2) {
 }
 
 // src/controllers/menu-items.ts
-var import_core41 = require("@axiom-lattice/core");
+var import_core42 = require("@axiom-lattice/core");
 function getTenantId15(request) {
   const userTenantId = request.user?.tenantId;
   if (userTenantId) return userTenantId;
@@ -16958,7 +16942,7 @@ function errorMessage(err) {
 async function getMenuItemList(request, _reply) {
   const tenantId = getTenantId15(request);
   try {
-    const registry = (0, import_core41.getMenuRegistry)();
+    const registry = (0, import_core42.getMenuRegistry)();
     const items = await registry.list({ tenantId, menuTarget: request.query.menuTarget });
     return { success: true, message: "Menu items retrieved", data: { records: items, total: items.length } };
   } catch (error) {
@@ -16970,7 +16954,7 @@ async function getMenuItemList(request, _reply) {
 async function getMenuItem(request, reply) {
   const tenantId = getTenantId15(request);
   try {
-    const registry = (0, import_core41.getMenuRegistry)();
+    const registry = (0, import_core42.getMenuRegistry)();
     const item = await registry.getById(request.params.id);
     if (!item || item.tenantId !== tenantId) {
       reply.status(404);
@@ -16987,7 +16971,7 @@ async function getMenuItem(request, reply) {
 async function createMenuItem(request, reply) {
   const tenantId = getTenantId15(request);
   try {
-    const registry = (0, import_core41.getMenuRegistry)();
+    const registry = (0, import_core42.getMenuRegistry)();
     const item = await registry.create({ ...request.body, tenantId });
     reply.status(201);
     return { success: true, message: "Menu item created", data: item };
@@ -17001,7 +16985,7 @@ async function createMenuItem(request, reply) {
 async function updateMenuItem(request, reply) {
   try {
     const tenantId = getTenantId15(request);
-    const registry = (0, import_core41.getMenuRegistry)();
+    const registry = (0, import_core42.getMenuRegistry)();
     const existing = await registry.getById(request.params.id);
     if (!existing || existing.tenantId !== tenantId) {
       reply.status(404);
@@ -17019,7 +17003,7 @@ async function updateMenuItem(request, reply) {
 async function deleteMenuItem(request, reply) {
   try {
     const tenantId = getTenantId15(request);
-    const registry = (0, import_core41.getMenuRegistry)();
+    const registry = (0, import_core42.getMenuRegistry)();
     const existing = await registry.getById(request.params.id);
     if (!existing || existing.tenantId !== tenantId) {
       reply.status(404);
@@ -17219,7 +17203,7 @@ function registerA2ABridgeRoutes(app2) {
 }
 
 // src/routes/stt.ts
-var import_core42 = require("@axiom-lattice/core");
+var import_core43 = require("@axiom-lattice/core");
 var ALLOWED_AUDIO_FORMATS = /* @__PURE__ */ new Set([
   "webm",
   "wav",
@@ -17232,7 +17216,7 @@ var ALLOWED_AUDIO_FORMATS = /* @__PURE__ */ new Set([
 var MAX_AUDIO_FILE_SIZE = 25 * 1024 * 1024;
 var registerSTTRoutes = (app2) => {
   app2.get("/api/stt/models", async (_request, reply) => {
-    const models = import_core42.sttModelLatticeManager.getAllSTTModelInfo();
+    const models = import_core43.sttModelLatticeManager.getAllSTTModelInfo();
     return reply.send({ models });
   });
   app2.post(
@@ -17275,7 +17259,7 @@ var registerSTTRoutes = (app2) => {
       try {
         let client;
         try {
-          client = (0, import_core42.getSTTClient)(modelKey2);
+          client = (0, import_core43.getSTTClient)(modelKey2);
         } catch {
           return reply.status(404).send({ error: `STT model "${modelKey2}" not found` });
         }
@@ -17297,7 +17281,7 @@ var registerSTTRoutes = (app2) => {
 };
 
 // src/controllers/local-a2a.ts
-var import_core43 = require("@axiom-lattice/core");
+var import_core44 = require("@axiom-lattice/core");
 var import_protocols9 = require("@axiom-lattice/protocols");
 function getTenantId16(request) {
   const userTenantId = request.user?.tenantId;
@@ -17311,7 +17295,7 @@ function getLocalRuntime(assistant) {
   return graphDefinition.localRuntime;
 }
 async function getLocalA2AAssistants(tenantId) {
-  const storeLattice = (0, import_core43.getStoreLattice)("default", "assistant");
+  const storeLattice = (0, import_core44.getStoreLattice)("default", "assistant");
   const assistants = await storeLattice.store.getAllAssistants(tenantId);
   const results = [];
   for (const assistant of assistants) {
@@ -17323,7 +17307,7 @@ async function getLocalA2AAssistants(tenantId) {
   return results;
 }
 async function getLocalA2AAssistant(tenantId, assistantId) {
-  const storeLattice = (0, import_core43.getStoreLattice)("default", "assistant");
+  const storeLattice = (0, import_core44.getStoreLattice)("default", "assistant");
   const assistant = await storeLattice.store.getAssistantById(tenantId, assistantId);
   if (!assistant) return null;
   const runtime = getLocalRuntime(assistant);
@@ -17565,11 +17549,11 @@ function registerTaskRoutes(app2, controller) {
 }
 
 // src/routes/index.ts
-var import_core54 = require("@axiom-lattice/core");
+var import_core55 = require("@axiom-lattice/core");
 
 // src/controllers/tasks.ts
 var import_protocols13 = require("@axiom-lattice/protocols");
-var import_core45 = require("@axiom-lattice/core");
+var import_core46 = require("@axiom-lattice/core");
 
 // src/services/collaboration/ProjectTaskThreadService.ts
 var import_protocols11 = require("@axiom-lattice/protocols");
@@ -17889,7 +17873,7 @@ var import_node_crypto9 = require("crypto");
 
 // src/services/collaboration/ProjectTaskExecutionService.ts
 var import_node_crypto8 = require("crypto");
-var import_core44 = require("@axiom-lattice/core");
+var import_core45 = require("@axiom-lattice/core");
 var import_protocols12 = require("@axiom-lattice/protocols");
 init_projectTaskScope();
 
@@ -17953,7 +17937,7 @@ var ProjectTaskExecutionService = class {
     if (!Number.isFinite(options.lifecycleSettlementTimeoutMs) || options.lifecycleSettlementTimeoutMs <= 0) {
       throw new Error("Project task lifecycle settlement timeout must be positive");
     }
-    this.runBridge = (0, import_core44.createTaskRunBridge)({ lifecycle: this.deps.lifecycle });
+    this.runBridge = (0, import_core45.createTaskRunBridge)({ lifecycle: this.deps.lifecycle });
   }
   /** Validates, atomically starts, dispatches, and settles a pending Project Task. */
   async start(input, signal) {
@@ -18148,15 +18132,15 @@ var ProjectTaskExecutionService = class {
         settlement.cleanup();
         return { kind: "deferred", task: input.task, thread: input.thread, messageId: input.inputMessageId };
       }
-      if (resumed.status === import_core44.ThreadStatus.INTERRUPTED && settlement.tryClaim()) {
+      if (resumed.status === import_core45.ThreadStatus.INTERRUPTED && settlement.tryClaim()) {
         settlement.cleanup();
         const outcome2 = await this.settleInterruptedEvent(input.task, input.thread, input.inputMessageId);
         settlement.resolve(outcome2);
         return outcome2;
       }
-      if ((resumed.status === import_core44.ThreadStatus.IDLE || resumed.status === import_core44.ThreadStatus.ERROR) && settlement.tryClaim()) {
+      if ((resumed.status === import_core45.ThreadStatus.IDLE || resumed.status === import_core45.ThreadStatus.ERROR) && settlement.tryClaim()) {
         settlement.cleanup();
-        const reason = resumed.status === import_core44.ThreadStatus.IDLE ? "Project task execution ended without lifecycle transition" : "Recovered Agent execution is in error state";
+        const reason = resumed.status === import_core45.ThreadStatus.IDLE ? "Project task execution ended without lifecycle transition" : "Recovered Agent execution is in error state";
         const outcome2 = await this.settleEndedRecovery(input, reason);
         settlement.resolve(outcome2);
         return outcome2;
@@ -19199,7 +19183,7 @@ function withErrors(handler) {
       if (error instanceof HttpTaskError) return reply.code(error.statusCode).send({ success: false, code: error.code, error: error.message });
       if (error instanceof TaskCommandError) return reply.code(error.statusCode).send({ success: false, code: error.code, error: error.message });
       if (error instanceof ProjectCollaborationError) return reply.code(error.statusCode).send({ success: false, code: error.code, error: error.message });
-      if (error instanceof import_core45.ProjectTaskOwnerPolicyError) return reply.code(403).send({ success: false, code: error.code, error: error.message });
+      if (error instanceof import_core46.ProjectTaskOwnerPolicyError) return reply.code(403).send({ success: false, code: error.code, error: error.message });
       if (error instanceof ProjectTaskThreadError) return reply.code(409).send({ success: false, code: error.code, error: error.message });
       request.log.error({ error }, "Task route failed");
       return reply.code(500).send({ success: false, code: "TASK_INTERNAL_ERROR", error: "Task operation failed" });
@@ -19836,7 +19820,7 @@ var import_zod6 = require("zod");
 // src/services/agent-web-app/AgentWebAppRuntimeService.ts
 var import_node_crypto10 = require("crypto");
 var import_protocols14 = require("@axiom-lattice/protocols");
-var import_core46 = require("@axiom-lattice/core");
+var import_core47 = require("@axiom-lattice/core");
 init_task_file_refs();
 function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -20000,12 +19984,12 @@ var AgentWebAppRuntimeService = class {
     const runtime = await this.resolveRuntime(webAppId, selection);
     await this.requireOwnedThread(runtime, userId, threadId);
     if (process.env.AXIOM_REPLICA_ID) {
-      const owner = await (0, import_core46.getThreadRunOwner)({
+      const owner = await (0, import_core47.getThreadRunOwner)({
         tenantId: runtime.webApp.tenantId,
         assistantId: runtime.webApp.assistantId,
         threadId
       });
-      if (owner && owner !== (0, import_core46.getReplicaId)()) {
+      if (owner && owner !== (0, import_core47.getReplicaId)()) {
         return {
           stream: (async function* () {
             yield (0, import_protocols14.buildAffinityMissChunk)(owner, threadId);
@@ -20358,7 +20342,7 @@ async function verifyWebAppToken(token, issuer, options = {}) {
 
 // src/routes/agent-web-app-runtime.ts
 var import_protocols15 = require("@axiom-lattice/protocols");
-var import_core47 = require("@axiom-lattice/core");
+var import_core48 = require("@axiom-lattice/core");
 var idSchema = import_zod6.z.string().min(1).max(128);
 var paramsSchema = import_zod6.z.object({ webAppId: idSchema }).strict();
 var threadParamsSchema = import_zod6.z.object({ webAppId: idSchema, threadId: idSchema }).strict();
@@ -20792,7 +20776,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(import_protocols15.REPLICA_HEADER, (0, import_core47.getReplicaId)());
+          reply.header(import_protocols15.REPLICA_HEADER, (0, import_core48.getReplicaId)());
           for (const [name, value] of Object.entries((0, import_protocols15.affinityEchoHeaders)(request.headers[import_protocols15.AGENT_AFFINITY_HEADER]))) {
             reply.header(name, value);
           }
@@ -20878,7 +20862,7 @@ function beginSse(reply, request) {
     "X-Accel-Buffering": "no",
     "Access-Control-Allow-Origin": "*",
     "Access-Control-Expose-Headers": `${import_protocols15.REPLICA_HEADER}, ${import_protocols15.AFFINITY_ECHO_HEADER}`,
-    [import_protocols15.REPLICA_HEADER]: (0, import_core47.getReplicaId)(),
+    [import_protocols15.REPLICA_HEADER]: (0, import_core48.getReplicaId)(),
     ...(0, import_protocols15.affinityEchoHeaders)(request.headers[import_protocols15.AGENT_AFFINITY_HEADER])
   });
 }
@@ -21115,7 +21099,7 @@ var import_zod9 = require("zod");
 
 // src/services/capability/CapabilityBundleService.ts
 var import_zod8 = require("zod");
-var import_core48 = require("@axiom-lattice/core");
+var import_core49 = require("@axiom-lattice/core");
 var CapabilityBundleServiceError = class extends Error {
   constructor(code, message, statusCode) {
     super(message);
@@ -21156,7 +21140,7 @@ function projectBundleIds(config) {
   return [...value];
 }
 function issue(error) {
-  if (error instanceof import_core48.CapabilityBundleMergeError || error instanceof import_core48.CapabilityBundleValidationError) return { code: error instanceof import_core48.CapabilityBundleValidationError && error.code === "CAPABILITY_BUNDLE_INVALID_CONFIG" ? "INVALID_BUNDLE_CONFIG" : error.code, message: error.message, bundleId: error instanceof import_core48.CapabilityBundleMergeError ? error.bundleId : void 0, capabilityType: error.capabilityType, fieldPath: error.fieldPath };
+  if (error instanceof import_core49.CapabilityBundleMergeError || error instanceof import_core49.CapabilityBundleValidationError) return { code: error instanceof import_core49.CapabilityBundleValidationError && error.code === "CAPABILITY_BUNDLE_INVALID_CONFIG" ? "INVALID_BUNDLE_CONFIG" : error.code, message: error.message, bundleId: error instanceof import_core49.CapabilityBundleMergeError ? error.bundleId : void 0, capabilityType: error.capabilityType, fieldPath: error.fieldPath };
   return { code: "CAPABILITY_BUNDLE_CONFIGURATION_ERROR", message: error instanceof Error ? error.message : "Invalid capability bundle configuration" };
 }
 var CapabilityBundleService = class {
@@ -21169,7 +21153,7 @@ var CapabilityBundleService = class {
     const errors = [];
     for (const value of values) {
       try {
-        (0, import_core48.validateCapabilityBundleInput)(value);
+        (0, import_core49.validateCapabilityBundleInput)(value);
         bundles.push(value);
       } catch {
         errors.push({ bundleId: value.id, code: "INVALID_BUNDLE_CONFIG", message: "Capability bundle record is invalid" });
@@ -21181,7 +21165,7 @@ var CapabilityBundleService = class {
     const value = await this.deps.bundleStore.getById(tenantId, id3);
     if (!value) throw new CapabilityBundleServiceError("BUNDLE_NOT_FOUND", "Capability bundle not found", 404);
     try {
-      (0, import_core48.validateCapabilityBundleInput)(value);
+      (0, import_core49.validateCapabilityBundleInput)(value);
     } catch {
       throw new CapabilityBundleServiceError("INVALID_BUNDLE_CONFIG", "Capability bundle record is invalid", 422);
     }
@@ -21189,7 +21173,7 @@ var CapabilityBundleService = class {
   }
   async create(tenantId, input) {
     rejectStableKey(input);
-    (0, import_core48.validateCapabilityBundleInput)(input);
+    (0, import_core49.validateCapabilityBundleInput)(input);
     const value = input;
     const name = value.name.trim();
     const base = slugify(name);
@@ -21200,10 +21184,10 @@ var CapabilityBundleService = class {
       let suffix = 2;
       while (keys2.has(key)) key = `${base}-${suffix++}`;
       const normalized = { ...value, key, name };
-      (0, import_core48.validateCapabilityBundleInput)(normalized);
+      (0, import_core49.validateCapabilityBundleInput)(normalized);
       try {
         const result = await this.deps.bundleStore.create(tenantId, normalized);
-        (0, import_core48.validateCapabilityBundleInput)(result);
+        (0, import_core49.validateCapabilityBundleInput)(result);
         return result;
       } catch (error) {
         if (!isDuplicate(error)) throw error;
@@ -21214,16 +21198,16 @@ var CapabilityBundleService = class {
   }
   async update(tenantId, id3, input) {
     rejectStableKey(input);
-    (0, import_core48.validateCapabilityBundleInput)(input, { partial: true });
+    (0, import_core49.validateCapabilityBundleInput)(input, { partial: true });
     if (!input || typeof input !== "object" || Array.isArray(input) || typeof input.expectedUpdatedAt !== "string" || !input.expectedUpdatedAt.trim()) throw new CapabilityBundleServiceError("INVALID_BUNDLE_CONFIG", "expectedUpdatedAt is required for capability bundle updates", 400);
     const value = input;
     const normalized = { ...value, ...value.name === void 0 ? {} : { name: value.name.trim() }, ...Object.prototype.hasOwnProperty.call(value, "description") ? { description: value.description?.trim() || void 0 } : {} };
-    (0, import_core48.validateCapabilityBundleInput)(normalized, { partial: true });
+    (0, import_core49.validateCapabilityBundleInput)(normalized, { partial: true });
     try {
       const result = await this.deps.bundleStore.update(tenantId, id3, normalized);
       if (!result) throw new CapabilityBundleServiceError("BUNDLE_NOT_FOUND", "Capability bundle not found", 404);
       if ("status" in result && result.status === "conflict") throw new CapabilityBundleServiceError("BUNDLE_CONFLICT", "Capability bundle changed after it was loaded; reload before saving", 409);
-      (0, import_core48.validateCapabilityBundleInput)(result);
+      (0, import_core49.validateCapabilityBundleInput)(result);
       return result;
     } catch (error) {
       if (error instanceof CapabilityBundleServiceError) throw error;
@@ -21258,8 +21242,8 @@ var CapabilityBundleService = class {
     if (missing.length > 0) return { bundleIds: ids, capabilities: [], overrides: [], sources: [], warnings: [], errors: missing.map((id3) => ({ code: "BUNDLE_NOT_FOUND", message: `Persisted capability bundle '${id3}' is missing`, bundleId: id3 })), revision: "" };
     try {
       const ordered = ids.map((id3) => byId.get(id3));
-      ordered.forEach((bundle) => (0, import_core48.validateCapabilityBundleInput)(bundle));
-      return (0, import_core48.mergeCapabilityBundles)(ordered);
+      ordered.forEach((bundle) => (0, import_core49.validateCapabilityBundleInput)(bundle));
+      return (0, import_core49.mergeCapabilityBundles)(ordered);
     } catch (error) {
       return { bundleIds: ids, capabilities: [], overrides: [], sources: [], warnings: [], errors: [issue(error)], revision: "" };
     }
@@ -21292,7 +21276,7 @@ var CapabilityBundleService = class {
     return ids.map((id3) => {
       const value = byId.get(id3);
       if (!value) throw new CapabilityBundleServiceError("BUNDLE_NOT_FOUND", "Capability bundle not found", 404);
-      (0, import_core48.validateCapabilityBundleInput)(value);
+      (0, import_core49.validateCapabilityBundleInput)(value);
       return value;
     });
   }
@@ -21307,7 +21291,7 @@ var CapabilityBundleService = class {
         continue;
       }
       try {
-        (0, import_core48.validateCapabilityBundleInput)(bundle);
+        (0, import_core49.validateCapabilityBundleInput)(bundle);
         valid.push(bundle);
       } catch (error) {
         errors.push({ ...issue(error), bundleId: id3 });
@@ -21315,7 +21299,7 @@ var CapabilityBundleService = class {
     }
     let preview;
     try {
-      preview = (0, import_core48.mergeCapabilityBundles)(valid);
+      preview = (0, import_core49.mergeCapabilityBundles)(valid);
     } catch (error) {
       preview = { bundleIds: ids, capabilities: [], overrides: [], sources: [], warnings: [], errors: [issue(error)], revision: "" };
     }
@@ -21467,7 +21451,7 @@ var import_zod11 = require("zod");
 // src/services/model-provider/ModelProviderService.ts
 var import_node_crypto14 = require("crypto");
 var import_protocols16 = require("@axiom-lattice/protocols");
-var import_core49 = require("@axiom-lattice/core");
+var import_core50 = require("@axiom-lattice/core");
 
 // src/services/model-provider/errors.ts
 var ModelProviderServiceError = class extends Error {
@@ -22271,9 +22255,9 @@ var ModelProviderService = class {
    */
   async assertSafeUrl(baseURL) {
     try {
-      await (0, import_core49.assertSafeUpstreamUrl)(baseURL);
+      await (0, import_core50.assertSafeUpstreamUrl)(baseURL);
     } catch (error) {
-      if (error instanceof import_core49.UnsafeUpstreamUrlError) {
+      if (error instanceof import_core50.UnsafeUpstreamUrlError) {
         throw new ModelProviderServiceError(
           unsafeReasonToErrorCode[error.reason],
           400,
@@ -23739,7 +23723,7 @@ async function execute(reply, operation) {
 // src/routes/cospace.ts
 var import_node_crypto20 = require("crypto");
 var import_zod15 = require("zod");
-var import_core50 = require("@axiom-lattice/core");
+var import_core51 = require("@axiom-lattice/core");
 var import_protocols19 = require("@axiom-lattice/protocols");
 var CoSpaceAuthError = class extends Error {
   constructor() {
@@ -23924,14 +23908,14 @@ function registerCoSpaceRoutes(app2, deps) {
         }
         let projectId;
         if (body.type === "human") {
-          projectId = (0, import_core50.generateDirectHumanProjectId)(
+          projectId = (0, import_core51.generateDirectHumanProjectId)(
             actor3.tenantId,
             params.workspaceId,
             actor3.userId,
             body.targetUserId
           );
         } else {
-          projectId = (0, import_core50.generateDirectBotProjectId)(
+          projectId = (0, import_core51.generateDirectBotProjectId)(
             actor3.tenantId,
             params.workspaceId,
             actor3.userId,
@@ -24138,7 +24122,7 @@ function registerCoSpaceRoutes(app2, deps) {
         );
         const bots = [];
         for (const assistant of assistants) {
-          const directProjectId = (0, import_core50.generateDirectBotProjectId)(
+          const directProjectId = (0, import_core51.generateDirectBotProjectId)(
             actor3.tenantId,
             params.workspaceId,
             actor3.userId,
@@ -24200,7 +24184,7 @@ function registerCoSpaceRoutes(app2, deps) {
           if (link.userId === actor3.userId) continue;
           const user = await deps.userStore.getUserById(link.userId);
           if (!user) continue;
-          const directProjectId = (0, import_core50.generateDirectHumanProjectId)(
+          const directProjectId = (0, import_core51.generateDirectHumanProjectId)(
             actor3.tenantId,
             params.workspaceId,
             actor3.userId,
@@ -25017,7 +25001,7 @@ function createRoomMessageRetentionJob(input) {
 
 // src/services/collaboration/ProjectTaskExecutionMutex.ts
 var import_protocols22 = require("@axiom-lattice/protocols");
-var import_core51 = require("@axiom-lattice/core");
+var import_core52 = require("@axiom-lattice/core");
 var MACHINE_LEASE_OPTIONS = { ttlMs: 6e4, acquireTimeoutMs: 9e4, retryDelayMs: 100 };
 function machineKey(scope) {
   const snapshot = (0, import_protocols22.snapshotExactRecord)(scope, ["tenantId", "assistantId", "projectId"]);
@@ -25045,9 +25029,9 @@ var ProjectTaskExecutionMutex = class {
     const leaseKey = `project-task-machine:${encodeURIComponent(scope.tenantId)}:${encodeURIComponent(scope.assistantId)}:${encodeURIComponent(scope.projectId)}`;
     await this.acquire(key, signal);
     try {
-      const store2 = (0, import_core51.getCoordinationLeaseStore)();
+      const store2 = (0, import_core52.getCoordinationLeaseStore)();
       if (!store2) return await operation();
-      return await (0, import_core51.withLease)(store2, leaseKey, (0, import_core51.getReplicaId)(), operation, MACHINE_LEASE_OPTIONS);
+      return await (0, import_core52.withLease)(store2, leaseKey, (0, import_core52.getReplicaId)(), operation, MACHINE_LEASE_OPTIONS);
     } finally {
       this.release(key);
     }
@@ -25100,7 +25084,7 @@ var ProjectTaskExecutionMutex = class {
 
 // src/services/collaboration/ProjectTaskObserver.ts
 var import_node_crypto22 = require("crypto");
-var import_core52 = require("@axiom-lattice/core");
+var import_core53 = require("@axiom-lattice/core");
 var import_protocols23 = require("@axiom-lattice/protocols");
 
 // src/services/collaboration/projectTaskDispatchMarker.ts
@@ -25137,7 +25121,7 @@ var ProjectTaskObserver = class {
         throw new Error(`Invalid Project task observer bound: ${name}`);
       }
     }
-    this.runBridge = (0, import_core52.createTaskRunBridge)({ lifecycle: this.deps.lifecycle });
+    this.runBridge = (0, import_core53.createTaskRunBridge)({ lifecycle: this.deps.lifecycle });
   }
   /** Fire-and-forget notifier adapter that never waits for observer work or machine acquisition. */
   async listener(event) {
@@ -26353,7 +26337,7 @@ function isRecord3(value) {
 init_projectTaskScope();
 
 // src/services/collaboration/ProjectRoomRealtimeRuntime.ts
-var import_core53 = require("@axiom-lattice/core");
+var import_core54 = require("@axiom-lattice/core");
 
 // src/services/collaboration/ProjectRoomEventBroker.ts
 var import_node_crypto24 = require("crypto");
@@ -27128,7 +27112,7 @@ function createProjectRoomRealtimeRuntime(deps) {
     broker,
     publisher,
     subscriber,
-    subscribe: (listener) => import_core53.taskLifecycleNotifier.subscribe(listener),
+    subscribe: (listener) => import_core54.taskLifecycleNotifier.subscribe(listener),
     log: deps.log,
     shutdownTimeoutMs: deps.shutdownTimeoutMs
   });
@@ -27866,35 +27850,35 @@ function hookErrorMessage(error) {
 function wrapReassignmentThreadError(error) {
   if (error instanceof ProjectTaskThreadError) {
     if (error.code === "PROJECT_TASK_THREAD_SCOPE_INVALID") {
-      return new import_core54.ManagedTaskStartError("PROJECT_TASK_CONTEXT_INVALID", error.message, {
+      return new import_core55.ManagedTaskStartError("PROJECT_TASK_CONTEXT_INVALID", error.message, {
         hint: "Project task, room, or roster scope changed; re-read the task and retry."
       });
     }
     if (error.code === "PROJECT_TASK_THREAD_OWNER_INVALID") {
-      return new import_core54.ManagedTaskStartError("TASK_REASSIGN_NO_CHANGE", error.message, {
+      return new import_core55.ManagedTaskStartError("TASK_REASSIGN_NO_CHANGE", error.message, {
         hint: "The target already owns this task; re-read before dispatching."
       });
     }
-    return new import_core54.ManagedTaskStartError("TASK_THREAD_CONFLICT", error.message, {
+    return new import_core55.ManagedTaskStartError("TASK_THREAD_CONFLICT", error.message, {
       hint: "Task Thread changed concurrently; re-read the task and retry."
     });
   }
-  return new import_core54.ManagedTaskStartError("TASK_EXECUTION_ENQUEUE_FAILED", hookErrorMessage(error), {
+  return new import_core55.ManagedTaskStartError("TASK_EXECUTION_ENQUEUE_FAILED", hookErrorMessage(error), {
     hint: "Re-read the task and retry the dispatch."
   });
 }
 function wrapReassignmentAuthorizationError(error) {
-  if (error instanceof import_core54.ProjectTaskOwnerPolicyError) {
+  if (error instanceof import_core55.ProjectTaskOwnerPolicyError) {
     if (error.code === "PROJECT_TASK_CALLER_INACTIVE") {
-      return new import_core54.ManagedTaskStartError("PROJECT_TASK_CALLER_INACTIVE", error.message, {
+      return new import_core55.ManagedTaskStartError("PROJECT_TASK_CALLER_INACTIVE", error.message, {
         hint: "Dispatch from an active Project Room member bot."
       });
     }
-    return new import_core54.ManagedTaskStartError("PROJECT_TASK_OWNER_INACTIVE", error.message, {
+    return new import_core55.ManagedTaskStartError("PROJECT_TASK_OWNER_INACTIVE", error.message, {
       hint: "Dispatch to an active bot in this Project's roster."
     });
   }
-  return new import_core54.ManagedTaskStartError("PROJECT_TASK_CONTEXT_INVALID", hookErrorMessage(error), {
+  return new import_core55.ManagedTaskStartError("PROJECT_TASK_CONTEXT_INVALID", hookErrorMessage(error), {
     hint: "Re-read the task and roster, then retry the dispatch."
   });
 }
@@ -27923,43 +27907,43 @@ async function transferGovernedDispatchOwner(task, options, deps) {
   const agentId = options?.agentId;
   if (!agentId || agentId === task.ownerId) return void 0;
   if (!task.workspaceId || !task.projectId) {
-    throw new import_core54.ManagedTaskStartError("PROJECT_TASK_CONTEXT_INVALID", "Task is not governed by a Project lifecycle.", {
+    throw new import_core55.ManagedTaskStartError("PROJECT_TASK_CONTEXT_INVALID", "Task is not governed by a Project lifecycle.", {
       hint: "Dispatch governed tasks from a trusted Project run; ordinary tasks execute immediately."
     });
   }
   return deps.mutex.runExclusive({ tenantId: task.tenantId, projectId: task.projectId }, async () => {
     const current = await deps.tasks.getById(task.tenantId, task.id);
     if (!current || !isProjectLifecycleTask(current) || current.workspaceId !== task.workspaceId || current.projectId !== task.projectId) {
-      throw new import_core54.ManagedTaskStartError("PROJECT_TASK_CONTEXT_INVALID", "Task is no longer a Project lifecycle task.", {
+      throw new import_core55.ManagedTaskStartError("PROJECT_TASK_CONTEXT_INVALID", "Task is no longer a Project lifecycle task.", {
         hint: "Re-read the task and confirm it still belongs to this Project before dispatching."
       });
     }
     if (current.ownerType !== "agent") {
-      throw new import_core54.ManagedTaskStartError("AGENT_TASK_REQUIRED", "Project task owner must be an Agent.", {
+      throw new import_core55.ManagedTaskStartError("AGENT_TASK_REQUIRED", "Project task owner must be an Agent.", {
         hint: "Assign the task to an Agent before dispatching."
       });
     }
     if (current.status !== "pending") {
-      throw new import_core54.ManagedTaskStartError("TASK_NOT_DISPATCHABLE", "Only a `pending` Project task can be dispatched.", {
+      throw new import_core55.ManagedTaskStartError("TASK_NOT_DISPATCHABLE", "Only a `pending` Project task can be dispatched.", {
         hint: `This task is '${current.status}'. Resolve it or create a new task before dispatching.`
       });
     }
     if (agentId === current.ownerId) return current;
     const room = await deps.rooms.getMainRoom(current.tenantId, current.projectId);
     if (!room || room.tenantId !== current.tenantId || room.workspaceId !== current.workspaceId || room.projectId !== current.projectId || room.type !== "main") {
-      throw new import_core54.ManagedTaskStartError("PROJECT_TASK_CONTEXT_INVALID", "Project main room is unavailable.", {
+      throw new import_core55.ManagedTaskStartError("PROJECT_TASK_CONTEXT_INVALID", "Project main room is unavailable.", {
         hint: "Open or repair the Project Room before dispatching."
       });
     }
     const target = await deps.botMemberships.findByAssistant(current.tenantId, current.projectId, agentId);
     if (!target || target.status !== "active" || target.tenantId !== current.tenantId || target.workspaceId !== current.workspaceId || target.projectId !== current.projectId || target.assistantId !== agentId || target.roomId !== room.id) {
-      throw new import_core54.ManagedTaskStartError("PROJECT_TASK_OWNER_INACTIVE", "Target Project task owner is not active in the exact roster.", {
+      throw new import_core55.ManagedTaskStartError("PROJECT_TASK_OWNER_INACTIVE", "Target Project task owner is not active in the exact roster.", {
         hint: "Dispatch to an active bot in this Project's roster."
       });
     }
     const caller = options?.callerMembershipId ? await deps.botMemberships.findById(current.tenantId, options.callerMembershipId) : null;
     if (!caller || !options?.callerAssistantId || caller.id !== options.callerMembershipId || caller.assistantId !== options.callerAssistantId || caller.status !== "active" || caller.tenantId !== current.tenantId || caller.workspaceId !== current.workspaceId || caller.projectId !== current.projectId || caller.roomId !== room.id) {
-      throw new import_core54.ManagedTaskStartError("PROJECT_TASK_CALLER_INACTIVE", "Current Project task caller is not active in the exact roster.", {
+      throw new import_core55.ManagedTaskStartError("PROJECT_TASK_CALLER_INACTIVE", "Current Project task caller is not active in the exact roster.", {
         hint: "Dispatch from an active Project Room member bot."
       });
     }
@@ -27994,7 +27978,7 @@ async function transferGovernedDispatchOwner(task, options, deps) {
       actor: `agent:${caller.assistantId}`
     });
     if (!result.success) {
-      throw new import_core54.ManagedTaskStartError(result.code, result.error, {
+      throw new import_core55.ManagedTaskStartError(result.code, result.error, {
         hint: result.hint ?? reassignmentFailureHint(result.code),
         ...result.retryable !== void 0 ? { retryable: result.retryable } : {}
       });
@@ -28003,19 +27987,19 @@ async function transferGovernedDispatchOwner(task, options, deps) {
   });
 }
 var registerLatticeRoutes = (app2, channelDeps, options = {}) => {
-  const webAppStore = (0, import_core54.getStoreLattice)("default", "agentWebApp").store;
-  const assistantStore = (0, import_core54.getStoreLattice)("default", "assistant").store;
-  const projectStore = (0, import_core54.getStoreLattice)("default", "project").store;
-  const projectMembershipStore = (0, import_core54.getStoreLattice)("default", "projectMembership").store;
-  const userTenantLinkStore = (0, import_core54.getStoreLattice)("default", "userTenantLink").store;
-  const projectRoomStore = (0, import_core54.getStoreLattice)("default", "projectRoom").store;
-  const projectBotMembershipStore = (0, import_core54.getStoreLattice)("default", "projectBotMembership").store;
-  const projectRoomMessageStore = (0, import_core54.getStoreLattice)("default", "projectRoomMessage").store;
-  const projectRoomReadStateStore = (0, import_core54.getStoreLattice)("default", "projectRoomReadState").store;
-  const userPushSubscriptionStore = (0, import_core54.getStoreLattice)("default", "userPushSubscription").store;
-  const threadStore = (0, import_core54.getStoreLattice)("default", "thread").store;
-  const taskStore = (0, import_core54.getStoreLattice)("default", "task").store;
-  const taskWorkItemStore = (0, import_core54.getStoreLattice)("default", "taskWorkItem").store;
+  const webAppStore = (0, import_core55.getStoreLattice)("default", "agentWebApp").store;
+  const assistantStore = (0, import_core55.getStoreLattice)("default", "assistant").store;
+  const projectStore = (0, import_core55.getStoreLattice)("default", "project").store;
+  const projectMembershipStore = (0, import_core55.getStoreLattice)("default", "projectMembership").store;
+  const userTenantLinkStore = (0, import_core55.getStoreLattice)("default", "userTenantLink").store;
+  const projectRoomStore = (0, import_core55.getStoreLattice)("default", "projectRoom").store;
+  const projectBotMembershipStore = (0, import_core55.getStoreLattice)("default", "projectBotMembership").store;
+  const projectRoomMessageStore = (0, import_core55.getStoreLattice)("default", "projectRoomMessage").store;
+  const projectRoomReadStateStore = (0, import_core55.getStoreLattice)("default", "projectRoomReadState").store;
+  const userPushSubscriptionStore = (0, import_core55.getStoreLattice)("default", "userPushSubscription").store;
+  const threadStore = (0, import_core55.getStoreLattice)("default", "thread").store;
+  const taskStore = (0, import_core55.getStoreLattice)("default", "task").store;
+  const taskWorkItemStore = (0, import_core55.getStoreLattice)("default", "taskWorkItem").store;
   const projectTaskEnabled = options.projectTaskEnabled ?? process.env.AXIOM_PROJECT_TASK_EXECUTION_ENABLED !== "false";
   const accessService = new ProjectAccessService({ projectStore, membershipStore: projectMembershipStore, userTenantLinkStore });
   const realtimeMode = resolveProjectRoomRealtimeMode();
@@ -28081,7 +28065,7 @@ var registerLatticeRoutes = (app2, channelDeps, options = {}) => {
     updateAssistant: assistantStore.updateAssistant.bind(assistantStore)
   });
   const resolveCoordinatorMentionName = async (tenantId) => {
-    const tenant2 = await (0, import_core54.getStoreLattice)("default", "tenant").store.getTenantById(tenantId);
+    const tenant2 = await (0, import_core55.getStoreLattice)("default", "tenant").store.getTenantById(tenantId);
     const value = tenant2?.metadata?.coordinatorMentionName;
     return typeof value === "string" && value.length > 0 ? value : void 0;
   };
@@ -28108,7 +28092,7 @@ var registerLatticeRoutes = (app2, channelDeps, options = {}) => {
       return membership !== null && membership.projectId === projectId ? membership : null;
     },
     getThreadStatus: async ({ tenantId, assistantId, threadId, workspaceId, projectId }) => {
-      const agent = import_core54.agentInstanceManager.getAgent({
+      const agent = import_core55.agentInstanceManager.getAgent({
         tenant_id: tenantId,
         assistant_id: assistantId,
         thread_id: threadId,
@@ -28117,9 +28101,9 @@ var registerLatticeRoutes = (app2, channelDeps, options = {}) => {
       });
       return String(await agent.getRunStatus());
     },
-    dispatcher: (0, import_core54.createTrustedAgentMessageDispatcher)((scope) => import_core54.agentInstanceManager.getAgent(scope))
+    dispatcher: (0, import_core55.createTrustedAgentMessageDispatcher)((scope) => import_core55.agentInstanceManager.getAgent(scope))
   });
-  const membershipService = new ProjectMembershipService({ membershipStore: projectMembershipStore, userTenantLinkStore, accessService, projectMutationMutex: import_core54.projectMutationMutex, roomStore: projectRoomStore, realtime, onRealtimeFailure: realtime && channelDeps?.warn ? ({ code, membershipId }) => channelDeps.warn?.("project-room:membership-realtime-failed", { code, membershipId }) : void 0 });
+  const membershipService = new ProjectMembershipService({ membershipStore: projectMembershipStore, userTenantLinkStore, accessService, projectMutationMutex: import_core55.projectMutationMutex, roomStore: projectRoomStore, realtime, onRealtimeFailure: realtime && channelDeps?.warn ? ({ code, membershipId }) => channelDeps.warn?.("project-room:membership-realtime-failed", { code, membershipId }) : void 0 });
   const rosterService = new ProjectRosterService({
     accessService,
     roomService,
@@ -28130,7 +28114,7 @@ var registerLatticeRoutes = (app2, channelDeps, options = {}) => {
     assistantStore,
     taskStore,
     bindingLifecycle,
-    projectMutationMutex: import_core54.projectMutationMutex,
+    projectMutationMutex: import_core55.projectMutationMutex,
     realtime,
     onRealtimeFailure: realtime && channelDeps?.warn ? ({ code, membershipId }) => channelDeps.warn?.("project-room:roster-realtime-failed", { code, membershipId }) : void 0
   });
@@ -28186,9 +28170,9 @@ var registerLatticeRoutes = (app2, channelDeps, options = {}) => {
   }
   if (projectTaskComposition) app2.addHook("onClose", async () => projectTaskComposition.lease.release());
   const taskThreadService = projectTaskComposition?.lease.runtime.threads ?? new ProjectTaskThreadService({ threads: threadStore, idFactory: import_node_crypto26.randomUUID });
-  const taskLifecycle = projectTaskComposition?.lease.runtime.lifecycle ?? (0, import_core54.createTaskLifecycleService)({ taskStore, workItemStore: taskWorkItemStore });
-  const reassignmentAuthorizer = (0, import_core54.createProjectTaskReassignmentAuthorizer)(
-    new import_core54.ProjectTaskOwnerPolicy(projectBotMembershipStore),
+  const taskLifecycle = projectTaskComposition?.lease.runtime.lifecycle ?? (0, import_core55.createTaskLifecycleService)({ taskStore, workItemStore: taskWorkItemStore });
+  const reassignmentAuthorizer = (0, import_core55.createProjectTaskReassignmentAuthorizer)(
+    new import_core55.ProjectTaskOwnerPolicy(projectBotMembershipStore),
     (input) => validateReassignmentThread(threadStore, input)
   );
   const taskCommandService = new TaskCommandService({
@@ -28197,7 +28181,7 @@ var registerLatticeRoutes = (app2, channelDeps, options = {}) => {
     lifecycle: taskLifecycle,
     execution: projectTaskComposition?.lease.runtime.execution,
     threads: taskThreadService,
-    agents: { getAgent: (params) => import_core54.agentInstanceManager.getAgent(params) },
+    agents: { getAgent: (params) => import_core55.agentInstanceManager.getAgent(params) },
     taskScope: (task) => resolveCommandTaskScope(task, {
       rooms: projectRoomStore,
       bots: projectBotMembershipStore,
@@ -28235,7 +28219,7 @@ var registerLatticeRoutes = (app2, channelDeps, options = {}) => {
     readStateService,
     interruptService: roomInterruptService,
     userDirectory: {
-      getUserById: (id3) => (0, import_core54.getStoreLattice)("default", "user").store.getUserById(id3).then((u) => u ? { name: u.name } : null)
+      getUserById: (id3) => (0, import_core55.getStoreLattice)("default", "user").store.getUserById(id3).then((u) => u ? { name: u.name } : null)
     }
   });
   registerProjectRosterRoutes(app2, { service: rosterService });
@@ -28246,7 +28230,7 @@ var registerLatticeRoutes = (app2, channelDeps, options = {}) => {
       createProject: projectStore.createProject.bind(projectStore)
     },
     workspaceStore: {
-      getWorkspaceById: (tenantId, id3) => (0, import_core54.getStoreLattice)("default", "workspace").store.getWorkspaceById(tenantId, id3)
+      getWorkspaceById: (tenantId, id3) => (0, import_core55.getStoreLattice)("default", "workspace").store.getWorkspaceById(tenantId, id3)
     },
     membershipStore: {
       list: projectMembershipStore.list.bind(projectMembershipStore),
@@ -28269,7 +28253,7 @@ var registerLatticeRoutes = (app2, channelDeps, options = {}) => {
       getUsersByTenant: userTenantLinkStore.getUsersByTenant.bind(userTenantLinkStore)
     },
     userStore: {
-      getUserById: (id3) => (0, import_core54.getStoreLattice)("default", "user").store.getUserById(id3).then((u) => u ? { id: u.id, name: u.name, email: u.email } : null)
+      getUserById: (id3) => (0, import_core55.getStoreLattice)("default", "user").store.getUserById(id3).then((u) => u ? { id: u.id, name: u.name, email: u.email } : null)
     },
     assistantStore: {
       getAssistantById: assistantStore.getAssistantById.bind(assistantStore),
@@ -28291,17 +28275,17 @@ var registerLatticeRoutes = (app2, channelDeps, options = {}) => {
     }
   });
   registerCapabilityBundleRoutes(app2, new CapabilityBundleController({
-    bundleStore: (0, import_core54.getStoreLattice)("default", "capabilityBundle").store,
+    bundleStore: (0, import_core55.getStoreLattice)("default", "capabilityBundle").store,
     projectStore
   }, { authRequired: process.env.AUTH_REQUIRED === "true" }));
   const modelProviderController = new ModelProviderController({
-    providerStore: (0, import_core54.getStoreLattice)("default", "modelProvider").store,
+    providerStore: (0, import_core55.getStoreLattice)("default", "modelProvider").store,
     userTenantLinkStore,
     registry: {
-      register: (tenantId, modelKey2, config) => import_core54.modelLatticeManager.registerLatticeWithTenant(tenantId, modelKey2, config),
-      has: (tenantId, modelKey2) => import_core54.modelLatticeManager.hasLatticeWithTenant(tenantId, modelKey2),
-      remove: (tenantId, modelKey2) => import_core54.modelLatticeManager.removeLatticeWithTenant(tenantId, modelKey2),
-      listRegistered: (tenantId) => import_core54.modelLatticeManager.getLatticeKeysByTenant(tenantId)
+      register: (tenantId, modelKey2, config) => import_core55.modelLatticeManager.registerLatticeWithTenant(tenantId, modelKey2, config),
+      has: (tenantId, modelKey2) => import_core55.modelLatticeManager.hasLatticeWithTenant(tenantId, modelKey2),
+      remove: (tenantId, modelKey2) => import_core55.modelLatticeManager.removeLatticeWithTenant(tenantId, modelKey2),
+      listRegistered: (tenantId) => import_core55.modelLatticeManager.getLatticeKeysByTenant(tenantId)
     }
   }, { authRequired: process.env.AUTH_REQUIRED === "true" });
   registerModelProviderRoutes(app2, modelProviderController);
@@ -28311,10 +28295,10 @@ var registerLatticeRoutes = (app2, channelDeps, options = {}) => {
       webAppStore,
       assistantStore,
       projectStore,
-      modelRegistry: { has: (key) => import_core54.modelLatticeManager.hasLattice(key) },
+      modelRegistry: { has: (key) => import_core55.modelLatticeManager.hasLattice(key) },
       configuredAgentResolver: createConfiguredAgentResolver({
-        hydrate: (tenantId) => import_core54.agentLatticeManager.initializeStoredAssistantsForTenant(tenantId),
-        has: (tenantId, assistantId) => import_core54.agentLatticeManager.hasAgentLatticeWithTenant(tenantId, assistantId)
+        hydrate: (tenantId) => import_core55.agentLatticeManager.initializeStoredAssistantsForTenant(tenantId),
+        has: (tenantId, assistantId) => import_core55.agentLatticeManager.hasAgentLatticeWithTenant(tenantId, assistantId)
       })
     })
   });
@@ -28351,28 +28335,28 @@ var registerLatticeRoutes = (app2, channelDeps, options = {}) => {
       },
       tasks: taskStore,
       workItems: taskWorkItemStore,
-      projectMutationMutex: import_core54.projectMutationMutex,
+      projectMutationMutex: import_core55.projectMutationMutex,
       ...projectTaskComposition ? { commands: taskCommandService } : {}
     }),
     service: new AgentWebAppRuntimeService({
       webAppStore,
-      threadStore: (0, import_core54.getStoreLattice)("default", "thread").store,
+      threadStore: (0, import_core55.getStoreLattice)("default", "thread").store,
       projectStore,
       assistantResolver: {
         resolve: async (tenantId, assistantId) => {
           const stored = await assistantStore.getAssistantById(tenantId, assistantId);
           if (stored) return { id: stored.id, name: stored.name, description: stored.description };
-          await import_core54.agentLatticeManager.initializeStoredAssistantsForTenant(tenantId);
-          const config = import_core54.agentLatticeManager.getAgentConfigWithTenant(tenantId, assistantId);
+          await import_core55.agentLatticeManager.initializeStoredAssistantsForTenant(tenantId);
+          const config = import_core55.agentLatticeManager.getAgentConfigWithTenant(tenantId, assistantId);
           return config ? { id: assistantId, name: config.name, description: config.description } : null;
         }
       },
       modelRegistry: {
-        has: (key) => import_core54.modelLatticeManager.hasLattice(key),
+        has: (key) => import_core55.modelLatticeManager.hasLattice(key),
         label: (key) => key
       },
       messageReader: {
-        getCurrentMessages: ({ tenantId, assistantId, threadId, workspaceId, projectId }) => import_core54.agentInstanceManager.getAgentForRead({
+        getCurrentMessages: ({ tenantId, assistantId, threadId, workspaceId, projectId }) => import_core55.agentInstanceManager.getAgentForRead({
           tenant_id: tenantId,
           assistant_id: assistantId,
           thread_id: threadId,
@@ -28381,7 +28365,7 @@ var registerLatticeRoutes = (app2, channelDeps, options = {}) => {
         }).getCurrentMessages()
       },
       agentResolver: {
-        getAgent: ({ tenantId, assistantId, threadId, workspaceId, projectId }) => import_core54.agentInstanceManager.getAgent({
+        getAgent: ({ tenantId, assistantId, threadId, workspaceId, projectId }) => import_core55.agentInstanceManager.getAgent({
           tenant_id: tenantId,
           assistant_id: assistantId,
           thread_id: threadId,
@@ -28399,8 +28383,8 @@ var registerLatticeRoutes = (app2, channelDeps, options = {}) => {
         if (webApp.tenantId !== preview.tenantId) return false;
         const assistant = await assistantStore.getAssistantById(preview.tenantId, webApp.assistantId);
         if (assistant) return !assistant.ownerUserId || assistant.ownerUserId === preview.userId;
-        await import_core54.agentLatticeManager.initializeStoredAssistantsForTenant(preview.tenantId);
-        return import_core54.agentLatticeManager.hasAgentLatticeWithTenant(preview.tenantId, webApp.assistantId);
+        await import_core55.agentLatticeManager.initializeStoredAssistantsForTenant(preview.tenantId);
+        return import_core55.agentLatticeManager.hasAgentLatticeWithTenant(preview.tenantId, webApp.assistantId);
       }
     })
   });
@@ -28457,14 +28441,14 @@ var registerLatticeRoutes = (app2, channelDeps, options = {}) => {
   app2.post("/api/personal-assistant", createPersonalAssistant);
   app2.get("/api/personal-assistant", getPersonalAssistant);
   app2.delete("/api/personal-assistant", deletePersonalAssistant);
-  import_core54.executionAuthorityRegistry.register({
+  import_core55.executionAuthorityRegistry.register({
     id: "project-lifecycle",
     matches: isProjectLifecycleTask,
     code: "PROJECT_TASK_EXECUTION_MANAGED",
     message: "Project tasks are executed by the durable Project queue runtime",
     onManagedStart: async (task, options2) => {
       if (!projectTaskComposition && options2?.agentId && options2.agentId !== task.ownerId) {
-        throw new import_core54.ManagedTaskStartError(
+        throw new import_core55.ManagedTaskStartError(
           "PROJECT_TASK_RUNTIME_UNAVAILABLE",
           "Project task ownership transfer requires the Project task runtime.",
           { hint: "Project task execution is disabled; enable the Project task runtime or dispatch to the current owner." }
@@ -28477,7 +28461,7 @@ var registerLatticeRoutes = (app2, channelDeps, options = {}) => {
         threads: taskThreadService,
         reassignmentAuthorizer,
         lifecycle: taskLifecycle,
-        mutex: import_core54.projectMutationMutex
+        mutex: import_core55.projectMutationMutex
       }) : void 0;
       const admitted = transferred ?? task;
       if (!admitted.workspaceId || !admitted.projectId) return;
@@ -28485,7 +28469,7 @@ var registerLatticeRoutes = (app2, channelDeps, options = {}) => {
         context: withExecutionRequest(admitted.context, (/* @__PURE__ */ new Date()).toISOString())
       }).catch(() => null);
       const eventTask = markerUpdated ?? admitted;
-      void import_core54.projectTaskAdmissionNotifier.publish({
+      void import_core55.projectTaskAdmissionNotifier.publish({
         tenantId: eventTask.tenantId,
         workspaceId: eventTask.workspaceId,
         projectId: eventTask.projectId,
@@ -28499,7 +28483,7 @@ var registerLatticeRoutes = (app2, channelDeps, options = {}) => {
     access: accessService,
     tasks: taskStore,
     workItems: taskWorkItemStore,
-    projectMutationMutex: import_core54.projectMutationMutex,
+    projectMutationMutex: import_core55.projectMutationMutex,
     commands: taskCommandService,
     readableProjects: async ({ tenantId, userId, workspaceId }) => {
       const projects = await projectStore.getProjectsByWorkspace(tenantId, workspaceId);
@@ -28781,9 +28765,9 @@ function tryCreateProjectTaskRuntime(input) {
   let stores;
   try {
     stores = {
-      tenants: (0, import_core54.getStoreLattice)("default", "tenant").store,
-      workspaces: (0, import_core54.getStoreLattice)("default", "workspace").store,
-      queue: (0, import_core54.getStoreLattice)("default", "threadMessageQueue").store
+      tenants: (0, import_core55.getStoreLattice)("default", "tenant").store,
+      workspaces: (0, import_core55.getStoreLattice)("default", "workspace").store,
+      queue: (0, import_core55.getStoreLattice)("default", "threadMessageQueue").store
     };
     const missing = missingRuntimeMethod(input, stores);
     if (missing) return { reason: missing };
@@ -28815,7 +28799,7 @@ function createRuntime(input, stores, log2) {
   const controller = new AbortController();
   const mutex = new ProjectTaskExecutionMutex();
   const threads = new ProjectTaskThreadService({ threads: input.threadStore, idFactory: import_node_crypto26.randomUUID });
-  const lifecycle = (0, import_core54.createTaskLifecycleService)({ taskStore: input.taskStore, workItemStore: input.taskWorkItemStore });
+  const lifecycle = (0, import_core55.createTaskLifecycleService)({ taskStore: input.taskStore, workItemStore: input.taskWorkItemStore });
   const projection = new RoomProjectionService({
     messages: input.projectRoomMessageStore,
     events: input.taskWorkItemStore,
@@ -28825,7 +28809,7 @@ function createRuntime(input, stores, log2) {
     realtime: input.realtime,
     idFactory: import_node_crypto26.randomUUID
   });
-  const agentFor = (task, thread) => import_core54.agentInstanceManager.getAgent({
+  const agentFor = (task, thread) => import_core55.agentInstanceManager.getAgent({
     tenant_id: task.tenantId,
     assistant_id: task.ownerId,
     thread_id: thread.id,
@@ -28839,7 +28823,7 @@ function createRuntime(input, stores, log2) {
     bots: input.projectBotMembershipStore,
     threads,
     lifecycle,
-    dispatcher: (0, import_core54.createTrustedAgentMessageDispatcher)((scope) => import_core54.agentInstanceManager.getAgent(scope)),
+    dispatcher: (0, import_core55.createTrustedAgentMessageDispatcher)((scope) => import_core55.agentInstanceManager.getAgent(scope)),
     queue: stores.queue,
     agentFor
   }, {
@@ -28866,8 +28850,8 @@ function createRuntime(input, stores, log2) {
   const taskLifecycleListener = ((event) => {
     void observer.listener(event);
   });
-  const unsubscribe = import_core54.taskLifecycleNotifier.subscribe(taskLifecycleListener);
-  const unsubscribeAdmission = import_core54.projectTaskAdmissionNotifier.subscribe((event, signal) => {
+  const unsubscribe = import_core55.taskLifecycleNotifier.subscribe(taskLifecycleListener);
+  const unsubscribeAdmission = import_core55.projectTaskAdmissionNotifier.subscribe((event, signal) => {
     observer.admit(event, signal);
   });
   let reconciliationWork;
@@ -29014,12 +28998,12 @@ function registerResourceRoutes(app2, controller) {
 }
 
 // src/export_registrations/index.ts
-var import_core65 = require("@axiom-lattice/core");
+var import_core66 = require("@axiom-lattice/core");
 
 // src/export_registrations/skill.registration.ts
-var import_core55 = require("@axiom-lattice/core");
+var import_core56 = require("@axiom-lattice/core");
 function getStore(context) {
-  return new import_core55.SandboxSkillStore({
+  return new import_core56.SandboxSkillStore({
     workspaceId: context?.workspaceId,
     projectId: context?.projectId
   });
@@ -29037,7 +29021,7 @@ var skillRegistration = {
   async listForExport(tenantId, context) {
     const store2 = getStore(context);
     const skills = await store2.getAllSkills(tenantId, toStoreContext(context));
-    return skills.filter((s) => !(0, import_core55.isBuiltInSkill)(s.id)).map((s) => ({
+    return skills.filter((s) => !(0, import_core56.isBuiltInSkill)(s.id)).map((s) => ({
       _exportId: "",
       data: {
         id: s.id,
@@ -29102,7 +29086,7 @@ var skillRegistration = {
     const insertions = [];
     for (const entity of entities) {
       const id3 = entity.data.id;
-      if ((0, import_core55.isBuiltInSkill)(id3)) continue;
+      if ((0, import_core56.isBuiltInSkill)(id3)) continue;
       if (existingIds.has(id3)) {
         conflicts.push({
           _exportId: entity._exportId,
@@ -29161,9 +29145,9 @@ var skillRegistration = {
 };
 
 // src/export_registrations/agent.registration.ts
-var import_core56 = require("@axiom-lattice/core");
+var import_core57 = require("@axiom-lattice/core");
 function getStore2() {
-  return (0, import_core56.getStoreLattice)("default", "assistant").store;
+  return (0, import_core57.getStoreLattice)("default", "assistant").store;
 }
 var agentRegistration = {
   entityType: "agent",
@@ -29243,9 +29227,9 @@ var agentRegistration = {
 };
 
 // src/export_registrations/database-config.registration.ts
-var import_core57 = require("@axiom-lattice/core");
+var import_core58 = require("@axiom-lattice/core");
 function getStore3() {
-  return (0, import_core57.getStoreLattice)("default", "database").store;
+  return (0, import_core58.getStoreLattice)("default", "database").store;
 }
 var databaseConfigRegistration = {
   entityType: "database_config",
@@ -29325,9 +29309,9 @@ var databaseConfigRegistration = {
 };
 
 // src/export_registrations/metrics-config.registration.ts
-var import_core58 = require("@axiom-lattice/core");
+var import_core59 = require("@axiom-lattice/core");
 function getStore4() {
-  return (0, import_core58.getStoreLattice)("default", "metrics").store;
+  return (0, import_core59.getStoreLattice)("default", "metrics").store;
 }
 var metricsConfigRegistration = {
   entityType: "metrics_config",
@@ -29407,9 +29391,9 @@ var metricsConfigRegistration = {
 };
 
 // src/export_registrations/mcp-config.registration.ts
-var import_core59 = require("@axiom-lattice/core");
+var import_core60 = require("@axiom-lattice/core");
 function getStore5() {
-  return (0, import_core59.getStoreLattice)("default", "mcp").store;
+  return (0, import_core60.getStoreLattice)("default", "mcp").store;
 }
 var mcpConfigRegistration = {
   entityType: "mcp_config",
@@ -29492,9 +29476,9 @@ var mcpConfigRegistration = {
 };
 
 // src/export_registrations/connection.registration.ts
-var import_core60 = require("@axiom-lattice/core");
+var import_core61 = require("@axiom-lattice/core");
 function getStore6() {
-  return (0, import_core60.getStoreLattice)("default", "connection").store;
+  return (0, import_core61.getStoreLattice)("default", "connection").store;
 }
 async function listAllConnections(tenantId) {
   const store2 = getStore6();
@@ -29519,7 +29503,8 @@ var connectionRegistration = {
         key: c2.key,
         name: c2.name,
         description: c2.description,
-        config: c2.config
+        config: c2.config,
+        secretFields: c2.secretFields
       }
     }));
   },
@@ -29563,22 +29548,24 @@ var connectionRegistration = {
       } catch {
       }
     }
+    const secretFields = Array.isArray(d.secretFields) ? d.secretFields : secretFieldsForConnection(await resolveTenantPluginByType(tenantId, type));
     await store2.create({
       tenantId,
       type,
       key,
       name: d.name,
       description: d.description,
-      config: d.config
+      config: d.config,
+      secretFields
     });
     return { newId: void 0 };
   }
 };
 
 // src/export_registrations/collection.registration.ts
-var import_core61 = require("@axiom-lattice/core");
+var import_core62 = require("@axiom-lattice/core");
 function getStore7() {
-  return (0, import_core61.getStoreLattice)("default", "collection").store;
+  return (0, import_core62.getStoreLattice)("default", "collection").store;
 }
 var collectionRegistration = {
   entityType: "collection",
@@ -29649,7 +29636,7 @@ var collectionRegistration = {
 };
 
 // src/export_registrations/channel-installation.registration.ts
-var import_core62 = require("@axiom-lattice/core");
+var import_core63 = require("@axiom-lattice/core");
 var import_crypto11 = require("crypto");
 var UUID_PATTERN2 = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
 var PUBLIC_CHANNELS = /* @__PURE__ */ new Set(["lark", "email", "slack", "wechat"]);
@@ -29683,7 +29670,7 @@ function validateImportData(data) {
   };
 }
 function getStore8() {
-  return (0, import_core62.getStoreLattice)("default", "channelInstallation").store;
+  return (0, import_core63.getStoreLattice)("default", "channelInstallation").store;
 }
 function getOverwriteError(tenantId, incomingChannel, existing) {
   if (!existing) return "Channel installation overwrite target must exist";
@@ -29817,9 +29804,9 @@ var channelInstallationRegistration = {
 };
 
 // src/export_registrations/menu.registration.ts
-var import_core63 = require("@axiom-lattice/core");
+var import_core64 = require("@axiom-lattice/core");
 function getStore9() {
-  return (0, import_core63.getStoreLattice)("default", "menu").store;
+  return (0, import_core64.getStoreLattice)("default", "menu").store;
 }
 var menuRegistration = {
   entityType: "menu",
@@ -29897,9 +29884,9 @@ var menuRegistration = {
 };
 
 // src/export_registrations/eval.registration.ts
-var import_core64 = require("@axiom-lattice/core");
+var import_core65 = require("@axiom-lattice/core");
 function getStore10() {
-  return (0, import_core64.getStoreLattice)("default", "eval").store;
+  return (0, import_core65.getStoreLattice)("default", "eval").store;
 }
 var evalRegistration = {
   entityType: "eval",
@@ -30225,7 +30212,7 @@ var evalRegistration = {
 
 // src/export_registrations/index.ts
 function registerAllBuiltinEntities() {
-  const registry = import_core65.ExportableEntityRegistry.getInstance();
+  const registry = import_core66.ExportableEntityRegistry.getInstance();
   registry.register(skillRegistration);
   registry.register(agentRegistration);
   registry.register(databaseConfigRegistration);
@@ -30356,7 +30343,7 @@ function createAuditLoggerMiddleware() {
 }
 
 // src/index.ts
-var import_core91 = require("@axiom-lattice/core");
+var import_core92 = require("@axiom-lattice/core");
 
 // src/swagger.ts
 var import_swagger = __toESM(require("@fastify/swagger"));
@@ -30422,7 +30409,7 @@ var configureSwagger = async (app2, customSwaggerConfig, customSwaggerUiConfig)
 
 // src/services/agent_task_consumer.ts
 var import_node_crypto27 = require("crypto");
-var import_core66 = require("@axiom-lattice/core");
+var import_core67 = require("@axiom-lattice/core");
 var import_protocols31 = require("@axiom-lattice/protocols");
 var handleAgentTask = async (taskRequest, retryCount = 0) => {
   const {
@@ -30442,7 +30429,7 @@ var handleAgentTask = async (taskRequest, retryCount = 0) => {
       `\u5F00\u59CB\u5904\u7406\u4EFB\u52A1 [assistant_id: ${assistant_id}, thread_id: ${thread_id}]`
     );
     const scope = (0, import_protocols31.resolveRunScope)(runConfig);
-    const agent = import_core66.agentInstanceManager.getAgent({ assistant_id, thread_id, tenant_id, workspace_id: scope.workspaceId, project_id: scope.projectId, custom_run_config: runConfig });
+    const agent = import_core67.agentInstanceManager.getAgent({ assistant_id, thread_id, tenant_id, workspace_id: scope.workspaceId, project_id: scope.projectId, custom_run_config: runConfig });
     if (callback_event) {
       const callbackEvent = callback_event;
       const messageId = typeof input?.id === "string" && input.id !== "" ? input.id : (0, import_node_crypto27.randomUUID)();
@@ -30463,13 +30450,13 @@ var handleAgentTask = async (taskRequest, retryCount = 0) => {
       const onCompleted = (evt) => {
         if (!belongsToMessage(evt)) return;
         settle(() => {
-          import_core66.eventBus.publish(callbackEvent, {
+          import_core67.eventBus.publish(callbackEvent, {
             success: true,
             state: evt.state
           });
           if (main_thread_id && main_tenant_id) {
             try {
-              const mainAgent = import_core66.agentInstanceManager.getAgent({
+              const mainAgent = import_core67.agentInstanceManager.getAgent({
                 assistant_id: main_assistant_id ?? assistant_id,
                 thread_id: main_thread_id,
                 tenant_id: main_tenant_id,
@@ -30502,7 +30489,7 @@ ${summary}`
       const onInterrupted = (evt) => {
         if (!belongsToMessage(evt)) return;
         settle(() => {
-          import_core66.eventBus.publish(callbackEvent, {
+          import_core67.eventBus.publish(callbackEvent, {
             success: true,
             state: evt.state
           });
@@ -30511,7 +30498,7 @@ ${summary}`
       const onFailed = (evt) => {
         if (!belongsToMessage(evt)) return;
         settle(() => {
-          import_core66.eventBus.publish(callbackEvent, {
+          import_core67.eventBus.publish(callbackEvent, {
             success: false,
             error: evt?.error instanceof Error ? evt.error.message : typeof evt?.error === "string" ? evt.error : "Agent execution failed"
           });
@@ -30526,13 +30513,13 @@ ${summary}`
       agent.subscribe("message:interrupted", onInterrupted);
       agent.subscribe("message:failed", onFailed);
       try {
-        await agent.addMessage({ input: { ...input, id: messageId }, command, custom_run_config: runConfig }, import_core66.QueueMode.STEER);
+        await agent.addMessage({ input: { ...input, id: messageId }, command, custom_run_config: runConfig }, import_core67.QueueMode.STEER);
       } catch (error) {
         dispose();
         throw error;
       }
     } else {
-      await agent.addMessage({ input, command, custom_run_config: runConfig }, import_core66.QueueMode.STEER);
+      await agent.addMessage({ input, command, custom_run_config: runConfig }, import_core67.QueueMode.STEER);
     }
     return true;
   } catch (error) {
@@ -30551,7 +30538,7 @@ ${summary}`
       return handleAgentTask(taskRequest, nextRetryCount);
     }
     if (callback_event) {
-      import_core66.eventBus.publish(callback_event, {
+      import_core67.eventBus.publish(callback_event, {
         success: false,
         error: error instanceof Error ? error.message : String(error)
       });
@@ -30588,7 +30575,7 @@ var _AgentTaskConsumer = class _AgentTaskConsumer {
    * 初始化事件监听和队列轮询
    */
   initialize() {
-    import_core66.eventBus.subscribe(import_core66.AGENT_TASK_EVENT, this.trigger_agent_task.bind(this));
+    import_core67.eventBus.subscribe(import_core67.AGENT_TASK_EVENT, this.trigger_agent_task.bind(this));
     this.startPollingQueue();
     console.log("Agent\u4EFB\u52A1\u6D88\u8D39\u8005\u5DF2\u542F\u52A8\u5E76\u76D1\u542C\u4EFB\u52A1\u4E8B\u4EF6\u548C\u961F\u5217");
   }
@@ -30707,7 +30694,7 @@ var _AgentTaskConsumer = class _AgentTaskConsumer {
     handleAgentTask(taskRequest).catch((error) => {
       console.error("\u5904\u7406Agent\u4EFB\u52A1\u65F6\u53D1\u751F\u672A\u6355\u83B7\u7684\u9519\u8BEF:", error);
       if (taskRequest.callback_event) {
-        import_core66.eventBus.publish(taskRequest.callback_event, {
+        import_core67.eventBus.publish(taskRequest.callback_event, {
           success: false,
           error: error instanceof Error ? error.message : String(error)
         });
@@ -30722,13 +30709,13 @@ _AgentTaskConsumer.agent_run_endpoint = "http://localhost:4001/api/runs";
 var AgentTaskConsumer = _AgentTaskConsumer;
 
 // src/index.ts
-var import_core92 = require("@axiom-lattice/core");
+var import_core93 = require("@axiom-lattice/core");
 
 // src/channels/ChannelInfrastructure.ts
-var import_core68 = require("@axiom-lattice/core");
+var import_core69 = require("@axiom-lattice/core");
 
 // src/router/MessageRouter.ts
-var import_core67 = require("@axiom-lattice/core");
+var import_core68 = require("@axiom-lattice/core");
 var import_protocols32 = require("@axiom-lattice/protocols");
 var import_crypto12 = require("crypto");
 var BindingNotFoundError = class extends Error {
@@ -31014,7 +31001,7 @@ var MessageRouter = class {
             channel: message.channel,
             adapterChannel: adapter.channel
           }, "Thread resolved by adapter strategy");
-          const threadStore = (0, import_core67.getStoreLattice)("default", "thread").store;
+          const threadStore = (0, import_core68.getStoreLattice)("default", "thread").store;
           try {
             await threadStore.createThread(
               tenantId,
@@ -31051,7 +31038,7 @@ var MessageRouter = class {
           }
         }
         if (!threadId) {
-          const threadStore = (0, import_core67.getStoreLattice)("default", "thread").store;
+          const threadStore = (0, import_core68.getStoreLattice)("default", "thread").store;
           const newThreadId = (0, import_crypto12.randomUUID)();
           console.log({
             event: "dispatch:thread:create",
@@ -31091,7 +31078,7 @@ var MessageRouter = class {
           senderId: message.sender.id,
           contentLength: message.content.text.length
         }, "Dispatching to agent");
-        const agent = import_core67.agentInstanceManager.getAgent({
+        const agent = import_core68.agentInstanceManager.getAgent({
           tenant_id: tenantId,
           assistant_id: agentId,
           thread_id: threadId,
@@ -31364,7 +31351,7 @@ function createChannelInfrastructure(deps) {
       onMessageCommitted: deps.onMessageCommitted ?? (deps.realtime ? (message) => deps.realtime?.messageCreated(message) : void 0),
       onCallbackFailure: (event) => deps.warn("project-room:message-commit-callback-failed", event)
     };
-    deps.adapterRegistry.register(createRoomChannelAdapter(new import_core68.RoomAgentMessageService(writerDeps)));
+    deps.adapterRegistry.register(createRoomChannelAdapter(new import_core69.RoomAgentMessageService(writerDeps)));
   } catch (error) {
     deps.warn("Room channel unavailable", { error: error instanceof Error ? error.message : String(error) });
   }
@@ -31385,11 +31372,11 @@ async function prepareProjectTaskRuntime(runtime, log2) {
 }
 
 // src/services/multiReplicaReadiness.ts
-var import_core69 = require("@axiom-lattice/core");
+var import_core70 = require("@axiom-lattice/core");
 var SHARED_STORE_KINDS = ["lease", "outbox", "threadMessageQueue", "task", "taskWorkItem"];
 function storeClassName(kind) {
   try {
-    return (0, import_core69.getStoreLattice)("default", kind).store.constructor?.name;
+    return (0, import_core70.getStoreLattice)("default", kind).store.constructor?.name;
   } catch {
     return void 0;
   }
@@ -31559,11 +31546,11 @@ var DEFAULT_LOGGER_CONFIG = {
 var loggerLattice = initializeLogger(DEFAULT_LOGGER_CONFIG);
 var logger7 = loggerLattice.client;
 function initializeLogger(config) {
-  if (import_core92.loggerLatticeManager.hasLattice("default")) {
-    import_core92.loggerLatticeManager.removeLattice("default");
+  if (import_core93.loggerLatticeManager.hasLattice("default")) {
+    import_core93.loggerLatticeManager.removeLattice("default");
   }
-  (0, import_core92.registerLoggerLattice)("default", config);
-  return (0, import_core92.getLoggerLattice)("default");
+  (0, import_core93.registerLoggerLattice)("default", config);
+  return (0, import_core93.getLoggerLattice)("default");
 }
 var app = (0, import_fastify.default)({
   logger: false,
@@ -31660,7 +31647,7 @@ app.setErrorHandler((error, request, reply) => {
 });
 function getConfiguredSandboxProvider() {
   const sandboxProviderType = process.env.SANDBOX_PROVIDER_TYPE || "microsandbox-remote";
-  return (0, import_core92.createSandboxProvider)({
+  return (0, import_core93.createSandboxProvider)({
     type: sandboxProviderType,
     remoteBaseURL: process.env.SANDBOX_BASE_URL,
     microsandboxServiceBaseURL: process.env.MICROSANDBOX_SERVICE_BASE_URL,
@@ -31676,7 +31663,7 @@ function getConfiguredSandboxProvider() {
 }
 async function restoreMcpConnections() {
   try {
-    const storeLattice = (0, import_core92.getStoreLattice)("default", "mcp");
+    const storeLattice = (0, import_core93.getStoreLattice)("default", "mcp");
     const store2 = storeLattice.store;
     if (!store2) {
       logger7.info("MCP store not configured, skipping connection restoration");
@@ -31689,8 +31676,8 @@ async function restoreMcpConnections() {
     logger7.info(`Restoring ${configs.length} MCP server connections...`);
     const deps = {
       store: store2,
-      manager: import_core92.mcpManager,
-      convertToConnection: import_core92.convertToConnection
+      manager: import_core93.mcpManager,
+      convertToConnection: import_core93.convertToConnection
     };
     const results = await Promise.allSettled(
       configs.map(
@@ -31731,9 +31718,9 @@ var start = async (config) => {
     let projectRoomRealtimeRuntime;
     if (projectRoomRealtimeMode === "single-gateway") {
       projectRoomRealtimeRuntime = createProjectRoomRealtimeRuntime({
-        tasks: (0, import_core92.getStoreLattice)("default", "task").store,
-        rooms: (0, import_core92.getStoreLattice)("default", "projectRoom").store,
-        memberships: (0, import_core92.getStoreLattice)("default", "projectBotMembership").store,
+        tasks: (0, import_core93.getStoreLattice)("default", "task").store,
+        rooms: (0, import_core93.getStoreLattice)("default", "projectRoom").store,
+        memberships: (0, import_core93.getStoreLattice)("default", "projectBotMembership").store,
         log: { warn: (message, context) => logger7.warn(message, context) }
       });
     }
@@ -31747,7 +31734,7 @@ var start = async (config) => {
       const infrastructure = createChannelInfrastructure({
         adapterRegistry,
         getStore: ((kind) => getStore11("default", kind).store),
-        trustedDispatcher: (0, import_core92.createTrustedAgentMessageDispatcher)((scope) => import_core92.agentInstanceManager.getAgent(scope)),
+        trustedDispatcher: (0, import_core93.createTrustedAgentMessageDispatcher)((scope) => import_core93.agentInstanceManager.getAgent(scope)),
         middlewares: [
           createDeduplicationMiddleware(),
           createRateLimitMiddleware(),
@@ -31758,7 +31745,7 @@ var start = async (config) => {
       });
       const bindingStore = infrastructure.bindingRegistry;
       const installationStore = infrastructure.installationStore;
-      (0, import_core91.setBindingRegistry)(bindingStore);
+      (0, import_core92.setBindingRegistry)(bindingStore);
       const router = infrastructure.router;
       app.addHook("onClose", async () => router.dispose());
       channelDeps = {
@@ -31774,10 +31761,10 @@ var start = async (config) => {
         error: err instanceof Error ? err.message : String(err)
       });
     }
-    (0, import_core91.setEvalRunService)(evalRunner);
+    (0, import_core92.setEvalRunService)(evalRunner);
     try {
-      const menuStore = (0, import_core92.getStoreLattice)("default", "menu").store;
-      (0, import_core91.setMenuRegistry)(menuStore);
+      const menuStore = (0, import_core93.getStoreLattice)("default", "menu").store;
+      (0, import_core92.setMenuRegistry)(menuStore);
       logger7.info("Menu registry initialized");
     } catch {
     }
@@ -31794,10 +31781,10 @@ var start = async (config) => {
       const { A2AAuthService: A2AAuthService2, parseEnvKeys: parseEnvKeys2 } = await Promise.resolve().then(() => (init_A2AAuthService(), A2AAuthService_exports));
       const { registerA2AStandardRoutes: registerA2AStandardRoutes2 } = await Promise.resolve().then(() => (init_a2a_standard(), a2a_standard_exports));
       const a2a = await Promise.resolve().then(() => (init_a2a(), a2a_exports));
-      const a2aKeyStore = (0, import_core92.getStoreLattice)("default", "a2aApiKey").store;
-      const assistantStore = (0, import_core92.getStoreLattice)("default", "assistant").store;
-      const projectStore = (0, import_core92.getStoreLattice)("default", "project").store;
-      const taskStore = (0, import_core92.getStoreLattice)("default", "task").store;
+      const a2aKeyStore = (0, import_core93.getStoreLattice)("default", "a2aApiKey").store;
+      const assistantStore = (0, import_core93.getStoreLattice)("default", "assistant").store;
+      const projectStore = (0, import_core93.getStoreLattice)("default", "project").store;
+      const taskStore = (0, import_core93.getStoreLattice)("default", "task").store;
       const authService = new A2AAuthService2({
         keyStore: a2aKeyStore,
         assistantStore,
@@ -31836,8 +31823,8 @@ var start = async (config) => {
       const { CollectionService: CollectionService2 } = await Promise.resolve().then(() => (init_collection_service(), collection_service_exports));
       openLattice2.register(createKbProvider2(new CollectionService2()));
       openLattice2.register(createOpenSandboxProvider2());
-      const threadStore = (0, import_core92.getStoreLattice)("default", "thread").store;
-      const assistantStore = (0, import_core92.getStoreLattice)("default", "assistant").store;
+      const threadStore = (0, import_core93.getStoreLattice)("default", "thread").store;
+      const assistantStore = (0, import_core93.getStoreLattice)("default", "assistant").store;
       openLattice2.register(
         createAgentProvider2({
           threadStore,
@@ -31871,17 +31858,17 @@ var start = async (config) => {
         error: err instanceof Error ? err.message : String(err)
       });
     }
-    if (!import_core92.sandboxLatticeManager.hasLattice("default")) {
-      import_core92.sandboxLatticeManager.registerLattice("default", getConfiguredSandboxProvider());
+    if (!import_core93.sandboxLatticeManager.hasLattice("default")) {
+      import_core93.sandboxLatticeManager.registerLattice("default", getConfiguredSandboxProvider());
       logger7.info("Registered sandbox manager from env configuration");
     }
     try {
       const { ResourceController: ResourceController2 } = await Promise.resolve().then(() => (init_resources(), resources_exports));
-      const sharedResourceStore = (0, import_core92.getStoreLattice)("default", "sharedResource").store;
-      const cache2 = new import_core92.TokenCache();
+      const sharedResourceStore = (0, import_core93.getStoreLattice)("default", "sharedResource").store;
+      const cache2 = new import_core93.TokenCache();
       const resourceController = new ResourceController2({
         store: sharedResourceStore,
-        sandboxManager: import_core92.sandboxLatticeManager,
+        sandboxManager: import_core93.sandboxLatticeManager,
         cache: cache2,
         logger: logger7
       });
@@ -31906,39 +31893,39 @@ var start = async (config) => {
       }
     }
     const target_port = config?.port || Number(process.env.PORT) || 4001;
-    (0, import_core92.configureCoordinationLeaseStore)((0, import_core92.getStoreLattice)("default", "lease").store);
-    const outboxStore = (0, import_core92.getStoreLattice)("default", "outbox").store;
-    import_core92.taskLifecycleNotifier.setOutbox(outboxStore);
-    import_core92.projectTaskAdmissionNotifier.setOutbox(outboxStore);
-    (0, import_core92.configurePluginCatalogSync)({ outbox: outboxStore, owner: (0, import_core92.getReplicaId)() });
+    (0, import_core93.configureCoordinationLeaseStore)((0, import_core93.getStoreLattice)("default", "lease").store);
+    const outboxStore = (0, import_core93.getStoreLattice)("default", "outbox").store;
+    import_core93.taskLifecycleNotifier.setOutbox(outboxStore);
+    import_core93.projectTaskAdmissionNotifier.setOutbox(outboxStore);
+    (0, import_core93.configurePluginCatalogSync)({ outbox: outboxStore, owner: (0, import_core93.getReplicaId)() });
     bridgeAssistantEvents(
-      (event, cb) => import_core92.eventBus.subscribe(event, cb),
+      (event, cb) => import_core93.eventBus.subscribe(event, cb),
       outboxStore,
-      (0, import_core92.getReplicaId)()
+      (0, import_core93.getReplicaId)()
     );
     if (projectRoomRealtimeRuntime) {
       projectRoomRealtimeRuntime.broker.setBroadcastHook((scope, serialized, sourceKey) => {
-        void publishRoomEvent(outboxStore, (0, import_core92.getReplicaId)(), scope, serialized, sourceKey);
+        void publishRoomEvent(outboxStore, (0, import_core93.getReplicaId)(), scope, serialized, sourceKey);
       });
     }
-    const outboxPoller = new import_core92.OutboxPoller({
+    const outboxPoller = new import_core93.OutboxPoller({
       store: outboxStore,
-      owner: (0, import_core92.getReplicaId)(),
+      owner: (0, import_core93.getReplicaId)(),
       handlers: {
-        "task-lifecycle": (payload) => import_core92.taskLifecycleNotifier.deliverFromOutbox(payload),
-        "project-task-admission": (payload) => import_core92.projectTaskAdmissionNotifier.deliverFromOutbox(payload),
+        "task-lifecycle": (payload) => import_core93.taskLifecycleNotifier.deliverFromOutbox(payload),
+        "project-task-admission": (payload) => import_core93.projectTaskAdmissionNotifier.deliverFromOutbox(payload),
         [ROOM_EVENT_TOPIC]: async (payload) => {
           if (projectRoomRealtimeRuntime) ingestRoomEvent(payload, projectRoomRealtimeRuntime.broker);
         },
-        "assistant-changed": (payload) => handleAssistantChanged(payload, (tenantId) => import_core92.agentLatticeManager.initializeStoredAssistantsForTenant(tenantId)),
+        "assistant-changed": (payload) => handleAssistantChanged(payload, (tenantId) => import_core93.agentLatticeManager.initializeStoredAssistantsForTenant(tenantId)),
         [MCP_CONFIG_CHANGED_TOPIC]: (payload) => reconcileMcpConfigChange(payload, {
-          store: (0, import_core92.getStoreLattice)("default", "mcp").store,
-          manager: import_core92.mcpManager,
-          convertToConnection: import_core92.convertToConnection
+          store: (0, import_core93.getStoreLattice)("default", "mcp").store,
+          manager: import_core93.mcpManager,
+          convertToConnection: import_core93.convertToConnection
         }),
-        [import_core92.PLUGIN_CATALOG_CHANGED_TOPIC]: async (payload) => {
+        [import_core93.PLUGIN_CATALOG_CHANGED_TOPIC]: async (payload) => {
           const tenantId = payload?.tenantId;
-          if (typeof tenantId === "string" && tenantId.length > 0) (0, import_core92.getSandboxPluginCatalog)().invalidate(tenantId);
+          if (typeof tenantId === "string" && tenantId.length > 0) (0, import_core93.getSandboxPluginCatalog)().invalidate(tenantId);
         }
       },
       log: logger7
@@ -31948,7 +31935,7 @@ var start = async (config) => {
     } catch (err) {
       logger7.warn("Outbox poller failed to start", { error: err instanceof Error ? err.message : String(err) });
     }
-    const leaseStore = (0, import_core92.getStoreLattice)("default", "lease").store;
+    const leaseStore = (0, import_core93.getStoreLattice)("default", "lease").store;
     if (leaseStore.constructor?.name === "InMemoryLeaseStore") {
       logger7.warn(
         "Startup recovery leader gate uses a non-distributed lease store (per-process only); configure a shared 'lease' store for multi-replica deployments",
@@ -31956,7 +31943,7 @@ var start = async (config) => {
       );
     }
     warnMultiReplicaReadiness(logger7);
-    const startup = await (0, import_core92.runAsLeader)(leaseStore, "startup-recovery", async () => {
+    const startup = await (0, import_core93.runAsLeader)(leaseStore, "startup-recovery", async () => {
       if (routes.projectTaskRuntime) {
         await prepareProjectTaskRuntime(routes.projectTaskRuntime, logger7);
       }
@@ -31965,9 +31952,9 @@ var start = async (config) => {
           const { createOrphanRecoveryRuntime: createOrphanRecoveryRuntime2 } = await Promise.resolve().then(() => (init_OrphanRecoveryRuntime(), OrphanRecoveryRuntime_exports));
           const { createRecoveryCallerDeps: createRecoveryCallerDeps2 } = await Promise.resolve().then(() => (init_RecoveryCallerDeps(), RecoveryCallerDeps_exports));
           const runtime = createOrphanRecoveryRuntime2({
-            taskStore: (0, import_core92.getStoreLattice)("default", "task").store,
-            workItemStore: (0, import_core92.getStoreLattice)("default", "taskWorkItem").store,
-            tenantStore: (0, import_core92.getStoreLattice)("default", "tenant").store,
+            taskStore: (0, import_core93.getStoreLattice)("default", "task").store,
+            workItemStore: (0, import_core93.getStoreLattice)("default", "taskWorkItem").store,
+            tenantStore: (0, import_core93.getStoreLattice)("default", "tenant").store,
             ...createRecoveryCallerDeps2(),
             log: logger7
           });
@@ -31976,9 +31963,9 @@ var start = async (config) => {
           logger7.warn("Task orphan recovery failed", { error: err instanceof Error ? err.message : String(err) });
         }
       }
-      if (import_core92.scheduleLatticeManager.hasLattice("default")) {
+      if (import_core93.scheduleLatticeManager.hasLattice("default")) {
         try {
-          const restored = await import_core92.scheduleLatticeManager.getScheduleLattice("default").restore();
+          const restored = await import_core93.scheduleLatticeManager.getScheduleLattice("default").restore();
           logger7.info("Scheduled tasks restored", { phase: "startup_recovery", restored });
         } catch (err) {
           logger7.warn("Scheduled task restore failed", {