metheus-governance-mcp-cli 0.2.178 → 0.2.180

package/cli.mjs

@@ -4269,6 +4269,7 @@ async function processRunnerRouteOnce(route, runtime, mode, options = {}) {
       bot,
       destination,
       archiveThread,
+      managedConversationBots,
       deps: buildRunnerRuntimeDeps(),
     });
     saveRunnerRouteState(routeKey, {

package/lib/runner-runtime.mjs

@@ -42,6 +42,10 @@ function firstNonEmptyString(values) {
   return "";
 }
 
+function normalizeMentionSelector(rawValue) {
+  return String(rawValue || "").trim().replace(/^@+/, "").toLowerCase();
+}
+
 function normalizeRunnerSharedInboxKey({ provider, bot, route }) {
   const normalizedProvider = String(provider || route?.provider || "").trim().toLowerCase() || "telegram";
   const botSelector = firstNonEmptyString([
@@ -60,6 +64,66 @@ function normalizeRunnerSharedInboxKey({ provider, bot, route }) {
   return `${normalizedProvider}::${botSelector}`;
 }
 
+function buildRouteBotUsernameCandidates(bot, route) {
+  return Array.from(new Set(
+    [
+      bot?.username,
+      bot?.name,
+      route?.botName,
+      route?.serverBotName,
+    ]
+      .map((value) => normalizeMentionSelector(value))
+      .filter(Boolean),
+  ));
+}
+
+function shouldImportManagedBotMessageForRoute({
+  update,
+  bot,
+  route,
+  managedConversationBots,
+}) {
+  const normalizedUpdate = safeObject(update);
+  if (normalizedUpdate.fromIsBot !== true) {
+    return false;
+  }
+  const managedSelectors = new Set(
+    ensureArray(managedConversationBots)
+      .flatMap((entry) => [
+        safeObject(entry).username,
+        safeObject(entry).display_name,
+        safeObject(safeObject(entry).bot).username,
+        safeObject(safeObject(entry).bot).name,
+        safeObject(safeObject(entry).route).botName,
+        safeObject(safeObject(entry).route).serverBotName,
+      ])
+      .map((value) => normalizeMentionSelector(value))
+      .filter(Boolean),
+  );
+  const senderSelector = normalizeMentionSelector(normalizedUpdate.fromUsername);
+  if (!senderSelector || !managedSelectors.has(senderSelector)) {
+    return false;
+  }
+  const currentBotSelectors = new Set(buildRouteBotUsernameCandidates(bot, route));
+  if (!currentBotSelectors.size) {
+    return false;
+  }
+  if (currentBotSelectors.has(senderSelector)) {
+    return false;
+  }
+  const explicitMentions = ensureArray(normalizedUpdate.mentionUsernames)
+    .map((value) => normalizeMentionSelector(value))
+    .filter(Boolean);
+  if (explicitMentions.some((value) => currentBotSelectors.has(value))) {
+    return true;
+  }
+  const replyTargetSelector = normalizeMentionSelector(normalizedUpdate.replyToFromUsername);
+  if (normalizedUpdate.replyToFromIsBot === true && replyTargetSelector && currentBotSelectors.has(replyTargetSelector)) {
+    return true;
+  }
+  return false;
+}
+
 function normalizeSharedInboxUpdate(rawUpdate) {
   const update = safeObject(rawUpdate);
   const updateID = intFromRawAllowZero(update.updateID ?? update.update_id, 0);
@@ -270,6 +334,7 @@ export async function archiveLocalTelegramMessagesForRoute({
   bot,
   destination,
   archiveThread,
+  managedConversationBots = [],
   deps,
 }) {
   const loadProviderEnvConfig = requireDependency(deps, "loadProviderEnvConfig");
@@ -407,7 +472,13 @@ export async function archiveLocalTelegramMessagesForRoute({
       handledUpdateID = Math.max(handledUpdateID, updateID);
       continue;
     }
-    if (boolFromRaw(archivePolicy.skipBotMessages, true) && update.fromIsBot) {
+    const allowManagedBotImport = shouldImportManagedBotMessageForRoute({
+      update,
+      bot,
+      route,
+      managedConversationBots,
+    });
+    if (boolFromRaw(archivePolicy.skipBotMessages, true) && update.fromIsBot && !allowManagedBotImport) {
       handledUpdateID = Math.max(handledUpdateID, updateID);
       continue;
     }

package/lib/selftest-telegram-e2e.mjs

@@ -602,15 +602,145 @@ export async function runSelftestTelegramE2E(push, deps) {
       deps: buildRunnerRuntimeDeps(),
     });
     const sharedInboxBodies = telegramE2EServer.state.comments.map((item) => String(item.body || ""));
-    push(
-      "telegram_shared_inbox_fans_out_updates_across_routes_for_same_bot",
-      sharedInboxBodies.some((item) => item.includes("message_id: 71"))
-        && sharedInboxBodies.some((item) => item.includes("message_id: 72")),
-      `comments=${sharedInboxBodies.length} bodies=${sharedInboxBodies.join(" || ")}`,
-    );
-  } catch (err) {
-    push("telegram_runner_e2e_local_mock", false, String(err?.message || err));
-  } finally {
+    push(
+      "telegram_shared_inbox_fans_out_updates_across_routes_for_same_bot",
+      sharedInboxBodies.some((item) => item.includes("message_id: 71"))
+        && sharedInboxBodies.some((item) => item.includes("message_id: 72")),
+      `comments=${sharedInboxBodies.length} bodies=${sharedInboxBodies.join(" || ")}`,
+    );
+
+    telegramE2EServer.state.comments = [];
+    telegramE2EServer.state.updates = [
+      {
+        update_id: 401,
+        message: {
+          message_id: 81,
+          date: Math.floor(Date.now() / 1000),
+          chat: {
+            id: Number(e2eDestination.chat_id),
+            type: "supergroup",
+            title: e2eDestination.label,
+          },
+          from: {
+            id: 6001,
+            is_bot: true,
+            first_name: "Lead Bot",
+            username: "lead_monitor_bot",
+          },
+          text: `@${String("PeerMonitorBot").replace(/^@+/, "")} please summarize the project`,
+        },
+      },
+    ];
+    await archiveLocalTelegramMessagesForRoute({
+      routeKey: runnerRouteKey(normalizeRunnerRoute({
+        ...e2eRoute,
+        name: "selftest-runner-e2e-managed-bot-mention-import",
+        server_bot_name: "PeerMonitorBot",
+      })),
+      route: {
+        ...e2eRoute,
+        name: "selftest-runner-e2e-managed-bot-mention-import",
+        server_bot_name: "PeerMonitorBot",
+      },
+      routeState: {},
+      runtime: {
+        baseURL: telegramE2EServer.baseURL,
+        timeoutSeconds: 10,
+        token: e2eToken,
+        actor: {
+          user_id: e2eActorUserID,
+        },
+      },
+      bot: {
+        id: "66666666-6666-4666-8666-666666666666",
+        name: "PeerMonitorBot",
+        role: "monitor",
+      },
+      destination: {
+        chatID: e2eDestination.chat_id,
+      },
+      archiveThread: {
+        threadID: e2eThreadID,
+      },
+      managedConversationBots: [
+        { username: "lead_monitor_bot" },
+        { username: "PeerMonitorBot" },
+      ],
+      deps: buildRunnerRuntimeDeps(),
+    });
+    push(
+      "telegram_managed_bot_public_delegate_is_imported_even_when_skip_bot_messages_is_true",
+      telegramE2EServer.state.comments.some((item) => String(item.body || "").includes("message_id: 81")),
+      `comments=${telegramE2EServer.state.comments.length}`,
+    );
+
+    telegramE2EServer.state.comments = [];
+    telegramE2EServer.state.updates = [
+      {
+        update_id: 402,
+        message: {
+          message_id: 82,
+          date: Math.floor(Date.now() / 1000),
+          chat: {
+            id: Number(e2eDestination.chat_id),
+            type: "supergroup",
+            title: e2eDestination.label,
+          },
+          from: {
+            id: 6002,
+            is_bot: true,
+            first_name: "External Bot",
+            username: "external_random_bot",
+          },
+          text: `@${String("PeerMonitorBot").replace(/^@+/, "")} hello from outside`,
+        },
+      },
+    ];
+    await archiveLocalTelegramMessagesForRoute({
+      routeKey: runnerRouteKey(normalizeRunnerRoute({
+        ...e2eRoute,
+        name: "selftest-runner-e2e-unmanaged-bot-skip",
+        server_bot_name: "PeerMonitorBot",
+      })),
+      route: {
+        ...e2eRoute,
+        name: "selftest-runner-e2e-unmanaged-bot-skip",
+        server_bot_name: "PeerMonitorBot",
+      },
+      routeState: {},
+      runtime: {
+        baseURL: telegramE2EServer.baseURL,
+        timeoutSeconds: 10,
+        token: e2eToken,
+        actor: {
+          user_id: e2eActorUserID,
+        },
+      },
+      bot: {
+        id: "77777777-7777-4777-8777-777777777777",
+        name: "PeerMonitorBot",
+        role: "monitor",
+      },
+      destination: {
+        chatID: e2eDestination.chat_id,
+      },
+      archiveThread: {
+        threadID: e2eThreadID,
+      },
+      managedConversationBots: [
+        { username: "lead_monitor_bot" },
+        { username: "PeerMonitorBot" },
+      ],
+      deps: buildRunnerRuntimeDeps(),
+    });
+    push(
+      "telegram_unmanaged_bot_message_remains_skipped_when_skip_bot_messages_is_true",
+      telegramE2EServer.state.comments.length === 0,
+      `comments=${telegramE2EServer.state.comments.length}`,
+    );
+  } catch (err) {
+    push("telegram_runner_e2e_local_mock", false, String(err?.message || err));
+  } finally {
     try {
       await telegramE2EServer?.close?.();
     } catch {}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "metheus-governance-mcp-cli",
-  "version": "0.2.178",
+  "version": "0.2.180",
   "description": "Metheus Governance MCP CLI (setup + stdio proxy)",
   "type": "module",
   "files": [