@axiom-lattice/gateway 4.9.2 → 4.10.1

package/dist/index.js

@@ -1731,25 +1731,25 @@ function extractText(msg) {
   }
   return null;
 }
-var import_zod18, logger6, wechatConfigSchema, MAX_RECONNECT_DELAY_MS, BASE_RECONNECT_DELAY_MS, HEARTBEAT_INTERVAL_MS, MSG_TYPE_USER, MSG_ITEM_TEXT, activeConnections2, seenClientIds, wechatChannelAdapter;
+var import_zod19, logger7, wechatConfigSchema, MAX_RECONNECT_DELAY_MS, BASE_RECONNECT_DELAY_MS, HEARTBEAT_INTERVAL_MS, MSG_TYPE_USER, MSG_ITEM_TEXT, activeConnections3, seenClientIds, wechatChannelAdapter;
 var init_WechatChannelAdapter = __esm({
   "src/channels/wechat/WechatChannelAdapter.ts"() {
     "use strict";
-    import_zod18 = require("zod");
+    import_zod19 = require("zod");
     init_wechat_client();
     init_context_store();
     init_Logger();
-    logger6 = new Logger({ serviceName: "lattice/gateway/wechat" });
-    wechatConfigSchema = import_zod18.z.object({
-      botToken: import_zod18.z.string(),
-      uin: import_zod18.z.string().optional()
+    logger7 = new Logger({ serviceName: "lattice/gateway/wechat" });
+    wechatConfigSchema = import_zod19.z.object({
+      botToken: import_zod19.z.string(),
+      uin: import_zod19.z.string().optional()
     });
     MAX_RECONNECT_DELAY_MS = 3e4;
     BASE_RECONNECT_DELAY_MS = 1e3;
     HEARTBEAT_INTERVAL_MS = 6e4;
     MSG_TYPE_USER = 1;
     MSG_ITEM_TEXT = 1;
-    activeConnections2 = /* @__PURE__ */ new Map();
+    activeConnections3 = /* @__PURE__ */ new Map();
     seenClientIds = /* @__PURE__ */ new Set();
     wechatChannelAdapter = {
       channel: "wechat",
@@ -1790,7 +1790,7 @@ var init_WechatChannelAdapter = __esm({
         const senderId = replyTarget.rawTarget.senderId;
         const contextToken = getContextToken(installation.id, senderId);
         if (!contextToken) {
-          logger6.warn("WeChat context token expired, cannot send reply", {
+          logger7.warn("WeChat context token expired, cannot send reply", {
             installationId: installation.id,
             senderId
           });
@@ -1808,24 +1808,24 @@ var init_WechatChannelAdapter = __esm({
       async connect(installation, deps) {
         const { id: installationId, tenantId, config } = installation;
         if (!config.botToken) {
-          logger6.warn("WeChat installation missing botToken, skipping", { installationId });
+          logger7.warn("WeChat installation missing botToken, skipping", { installationId });
           return;
         }
-        if (activeConnections2.has(installationId)) {
-          logger6.warn("WeChat polling already running for installation, skipping", { installationId });
+        if (activeConnections3.has(installationId)) {
+          logger7.warn("WeChat polling already running for installation, skipping", { installationId });
           return;
         }
-        logger6.info("WeChat polling starting", { installationId, tenantId });
+        logger7.info("WeChat polling starting", { installationId, tenantId });
         const abortController = new AbortController();
         const heartbeatTimer = setInterval(() => {
-          const state2 = activeConnections2.get(installationId);
+          const state2 = activeConnections3.get(installationId);
           if (!state2) {
             clearInterval(heartbeatTimer);
             return;
           }
           const elapsed = Date.now() - state2.lastActivity;
           if (elapsed > HEARTBEAT_INTERVAL_MS * 2) {
-            logger6.error("WeChat polling heartbeat lost \u2014 no activity", {
+            logger7.error("WeChat polling heartbeat lost \u2014 no activity", {
               installationId,
               elapsedMs: elapsed
             });
@@ -1838,26 +1838,26 @@ var init_WechatChannelAdapter = __esm({
           lastActivity: Date.now(),
           heartbeatTimer
         };
-        activeConnections2.set(installationId, state);
+        activeConnections3.set(installationId, state);
         const router = deps?.router;
         let syncBuffer = "";
         let reconnectDelay = BASE_RECONNECT_DELAY_MS;
         const scheduleNextPoll = () => {
           poll().catch((err) => {
-            logger6.error("WeChat poll iteration crashed", {
+            logger7.error("WeChat poll iteration crashed", {
               installationId,
               error: err instanceof Error ? err.message : String(err)
             });
-            const currentState = activeConnections2.get(installationId);
+            const currentState = activeConnections3.get(installationId);
             if (currentState && !currentState.abortController.signal.aborted) {
               setTimeout(scheduleNextPoll, reconnectDelay);
             }
           });
         };
         const poll = async () => {
-          const currentState = activeConnections2.get(installationId);
+          const currentState = activeConnections3.get(installationId);
           if (!currentState || currentState.abortController.signal.aborted) {
-            logger6.info("WeChat polling aborted", { installationId });
+            logger7.info("WeChat polling aborted", { installationId });
             return;
           }
           try {
@@ -1870,7 +1870,7 @@ var init_WechatChannelAdapter = __esm({
             reconnectDelay = BASE_RECONNECT_DELAY_MS;
             currentState.lastActivity = Date.now();
             if (result.msgs.length > 0) {
-              logger6.info("WeChat poll received messages", {
+              logger7.info("WeChat poll received messages", {
                 installationId,
                 count: result.msgs.length
               });
@@ -1887,7 +1887,7 @@ var init_WechatChannelAdapter = __esm({
               if (inbound && router) {
                 const dispatchResult = await router.dispatch(inbound);
                 if (!dispatchResult.success) {
-                  logger6.warn("WeChat dispatch failed", {
+                  logger7.warn("WeChat dispatch failed", {
                     installationId,
                     error: dispatchResult.error?.message
                   });
@@ -1896,10 +1896,10 @@ var init_WechatChannelAdapter = __esm({
             }
           } catch (err) {
             if (err instanceof Error && err.name === "AbortError") {
-              logger6.info("WeChat poll aborted by signal", { installationId });
+              logger7.info("WeChat poll aborted by signal", { installationId });
               return;
             }
-            logger6.error("WeChat poll error", {
+            logger7.error("WeChat poll error", {
               installationId,
               error: err instanceof Error ? err.message : String(err)
             });
@@ -1909,19 +1909,19 @@ var init_WechatChannelAdapter = __esm({
           scheduleNextPoll();
         };
         scheduleNextPoll();
-        logger6.info("WeChat polling started", { installationId });
+        logger7.info("WeChat polling started", { installationId });
       },
       async disconnect(installationId) {
-        const state = activeConnections2.get(installationId);
+        const state = activeConnections3.get(installationId);
         if (!state) {
-          logger6.warn("WeChat polling not running, nothing to disconnect", { installationId });
+          logger7.warn("WeChat polling not running, nothing to disconnect", { installationId });
           return;
         }
-        logger6.info("WeChat polling disconnecting", { installationId });
+        logger7.info("WeChat polling disconnecting", { installationId });
         state.abortController.abort();
         clearInterval(state.heartbeatTimer);
-        activeConnections2.delete(installationId);
-        logger6.info("WeChat polling disconnected", { installationId });
+        activeConnections3.delete(installationId);
+        logger7.info("WeChat polling disconnected", { installationId });
       }
     };
   }
@@ -2057,7 +2057,7 @@ function extractFailureReason(task) {
   return extractText2(task.status.message.parts);
 }
 function observationEventKey(task, result, failureReason) {
-  const digest = (0, import_node_crypto30.createHash)("sha256").update(JSON.stringify({
+  const digest = (0, import_node_crypto31.createHash)("sha256").update(JSON.stringify({
     state: task.status.state,
     timestamp: task.status.timestamp,
     message: task.status.message,
@@ -2067,7 +2067,7 @@ function observationEventKey(task, result, failureReason) {
   return `a2a-status-observation:${task.id}:${digest}`;
 }
 function snapshotEventKey(task) {
-  const digest = (0, import_node_crypto30.createHash)("sha256").update(JSON.stringify(task)).digest("hex");
+  const digest = (0, import_node_crypto31.createHash)("sha256").update(JSON.stringify(task)).digest("hex");
   return `a2a-task-snapshot:${task.id}:${digest}`;
 }
 function isGovernedObservation(state) {
@@ -2079,11 +2079,11 @@ function isA2ATaskSnapshot(value) {
 function snapshotSequence(value) {
   return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : void 0;
 }
-var import_node_crypto30, import_node_util, import_core80, TASK_STATUS_TO_A2A_STATE, TITLE_MAX_LENGTH, A2ATaskScopeConflictError, A2ATaskStoreAdapter;
+var import_node_crypto31, import_node_util, import_core80, TASK_STATUS_TO_A2A_STATE, TITLE_MAX_LENGTH, A2ATaskScopeConflictError, A2ATaskStoreAdapter;
 var init_A2ATaskStoreAdapter = __esm({
   "src/services/a2a/A2ATaskStoreAdapter.ts"() {
     "use strict";
-    import_node_crypto30 = require("crypto");
+    import_node_crypto31 = require("crypto");
     import_node_util = require("util");
     import_core80 = require("@axiom-lattice/core");
     TASK_STATUS_TO_A2A_STATE = {
@@ -3601,11 +3601,11 @@ function grantCovers(grants, domain, action) {
     (g) => g.domain === domain && (!g.items || g.items.length === 0 || g.items.includes(action))
   );
 }
-var import_zod19, GrantDeniedError, ValidationError, ActionNotFoundError, OpenLattice, openLattice;
+var import_zod20, GrantDeniedError, ValidationError, ActionNotFoundError, OpenLattice, openLattice;
 var init_openLattice = __esm({
   "src/services/open/openLattice.ts"() {
     "use strict";
-    import_zod19 = require("zod");
+    import_zod20 = require("zod");
     GrantDeniedError = class extends Error {
       constructor(toolName) {
         super(`GRANT_DENIED: no grant covers ${toolName}`);
@@ -3745,7 +3745,7 @@ var init_openLattice = __esm({
           throw new GrantDeniedError(toolName);
         }
         const resolvedSchema = resolved.action.schema;
-        const parsed = "safeParse" in resolvedSchema ? resolvedSchema.safeParse(args) : import_zod19.z.object(resolvedSchema).safeParse(args);
+        const parsed = "safeParse" in resolvedSchema ? resolvedSchema.safeParse(args) : import_zod20.z.object(resolvedSchema).safeParse(args);
         if (!parsed.success) {
           throw new ValidationError(parsed.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; "));
         }
@@ -3878,7 +3878,7 @@ var init_openMcpServer = __esm({
 
 // src/services/open/pluginExposeAdapter.ts
 function schemaOf(tool) {
-  return tool.lc_kwargs?.schema ?? tool.schema ?? import_zod20.z.object({}).passthrough();
+  return tool.lc_kwargs?.schema ?? tool.schema ?? import_zod21.z.object({}).passthrough();
 }
 function createPluginProvider(domain, tools, options = {}) {
   function toAction(info) {
@@ -3926,11 +3926,11 @@ function createPluginProvider(domain, tools, options = {}) {
     }
   };
 }
-var import_zod20;
+var import_zod21;
 var init_pluginExposeAdapter = __esm({
   "src/services/open/pluginExposeAdapter.ts"() {
     "use strict";
-    import_zod20 = require("zod");
+    import_zod21 = require("zod");
   }
 });
 
@@ -4571,21 +4571,21 @@ function createOpenSandboxProvider() {
         name: "files_read",
         label: "Read files",
         description: "Read a file from the project sandbox.",
-        schema: { path: import_zod21.z.string().min(1) },
+        schema: { path: import_zod22.z.string().min(1) },
         annotations: { readOnlyHint: true, destructiveHint: false }
       },
       {
         name: "files_list",
         label: "List files",
         description: "List files under a directory in the project sandbox.",
-        schema: { path: import_zod21.z.string(), recursive: import_zod21.z.boolean().optional() },
+        schema: { path: import_zod22.z.string(), recursive: import_zod22.z.boolean().optional() },
         annotations: { readOnlyHint: true, destructiveHint: false }
       },
       {
         name: "files_write",
         label: "Write files",
         description: "Write content to a file in the project sandbox.",
-        schema: { path: import_zod21.z.string().min(1), content: import_zod21.z.string() },
+        schema: { path: import_zod22.z.string().min(1), content: import_zod22.z.string() },
         annotations: { readOnlyHint: false, destructiveHint: true }
       },
       {
@@ -4593,9 +4593,9 @@ function createOpenSandboxProvider() {
         label: "Run shell commands",
         description: "Execute a shell command in the project sandbox. Returns stdout (up to 64KB) and exit code.",
         schema: {
-          command: import_zod21.z.string().min(1),
-          exec_dir: import_zod21.z.string().optional(),
-          timeout: import_zod21.z.number().int().min(1e3).optional()
+          command: import_zod22.z.string().min(1),
+          exec_dir: import_zod22.z.string().optional(),
+          timeout: import_zod22.z.number().int().min(1e3).optional()
         },
         annotations: { readOnlyHint: false, destructiveHint: true }
       }
@@ -4650,11 +4650,11 @@ ${truncated}`
     }
   };
 }
-var import_zod21, import_core89, MAX_OUTPUT_BYTES;
+var import_zod22, import_core89, MAX_OUTPUT_BYTES;
 var init_sandboxProvider = __esm({
   "src/services/open/providers/sandboxProvider.ts"() {
     "use strict";
-    import_zod21 = require("zod");
+    import_zod22 = require("zod");
     import_core89 = require("@axiom-lattice/core");
     MAX_OUTPUT_BYTES = 64e3;
   }
@@ -4952,9 +4952,9 @@ function createKbProvider(collectionService3) {
         label: "Search collections",
         description: "Search a knowledge base collection. Returns matched entries with content, metadata and similarity score.",
         schema: {
-          collection: import_zod22.z.string().min(1),
-          query: import_zod22.z.string().min(1),
-          limit: import_zod22.z.number().int().min(1).max(50).optional()
+          collection: import_zod23.z.string().min(1),
+          query: import_zod23.z.string().min(1),
+          limit: import_zod23.z.number().int().min(1).max(50).optional()
         },
         annotations: { readOnlyHint: true, destructiveHint: false }
       }
@@ -4982,11 +4982,11 @@ function createKbProvider(collectionService3) {
     }
   };
 }
-var import_zod22;
+var import_zod23;
 var init_kbProvider = __esm({
   "src/services/open/providers/kbProvider.ts"() {
     "use strict";
-    import_zod22 = require("zod");
+    import_zod23 = require("zod");
   }
 });
 
@@ -5024,7 +5024,7 @@ function createAgentProvider(deps = {}) {
             toolName: `invoke_${assistantId}`,
             label: name,
             description: `Invoke the "${name}" agent${description ? ` \u2014 ${description}` : ""}. Returns its final reply.`,
-            schema: { message: import_zod23.z.string().min(1) },
+            schema: { message: import_zod24.z.string().min(1) },
             annotations: { readOnlyHint: false, destructiveHint: false }
           };
         })
@@ -5072,11 +5072,11 @@ function createAgentProvider(deps = {}) {
     }
   };
 }
-var import_zod23, import_core93, import_protocols39, STOP_TYPES;
+var import_zod24, import_core93, import_protocols39, STOP_TYPES;
 var init_agentProvider = __esm({
   "src/services/open/providers/agentProvider.ts"() {
     "use strict";
-    import_zod23 = require("zod");
+    import_zod24 = require("zod");
     import_core93 = require("@axiom-lattice/core");
     import_protocols39 = require("@axiom-lattice/protocols");
     STOP_TYPES = [import_protocols39.MessageChunkTypes.MESSAGE_COMPLETED];
@@ -16375,6 +16375,9 @@ function isLarkConfig(config) {
 function isWechatConfig(config) {
   return isString(config.botToken) && isOptionalString(config.uin);
 }
+function isWecomConfig(config) {
+  return isString(config.botId) && isString(config.secret) && isOptionalString(config.assistantId);
+}
 function snapshotPublicCreateRequest(value) {
   const body = snapshotPlainObject(value);
   const allowedKeys = /* @__PURE__ */ new Set([
@@ -16401,6 +16404,9 @@ function snapshotPublicCreateRequest(value) {
   if (body.channel === "wechat" && isWechatConfig(config)) {
     return { ...base, channel: "wechat", config };
   }
+  if (body.channel === "wecom" && isWecomConfig(config)) {
+    return { ...base, channel: "wecom", config };
+  }
   if (body.channel === "email" || body.channel === "slack") return { ...base, channel: body.channel, config };
   return null;
 }
@@ -16421,6 +16427,7 @@ function snapshotPublicUpdateRequest(value, channel) {
     if (!config) return null;
     if (channel === "lark" && !isLarkConfig(config)) return null;
     if (channel === "wechat" && !isWechatConfig(config)) return null;
+    if (channel === "wecom" && !isWecomConfig(config)) return null;
   }
   return {
     name: body.name,
@@ -16773,7 +16780,7 @@ function registerChannelInstallationRoutes(app2) {
         type: "object",
         additionalProperties: false,
         properties: {
-          channel: { type: "string", enum: ["lark", "email", "slack", "wechat"] }
+          channel: { type: "string", enum: ["lark", "email", "slack", "wechat", "wecom"] }
         }
       }
     }
@@ -30270,7 +30277,7 @@ var collectionRegistration = {
 var import_core66 = 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"]);
+var PUBLIC_CHANNELS = /* @__PURE__ */ new Set(["lark", "email", "slack", "wechat", "wecom"]);
 function isPublicChannel(channel) {
   return typeof channel === "string" && PUBLIC_CHANNELS.has(channel);
 }
@@ -30291,6 +30298,9 @@ function validateImportData(data) {
   if (channel === "wechat" && typeof configRecord.botToken !== "string") {
     throw new Error("WeChat channel installation config requires botToken");
   }
+  if (channel === "wecom" && (typeof configRecord.botId !== "string" || typeof configRecord.secret !== "string")) {
+    throw new Error("WeCom channel installation config requires botId and secret");
+  }
   return {
     channel,
     name: typeof data.name === "string" ? data.name : void 0,
@@ -30976,6 +30986,197 @@ function createAuditLoggerMiddleware() {
 // src/index.ts
 var import_core97 = require("@axiom-lattice/core");
 
+// src/channels/wecom/WecomChannelAdapter.ts
+var import_node_crypto27 = require("crypto");
+var import_zod17 = require("zod");
+var WecomAiBot = __toESM(require("@wecom/aibot-node-sdk"));
+
+// src/channels/wecom/parser.ts
+function parseWecomTextFrame(frame) {
+  if (!frame || typeof frame !== "object") return null;
+  const { headers, body } = frame;
+  const reqId = headers?.req_id;
+  if (typeof reqId !== "string" || !body) return null;
+  if (body.msgtype !== "text") return null;
+  const fromUserId = body.from?.userid;
+  const content = body.text?.content;
+  if (typeof fromUserId !== "string" || typeof content !== "string") {
+    return null;
+  }
+  return {
+    reqId,
+    msgId: typeof body.msgid === "string" ? body.msgid : "",
+    fromUserId,
+    chatId: typeof body.chatid === "string" ? body.chatid : void 0,
+    chatType: body.chattype === "group" ? "group" : "direct",
+    text: content
+  };
+}
+
+// src/channels/wecom/WecomChannelAdapter.ts
+init_Logger();
+var logger6 = new Logger({ serviceName: "lattice/gateway/wecom" });
+var wecomConfigSchema = import_zod17.z.object({
+  botId: import_zod17.z.string(),
+  secret: import_zod17.z.string()
+});
+var RECONNECT_BASE_MS = 5e3;
+var RECONNECT_MAX_MS = 6e4;
+var activeConnections2 = /* @__PURE__ */ new Map();
+var wecomChannelAdapter = {
+  channel: "wecom",
+  configSchema: wecomConfigSchema,
+  async receive(rawPayload, installation) {
+    const parsed = parseWecomTextFrame(rawPayload);
+    if (!parsed) return null;
+    return {
+      channel: "wecom",
+      channelInstallationId: installation.id,
+      tenantId: installation.tenantId,
+      sender: { id: parsed.fromUserId },
+      content: {
+        text: parsed.text,
+        // `messageId` 供去重中间件使用（企业微信可能重投同一 msgid）。
+        metadata: {
+          messageId: parsed.msgId,
+          chatId: parsed.chatId,
+          chatType: parsed.chatType
+        }
+      },
+      conversation: {
+        id: parsed.chatId ?? parsed.fromUserId,
+        type: parsed.chatType
+      },
+      replyTarget: {
+        adapterChannel: "wecom",
+        channelInstallationId: installation.id,
+        // 回复需原样带回入站帧（含 `headers.req_id`）。frame 是纯 JSON，
+        // replyTarget 仅在内存流转，不落库。
+        rawTarget: { frame: rawPayload }
+      }
+    };
+  },
+  async sendReply(replyTarget, message, installation) {
+    const connection = activeConnections2.get(installation.id);
+    if (!connection) {
+      logger6.warn("WeCom bot not connected, cannot reply", {
+        installationId: installation.id
+      });
+      return;
+    }
+    connection.client.reply(replyTarget.rawTarget.frame, {
+      msgtype: "stream",
+      stream: {
+        id: (0, import_node_crypto27.randomUUID)(),
+        finish: true,
+        content: message.text
+      }
+    });
+  },
+  resolveThreadId(message, binding) {
+    const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+    const agentId = binding.agentId;
+    if (message.conversation?.type === "group") {
+      return `wecom:group:${message.conversation.id}:${agentId}:${date}`;
+    }
+    return `wecom:dm:${message.sender.id}:${agentId}:${date}`;
+  },
+  async connect(installation, deps) {
+    const { id: installationId, tenantId, config } = installation;
+    if (!config.botId || !config.secret) {
+      logger6.warn("WeCom installation missing botId/secret, skipping", { installationId });
+      return;
+    }
+    if (activeConnections2.has(installationId)) {
+      logger6.warn("WeCom long connection already running, skipping", { installationId });
+      return;
+    }
+    const { router, wsClientFactory } = deps ?? {};
+    const client = (wsClientFactory ?? createDefaultWecomClient)(config);
+    const connection = { client, intentional: false, attempts: 0 };
+    client.on("message.text", (frame) => {
+      wecomChannelAdapter.receive(frame, installation).then((inbound) => {
+        if (!inbound || !router) return void 0;
+        return router.dispatch(inbound);
+      }).catch((error) => {
+        logger6.error("WeCom message dispatch error", {
+          installationId,
+          error: error instanceof Error ? error.message : String(error)
+        });
+      });
+    });
+    client.on("authenticated", () => {
+      connection.attempts = 0;
+    });
+    client.on("event.disconnected_event", () => {
+      logger6.warn("WeCom connection kicked by a newer connection; will reconnect", {
+        installationId
+      });
+      scheduleReconnect(installationId, connection);
+    });
+    activeConnections2.set(installationId, connection);
+    client.connect();
+    logger6.info("WeCom long connection starting", { installationId, tenantId });
+  },
+  async disconnect(installationId) {
+    const connection = activeConnections2.get(installationId);
+    if (!connection) {
+      logger6.warn("WeCom long connection not running, nothing to disconnect", { installationId });
+      return;
+    }
+    connection.intentional = true;
+    if (connection.timer) {
+      clearTimeout(connection.timer);
+      connection.timer = void 0;
+    }
+    try {
+      connection.client.disconnect();
+    } catch (error) {
+      logger6.error("WeCom long connection stop error", {
+        installationId,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+    activeConnections2.delete(installationId);
+    logger6.info("WeCom long connection disconnected", { installationId });
+  }
+};
+function scheduleReconnect(installationId, connection) {
+  if (connection.intentional || connection.timer) return;
+  const delay2 = Math.min(RECONNECT_BASE_MS * 2 ** connection.attempts, RECONNECT_MAX_MS);
+  connection.attempts += 1;
+  logger6.info("WeCom reconnect scheduled", {
+    installationId,
+    delayMs: delay2,
+    attempt: connection.attempts
+  });
+  const timer = setTimeout(() => {
+    connection.timer = void 0;
+    if (connection.intentional || activeConnections2.get(installationId) !== connection) {
+      return;
+    }
+    try {
+      connection.client.connect();
+    } catch (error) {
+      logger6.error("WeCom reconnect failed", {
+        installationId,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      scheduleReconnect(installationId, connection);
+    }
+  }, delay2);
+  timer.unref?.();
+  connection.timer = timer;
+}
+function createDefaultWecomClient(config) {
+  return new WecomAiBot.WSClient({
+    botId: config.botId,
+    secret: config.secret,
+    // 断网无限重连；被踢（disconnected_event）由 scheduleReconnect 兜底。
+    maxReconnectAttempts: -1
+  });
+}
+
 // src/swagger.ts
 var import_swagger = __toESM(require("@fastify/swagger"));
 var import_swagger_ui = __toESM(require("@fastify/swagger-ui"));
@@ -31039,7 +31240,7 @@ var configureSwagger = async (app2, customSwaggerConfig, customSwaggerUiConfig)
 };
 
 // src/services/agent_task_consumer.ts
-var import_node_crypto27 = require("crypto");
+var import_node_crypto28 = require("crypto");
 var import_core70 = require("@axiom-lattice/core");
 var import_protocols32 = require("@axiom-lattice/protocols");
 var handleAgentTask = async (taskRequest, retryCount = 0) => {
@@ -31063,7 +31264,7 @@ var handleAgentTask = async (taskRequest, retryCount = 0) => {
     const agent = import_core70.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)();
+      const messageId = typeof input?.id === "string" && input.id !== "" ? input.id : (0, import_node_crypto28.randomUUID)();
       let settled = false;
       const subscriptions = [];
       const dispose = () => {
@@ -31930,9 +32131,9 @@ var MessageRouter = class {
 };
 
 // src/channels/room/RoomChannelAdapter.ts
-var import_zod17 = require("zod");
+var import_zod18 = require("zod");
 var import_protocols34 = require("@axiom-lattice/protocols");
-var roomConfigSchema = import_zod17.z.object({}).strict();
+var roomConfigSchema = import_zod18.z.object({}).strict();
 function createRoomChannelAdapter(writer) {
   return {
     channel: "room",
@@ -32053,11 +32254,11 @@ async function prepareProjectTaskRuntime(runtime, log2) {
 var import_core74 = require("@axiom-lattice/core");
 
 // src/services/plugins/PluginDeploymentService.ts
-var import_node_crypto29 = require("crypto");
+var import_node_crypto30 = require("crypto");
 var import_core73 = require("@axiom-lattice/core");
 
 // src/services/plugins/pluginDeploymentNaming.ts
-var import_node_crypto28 = require("crypto");
+var import_node_crypto29 = require("crypto");
 var PLUGIN_GUEST_PORT = 8080;
 var SANDBOX_NAME_HASH_LENGTH = 16;
 function pluginSandboxName(tenantId, pluginType) {
@@ -32067,7 +32268,7 @@ function pluginSandboxName(tenantId, pluginType) {
   if (!pluginType || typeof pluginType !== "string") {
     throw new Error("pluginSandboxName: pluginType must be a non-empty string");
   }
-  const hash = (0, import_node_crypto28.createHash)("sha256").update(`${tenantId}\0${pluginType}`).digest("hex").slice(0, SANDBOX_NAME_HASH_LENGTH);
+  const hash = (0, import_node_crypto29.createHash)("sha256").update(`${tenantId}\0${pluginType}`).digest("hex").slice(0, SANDBOX_NAME_HASH_LENGTH);
   return `plugin-${hash}`;
 }
 
@@ -32194,7 +32395,7 @@ var PluginDeploymentService = class {
       const failedAt = this.nowIso();
       await this.store.upsert(
         this.buildRecord({
-          id: existing?.id ?? (0, import_node_crypto29.randomUUID)(),
+          id: existing?.id ?? (0, import_node_crypto30.randomUUID)(),
           tenantId,
           pluginType,
           pluginVersion: manifest.version,
@@ -32216,7 +32417,7 @@ var PluginDeploymentService = class {
       );
     }
     const record = this.buildRecord({
-      id: existing?.id ?? (0, import_node_crypto29.randomUUID)(),
+      id: existing?.id ?? (0, import_node_crypto30.randomUUID)(),
       tenantId,
       pluginType,
       pluginVersion: manifest.version,
@@ -32818,11 +33019,11 @@ function readPluginDeploymentLimits(env = process.env) {
   };
 }
 function startPluginDeploymentRuntime(options) {
-  const { lease, holder, logger: logger8 } = options;
+  const { lease, holder, logger: logger9 } = options;
   const forcedOn = process.env[PLUGIN_DEPLOYMENT_RUNTIME_FLAG] === "true" || process.env[PLUGIN_DEPLOYMENT_RUNTIME_FLAG] === "1";
   const effectiveServiceBaseUrl = options.wiring.serviceBaseUrl ?? process.env.MICROSANDBOX_SERVICE_BASE_URL;
   if (forcedOn && !effectiveServiceBaseUrl) {
-    logger8.warn(
+    logger9.warn(
       `${PLUGIN_DEPLOYMENT_RUNTIME_FLAG} is enabled but MICROSANDBOX_SERVICE_BASE_URL is empty; skipping plugin deployment runtime`,
       { holder }
     );
@@ -32841,8 +33042,8 @@ function startPluginDeploymentRuntime(options) {
   };
   const service2 = createService(deps);
   register(service2);
-  logger8.info("plugin deployment runtime started", { holder });
-  const reconcile = runStartupReconcile(service2, reconcileDeadlineMs, logger8, holder);
+  logger9.info("plugin deployment runtime started", { holder });
+  const reconcile = runStartupReconcile(service2, reconcileDeadlineMs, logger9, holder);
   let held = false;
   let inFlight = false;
   const tick = async () => {
@@ -32850,18 +33051,18 @@ function startPluginDeploymentRuntime(options) {
     inFlight = true;
     try {
       if (held) {
-        held = await renewLease(lease, holder, logger8);
+        held = await renewLease(lease, holder, logger9);
         if (!held) {
-          logger8.warn("plugin deployment lease lost; watchdog paused", { holder });
+          logger9.warn("plugin deployment lease lost; watchdog paused", { holder });
         }
       } else {
-        held = await acquireLease(lease, holder, logger8);
+        held = await acquireLease(lease, holder, logger9);
         if (held) {
-          logger8.info("plugin deployment lease acquired", { holder });
+          logger9.info("plugin deployment lease acquired", { holder });
         }
       }
       if (!held) return;
-      await runWatchdog(service2, holder, logger8);
+      await runWatchdog(service2, holder, logger9);
     } finally {
       inFlight = false;
     }
@@ -32877,7 +33078,7 @@ function startPluginDeploymentRuntime(options) {
         try {
           await lease.release(PLUGIN_DEPLOYMENT_LEASE_KEY, holder);
         } catch (error) {
-          logger8.warn("plugin deployment lease release failed", {
+          logger9.warn("plugin deployment lease release failed", {
             holder,
             error: errorMessage5(error)
           });
@@ -32885,16 +33086,16 @@ function startPluginDeploymentRuntime(options) {
         held = false;
       }
       register(void 0);
-      logger8.info("plugin deployment runtime stopped", { holder });
+      logger9.info("plugin deployment runtime stopped", { holder });
     }
   };
 }
-async function runStartupReconcile(service2, deadlineMs, logger8, holder) {
+async function runStartupReconcile(service2, deadlineMs, logger9, holder) {
   try {
     await withDeadline(service2.startupReconcile(), deadlineMs);
-    logger8.info("plugin deployment startup reconcile complete", { holder });
+    logger9.info("plugin deployment startup reconcile complete", { holder });
   } catch (error) {
-    logger8.warn("plugin deployment startup reconcile failed", {
+    logger9.warn("plugin deployment startup reconcile failed", {
       holder,
       error: errorMessage5(error)
     });
@@ -32917,7 +33118,7 @@ async function withDeadline(work, deadlineMs) {
     if (timer !== void 0) clearTimeout(timer);
   }
 }
-async function acquireLease(lease, holder, logger8) {
+async function acquireLease(lease, holder, logger9) {
   try {
     return await lease.tryAcquire(
       PLUGIN_DEPLOYMENT_LEASE_KEY,
@@ -32925,14 +33126,14 @@ async function acquireLease(lease, holder, logger8) {
       PLUGIN_DEPLOYMENT_LEASE_TTL_MS
     );
   } catch (error) {
-    logger8.warn("plugin deployment lease acquire failed", {
+    logger9.warn("plugin deployment lease acquire failed", {
       holder,
       error: errorMessage5(error)
     });
     return false;
   }
 }
-async function renewLease(lease, holder, logger8) {
+async function renewLease(lease, holder, logger9) {
   try {
     return await lease.renew(
       PLUGIN_DEPLOYMENT_LEASE_KEY,
@@ -32940,18 +33141,18 @@ async function renewLease(lease, holder, logger8) {
       PLUGIN_DEPLOYMENT_LEASE_TTL_MS
     );
   } catch (error) {
-    logger8.warn("plugin deployment lease renew failed", {
+    logger9.warn("plugin deployment lease renew failed", {
       holder,
       error: errorMessage5(error)
     });
     return false;
   }
 }
-async function runWatchdog(service2, holder, logger8) {
+async function runWatchdog(service2, holder, logger9) {
   try {
     await service2.healthWatchdog();
   } catch (error) {
-    logger8.warn("plugin deployment health watchdog failed", {
+    logger9.warn("plugin deployment health watchdog failed", {
       holder,
       error: errorMessage5(error)
     });
@@ -32989,29 +33190,29 @@ function storeClassName(kind) {
     return void 0;
   }
 }
-function warnMultiReplicaReadiness(logger8) {
+function warnMultiReplicaReadiness(logger9) {
   if (typeof process.env.AXIOM_REPLICA_ID !== "string" || process.env.AXIOM_REPLICA_ID.trim() === "") return;
   for (const kind of SHARED_STORE_KINDS) {
     const name = storeClassName(kind);
     if (name === void 0 || !name.startsWith("InMemory")) continue;
-    logger8.warn(`Multi-replica: store '${kind}' is ${name} (not shared); configure a shared store`, {
+    logger9.warn(`Multi-replica: store '${kind}' is ${name} (not shared); configure a shared store`, {
       phase: "multi_replica_readiness",
       store: kind
     });
   }
   if (!process.env.AUTH_TOKEN_SECRET?.trim() && !process.env.JWT_SECRET?.trim()) {
-    logger8.warn(
+    logger9.warn(
       "Multi-replica: AUTH_TOKEN_SECRET/JWT_SECRET unset; console sessions are signed per-process and will not verify across replicas",
       { phase: "multi_replica_readiness", env: "AUTH_TOKEN_SECRET" }
     );
   }
   if (!process.env.LATTICE_ENCRYPTION_KEY?.trim()) {
-    logger8.warn(
+    logger9.warn(
       "Multi-replica: LATTICE_ENCRYPTION_KEY unset; stored credentials use the shared dev default and may not decrypt across differing keys",
       { phase: "multi_replica_readiness", env: "LATTICE_ENCRYPTION_KEY" }
     );
   }
-  logger8.warn(
+  logger9.warn(
     "Multi-replica: agent run SSE and resume_stream are process-local; route a thread's follow-up runs to the replica streaming it (sticky routing) or share the stream/queue state",
     { phase: "multi_replica_readiness", feature: "agent-run-sse" }
   );
@@ -33154,7 +33355,7 @@ var DEFAULT_LOGGER_CONFIG = {
   loggerName: "lattice/gateway"
 };
 var loggerLattice = initializeLogger(DEFAULT_LOGGER_CONFIG);
-var logger7 = loggerLattice.client;
+var logger8 = loggerLattice.client;
 function initializeLogger(config) {
   if (import_core98.loggerLatticeManager.hasLattice("default")) {
     import_core98.loggerLatticeManager.removeLattice("default");
@@ -33241,7 +33442,7 @@ app.setErrorHandler((error, request, reply) => {
     "x-request-id": getHeaderValue(request.headers["x-request-id"]),
     "x-user-id": getHeaderValue(request.headers["x-user-id"])
   };
-  logger7.error(
+  logger8.error(
     `\u8BF7\u6C42\u9519\u8BEF: ${request.method} ${request.url} error:${error.message}`,
     {
       ...context,
@@ -33277,14 +33478,14 @@ async function restoreMcpConnections() {
     const storeLattice = (0, import_core98.getStoreLattice)("default", "mcp");
     const store2 = storeLattice.store;
     if (!store2) {
-      logger7.info("MCP store not configured, skipping connection restoration");
+      logger8.info("MCP store not configured, skipping connection restoration");
       return;
     }
     const configs = (await store2.getAllConfigsWithoutTenant()).filter(
       (c2) => c2.status === "connected"
     );
     if (configs.length === 0) return;
-    logger7.info(`Restoring ${configs.length} MCP server connections...`);
+    logger8.info(`Restoring ${configs.length} MCP server connections...`);
     const deps = {
       store: store2,
       manager: import_core98.mcpManager,
@@ -33301,15 +33502,15 @@ async function restoreMcpConnections() {
     results.forEach((result, index) => {
       if (result.status === "rejected") {
         const config = configs[index];
-        logger7.warn(
+        logger8.warn(
           `Failed to restore MCP server "${config.tenantId}/${config.key}"`,
           { error: result.reason }
         );
       }
     });
-    logger7.info(`MCP connection restoration complete: ${configs.length} servers`);
+    logger8.info(`MCP connection restoration complete: ${configs.length} servers`);
   } catch (err) {
-    logger7.error("MCP connection restoration failed", { error: err });
+    logger8.error("MCP connection restoration failed", { error: err });
   }
 }
 var start = async (config) => {
@@ -33322,7 +33523,7 @@ var start = async (config) => {
         file: config.loggerConfig.file || DEFAULT_LOGGER_CONFIG.file
       };
       loggerLattice = initializeLogger(loggerConfig);
-      logger7 = loggerLattice.client;
+      logger8 = loggerLattice.client;
     }
     app.decorate("loggerLattice", loggerLattice);
     const projectRoomRealtimeMode = resolveProjectRoomRealtimeMode();
@@ -33332,12 +33533,13 @@ var start = async (config) => {
         tasks: (0, import_core98.getStoreLattice)("default", "task").store,
         rooms: (0, import_core98.getStoreLattice)("default", "projectRoom").store,
         memberships: (0, import_core98.getStoreLattice)("default", "projectBotMembership").store,
-        log: { warn: (message, context) => logger7.warn(message, context) }
+        log: { warn: (message, context) => logger8.warn(message, context) }
       });
     }
     let channelDeps;
     const adapterRegistry = new ChannelAdapterRegistry();
     adapterRegistry.register(larkChannelAdapter);
+    adapterRegistry.register(wecomChannelAdapter);
     const { wechatChannelAdapter: wechatChannelAdapter2 } = await Promise.resolve().then(() => (init_WechatChannelAdapter(), WechatChannelAdapter_exports));
     adapterRegistry.register(wechatChannelAdapter2);
     try {
@@ -33350,7 +33552,7 @@ var start = async (config) => {
           createRateLimitMiddleware(),
           createAuditLoggerMiddleware()
         ],
-        warn: (message, context) => logger7.warn(message, context),
+        warn: (message, context) => logger8.warn(message, context),
         realtime: projectRoomRealtimeRuntime?.publisher
       });
       const bindingStore = infrastructure.bindingRegistry;
@@ -33364,10 +33566,10 @@ var start = async (config) => {
         installationStore,
         bindingRegistry: bindingStore,
         realtime: projectRoomRealtimeRuntime?.publisher,
-        warn: (message, context) => logger7.warn(message, context)
+        warn: (message, context) => logger8.warn(message, context)
       };
     } catch (err) {
-      logger7.warn("Channel infrastructure unavailable", {
+      logger8.warn("Channel infrastructure unavailable", {
         error: err instanceof Error ? err.message : String(err)
       });
     }
@@ -33375,7 +33577,7 @@ var start = async (config) => {
     try {
       const menuStore = (0, import_core98.getStoreLattice)("default", "menu").store;
       (0, import_core97.setMenuRegistry)(menuStore);
-      logger7.info("Menu registry initialized");
+      logger8.info("Menu registry initialized");
     } catch {
     }
     registerAllBuiltinEntities();
@@ -33384,7 +33586,7 @@ var start = async (config) => {
     }
     const routes = registerLatticeRoutes(app, channelDeps, {
       projectTaskEnabled: process.env.AXIOM_PROJECT_TASK_EXECUTION_ENABLED !== "false",
-      projectTaskLog: { warn: (message, context) => logger7.warn(message, context) },
+      projectTaskLog: { warn: (message, context) => logger8.warn(message, context) },
       projectRoomRealtimeRuntime
     });
     try {
@@ -33412,9 +33614,9 @@ var start = async (config) => {
         getProjectStore: () => projectStore
       });
       a2a.registerA2ARoutes(app);
-      logger7.info("A2A standard routes registered");
+      logger8.info("A2A standard routes registered");
     } catch (err) {
-      logger7.warn("A2A standard routes unavailable", {
+      logger8.warn("A2A standard routes unavailable", {
         error: err instanceof Error ? err.message : String(err)
       });
     }
@@ -33451,26 +33653,26 @@ var start = async (config) => {
       registerOpenFilesRoutes2(app);
       registerOpenAuditRoutes2(app);
       registerOpenExposureRoutes2(app);
-      logger7.info("Open API routes registered (kb + sandbox providers, session exchange)");
+      logger8.info("Open API routes registered (kb + sandbox providers, session exchange)");
     } catch (err) {
-      logger7.warn("Open API routes unavailable", {
+      logger8.warn("Open API routes unavailable", {
         error: err instanceof Error ? err.message : String(err)
       });
     }
     try {
       const { registerGatewaySandboxOpenCredentialProvider: registerGatewaySandboxOpenCredentialProvider2 } = await Promise.resolve().then(() => (init_sandboxOpenCredentialProvider(), sandboxOpenCredentialProvider_exports));
       registerGatewaySandboxOpenCredentialProvider2((error) => {
-        logger7.warn("sandbox open-credential provider failed", { error });
+        logger8.warn("sandbox open-credential provider failed", { error });
       });
-      logger7.info("Sandbox open-credential provider registered");
+      logger8.info("Sandbox open-credential provider registered");
     } catch (err) {
-      logger7.warn("Sandbox open-credential provider unavailable", {
+      logger8.warn("Sandbox open-credential provider unavailable", {
         error: err instanceof Error ? err.message : String(err)
       });
     }
     if (!import_core98.sandboxLatticeManager.hasLattice("default")) {
       import_core98.sandboxLatticeManager.registerLattice("default", getConfiguredSandboxProvider());
-      logger7.info("Registered sandbox manager from env configuration");
+      logger8.info("Registered sandbox manager from env configuration");
     }
     if (isPluginDeploymentRuntimeEnabled()) {
       try {
@@ -33497,21 +33699,21 @@ var start = async (config) => {
             listAllDeployments,
             // The service logs fields-first; the gateway logger is message-first.
             logger: {
-              info: (fields, message) => logger7.info(message ?? "plugin deployment", fields),
-              warn: (fields, message) => logger7.warn(message ?? "plugin deployment", fields),
-              error: (fields, message) => logger7.error(message ?? "plugin deployment", fields)
+              info: (fields, message) => logger8.info(message ?? "plugin deployment", fields),
+              warn: (fields, message) => logger8.warn(message ?? "plugin deployment", fields),
+              error: (fields, message) => logger8.error(message ?? "plugin deployment", fields)
             }
           },
           lease: leaseStore2,
           holder: (0, import_core98.getReplicaId)(),
-          logger: logger7
+          logger: logger8
         });
         app.addHook("onClose", async () => {
           await pluginDeploymentRuntime.dispose();
         });
-        logger7.info("Plugin deployment runtime started");
+        logger8.info("Plugin deployment runtime started");
       } catch (err) {
-        logger7.warn("Plugin deployment runtime unavailable", {
+        logger8.warn("Plugin deployment runtime unavailable", {
           error: err instanceof Error ? err.message : String(err)
         });
       }
@@ -33524,12 +33726,12 @@ var start = async (config) => {
         store: sharedResourceStore,
         sandboxManager: import_core98.sandboxLatticeManager,
         cache: cache2,
-        logger: logger7
+        logger: logger8
       });
       registerResourceRoutes(app, resourceController);
-      logger7.info("Resource share routes registered");
+      logger8.info("Resource share routes registered");
     } catch (err) {
-      logger7.warn("Resource share infrastructure unavailable", {
+      logger8.warn("Resource share infrastructure unavailable", {
         error: err instanceof Error ? err.message : String(err)
       });
     }
@@ -33542,14 +33744,14 @@ var start = async (config) => {
             deps: { router: channelDeps.router }
           }),
           disconnect: () => (0, import_core98.disconnectAllChannels)((channel) => adapterRegistry.get(channel)),
-          log: { warn: (message, context) => logger7.warn(message, context) }
+          log: { warn: (message, context) => logger8.warn(message, context) }
         });
         app.addHook("onClose", async () => {
           await channelLeader.stop();
         });
         channelLeader.start();
       } catch (err) {
-        logger7.error("Failed to start channel connections", {
+        logger8.error("Failed to start channel connections", {
           error: err instanceof Error ? err.message : String(err)
         });
       }
@@ -33596,24 +33798,24 @@ var start = async (config) => {
           await handleModelProviderChanged(payload, (tenantId, providerId2) => controller.reconcileProvider(tenantId, providerId2));
         }
       },
-      log: logger7
+      log: logger8
     });
     try {
       await outboxPoller.start();
     } catch (err) {
-      logger7.warn("Outbox poller failed to start", { error: err instanceof Error ? err.message : String(err) });
+      logger8.warn("Outbox poller failed to start", { error: err instanceof Error ? err.message : String(err) });
     }
     const leaseStore = (0, import_core98.getStoreLattice)("default", "lease").store;
     if (leaseStore.constructor?.name === "InMemoryLeaseStore") {
-      logger7.warn(
+      logger8.warn(
         "Startup recovery leader gate uses a non-distributed lease store (per-process only); configure a shared 'lease' store for multi-replica deployments",
         { phase: "startup_recovery" }
       );
     }
-    warnMultiReplicaReadiness(logger7);
+    warnMultiReplicaReadiness(logger8);
     const startup = await (0, import_core98.runAsLeader)(leaseStore, "startup-recovery", async () => {
       if (routes.projectTaskRuntime) {
-        await prepareProjectTaskRuntime(routes.projectTaskRuntime, logger7);
+        await prepareProjectTaskRuntime(routes.projectTaskRuntime, logger8);
       }
       if (process.env.AXIOM_TASK_ORPHAN_RECOVERY === "true") {
         try {
@@ -33624,19 +33826,19 @@ var start = async (config) => {
             workItemStore: (0, import_core98.getStoreLattice)("default", "taskWorkItem").store,
             tenantStore: (0, import_core98.getStoreLattice)("default", "tenant").store,
             ...createRecoveryCallerDeps2(),
-            log: logger7
+            log: logger8
           });
           await runtime.recoverAll();
         } catch (err) {
-          logger7.warn("Task orphan recovery failed", { error: err instanceof Error ? err.message : String(err) });
+          logger8.warn("Task orphan recovery failed", { error: err instanceof Error ? err.message : String(err) });
         }
       }
       if (import_core98.scheduleLatticeManager.hasLattice("default")) {
         try {
           const restored = await import_core98.scheduleLatticeManager.getScheduleLattice("default").restore();
-          logger7.info("Scheduled tasks restored", { phase: "startup_recovery", restored });
+          logger8.info("Scheduled tasks restored", { phase: "startup_recovery", restored });
         } catch (err) {
-          logger7.warn("Scheduled task restore failed", {
+          logger8.warn("Scheduled task restore failed", {
             phase: "startup_recovery",
             error: err instanceof Error ? err.message : String(err)
           });
@@ -33644,13 +33846,13 @@ var start = async (config) => {
       }
     }, { hold: true, ttlMs: 5 * 6e4 });
     if (!startup.ran) {
-      logger7.info("Startup recovery skipped (another replica leads)", { phase: "startup_recovery" });
+      logger8.info("Startup recovery skipped (another replica leads)", { phase: "startup_recovery" });
     }
     await app.listen({ port: target_port, host: "0.0.0.0" });
-    logger7.info(`Lattice Gateway is running on port: ${target_port}`);
+    logger8.info(`Lattice Gateway is running on port: ${target_port}`);
     const outboxRetention = createOutboxRetentionJob({
       outbox: outboxStore,
-      log: logger7
+      log: logger8
     });
     outboxRetention.start();
     let agentTaskConsumer;
@@ -33663,15 +33865,15 @@ var start = async (config) => {
       }
     }
     restoreMcpConnections().catch((error) => {
-      logger7.error("MCP connection restoration failed", { error });
+      logger8.error("MCP connection restoration failed", { error });
     });
     if (config?.gracefulShutdown !== false && !shutdownHandlersInstalled) {
       shutdownHandlersInstalled = true;
       const gracefulShutdown = createGracefulShutdown({
         timeoutMs: config?.gracefulShutdownTimeoutMs ?? 1e4,
         log: {
-          info: (message, context) => logger7.info(message, context),
-          warn: (message, context) => logger7.warn(message, context)
+          info: (message, context) => logger8.info(message, context),
+          warn: (message, context) => logger8.warn(message, context)
         },
         steps: [
           async () => {
@@ -33689,7 +33891,7 @@ var start = async (config) => {
       process.once("SIGINT", () => void gracefulShutdown("SIGINT"));
     }
   } catch (err) {
-    logger7.error("Server start failed", { error: err });
+    logger8.error("Server start failed", { error: err });
     process.exit(1);
   }
 };