@axiom-lattice/gateway 4.1.0 → 4.1.1

package/dist/index.js

@@ -1040,18 +1040,18 @@ function extractText(msg) {
   }
   return null;
 }
-var import_zod6, logger4, wechatConfigSchema, MAX_RECONNECT_DELAY_MS, BASE_RECONNECT_DELAY_MS, HEARTBEAT_INTERVAL_MS, MSG_TYPE_USER, MSG_ITEM_TEXT, activeConnections2, seenClientIds, wechatChannelAdapter;
+var import_zod8, logger5, wechatConfigSchema, MAX_RECONNECT_DELAY_MS, BASE_RECONNECT_DELAY_MS, HEARTBEAT_INTERVAL_MS, MSG_TYPE_USER, MSG_ITEM_TEXT, activeConnections2, seenClientIds, wechatChannelAdapter;
 var init_WechatChannelAdapter = __esm({
   "src/channels/wechat/WechatChannelAdapter.ts"() {
     "use strict";
-    import_zod6 = require("zod");
+    import_zod8 = require("zod");
     init_wechat_client();
     init_context_store();
     init_Logger();
-    logger4 = new Logger({ serviceName: "lattice/gateway/wechat" });
-    wechatConfigSchema = import_zod6.z.object({
-      botToken: import_zod6.z.string(),
-      uin: import_zod6.z.string().optional()
+    logger5 = new Logger({ serviceName: "lattice/gateway/wechat" });
+    wechatConfigSchema = import_zod8.z.object({
+      botToken: import_zod8.z.string(),
+      uin: import_zod8.z.string().optional()
     });
     MAX_RECONNECT_DELAY_MS = 3e4;
     BASE_RECONNECT_DELAY_MS = 1e3;
@@ -1099,7 +1099,7 @@ var init_WechatChannelAdapter = __esm({
         const senderId = replyTarget.rawTarget.senderId;
         const contextToken = getContextToken(installation.id, senderId);
         if (!contextToken) {
-          logger4.warn("WeChat context token expired, cannot send reply", {
+          logger5.warn("WeChat context token expired, cannot send reply", {
             installationId: installation.id,
             senderId
           });
@@ -1117,14 +1117,14 @@ var init_WechatChannelAdapter = __esm({
       async connect(installation, deps) {
         const { id: installationId, tenantId, config } = installation;
         if (!config.botToken) {
-          logger4.warn("WeChat installation missing botToken, skipping", { installationId });
+          logger5.warn("WeChat installation missing botToken, skipping", { installationId });
           return;
         }
         if (activeConnections2.has(installationId)) {
-          logger4.warn("WeChat polling already running for installation, skipping", { installationId });
+          logger5.warn("WeChat polling already running for installation, skipping", { installationId });
           return;
         }
-        logger4.info("WeChat polling starting", { installationId, tenantId });
+        logger5.info("WeChat polling starting", { installationId, tenantId });
         const abortController = new AbortController();
         const heartbeatTimer = setInterval(() => {
           const state2 = activeConnections2.get(installationId);
@@ -1134,7 +1134,7 @@ var init_WechatChannelAdapter = __esm({
           }
           const elapsed = Date.now() - state2.lastActivity;
           if (elapsed > HEARTBEAT_INTERVAL_MS * 2) {
-            logger4.error("WeChat polling heartbeat lost \u2014 no activity", {
+            logger5.error("WeChat polling heartbeat lost \u2014 no activity", {
               installationId,
               elapsedMs: elapsed
             });
@@ -1153,7 +1153,7 @@ var init_WechatChannelAdapter = __esm({
         let reconnectDelay = BASE_RECONNECT_DELAY_MS;
         const scheduleNextPoll = () => {
           poll().catch((err) => {
-            logger4.error("WeChat poll iteration crashed", {
+            logger5.error("WeChat poll iteration crashed", {
               installationId,
               error: err instanceof Error ? err.message : String(err)
             });
@@ -1166,7 +1166,7 @@ var init_WechatChannelAdapter = __esm({
         const poll = async () => {
           const currentState = activeConnections2.get(installationId);
           if (!currentState || currentState.abortController.signal.aborted) {
-            logger4.info("WeChat polling aborted", { installationId });
+            logger5.info("WeChat polling aborted", { installationId });
             return;
           }
           try {
@@ -1179,7 +1179,7 @@ var init_WechatChannelAdapter = __esm({
             reconnectDelay = BASE_RECONNECT_DELAY_MS;
             currentState.lastActivity = Date.now();
             if (result.msgs.length > 0) {
-              logger4.info("WeChat poll received messages", {
+              logger5.info("WeChat poll received messages", {
                 installationId,
                 count: result.msgs.length
               });
@@ -1196,7 +1196,7 @@ var init_WechatChannelAdapter = __esm({
               if (inbound && router) {
                 const dispatchResult = await router.dispatch(inbound);
                 if (!dispatchResult.success) {
-                  logger4.warn("WeChat dispatch failed", {
+                  logger5.warn("WeChat dispatch failed", {
                     installationId,
                     error: dispatchResult.error?.message
                   });
@@ -1205,10 +1205,10 @@ var init_WechatChannelAdapter = __esm({
             }
           } catch (err) {
             if (err instanceof Error && err.name === "AbortError") {
-              logger4.info("WeChat poll aborted by signal", { installationId });
+              logger5.info("WeChat poll aborted by signal", { installationId });
               return;
             }
-            logger4.error("WeChat poll error", {
+            logger5.error("WeChat poll error", {
               installationId,
               error: err instanceof Error ? err.message : String(err)
             });
@@ -1218,19 +1218,19 @@ var init_WechatChannelAdapter = __esm({
           scheduleNextPoll();
         };
         scheduleNextPoll();
-        logger4.info("WeChat polling started", { installationId });
+        logger5.info("WeChat polling started", { installationId });
       },
       async disconnect(installationId) {
         const state = activeConnections2.get(installationId);
         if (!state) {
-          logger4.warn("WeChat polling not running, nothing to disconnect", { installationId });
+          logger5.warn("WeChat polling not running, nothing to disconnect", { installationId });
           return;
         }
-        logger4.info("WeChat polling disconnecting", { installationId });
+        logger5.info("WeChat polling disconnecting", { installationId });
         state.abortController.abort();
         clearInterval(state.heartbeatTimer);
         activeConnections2.delete(installationId);
-        logger4.info("WeChat polling disconnected", { installationId });
+        logger5.info("WeChat polling disconnected", { installationId });
       }
     };
   }
@@ -1895,12 +1895,12 @@ function agentMessage(text) {
     parts: [{ kind: "text", text }]
   };
 }
-var import_uuid10, import_core55, import_protocols8, _AxiomAgentExecutor, AxiomAgentExecutor;
+var import_uuid10, import_core56, import_protocols8, _AxiomAgentExecutor, AxiomAgentExecutor;
 var init_AxiomAgentExecutor = __esm({
   "src/services/a2a/AxiomAgentExecutor.ts"() {
     "use strict";
     import_uuid10 = require("uuid");
-    import_core55 = require("@axiom-lattice/core");
+    import_core56 = require("@axiom-lattice/core");
     import_protocols8 = require("@axiom-lattice/protocols");
     init_a2aFileRefs();
     init_task_file_refs();
@@ -1987,7 +1987,7 @@ var init_AxiomAgentExecutor = __esm({
           await this.taskStore.save(initialTask);
           bus.publish(initialTask);
           try {
-            const agent = import_core55.agentInstanceManager.getAgent({
+            const agent = import_core56.agentInstanceManager.getAgent({
               assistant_id: this.scope.assistantId,
               thread_id: threadId,
               tenant_id: this.scope.tenantId,
@@ -2137,7 +2137,7 @@ ${formatFileRefsSection(inputFiles)}` : text;
         const threadId = task ? asString2(task.metadata?.threadId) : void 0;
         if (threadId) {
           try {
-            const agent = import_core55.agentInstanceManager.getAgent({
+            const agent = import_core56.agentInstanceManager.getAgent({
               assistant_id: this.scope.assistantId,
               thread_id: threadId,
               tenant_id: this.scope.tenantId,
@@ -2499,13 +2499,13 @@ function isAsyncGenerator(value) {
 }
 function registerA2AStandardRoutes(app2, deps) {
   const authService = deps.authService;
-  const getTaskStore = deps.getTaskStoreLattice ?? (() => (0, import_core56.getStoreLattice)("default", "task").store);
-  const getTaskWorkItemStore2 = deps.getTaskWorkItemStore ?? (() => (0, import_core56.getStoreLattice)("default", "taskWorkItem").store);
-  const getAssistantStore3 = deps.getAssistantStore ?? (() => (0, import_core56.getStoreLattice)("default", "assistant").store);
-  const getProjectStore2 = deps.getProjectStore ?? (() => (0, import_core56.getStoreLattice)("default", "project").store);
+  const getTaskStore = deps.getTaskStoreLattice ?? (() => (0, import_core57.getStoreLattice)("default", "task").store);
+  const getTaskWorkItemStore2 = deps.getTaskWorkItemStore ?? (() => (0, import_core57.getStoreLattice)("default", "taskWorkItem").store);
+  const getAssistantStore3 = deps.getAssistantStore ?? (() => (0, import_core57.getStoreLattice)("default", "assistant").store);
+  const getProjectStore2 = deps.getProjectStore ?? (() => (0, import_core57.getStoreLattice)("default", "project").store);
   const getTenantStore = deps.getTenantStore ?? (() => {
     try {
-      return (0, import_core56.getStoreLattice)("default", "tenant").store;
+      return (0, import_core57.getStoreLattice)("default", "tenant").store;
     } catch {
       return void 0;
     }
@@ -2520,10 +2520,10 @@ function registerA2AStandardRoutes(app2, deps) {
     const tenantStore = getTenantStore();
     if (!tenantStore) return null;
     const tenants = await tenantStore.getAllTenants();
-    for (const tenant of tenants) {
-      if (tenant.id === tenantId) continue;
+    for (const tenant2 of tenants) {
+      if (tenant2.id === tenantId) continue;
       const found = await getAssistantStore3().getAssistantById(
-        tenant.id,
+        tenant2.id,
         assistantId
       );
       if (found) return found;
@@ -2597,7 +2597,7 @@ function registerA2AStandardRoutes(app2, deps) {
       const taskStore = new A2ATaskStoreAdapter({
         taskStore: internalTaskStore,
         workItemStore,
-        lifecycle: (0, import_core56.createTaskLifecycleService)({
+        lifecycle: (0, import_core57.createTaskLifecycleService)({
           taskStore: internalTaskStore,
           workItemStore
         }),
@@ -2716,7 +2716,7 @@ data: ${JSON.stringify(errorResponse)}
       const taskStore = new A2ATaskStoreAdapter({
         taskStore: internalTaskStore,
         workItemStore,
-        lifecycle: (0, import_core56.createTaskLifecycleService)({
+        lifecycle: (0, import_core57.createTaskLifecycleService)({
           taskStore: internalTaskStore,
           workItemStore
         }),
@@ -2761,13 +2761,13 @@ data: ${JSON.stringify(data)}
     }
   );
 }
-var import_uuid11, import_server2, import_core56, SSE_HEADERS;
+var import_uuid11, import_server2, import_core57, SSE_HEADERS;
 var init_a2a_standard = __esm({
   "src/routes/a2a-standard.ts"() {
     "use strict";
     import_uuid11 = require("uuid");
     import_server2 = require("@a2a-js/sdk/server");
-    import_core56 = require("@axiom-lattice/core");
+    import_core57 = require("@axiom-lattice/core");
     init_A2AAuthService();
     init_A2AAgentCardBuilder();
     init_A2ATaskStoreAdapter();
@@ -2941,12 +2941,12 @@ var resources_exports = {};
 __export(resources_exports, {
   ResourceController: () => ResourceController
 });
-var import_bcryptjs, import_core57, ResourceController;
+var import_bcryptjs, import_core58, ResourceController;
 var init_resources = __esm({
   "src/controllers/resources.ts"() {
     "use strict";
     import_bcryptjs = __toESM(require("bcryptjs"));
-    import_core57 = require("@axiom-lattice/core");
+    import_core58 = require("@axiom-lattice/core");
     init_mime();
     ResourceController = class {
       constructor(deps) {
@@ -2961,14 +2961,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_core57.createSharePayload)(
+        const payload = (0, import_core58.createSharePayload)(
           tenantId,
           workspaceId,
           projectId,
           userId,
           body
         );
-        const token = (0, import_core57.generateToken)();
+        const token = (0, import_core58.generateToken)();
         try {
           await this.deps.store.create({ ...payload, token });
           this.deps.logger.info(
@@ -3120,7 +3120,7 @@ var init_resources = __esm({
             resourcePath: subPath
           }, subPath, ext, request, reply);
         }
-        const volume = (0, import_core57.buildNamedVolumeName)("p", "project", tenantId, workspaceId, projectId);
+        const volume = (0, import_core58.buildNamedVolumeName)("p", "project", tenantId, workspaceId, projectId);
         return this._resolveAndServe(
           volume,
           subPath,
@@ -4395,7 +4395,7 @@ var recoverRun = async (request, reply) => {
     const { assistantId, threadId } = request.params;
     const tenant_id = request.headers["x-tenant-id"];
     const workspace_id = request.headers["x-workspace-id"] || "default";
-    const project_id = request.headers["x-project-id"] || "default";
+    const project_id = request.headers["x-project-id"];
     const agent = import_core3.agentInstanceManager.getAgent({
       assistant_id: assistantId,
       thread_id: threadId,
@@ -4403,8 +4403,7 @@ var recoverRun = async (request, reply) => {
       workspace_id,
       project_id
     });
-    await agent.resumeTask();
-    const status = await agent.getRunStatus();
+    const { status } = await agent.resumeTask();
     reply.status(200).send({
       success: true,
       threadId,
@@ -5291,6 +5290,7 @@ async function getHealth(request, reply) {
 
 // src/services/skill_service.ts
 var import_core10 = require("@axiom-lattice/core");
+var PLUGIN_SKILL_SOURCE = "builtin-plugin";
 function getTenantId4(request) {
   return request.user?.tenantId || request.headers["x-tenant-id"] || "default";
 }
@@ -5306,28 +5306,63 @@ function buildContext(request) {
     projectId: getProjectId(request)
   };
 }
+function pluginSkillToSkill(item, tenantId, content) {
+  return {
+    id: item.id,
+    tenantId,
+    name: item.name,
+    description: item.description,
+    version: item.version,
+    pluginType: item.pluginType,
+    resourcePaths: item.resourcePaths,
+    source: PLUGIN_SKILL_SOURCE,
+    readOnly: true,
+    content,
+    createdAt: /* @__PURE__ */ new Date(0),
+    updatedAt: /* @__PURE__ */ new Date(0)
+  };
+}
 var SkillService = class {
   constructor() {
     this.store = new import_core10.SandboxSkillStore();
   }
   async getAllSkills(request) {
     const tenantId = getTenantId4(request);
-    return this.store.getAllSkills(tenantId, buildContext(request));
+    const storeSkills = await this.store.getAllSkills(tenantId, buildContext(request));
+    const merged = /* @__PURE__ */ new Map();
+    for (const skill of storeSkills) {
+      merged.set(skill.id, skill);
+    }
+    for (const item of import_core10.PluginRegistry.listSkills()) {
+      merged.set(item.id, pluginSkillToSkill(item, tenantId));
+    }
+    return Array.from(merged.values());
   }
   async getSkillById(request, id) {
     const tenantId = getTenantId4(request);
+    const plugin = import_core10.PluginRegistry.getSkill(id);
+    if (plugin) {
+      const { definition } = plugin;
+      const item = import_core10.PluginRegistry.listSkills().find((entry) => entry.id === id);
+      if (item) {
+        return pluginSkillToSkill(item, tenantId, definition.content);
+      }
+    }
     return this.store.getSkillById(tenantId, id, buildContext(request));
   }
   async createSkill(request, id, data) {
     const tenantId = getTenantId4(request);
+    this.assertNotPluginSkill(id, "created");
     return this.store.createSkill(tenantId, id, data, buildContext(request));
   }
   async updateSkill(request, id, updates) {
     const tenantId = getTenantId4(request);
+    this.assertNotPluginSkill(id, "modified");
     return this.store.updateSkill(tenantId, id, updates, buildContext(request));
   }
   async deleteSkill(request, id) {
     const tenantId = getTenantId4(request);
+    this.assertNotPluginSkill(id, "deleted");
     return this.store.deleteSkill(tenantId, id, buildContext(request));
   }
   async searchByMetadata(request, key, value) {
@@ -5342,6 +5377,16 @@ var SkillService = class {
     const tenantId = getTenantId4(request);
     return this.store.filterByLicense(tenantId, license, buildContext(request));
   }
+  /**
+   * Guard against mutating a registered plugin skill.
+   * Message style mirrors SandboxSkillStore built-in errors so the controller's
+   * existing "built-in skill" -> 403 mapping applies.
+   */
+  assertNotPluginSkill(id, action) {
+    if (import_core10.PluginRegistry.getSkill(id)) {
+      throw new Error(`Skill "${id}" is a built-in skill and cannot be ${action}`);
+    }
+  }
 };
 
 // src/controllers/skills.ts
@@ -5356,6 +5401,11 @@ function serializeSkill(skill) {
     metadata: skill.metadata || {},
     content: skill.content,
     subSkills: skill.subSkills,
+    source: skill.source,
+    pluginType: skill.pluginType,
+    version: skill.version,
+    resources: skill.resourcePaths,
+    readOnly: skill.readOnly,
     createdAt: skill.createdAt instanceof Date ? skill.createdAt.toISOString() : (/* @__PURE__ */ new Date()).toISOString(),
     updatedAt: skill.updatedAt instanceof Date ? skill.updatedAt.toISOString() : (/* @__PURE__ */ new Date()).toISOString()
   };
@@ -8480,6 +8530,10 @@ function createZip(entries) {
   end.writeUInt32LE(offset, 16);
   return Buffer.concat([...localParts, centralDirectory, end]);
 }
+var CAPABILITY_BUNDLE_CONFIG_MESSAGE = "Use /api/projects/:projectId/capability-bundles to update capability bundle IDs";
+function writesCapabilityBundleIds(config) {
+  return config !== void 0 && Object.prototype.hasOwnProperty.call(config, "capabilityBundleIds");
+}
 var WorkspaceController = class {
   constructor() {
     this.workspaceStore = (0, import_core24.getStoreLattice)("default", "workspace").store;
@@ -8587,6 +8641,13 @@ var WorkspaceController = class {
     const tenantId = this.getTenantId(request);
     const { workspaceId } = request.params;
     const data = request.body;
+    if (writesCapabilityBundleIds(data.config)) {
+      return reply.status(400).send({
+        success: false,
+        code: "INVALID_BUNDLE_CONFIG",
+        message: CAPABILITY_BUNDLE_CONFIG_MESSAGE
+      });
+    }
     const id = (0, import_uuid3.v4)();
     const project = await this.projectStore.createProject(
       tenantId,
@@ -8609,6 +8670,13 @@ var WorkspaceController = class {
     const tenantId = this.getTenantId(request);
     const { projectId } = request.params;
     const updates = request.body;
+    if (writesCapabilityBundleIds(updates.config)) {
+      return reply.status(400).send({
+        success: false,
+        code: "INVALID_BUNDLE_CONFIG",
+        message: CAPABILITY_BUNDLE_CONFIG_MESSAGE
+      });
+    }
     const project = await this.projectStore.updateProject(
       tenantId,
       projectId,
@@ -8766,6 +8834,40 @@ var WorkspaceController = class {
       if (!project || project.workspaceId !== workspaceId) {
         throw new FolderDownloadError(404, "PROJECT_NOT_FOUND", "Project not found");
       }
+      if (storedWorkspace.storageType === "sandbox") {
+        const sandboxManager = (0, import_core26.getSandBoxManager)();
+        const volumeConfig = {
+          assistant_id: assistantId || "",
+          thread_id: "",
+          tenantId,
+          workspaceId,
+          projectId
+        };
+        const sandbox = await sandboxManager.getSandboxFromConfig(volumeConfig);
+        if (!sandbox.packDirectory || !sandbox.file.deleteFile) {
+          throw new FolderDownloadError(502, "BACKEND_UNSUPPORTED", "Backend does not support folder archive cleanup");
+        }
+        let packed;
+        try {
+          packed = await sandbox.packDirectory(folderPath);
+          if (packed.size === void 0) {
+            throw new FolderDownloadError(502, "BACKEND_UNSUPPORTED", "Backend does not report packed archive size");
+          }
+          if (!Number.isFinite(packed.size) || packed.size < 0 || packed.size > MAX_ZIP_TOTAL_SIZE) {
+            throw new FolderDownloadError(400, "SIZE_LIMIT", "Packed folder exceeds download size limits");
+          }
+          const buffer = await sandbox.file.downloadFile({ file: packed.path });
+          return reply.status(200).type("application/zip").header("Content-Disposition", `attachment; filename*=UTF-8''${encodeURIComponent(packed.filename)}`).send(buffer);
+        } finally {
+          if (packed) {
+            try {
+              await sandbox.file.deleteFile(packed.path);
+            } catch (cleanupError) {
+              console.warn("Failed to clean up packed sandbox folder archive", cleanupError);
+            }
+          }
+        }
+      }
       const { backend, workspace } = await this.getBackend(
         tenantId,
         workspaceId,
@@ -8773,7 +8875,7 @@ var WorkspaceController = class {
         assistantId,
         folderPath
       );
-      if (!backend.lsInfo || workspace.storageType === "sandbox" && !backend.readBinary) {
+      if (!backend.lsInfo) {
         throw new FolderDownloadError(502, "BACKEND_UNSUPPORTED", "Backend does not support folder downloads");
       }
       let listEntries2;
@@ -11304,31 +11406,31 @@ var TenantsController = class {
   async createTenant(request, reply) {
     const data = request.body;
     const id = (0, import_uuid7.v4)();
-    const tenant = await this.tenantStore.createTenant(id, data);
-    return reply.status(201).send({ success: true, data: tenant });
+    const tenant2 = await this.tenantStore.createTenant(id, data);
+    return reply.status(201).send({ success: true, data: tenant2 });
   }
   async getTenant(request, reply) {
     const { tenantId } = request.params;
-    const tenant = await this.tenantStore.getTenantById(tenantId);
-    if (!tenant) {
+    const tenant2 = await this.tenantStore.getTenantById(tenantId);
+    if (!tenant2) {
       return reply.status(404).send({
         success: false,
         error: "Tenant not found"
       });
     }
-    return { success: true, data: tenant };
+    return { success: true, data: tenant2 };
   }
   async updateTenant(request, reply) {
     const { tenantId } = request.params;
     const updates = request.body;
-    const tenant = await this.tenantStore.updateTenant(tenantId, updates);
-    if (!tenant) {
+    const tenant2 = await this.tenantStore.updateTenant(tenantId, updates);
+    if (!tenant2) {
       return reply.status(404).send({
         success: false,
         error: "Tenant not found"
       });
     }
-    return { success: true, data: tenant };
+    return { success: true, data: tenant2 };
   }
   async deleteTenant(request, reply) {
     const { tenantId } = request.params;
@@ -11481,10 +11583,10 @@ var AuthController = class {
       const links = await this.userTenantLinkStore.getTenantsByUser(userId);
       const tenantsWithDetails = await Promise.all(
         links.map(async (link) => {
-          const tenant = await this.tenantStore.getTenantById(link.tenantId);
+          const tenant2 = await this.tenantStore.getTenantById(link.tenantId);
           return {
             ...link,
-            tenant: tenant || null
+            tenant: tenant2 || null
           };
         })
       );
@@ -11517,8 +11619,8 @@ var AuthController = class {
           error: "You do not have access to this tenant"
         });
       }
-      const tenant = await this.tenantStore.getTenantById(tenantId);
-      if (!tenant) {
+      const tenant2 = await this.tenantStore.getTenantById(tenantId);
+      if (!tenant2) {
         return reply.status(404).send({
           success: false,
           error: "Tenant not found"
@@ -11542,7 +11644,7 @@ var AuthController = class {
       return {
         success: true,
         data: {
-          tenant,
+          tenant: tenant2,
           token,
           personalAssistant
         }
@@ -11612,8 +11714,8 @@ var AuthController = class {
           error: "User not found"
         });
       }
-      const tenant = await this.tenantStore.getTenantById(tenantId);
-      if (!tenant) {
+      const tenant2 = await this.tenantStore.getTenantById(tenantId);
+      if (!tenant2) {
         return reply.status(404).send({
           success: false,
           error: "Tenant not found"
@@ -13458,7 +13560,7 @@ function registerTaskRoutes(app2) {
 }
 
 // src/routes/index.ts
-var import_core41 = require("@axiom-lattice/core");
+var import_core42 = require("@axiom-lattice/core");
 
 // src/services/agent-web-app/AgentWebAppService.ts
 function createConfiguredAgentResolver(registry) {
@@ -14417,42 +14519,399 @@ function isAttachmentPayload(value) {
 
 // src/routes/index.ts
 init_workspace_file_service();
+
+// src/controllers/capability-bundles.ts
+var import_zod7 = require("zod");
+
+// src/services/capability/CapabilityBundleService.ts
+var import_zod6 = require("zod");
+var import_core41 = require("@axiom-lattice/core");
+var CapabilityBundleServiceError = class extends Error {
+  constructor(code, message, statusCode) {
+    super(message);
+    this.code = code;
+    this.statusCode = statusCode;
+    this.name = "CapabilityBundleServiceError";
+  }
+};
+var uuid = import_zod6.z.string().uuid();
+function ownRecord(value) {
+  if (value === void 0 || value === null) return {};
+  if (typeof value !== "object" || Array.isArray(value)) throw new CapabilityBundleServiceError("INVALID_BUNDLE_CONFIG", "Project config must be an object", 409);
+  const result = {};
+  for (const [key, entry] of Object.entries(value)) {
+    if (key !== "__proto__" && key !== "constructor" && key !== "prototype") result[key] = entry;
+  }
+  return result;
+}
+function isDuplicate(error) {
+  return error instanceof Error && /already exists|unique|duplicate/i.test(error.message);
+}
+function rejectStableKey(input) {
+  if (input !== null && typeof input === "object" && !Array.isArray(input) && Object.prototype.hasOwnProperty.call(input, "key")) {
+    throw new CapabilityBundleServiceError("INVALID_INPUT", "Capability bundle key is generated and cannot be supplied or changed", 400);
+  }
+}
+function slugify(name) {
+  const slug = name.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  return slug || "runtime-profile";
+}
+function projectBundleIds(config) {
+  const record = ownRecord(config);
+  if (!Object.prototype.hasOwnProperty.call(record, "capabilityBundleIds")) return [];
+  const value = record.capabilityBundleIds;
+  if (!Array.isArray(value) || value.some((id) => typeof id !== "string" || !uuid.safeParse(id).success) || new Set(value).size !== value.length) {
+    throw new CapabilityBundleServiceError("INVALID_BUNDLE_CONFIG", "Project capabilityBundleIds must be a unique array of UUIDs", 409);
+  }
+  return [...value];
+}
+function issue(error) {
+  if (error instanceof import_core41.CapabilityBundleMergeError || error instanceof import_core41.CapabilityBundleValidationError) return { code: error instanceof import_core41.CapabilityBundleValidationError && error.code === "CAPABILITY_BUNDLE_INVALID_CONFIG" ? "INVALID_BUNDLE_CONFIG" : error.code, message: error.message, bundleId: error instanceof import_core41.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 {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  async list(tenantId) {
+    const values = await this.deps.bundleStore.listByTenant(tenantId);
+    const bundles = [];
+    const errors = [];
+    for (const value of values) {
+      try {
+        (0, import_core41.validateCapabilityBundleInput)(value);
+        bundles.push(value);
+      } catch {
+        errors.push({ bundleId: value.id, code: "INVALID_BUNDLE_CONFIG", message: "Capability bundle record is invalid" });
+      }
+    }
+    return { bundles, errors };
+  }
+  async get(tenantId, id) {
+    const value = await this.deps.bundleStore.getById(tenantId, id);
+    if (!value) throw new CapabilityBundleServiceError("BUNDLE_NOT_FOUND", "Capability bundle not found", 404);
+    try {
+      (0, import_core41.validateCapabilityBundleInput)(value);
+    } catch {
+      throw new CapabilityBundleServiceError("INVALID_BUNDLE_CONFIG", "Capability bundle record is invalid", 422);
+    }
+    return value;
+  }
+  async create(tenantId, input) {
+    rejectStableKey(input);
+    (0, import_core41.validateCapabilityBundleInput)(input);
+    const value = input;
+    const name = value.name.trim();
+    const base = slugify(name);
+    for (let attempt = 0; attempt < 5; attempt += 1) {
+      const existing = await this.deps.bundleStore.listByTenant(tenantId) ?? [];
+      const keys = new Set(existing.map((bundle) => bundle.key));
+      let key = base;
+      let suffix = 2;
+      while (keys.has(key)) key = `${base}-${suffix++}`;
+      const normalized = { ...value, key, name };
+      (0, import_core41.validateCapabilityBundleInput)(normalized);
+      try {
+        const result = await this.deps.bundleStore.create(tenantId, normalized);
+        (0, import_core41.validateCapabilityBundleInput)(result);
+        return result;
+      } catch (error) {
+        if (!isDuplicate(error)) throw error;
+        if (attempt === 4) throw new CapabilityBundleServiceError("DUPLICATE_BUNDLE_KEY", "Capability bundle key already exists", 409);
+      }
+    }
+    throw new CapabilityBundleServiceError("DUPLICATE_BUNDLE_KEY", "Capability bundle key already exists", 409);
+  }
+  async update(tenantId, id, input) {
+    rejectStableKey(input);
+    (0, import_core41.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_core41.validateCapabilityBundleInput)(normalized, { partial: true });
+    try {
+      const result = await this.deps.bundleStore.update(tenantId, id, 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_core41.validateCapabilityBundleInput)(result);
+      return result;
+    } catch (error) {
+      if (error instanceof CapabilityBundleServiceError) throw error;
+      if (isDuplicate(error)) throw new CapabilityBundleServiceError("DUPLICATE_BUNDLE_KEY", "Capability bundle key already exists", 409);
+      throw error;
+    }
+  }
+  async remove(tenantId, id) {
+    const result = await this.deps.bundleStore.deleteIfUnreferenced(tenantId, id);
+    if (result === "not_found") throw new CapabilityBundleServiceError("BUNDLE_NOT_FOUND", "Capability bundle not found", 404);
+    if (result === "in_use") throw new CapabilityBundleServiceError("BUNDLE_IN_USE", "Capability bundle is in use", 409);
+  }
+  async getProjectBundles(tenantId, projectId) {
+    const project = await this.deps.projectStore.getProjectById(tenantId, projectId);
+    if (!project) throw new CapabilityBundleServiceError("PROJECT_NOT_FOUND", "Project not found", 404);
+    const ids = projectBundleIds(project.config);
+    const stored = await this.deps.bundleStore.getManyByIds(tenantId, ids) ?? [];
+    return this.compose(project, ids, stored);
+  }
+  async previewProject(tenantId, projectId) {
+    const project = await this.deps.projectStore.getProjectById(tenantId, projectId);
+    if (!project) throw new CapabilityBundleServiceError("PROJECT_NOT_FOUND", "Project not found", 404);
+    let ids;
+    try {
+      ids = projectBundleIds(project.config);
+    } catch (error) {
+      return { bundleIds: [], capabilities: [], overrides: [], sources: [], warnings: [], errors: [{ code: "INVALID_BUNDLE_CONFIG", message: error instanceof Error ? error.message : "Invalid project capability configuration" }], revision: "" };
+    }
+    const stored = await this.deps.bundleStore.getManyByIds(tenantId, ids) ?? [];
+    const byId = new Map(stored.map((value) => [value.id, value]));
+    const missing = ids.filter((id) => !byId.has(id));
+    if (missing.length > 0) return { bundleIds: ids, capabilities: [], overrides: [], sources: [], warnings: [], errors: missing.map((id) => ({ code: "BUNDLE_NOT_FOUND", message: `Persisted capability bundle '${id}' is missing`, bundleId: id })), revision: "" };
+    try {
+      const ordered = ids.map((id) => byId.get(id));
+      ordered.forEach((bundle) => (0, import_core41.validateCapabilityBundleInput)(bundle));
+      return (0, import_core41.mergeCapabilityBundles)(ordered);
+    } catch (error) {
+      return { bundleIds: ids, capabilities: [], overrides: [], sources: [], warnings: [], errors: [issue(error)], revision: "" };
+    }
+  }
+  async project(tenantId, projectId, ids, persist, expectedRevisions) {
+    const current = await this.deps.projectStore.getProjectById(tenantId, projectId);
+    if (!current) throw new CapabilityBundleServiceError("PROJECT_NOT_FOUND", "Project not found", 404);
+    if (new Set(ids).size !== ids.length) throw new CapabilityBundleServiceError("DUPLICATE_PROJECT_BUNDLE", "Duplicate capability bundle ID", 400);
+    if (persist) this.assertExpectedRevisions(ids, expectedRevisions);
+    const ordered = await this.loadOrderedBundles(tenantId, ids);
+    let resultProject = current;
+    if (persist) {
+      projectBundleIds(current.config);
+      const update = await this.deps.projectStore.updateCapabilityBundleIds(tenantId, projectId, ids, expectedRevisions);
+      if (update.status === "project_not_found") throw new CapabilityBundleServiceError("PROJECT_NOT_FOUND", "Project not found", 404);
+      if (update.status === "bundle_not_found") throw new CapabilityBundleServiceError("BUNDLE_NOT_FOUND", "Capability bundle not found", 404);
+      if (update.status === "bundle_conflict") throw new CapabilityBundleServiceError("BUNDLE_CONFLICT", "Capability bundle changed after preview; preview the current bundle contents before saving", 409);
+      resultProject = update.project;
+    }
+    return this.compose(resultProject, ids, ordered);
+  }
+  assertExpectedRevisions(ids, revisions) {
+    if (!revisions || Object.keys(revisions).length !== ids.length || ids.some((id) => typeof revisions[id] !== "string" || !revisions[id].trim()) || Object.keys(revisions).some((id) => !ids.includes(id))) {
+      throw new CapabilityBundleServiceError("BUNDLE_CONFLICT", "Expected revisions must exactly match the selected capability bundles", 409);
+    }
+  }
+  async loadOrderedBundles(tenantId, ids) {
+    const stored = await this.deps.bundleStore.getManyByIds(tenantId, ids) ?? [];
+    const byId = new Map(stored.map((value) => [value.id, value]));
+    return ids.map((id) => {
+      const value = byId.get(id);
+      if (!value) throw new CapabilityBundleServiceError("BUNDLE_NOT_FOUND", "Capability bundle not found", 404);
+      (0, import_core41.validateCapabilityBundleInput)(value);
+      return value;
+    });
+  }
+  compose(project, ids, bundles) {
+    const valid = [];
+    const errors = [];
+    const byId = new Map(bundles.map((bundle) => [bundle.id, bundle]));
+    for (const id of ids) {
+      const bundle = byId.get(id);
+      if (!bundle) {
+        errors.push({ code: "BUNDLE_NOT_FOUND", message: `Persisted capability bundle '${id}' is missing`, bundleId: id });
+        continue;
+      }
+      try {
+        (0, import_core41.validateCapabilityBundleInput)(bundle);
+        valid.push(bundle);
+      } catch (error) {
+        errors.push({ ...issue(error), bundleId: id });
+      }
+    }
+    let preview;
+    try {
+      preview = (0, import_core41.mergeCapabilityBundles)(valid);
+    } catch (error) {
+      preview = { bundleIds: ids, capabilities: [], overrides: [], sources: [], warnings: [], errors: [issue(error)], revision: "" };
+    }
+    preview = { ...preview, bundleIds: ids, errors: [...errors, ...preview.errors] };
+    return { project, persistedBundleIds: ids, bundles: valid, preview };
+  }
+};
+
+// src/controllers/capability-bundles.ts
+init_Logger();
+var logger3 = new Logger({ serviceName: "lattice/gateway/capability-bundles" });
+var capability = import_zod7.z.unknown();
+var createSchema = import_zod7.z.object({ name: import_zod7.z.string(), description: import_zod7.z.string().optional(), capabilities: import_zod7.z.array(capability) }).strict();
+var updateSchema = createSchema.partial().extend({ expectedUpdatedAt: import_zod7.z.string().optional() });
+var bundleIdSchema = import_zod7.z.string().uuid();
+var bundleParamsSchema = import_zod7.z.object({ bundleId: bundleIdSchema });
+var projectSchema = import_zod7.z.object({ bundleIds: import_zod7.z.array(bundleIdSchema), expectedRevisions: import_zod7.z.record(import_zod7.z.string()).optional() }).strict();
+function tenant(request, authRequired2) {
+  const authenticated = request.user?.tenantId;
+  const header = request.headers["x-tenant-id"];
+  const requested = Array.isArray(header) ? header[0] : header;
+  if (authenticated) {
+    if (requested && requested !== authenticated) throw new CapabilityBundleServiceError("INVALID_INPUT", "Forbidden", 403);
+    return authenticated;
+  }
+  if (authRequired2) throw new CapabilityBundleServiceError("INVALID_INPUT", "Unauthorized", 401);
+  return requested || "default";
+}
+function sendError(reply, error) {
+  if (error instanceof CapabilityBundleServiceError) return reply.status(error.statusCode).send({ success: false, code: error.code, message: error.message });
+  if (error instanceof Error && error.name === "CapabilityBundleValidationError") {
+    const validationError = error;
+    const code = validationError.code === "CAPABILITY_BUNDLE_INELIGIBLE_CAPABILITY" ? "BUNDLE_PLUGIN_NOT_ELIGIBLE" : validationError.code === "CAPABILITY_BUNDLE_CREDENTIALS_FORBIDDEN" || validationError.code === "CAPABILITY_BUNDLE_INVALID_CONFIG" ? "INVALID_BUNDLE_CONFIG" : validationError.code;
+    return reply.status(400).send({ success: false, code, message: error.message, capabilityType: validationError.capabilityType, fieldPath: validationError.fieldPath });
+  }
+  logger3.error("Capability bundle controller error", { error: error instanceof Error ? error : new Error(String(error)) });
+  return reply.status(500).send({ success: false, code: "INTERNAL_ERROR", message: "Internal server error" });
+}
+var CapabilityBundleController = class {
+  constructor(deps, options = {}) {
+    this.service = new CapabilityBundleService(deps);
+    this.authRequired = options.authRequired ?? true;
+  }
+  async listBundles(request, reply) {
+    try {
+      const result = await this.service.list(tenant(request, this.authRequired));
+      return reply.send({ success: true, data: result.bundles, errors: result.errors });
+    } catch (error) {
+      return sendError(reply, error);
+    }
+  }
+  async getBundle(request, reply) {
+    try {
+      const tenantId = tenant(request, this.authRequired);
+      const parsed = bundleParamsSchema.safeParse(request.params);
+      if (!parsed.success) return reply.status(400).send({ success: false, code: "INVALID_INPUT", message: "Invalid capability bundle ID" });
+      return reply.send({ success: true, data: await this.service.get(tenantId, parsed.data.bundleId) });
+    } catch (error) {
+      return sendError(reply, error);
+    }
+  }
+  async createBundle(request, reply) {
+    try {
+      const tenantId = tenant(request, this.authRequired);
+      const parsed = createSchema.safeParse(request.body);
+      if (!parsed.success) return reply.status(400).send({ success: false, code: "INVALID_INPUT", message: "Invalid capability bundle body" });
+      return reply.status(201).send({ success: true, data: await this.service.create(tenantId, parsed.data) });
+    } catch (error) {
+      return sendError(reply, error);
+    }
+  }
+  async updateBundle(request, reply) {
+    try {
+      const tenantId = tenant(request, this.authRequired);
+      const params = bundleParamsSchema.safeParse(request.params);
+      const parsed = updateSchema.safeParse(request.body);
+      if (!params.success || !parsed.success) return reply.status(400).send({ success: false, code: "INVALID_INPUT", message: "Invalid capability bundle request" });
+      return reply.send({ success: true, data: await this.service.update(tenantId, params.data.bundleId, parsed.data) });
+    } catch (error) {
+      return sendError(reply, error);
+    }
+  }
+  async deleteBundle(request, reply) {
+    try {
+      const tenantId = tenant(request, this.authRequired);
+      const parsed = bundleParamsSchema.safeParse(request.params);
+      if (!parsed.success) return reply.status(400).send({ success: false, code: "INVALID_INPUT", message: "Invalid capability bundle ID" });
+      await this.service.remove(tenantId, parsed.data.bundleId);
+      return reply.send({ success: true, data: null });
+    } catch (error) {
+      return sendError(reply, error);
+    }
+  }
+  async updateProjectBundles(request, reply) {
+    try {
+      const tenantId = tenant(request, this.authRequired);
+      const parsed = projectSchema.safeParse(request.body);
+      if (!parsed.success) return reply.status(400).send({ success: false, code: "INVALID_INPUT", message: "Invalid project capability bundle body" });
+      const result = await this.service.project(tenantId, request.params.projectId, parsed.data.bundleIds, true, parsed.data.expectedRevisions);
+      return reply.send({ success: true, data: { project: result.project, persistedBundleIds: result.persistedBundleIds, bundles: result.bundles, preview: result.preview } });
+    } catch (error) {
+      return sendError(reply, error);
+    }
+  }
+  async getProjectBundles(request, reply) {
+    try {
+      const result = await this.service.getProjectBundles(tenant(request, this.authRequired), request.params.projectId);
+      if (result.preview.errors.some((issue2) => issue2.code === "CAPABILITY_BUNDLE_CREDENTIALS_FORBIDDEN")) return reply.status(400).send({ success: false, code: "INVALID_BUNDLE_CONFIG", message: "Capability bundle record is invalid" });
+      return reply.send({ success: true, data: { project: result.project, persistedBundleIds: result.persistedBundleIds, bundles: result.bundles, preview: result.preview } });
+    } catch (error) {
+      return sendError(reply, error);
+    }
+  }
+  async getProjectPreview(request, reply) {
+    try {
+      const preview = await this.service.previewProject(tenant(request, this.authRequired), request.params.projectId);
+      return reply.send({ success: true, data: preview });
+    } catch (error) {
+      return sendError(reply, error);
+    }
+  }
+  async postProjectPreview(request, reply) {
+    try {
+      const tenantId = tenant(request, this.authRequired);
+      const parsed = projectSchema.safeParse(request.body);
+      if (!parsed.success) return reply.status(400).send({ success: false, code: "INVALID_INPUT", message: "Invalid project capability bundle body" });
+      const result = await this.service.project(tenantId, request.params.projectId, parsed.data.bundleIds, false);
+      return reply.send({ success: true, data: result.preview });
+    } catch (error) {
+      return sendError(reply, error);
+    }
+  }
+};
+function registerCapabilityBundleRoutes(app2, controller) {
+  app2.get("/api/capability-bundles", controller.listBundles.bind(controller));
+  app2.post("/api/capability-bundles", controller.createBundle.bind(controller));
+  app2.get("/api/capability-bundles/:bundleId", controller.getBundle.bind(controller));
+  app2.put("/api/capability-bundles/:bundleId", controller.updateBundle.bind(controller));
+  app2.delete("/api/capability-bundles/:bundleId", controller.deleteBundle.bind(controller));
+  app2.get("/api/projects/:projectId/capability-bundles", controller.getProjectBundles.bind(controller));
+  app2.put("/api/projects/:projectId/capability-bundles", controller.updateProjectBundles.bind(controller));
+  app2.get("/api/projects/:projectId/capability-preview", controller.getProjectPreview.bind(controller));
+  app2.post("/api/projects/:projectId/capability-preview", controller.postProjectPreview.bind(controller));
+}
+
+// src/routes/index.ts
 var registerLatticeRoutes = (app2, channelDeps) => {
-  const webAppStore = (0, import_core41.getStoreLattice)("default", "agentWebApp").store;
-  const assistantStore = (0, import_core41.getStoreLattice)("default", "assistant").store;
-  const projectStore = (0, import_core41.getStoreLattice)("default", "project").store;
+  const webAppStore = (0, import_core42.getStoreLattice)("default", "agentWebApp").store;
+  const assistantStore = (0, import_core42.getStoreLattice)("default", "assistant").store;
+  const projectStore = (0, import_core42.getStoreLattice)("default", "project").store;
+  registerCapabilityBundleRoutes(app2, new CapabilityBundleController({
+    bundleStore: (0, import_core42.getStoreLattice)("default", "capabilityBundle").store,
+    projectStore
+  }, { authRequired: process.env.AUTH_REQUIRED === "true" }));
   registerAgentWebAppRoutes(app2, {
     service: new AgentWebAppService({
       webAppStore,
       assistantStore,
       projectStore,
-      modelRegistry: { has: (key) => import_core41.modelLatticeManager.hasLattice(key) },
+      modelRegistry: { has: (key) => import_core42.modelLatticeManager.hasLattice(key) },
       configuredAgentResolver: createConfiguredAgentResolver({
-        hydrate: (tenantId) => import_core41.agentLatticeManager.initializeStoredAssistantsForTenant(tenantId),
-        has: (tenantId, assistantId) => import_core41.agentLatticeManager.hasAgentLatticeWithTenant(tenantId, assistantId)
+        hydrate: (tenantId) => import_core42.agentLatticeManager.initializeStoredAssistantsForTenant(tenantId),
+        has: (tenantId, assistantId) => import_core42.agentLatticeManager.hasAgentLatticeWithTenant(tenantId, assistantId)
       })
     })
   });
   registerAgentWebAppRuntimeRoutes(app2, {
     service: new AgentWebAppRuntimeService({
       webAppStore,
-      threadStore: (0, import_core41.getStoreLattice)("default", "thread").store,
+      threadStore: (0, import_core42.getStoreLattice)("default", "thread").store,
       projectStore,
       assistantResolver: {
         resolve: async (tenantId, assistantId) => {
           const stored = await assistantStore.getAssistantById(tenantId, assistantId);
           if (stored) return stored;
-          await import_core41.agentLatticeManager.initializeStoredAssistantsForTenant(tenantId);
-          const config = import_core41.agentLatticeManager.getAgentConfigWithTenant(tenantId, assistantId);
+          await import_core42.agentLatticeManager.initializeStoredAssistantsForTenant(tenantId);
+          const config = import_core42.agentLatticeManager.getAgentConfigWithTenant(tenantId, assistantId);
           return config ? { id: assistantId, name: config.name, description: config.description } : null;
         }
       },
       modelRegistry: {
-        has: (key) => import_core41.modelLatticeManager.hasLattice(key),
+        has: (key) => import_core42.modelLatticeManager.hasLattice(key),
         label: (key) => key
       },
       messageReader: {
-        getCurrentMessages: ({ tenantId, assistantId, threadId, workspaceId, projectId }) => import_core41.agentInstanceManager.getAgent({
+        getCurrentMessages: ({ tenantId, assistantId, threadId, workspaceId, projectId }) => import_core42.agentInstanceManager.getAgent({
           tenant_id: tenantId,
           assistant_id: assistantId,
           thread_id: threadId,
@@ -14461,7 +14920,7 @@ var registerLatticeRoutes = (app2, channelDeps) => {
         }).getCurrentMessages()
       },
       agentResolver: {
-        getAgent: ({ tenantId, assistantId, threadId, workspaceId, projectId }) => import_core41.agentInstanceManager.getAgent({
+        getAgent: ({ tenantId, assistantId, threadId, workspaceId, projectId }) => import_core42.agentInstanceManager.getAgent({
           tenant_id: tenantId,
           assistant_id: assistantId,
           thread_id: threadId,
@@ -14479,8 +14938,8 @@ var registerLatticeRoutes = (app2, channelDeps) => {
         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_core41.agentLatticeManager.initializeStoredAssistantsForTenant(preview.tenantId);
-        return import_core41.agentLatticeManager.hasAgentLatticeWithTenant(preview.tenantId, webApp.assistantId);
+        await import_core42.agentLatticeManager.initializeStoredAssistantsForTenant(preview.tenantId);
+        return import_core42.agentLatticeManager.hasAgentLatticeWithTenant(preview.tenantId, webApp.assistantId);
       }
     })
   });
@@ -14780,12 +15239,12 @@ function registerResourceRoutes(app2, controller) {
 }
 
 // src/export_registrations/index.ts
-var import_core52 = require("@axiom-lattice/core");
+var import_core53 = require("@axiom-lattice/core");
 
 // src/export_registrations/skill.registration.ts
-var import_core42 = require("@axiom-lattice/core");
+var import_core43 = require("@axiom-lattice/core");
 function getStore2(context) {
-  return new import_core42.SandboxSkillStore({
+  return new import_core43.SandboxSkillStore({
     workspaceId: context?.workspaceId,
     projectId: context?.projectId
   });
@@ -14803,7 +15262,7 @@ var skillRegistration = {
   async listForExport(tenantId, context) {
     const store2 = getStore2(context);
     const skills = await store2.getAllSkills(tenantId, toStoreContext(context));
-    return skills.filter((s) => !(0, import_core42.isBuiltInSkill)(s.id)).map((s) => ({
+    return skills.filter((s) => !(0, import_core43.isBuiltInSkill)(s.id)).map((s) => ({
       _exportId: "",
       data: {
         id: s.id,
@@ -14868,7 +15327,7 @@ var skillRegistration = {
     const insertions = [];
     for (const entity of entities) {
       const id = entity.data.id;
-      if ((0, import_core42.isBuiltInSkill)(id)) continue;
+      if ((0, import_core43.isBuiltInSkill)(id)) continue;
       if (existingIds.has(id)) {
         conflicts.push({
           _exportId: entity._exportId,
@@ -14927,9 +15386,9 @@ var skillRegistration = {
 };
 
 // src/export_registrations/agent.registration.ts
-var import_core43 = require("@axiom-lattice/core");
+var import_core44 = require("@axiom-lattice/core");
 function getStore3() {
-  return (0, import_core43.getStoreLattice)("default", "assistant").store;
+  return (0, import_core44.getStoreLattice)("default", "assistant").store;
 }
 var agentRegistration = {
   entityType: "agent",
@@ -15009,9 +15468,9 @@ var agentRegistration = {
 };
 
 // src/export_registrations/database-config.registration.ts
-var import_core44 = require("@axiom-lattice/core");
+var import_core45 = require("@axiom-lattice/core");
 function getStore4() {
-  return (0, import_core44.getStoreLattice)("default", "database").store;
+  return (0, import_core45.getStoreLattice)("default", "database").store;
 }
 var databaseConfigRegistration = {
   entityType: "database_config",
@@ -15091,9 +15550,9 @@ var databaseConfigRegistration = {
 };
 
 // src/export_registrations/metrics-config.registration.ts
-var import_core45 = require("@axiom-lattice/core");
+var import_core46 = require("@axiom-lattice/core");
 function getStore5() {
-  return (0, import_core45.getStoreLattice)("default", "metrics").store;
+  return (0, import_core46.getStoreLattice)("default", "metrics").store;
 }
 var metricsConfigRegistration = {
   entityType: "metrics_config",
@@ -15173,9 +15632,9 @@ var metricsConfigRegistration = {
 };
 
 // src/export_registrations/mcp-config.registration.ts
-var import_core46 = require("@axiom-lattice/core");
+var import_core47 = require("@axiom-lattice/core");
 function getStore6() {
-  return (0, import_core46.getStoreLattice)("default", "mcp").store;
+  return (0, import_core47.getStoreLattice)("default", "mcp").store;
 }
 var mcpConfigRegistration = {
   entityType: "mcp_config",
@@ -15258,9 +15717,9 @@ var mcpConfigRegistration = {
 };
 
 // src/export_registrations/connection.registration.ts
-var import_core47 = require("@axiom-lattice/core");
+var import_core48 = require("@axiom-lattice/core");
 function getStore7() {
-  return (0, import_core47.getStoreLattice)("default", "connection").store;
+  return (0, import_core48.getStoreLattice)("default", "connection").store;
 }
 async function listAllConnections(tenantId) {
   const store2 = getStore7();
@@ -15342,9 +15801,9 @@ var connectionRegistration = {
 };
 
 // src/export_registrations/collection.registration.ts
-var import_core48 = require("@axiom-lattice/core");
+var import_core49 = require("@axiom-lattice/core");
 function getStore8() {
-  return (0, import_core48.getStoreLattice)("default", "collection").store;
+  return (0, import_core49.getStoreLattice)("default", "collection").store;
 }
 var collectionRegistration = {
   entityType: "collection",
@@ -15415,11 +15874,11 @@ var collectionRegistration = {
 };
 
 // src/export_registrations/channel-installation.registration.ts
-var import_core49 = require("@axiom-lattice/core");
+var import_core50 = require("@axiom-lattice/core");
 var import_crypto10 = require("crypto");
 var UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
 function getStore9() {
-  return (0, import_core49.getStoreLattice)("default", "channelInstallation").store;
+  return (0, import_core50.getStoreLattice)("default", "channelInstallation").store;
 }
 var channelInstallationRegistration = {
   entityType: "channel_installation",
@@ -15518,9 +15977,9 @@ var channelInstallationRegistration = {
 };
 
 // src/export_registrations/menu.registration.ts
-var import_core50 = require("@axiom-lattice/core");
+var import_core51 = require("@axiom-lattice/core");
 function getStore10() {
-  return (0, import_core50.getStoreLattice)("default", "menu").store;
+  return (0, import_core51.getStoreLattice)("default", "menu").store;
 }
 var menuRegistration = {
   entityType: "menu",
@@ -15598,9 +16057,9 @@ var menuRegistration = {
 };
 
 // src/export_registrations/eval.registration.ts
-var import_core51 = require("@axiom-lattice/core");
+var import_core52 = require("@axiom-lattice/core");
 function getStore11() {
-  return (0, import_core51.getStoreLattice)("default", "eval").store;
+  return (0, import_core52.getStoreLattice)("default", "eval").store;
 }
 var evalRegistration = {
   entityType: "eval",
@@ -15926,7 +16385,7 @@ var evalRegistration = {
 
 // src/export_registrations/index.ts
 function registerAllBuiltinEntities() {
-  const registry = import_core52.ExportableEntityRegistry.getInstance();
+  const registry = import_core53.ExportableEntityRegistry.getInstance();
   registry.register(skillRegistration);
   registry.register(agentRegistration);
   registry.register(databaseConfigRegistration);
@@ -15940,7 +16399,7 @@ function registerAllBuiltinEntities() {
 }
 
 // src/router/MessageRouter.ts
-var import_core53 = require("@axiom-lattice/core");
+var import_core54 = require("@axiom-lattice/core");
 var import_crypto11 = require("crypto");
 var BindingNotFoundError = class extends Error {
   constructor(message) {
@@ -16110,7 +16569,7 @@ var MessageRouter = class {
             channel: message.channel,
             adapterChannel: adapter.channel
           }, "Thread resolved by adapter strategy");
-          const threadStore = (0, import_core53.getStoreLattice)("default", "thread").store;
+          const threadStore = (0, import_core54.getStoreLattice)("default", "thread").store;
           try {
             await threadStore.createThread(
               tenantId,
@@ -16147,7 +16606,7 @@ var MessageRouter = class {
           }
         }
         if (!threadId) {
-          const threadStore = (0, import_core53.getStoreLattice)("default", "thread").store;
+          const threadStore = (0, import_core54.getStoreLattice)("default", "thread").store;
           const newThreadId = (0, import_crypto11.randomUUID)();
           console.log({
             event: "dispatch:thread:create",
@@ -16187,7 +16646,7 @@ var MessageRouter = class {
           senderId: message.sender.id,
           contentLength: message.content.text.length
         }, "Dispatching to agent");
-        const agent = import_core53.agentInstanceManager.getAgent({
+        const agent = import_core54.agentInstanceManager.getAgent({
           tenant_id: tenantId,
           assistant_id: agentId,
           thread_id: threadId,
@@ -16395,13 +16854,13 @@ function createRateLimitMiddleware(maxRequests = 10, windowMs = 60 * 1e3, maxEnt
 
 // src/router/middlewares/auditLogger.ts
 init_Logger();
-var logger3 = new Logger({ serviceName: "lattice/gateway/audit" });
+var logger4 = new Logger({ serviceName: "lattice/gateway/audit" });
 function createAuditLoggerMiddleware() {
   return async (ctx, next) => {
     const start2 = Date.now();
     try {
       await next();
-      logger3.info("message routed", {
+      logger4.info("message routed", {
         event: "message:routed",
         channel: ctx.inboundMessage.channel,
         senderId: ctx.inboundMessage.sender.id,
@@ -16411,7 +16870,7 @@ function createAuditLoggerMiddleware() {
         status: "success"
       });
     } catch (error) {
-      logger3.error(
+      logger4.error(
         error instanceof Error ? error.message : String(error),
         {
           event: "message:error",
@@ -16427,7 +16886,7 @@ function createAuditLoggerMiddleware() {
 }
 
 // src/index.ts
-var import_core58 = require("@axiom-lattice/core");
+var import_core59 = require("@axiom-lattice/core");
 
 // src/swagger.ts
 var import_swagger = __toESM(require("@fastify/swagger"));
@@ -16492,7 +16951,7 @@ var configureSwagger = async (app2, customSwaggerConfig, customSwaggerUiConfig)
 };
 
 // src/services/agent_task_consumer.ts
-var import_core54 = require("@axiom-lattice/core");
+var import_core55 = require("@axiom-lattice/core");
 var handleAgentTask = async (taskRequest, retryCount = 0) => {
   const {
     assistant_id,
@@ -16510,17 +16969,17 @@ var handleAgentTask = async (taskRequest, retryCount = 0) => {
     console.log(
       `\u5F00\u59CB\u5904\u7406\u4EFB\u52A1 [assistant_id: ${assistant_id}, thread_id: ${thread_id}]`
     );
-    const agent = import_core54.agentInstanceManager.getAgent({ assistant_id, thread_id, tenant_id, workspace_id: runConfig?.workspaceId, project_id: runConfig?.projectId, custom_run_config: runConfig });
-    await agent.addMessage({ input, command, custom_run_config: runConfig }, import_core54.QueueMode.STEER);
+    const agent = import_core55.agentInstanceManager.getAgent({ assistant_id, thread_id, tenant_id, workspace_id: runConfig?.workspaceId, project_id: runConfig?.projectId, custom_run_config: runConfig });
+    await agent.addMessage({ input, command, custom_run_config: runConfig }, import_core55.QueueMode.STEER);
     if (callback_event) {
       agent.subscribeOnce("message:completed", (evt) => {
-        import_core54.eventBus.publish(callback_event, {
+        import_core55.eventBus.publish(callback_event, {
           success: true,
           state: evt.state
         });
         if (main_thread_id && main_tenant_id) {
           try {
-            const mainAgent = import_core54.agentInstanceManager.getAgent({
+            const mainAgent = import_core55.agentInstanceManager.getAgent({
               assistant_id: main_assistant_id ?? assistant_id,
               thread_id: main_thread_id,
               tenant_id: main_tenant_id,
@@ -16550,7 +17009,7 @@ ${summary}`
         }
       });
       agent.subscribeOnce("message:interrupted", (evt) => {
-        import_core54.eventBus.publish(callback_event, {
+        import_core55.eventBus.publish(callback_event, {
           success: true,
           state: evt.state
         });
@@ -16573,7 +17032,7 @@ ${summary}`
       return handleAgentTask(taskRequest, nextRetryCount);
     }
     if (callback_event) {
-      import_core54.eventBus.publish(callback_event, {
+      import_core55.eventBus.publish(callback_event, {
         success: false,
         error: error instanceof Error ? error.message : String(error)
       });
@@ -16610,7 +17069,7 @@ var _AgentTaskConsumer = class _AgentTaskConsumer {
    * 初始化事件监听和队列轮询
    */
   initialize() {
-    import_core54.eventBus.subscribe(import_core54.AGENT_TASK_EVENT, this.trigger_agent_task.bind(this));
+    import_core55.eventBus.subscribe(import_core55.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");
   }
@@ -16729,7 +17188,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_core54.eventBus.publish(taskRequest.callback_event, {
+        import_core55.eventBus.publish(taskRequest.callback_event, {
           success: false,
           error: error instanceof Error ? error.message : String(error)
         });
@@ -16744,7 +17203,7 @@ _AgentTaskConsumer.agent_run_endpoint = "http://localhost:4001/api/runs";
 var AgentTaskConsumer = _AgentTaskConsumer;
 
 // src/index.ts
-var import_core59 = require("@axiom-lattice/core");
+var import_core60 = require("@axiom-lattice/core");
 var import_protocols9 = require("@axiom-lattice/protocols");
 var import_meta = {};
 process.on("unhandledRejection", (reason, promise) => {
@@ -16758,13 +17217,13 @@ var DEFAULT_LOGGER_CONFIG = {
   loggerName: "lattice/gateway"
 };
 var loggerLattice = initializeLogger(DEFAULT_LOGGER_CONFIG);
-var logger5 = loggerLattice.client;
+var logger6 = loggerLattice.client;
 function initializeLogger(config) {
-  if (import_core59.loggerLatticeManager.hasLattice("default")) {
-    import_core59.loggerLatticeManager.removeLattice("default");
+  if (import_core60.loggerLatticeManager.hasLattice("default")) {
+    import_core60.loggerLatticeManager.removeLattice("default");
   }
-  (0, import_core59.registerLoggerLattice)("default", config);
-  return (0, import_core59.getLoggerLattice)("default");
+  (0, import_core60.registerLoggerLattice)("default", config);
+  return (0, import_core60.getLoggerLattice)("default");
 }
 var app = (0, import_fastify.default)({
   logger: false,
@@ -16791,7 +17250,9 @@ var getHeaderValue = (header) => {
 var authRequired = process.env.AUTH_REQUIRED === "true";
 registerConsoleAuthHook(app, { authRequired });
 app.addHook("onRequest", (request, reply, done) => {
-  if (!request.headers["x-project-id"]) {
+  const requestPath = request.url.split("?", 1)[0];
+  const isAgentRunRequest = requestPath === "/api/runs" || requestPath === "/api/resume_stream" || requestPath.includes("/threads/") && requestPath.endsWith("/recover");
+  if (!request.headers["x-project-id"] && !isAgentRunRequest) {
     request.headers["x-project-id"] = "default";
   }
   done();
@@ -16841,7 +17302,7 @@ app.setErrorHandler((error, request, reply) => {
     "x-request-id": getHeaderValue(request.headers["x-request-id"]),
     "x-user-id": getHeaderValue(request.headers["x-user-id"])
   };
-  logger5.error(
+  logger6.error(
     `\u8BF7\u6C42\u9519\u8BEF: ${request.method} ${request.url} error:${error.message}`,
     {
       ...context,
@@ -16857,7 +17318,7 @@ app.setErrorHandler((error, request, reply) => {
 });
 function getConfiguredSandboxProvider() {
   const sandboxProviderType = process.env.SANDBOX_PROVIDER_TYPE || "microsandbox-remote";
-  return (0, import_core59.createSandboxProvider)({
+  return (0, import_core60.createSandboxProvider)({
     type: sandboxProviderType,
     remoteBaseURL: process.env.SANDBOX_BASE_URL,
     microsandboxServiceBaseURL: process.env.MICROSANDBOX_SERVICE_BASE_URL,
@@ -16873,37 +17334,37 @@ function getConfiguredSandboxProvider() {
 }
 async function restoreMcpConnections() {
   try {
-    const storeLattice = (0, import_core59.getStoreLattice)("default", "mcp");
+    const storeLattice = (0, import_core60.getStoreLattice)("default", "mcp");
     const store2 = storeLattice.store;
     if (!store2) {
-      logger5.info("MCP store not configured, skipping connection restoration");
+      logger6.info("MCP store not configured, skipping connection restoration");
       return;
     }
     const configs = await store2.getAllConfigs("default");
     const connectedConfigs = configs.filter((c2) => c2.status === "connected");
     if (connectedConfigs.length === 0) return;
-    logger5.info(`Restoring ${connectedConfigs.length} MCP server connections...`);
+    logger6.info(`Restoring ${connectedConfigs.length} MCP server connections...`);
     const { convertToConnection: convertToConnection2 } = await Promise.resolve().then(() => (init_mcp_configs(), mcp_configs_exports));
     for (const config of connectedConfigs) {
       try {
         const connection = convertToConnection2(config.config);
-        import_core59.mcpManager.addServer(config.key, connection);
+        import_core60.mcpManager.addServer(config.key, connection);
       } catch (err) {
-        logger5.warn(`Failed to prepare MCP server "${config.key}" for restoration`, { error: err });
+        logger6.warn(`Failed to prepare MCP server "${config.key}" for restoration`, { error: err });
       }
     }
-    await import_core59.mcpManager.connect();
+    await import_core60.mcpManager.connect();
     for (const config of connectedConfigs) {
       try {
-        await import_core59.mcpManager.registerToolsToToolLattice(config.key, config.selectedTools);
-        logger5.info(`MCP server "${config.key}" restored with ${config.selectedTools.length} tools`);
+        await import_core60.mcpManager.registerToolsToToolLattice(config.key, config.selectedTools);
+        logger6.info(`MCP server "${config.key}" restored with ${config.selectedTools.length} tools`);
       } catch (err) {
-        logger5.warn(`Failed to register tools for MCP server "${config.key}"`, { error: err });
+        logger6.warn(`Failed to register tools for MCP server "${config.key}"`, { error: err });
       }
     }
-    logger5.info(`MCP connection restoration complete: ${connectedConfigs.length} servers`);
+    logger6.info(`MCP connection restoration complete: ${connectedConfigs.length} servers`);
   } catch (err) {
-    logger5.error("MCP connection restoration failed", { error: err });
+    logger6.error("MCP connection restoration failed", { error: err });
   }
 }
 var start = async (config) => {
@@ -16916,7 +17377,7 @@ var start = async (config) => {
         file: config.loggerConfig.file || DEFAULT_LOGGER_CONFIG.file
       };
       loggerLattice = initializeLogger(loggerConfig);
-      logger5 = loggerLattice.client;
+      logger6 = loggerLattice.client;
     }
     app.decorate("loggerLattice", loggerLattice);
     let channelDeps;
@@ -16928,7 +17389,7 @@ var start = async (config) => {
       const { getStoreLattice: getStore12 } = await import("@axiom-lattice/core");
       const bindingStore = getStore12("default", "channelBinding").store;
       const installationStore = getStore12("default", "channelInstallation").store;
-      (0, import_core58.setBindingRegistry)(bindingStore);
+      (0, import_core59.setBindingRegistry)(bindingStore);
       const router = new MessageRouter({
         middlewares: [
           createDeduplicationMiddleware(),
@@ -16941,15 +17402,15 @@ var start = async (config) => {
       });
       channelDeps = { router, installationStore };
     } catch (err) {
-      logger5.warn("Channel infrastructure unavailable", {
+      logger6.warn("Channel infrastructure unavailable", {
         error: err instanceof Error ? err.message : String(err)
       });
     }
-    (0, import_core58.setEvalRunService)(evalRunner);
+    (0, import_core59.setEvalRunService)(evalRunner);
     try {
-      const menuStore = (0, import_core59.getStoreLattice)("default", "menu").store;
-      (0, import_core58.setMenuRegistry)(menuStore);
-      logger5.info("Menu registry initialized");
+      const menuStore = (0, import_core60.getStoreLattice)("default", "menu").store;
+      (0, import_core59.setMenuRegistry)(menuStore);
+      logger6.info("Menu registry initialized");
     } catch {
     }
     registerAllBuiltinEntities();
@@ -16961,10 +17422,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_core59.getStoreLattice)("default", "a2aApiKey").store;
-      const assistantStore = (0, import_core59.getStoreLattice)("default", "assistant").store;
-      const projectStore = (0, import_core59.getStoreLattice)("default", "project").store;
-      const taskStore = (0, import_core59.getStoreLattice)("default", "task").store;
+      const a2aKeyStore = (0, import_core60.getStoreLattice)("default", "a2aApiKey").store;
+      const assistantStore = (0, import_core60.getStoreLattice)("default", "assistant").store;
+      const projectStore = (0, import_core60.getStoreLattice)("default", "project").store;
+      const taskStore = (0, import_core60.getStoreLattice)("default", "task").store;
       const authService = new A2AAuthService2({
         keyStore: a2aKeyStore,
         assistantStore,
@@ -16982,30 +17443,30 @@ var start = async (config) => {
         getProjectStore: () => projectStore
       });
       a2a.registerA2ARoutes(app);
-      logger5.info("A2A standard routes registered");
+      logger6.info("A2A standard routes registered");
     } catch (err) {
-      logger5.warn("A2A standard routes unavailable", {
+      logger6.warn("A2A standard routes unavailable", {
         error: err instanceof Error ? err.message : String(err)
       });
     }
-    if (!import_core59.sandboxLatticeManager.hasLattice("default")) {
-      import_core59.sandboxLatticeManager.registerLattice("default", getConfiguredSandboxProvider());
-      logger5.info("Registered sandbox manager from env configuration");
+    if (!import_core60.sandboxLatticeManager.hasLattice("default")) {
+      import_core60.sandboxLatticeManager.registerLattice("default", getConfiguredSandboxProvider());
+      logger6.info("Registered sandbox manager from env configuration");
     }
     try {
       const { ResourceController: ResourceController2 } = await Promise.resolve().then(() => (init_resources(), resources_exports));
-      const sharedResourceStore = (0, import_core59.getStoreLattice)("default", "sharedResource").store;
-      const cache = new import_core59.TokenCache();
+      const sharedResourceStore = (0, import_core60.getStoreLattice)("default", "sharedResource").store;
+      const cache = new import_core60.TokenCache();
       const resourceController = new ResourceController2({
         store: sharedResourceStore,
-        sandboxManager: import_core59.sandboxLatticeManager,
+        sandboxManager: import_core60.sandboxLatticeManager,
         cache,
-        logger: logger5
+        logger: logger6
       });
       registerResourceRoutes(app, resourceController);
-      logger5.info("Resource share routes registered");
+      logger6.info("Resource share routes registered");
     } catch (err) {
-      logger5.warn("Resource share infrastructure unavailable", {
+      logger6.warn("Resource share infrastructure unavailable", {
         error: err instanceof Error ? err.message : String(err)
       });
     }
@@ -17017,14 +17478,14 @@ var start = async (config) => {
           { deps: { router: channelDeps.router } }
         );
       } catch (err) {
-        logger5.error("Failed to start channel connections", {
+        logger6.error("Failed to start channel connections", {
           error: err instanceof Error ? err.message : String(err)
         });
       }
     }
     const target_port = config?.port || Number(process.env.PORT) || 4001;
     await app.listen({ port: target_port, host: "0.0.0.0" });
-    logger5.info(`Lattice Gateway is running on port: ${target_port}`);
+    logger6.info(`Lattice Gateway is running on port: ${target_port}`);
     const queueServiceConfig = config?.queueServiceConfig;
     if (queueServiceConfig) {
       setQueueServiceType(queueServiceConfig.type);
@@ -17034,17 +17495,17 @@ var start = async (config) => {
       }
     }
     if (process.env.AXIOM_RESTORE_PENDING_ON_STARTUP === "true") {
-      import_core59.agentInstanceManager.restore().then((stats) => {
-        logger5.info(`Agent recovery complete: ${stats.restored} threads restored, ${stats.errors} errors`);
+      import_core60.agentInstanceManager.restore().then((stats) => {
+        logger6.info(`Agent recovery complete: ${stats.restored} threads restored, ${stats.errors} errors`);
       }).catch((error) => {
-        logger5.error("Agent recovery failed", { error });
+        logger6.error("Agent recovery failed", { error });
       });
     }
     restoreMcpConnections().catch((error) => {
-      logger5.error("MCP connection restoration failed", { error });
+      logger6.error("MCP connection restoration failed", { error });
     });
   } catch (err) {
-    logger5.error("Server start failed", { error: err });
+    logger6.error("Server start failed", { error: err });
     process.exit(1);
   }
 };