metheus-governance-mcp-cli 0.2.261 → 0.2.262

package/lib/runner-runtime.mjs

@@ -51,6 +51,38 @@ function normalizeMentionSelector(rawValue) {
   return String(rawValue || "").trim().replace(/^@+/, "").toLowerCase();
 }
 
+function buildRunnerRouteOwnershipKey(routeRaw) {
+  const route = safeObject(routeRaw);
+  const name = String(route.name || "").trim() || "-";
+  const projectID = String(route.projectID || route.project_id || "").trim() || "-";
+  const provider = String(route.provider || "").trim().toLowerCase() || "-";
+  const role = String(route.role || route.bot_role || route.botRole || "").trim().toLowerCase() || "-";
+  const botID = String(
+    route.botID
+    || route.bot_id
+    || route.server_bot_id
+    || route.serverBotID
+    || "",
+  ).trim();
+  const botName = String(
+    route.botName
+    || route.bot_name
+    || route.server_bot_name
+    || route.serverBotName
+    || "",
+  ).trim();
+  const destinationID = String(route.destinationID || route.destination_id || "").trim();
+  const destinationLabel = String(route.destinationLabel || route.destination_label || "").trim();
+  return [
+    name,
+    projectID,
+    provider,
+    role,
+    botID || botName || "-",
+    destinationID || destinationLabel || "-",
+  ].join("::");
+}
+
 function normalizeRunnerSharedInboxKey({ provider, bot, route }) {
   const normalizedProvider = String(provider || route?.provider || "").trim().toLowerCase() || "telegram";
   const botSelector = firstNonEmptyString([
@@ -98,6 +130,130 @@ function buildManagedConversationBotSelectors(managedConversationBots) {
   );
 }
 
+function buildRunnerLocalInboundOwnerMap({
+  routeKey,
+  route,
+  bot,
+  managedConversationBots,
+}) {
+  const owners = new Map();
+  const appendOwner = (selectorRaw, ownerRaw = {}) => {
+    const selector = normalizeMentionSelector(selectorRaw);
+    const ownerRouteKey = String(
+      ownerRaw.routeKey
+      || ownerRaw.route_key
+      || buildRunnerRouteOwnershipKey(ownerRaw.route),
+    ).trim();
+    const ownerBotUsername = normalizeMentionSelector(
+      ownerRaw.botUsername
+      || ownerRaw.bot_username
+      || ownerRaw.username
+      || safeObject(ownerRaw.bot).username
+      || safeObject(ownerRaw.bot).name
+      || safeObject(ownerRaw.route).botName
+      || safeObject(ownerRaw.route).bot_name
+      || safeObject(ownerRaw.route).serverBotName
+      || safeObject(ownerRaw.route).server_bot_name
+      || selector,
+    );
+    if (!selector || !ownerRouteKey) {
+      return;
+    }
+    owners.set(selector, {
+      selector,
+      routeKey: ownerRouteKey,
+      botUsername: ownerBotUsername || selector,
+    });
+  };
+
+  appendOwner(
+    bot?.username
+    || bot?.name
+    || route?.botName
+    || route?.bot_name
+    || route?.serverBotName
+    || route?.server_bot_name,
+    {
+      routeKey,
+      botUsername:
+        bot?.username
+        || bot?.name
+        || route?.botName
+        || route?.bot_name
+        || route?.serverBotName
+        || route?.server_bot_name,
+    },
+  );
+
+  for (const entryRaw of ensureArray(managedConversationBots)) {
+    const entry = safeObject(entryRaw);
+    appendOwner(
+      entry.username
+      || entry.display_name
+      || safeObject(entry.bot).username
+      || safeObject(entry.bot).name
+      || safeObject(entry.route).botName
+      || safeObject(entry.route).bot_name
+      || safeObject(entry.route).serverBotName
+      || safeObject(entry.route).server_bot_name,
+      entry,
+    );
+  }
+
+  return owners;
+}
+
+function resolveRunnerLocalInboundArtifactOwners({
+  update,
+  routeKey,
+  route,
+  bot,
+  managedConversationBots,
+}) {
+  const normalizedUpdate = safeObject(update);
+  const ownersBySelector = buildRunnerLocalInboundOwnerMap({
+    routeKey,
+    route,
+    bot,
+    managedConversationBots,
+  });
+  const currentBotSelector = normalizeMentionSelector(
+    bot?.username
+    || bot?.name
+    || route?.botName
+    || route?.bot_name
+    || route?.serverBotName
+    || route?.server_bot_name,
+  );
+  const currentOwner = currentBotSelector ? ownersBySelector.get(currentBotSelector) : null;
+
+  const explicitMentions = Array.from(new Set(
+    ensureArray(normalizedUpdate.mentionUsernames)
+      .map((value) => normalizeMentionSelector(value))
+      .filter(Boolean),
+  ));
+  if (explicitMentions.length > 0) {
+    const explicitOwners = explicitMentions
+      .map((selector) => ownersBySelector.get(selector))
+      .filter((owner) => owner && owner.routeKey);
+    if (explicitOwners.length > 0) {
+      return explicitOwners;
+    }
+    return [];
+  }
+
+  const replyTargetSelector = normalizeMentionSelector(normalizedUpdate.replyToFromUsername);
+  if (
+    normalizedUpdate.replyToFromIsBot === true
+    && replyTargetSelector
+    && ownersBySelector.has(replyTargetSelector)
+  ) {
+    return [ownersBySelector.get(replyTargetSelector)];
+  }
+
+  return currentOwner ? [currentOwner] : [];
+}
+
 function managedConversationBotTargetsCurrentRoute({
   update,
   bot,
@@ -327,49 +483,72 @@ function buildRunnerLocalInboundEnvelopeFromReceipt(rawReceipt) {
   });
 }
 
-function buildRunnerLocalInboundArtifacts(updates, routeKey, bot, destination) {
-  const currentBotSelector = normalizeMentionSelector(
-    bot?.username
-    || bot?.name
-    || "",
-  );
+function buildRunnerLocalInboundArtifacts(updates, routeKey, route, bot, destination, managedConversationBots = []) {
   const normalizedRouteKey = String(routeKey || "").trim();
   const destinationChatID = String(destination?.chatID || "").trim();
   return ensureArray(updates)
     .filter((update) => String(update.chatID || "").trim() === destinationChatID)
     .filter((update) => String(update.text || "").trim())
-    .map((update) => {
-      const chatID = String(update.chatID || "").trim();
-      const messageID = intFromRawAllowZero(update.messageID, 0);
-      const receiptKey = buildRunnerRecentLocalInboundReceiptKey(chatID, messageID);
-      const receiptEntry = normalizeRunnerRecentLocalInboundReceipt({
-        update_id: intFromRawAllowZero(update.updateID, 0),
-        chat_id: chatID,
-        chat_type: update.chatType,
-        chat_title: update.chatTitle,
-        message_id: messageID,
-        message_thread_id: intFromRawAllowZero(update.messageThreadID, 0),
-        reply_to_message_id: intFromRawAllowZero(update.replyToMessageID, 0),
-        kind: update.fromIsBot ? "bot_reply" : "telegram_message",
-        sender_id: update.fromID,
-        sender: update.fromName,
-        sender_username: update.fromUsername,
-        sender_is_bot: update.fromIsBot === true,
-        body: update.text,
-        occurred_at: update.occurredAt,
-        receipt_origin: "local_telegram_inbound",
-        receipt_route_key: normalizedRouteKey,
-        receipt_bot_username: currentBotSelector,
-        received_at: firstNonEmptyString([update.occurredAt, new Date().toISOString()]),
-      }, receiptKey);
-      return { receiptEntry };
+    .flatMap((update) => {
+      const owners = resolveRunnerLocalInboundArtifactOwners({
+        update,
+        routeKey: normalizedRouteKey,
+        route,
+        bot,
+        managedConversationBots,
+      });
+      return owners.map((owner) => {
+        const chatID = String(update.chatID || "").trim();
+        const messageID = intFromRawAllowZero(update.messageID, 0);
+        const receiptKey = buildRunnerRecentLocalInboundReceiptKey(chatID, messageID);
+        const receiptEntry = normalizeRunnerRecentLocalInboundReceipt({
+          update_id: intFromRawAllowZero(update.updateID, 0),
+          chat_id: chatID,
+          chat_type: update.chatType,
+          chat_title: update.chatTitle,
+          message_id: messageID,
+          message_thread_id: intFromRawAllowZero(update.messageThreadID, 0),
+          reply_to_message_id: intFromRawAllowZero(update.replyToMessageID, 0),
+          kind: update.fromIsBot ? "bot_reply" : "telegram_message",
+          sender_id: update.fromID,
+          sender: update.fromName,
+          sender_username: update.fromUsername,
+          sender_is_bot: update.fromIsBot === true,
+          body: update.text,
+          occurred_at: update.occurredAt,
+          receipt_origin: "local_telegram_inbound",
+          receipt_route_key: owner.routeKey,
+          receipt_bot_username: owner.botUsername,
+          received_at: firstNonEmptyString([update.occurredAt, new Date().toISOString()]),
+        }, receiptKey);
+        return {
+          ownerRouteKey: String(owner.routeKey || "").trim(),
+          receiptEntry,
+        };
+      });
     })
     .filter((artifact) => {
       const normalizedEntry = ensureArray(safeObject(artifact).receiptEntry);
-      return normalizedEntry.length === 2;
+      return normalizedEntry.length === 2 && String(safeObject(artifact).ownerRouteKey || "").trim();
     });
 }
 
+function groupRunnerLocalInboundArtifactsByRoute(localInboundArtifacts) {
+  const grouped = new Map();
+  for (const artifactRaw of ensureArray(localInboundArtifacts)) {
+    const artifact = safeObject(artifactRaw);
+    const ownerRouteKey = String(artifact.ownerRouteKey || "").trim();
+    const normalizedEntry = ensureArray(artifact.receiptEntry);
+    if (!ownerRouteKey || normalizedEntry.length !== 2) {
+      continue;
+    }
+    const routeArtifacts = grouped.get(ownerRouteKey) || [];
+    routeArtifacts.push({ receiptEntry: normalizedEntry });
+    grouped.set(ownerRouteKey, routeArtifacts);
+  }
+  return Object.fromEntries(grouped.entries());
+}
+
 function buildRunnerRecentLocalInboundEnvelopes(routeStateRaw, recentLocalInboundReceipts) {
   const routeState = safeObject(routeStateRaw);
   const relevantEnvelopes = Object.values(safeObject(recentLocalInboundReceipts))
@@ -904,12 +1083,15 @@ export async function archiveLocalTelegramMessagesForRoute({
   const localInboundArtifacts = buildRunnerLocalInboundArtifacts(
     updates,
     routeKey,
+    route,
     bot,
     destination,
+    managedConversationBots,
   );
+  const localInboundArtifactsByRoute = groupRunnerLocalInboundArtifactsByRoute(localInboundArtifacts);
   const recentLocalInboundReceipts = buildRunnerRecentLocalInboundReceipts(
     routeState,
-    localInboundArtifacts,
+    ensureArray(localInboundArtifactsByRoute[routeKey]),
   );
   const recentLocalInboundEnvelopes = buildRunnerRecentLocalInboundEnvelopes(
     routeState,
@@ -926,13 +1108,36 @@ export async function archiveLocalTelegramMessagesForRoute({
     if (sharedInboxPatch && saveBotRunnerState) {
       saveBotRunnerState(sharedInboxPatch);
     }
-    saveRunnerRouteState(
+    const inputRouteKeys = Array.from(new Set([
       routeKey,
-      buildRunnerRouteInputStatePatch({
-        recentLocalInboundEnvelopes,
-        recentLocalInboundReceipts,
-      }),
-    );
+      ...Object.keys(safeObject(localInboundArtifactsByRoute)),
+    ]));
+    for (const targetRouteKey of inputRouteKeys) {
+      const fullState = loadBotRunnerState ? safeObject(loadBotRunnerState()) : {};
+      const targetRouteState = safeObject(
+        safeObject(fullState.routes)[targetRouteKey]
+        || (targetRouteKey === routeKey ? routeState : {}),
+      );
+      const targetRecentLocalInboundReceipts = targetRouteKey === routeKey
+        ? recentLocalInboundReceipts
+        : buildRunnerRecentLocalInboundReceipts(
+          targetRouteState,
+          ensureArray(localInboundArtifactsByRoute[targetRouteKey]),
+        );
+      const targetRecentLocalInboundEnvelopes = targetRouteKey === routeKey
+        ? recentLocalInboundEnvelopes
+        : buildRunnerRecentLocalInboundEnvelopes(
+          targetRouteState,
+          targetRecentLocalInboundReceipts,
+        );
+      saveRunnerRouteState(
+        targetRouteKey,
+        buildRunnerRouteInputStatePatch({
+          recentLocalInboundEnvelopes: targetRecentLocalInboundEnvelopes,
+          recentLocalInboundReceipts: targetRecentLocalInboundReceipts,
+        }),
+      );
+    }
     saveRunnerRouteState(
       routeKey,
       buildRunnerRoutePollingStatePatch({

package/lib/selftest-telegram-e2e.mjs

@@ -1436,6 +1436,113 @@ export async function runSelftestTelegramE2E(push, deps) {
       telegramE2EServer.state.comments.length === 0,
       `comments=${telegramE2EServer.state.comments.length}`,
     );
+
+    telegramE2EServer.state.comments = [];
+    telegramE2EServer.state.updates = [
+      {
+        update_id: 403,
+        message: {
+          message_id: 83,
+          date: Math.floor(Date.now() / 1000),
+          chat: {
+            id: Number(e2eDestination.chat_id),
+            type: "supergroup",
+            title: e2eDestination.label,
+          },
+          from: {
+            id: 7001,
+            is_bot: false,
+            first_name: "Operator",
+            username: "operator_user",
+          },
+          text: "@RyoAI2_bot 하이",
+          entities: buildTelegramMentionEntities("@RyoAI2_bot 하이"),
+        },
+      },
+    ];
+    const routeRyoai1 = normalizeRunnerRoute({
+      ...e2eRoute,
+      name: "selftest-runner-e2e-ownership-ryoai1",
+      server_bot_name: "RyoAI_bot",
+      server_bot_id: "88888888-8888-4888-8888-888888888881",
+      destination_id: "dest-telegram",
+      destination_label: e2eDestination.label,
+    });
+    const routeRyoai2 = normalizeRunnerRoute({
+      ...e2eRoute,
+      name: "selftest-runner-e2e-ownership-ryoai2",
+      server_bot_name: "RyoAI2_bot",
+      server_bot_id: "88888888-8888-4888-8888-888888888882",
+      destination_id: "dest-telegram",
+      destination_label: e2eDestination.label,
+    });
+    const routeRyoai3 = normalizeRunnerRoute({
+      ...e2eRoute,
+      name: "selftest-runner-e2e-ownership-ryoai3",
+      server_bot_name: "RyoAI3_bot",
+      server_bot_id: "88888888-8888-4888-8888-888888888883",
+      destination_id: "dest-telegram",
+      destination_label: e2eDestination.label,
+    });
+    const routeRyoai2Key = runnerRouteKey(routeRyoai2);
+    const routeRyoai3Key = runnerRouteKey(routeRyoai3);
+    await archiveLocalTelegramMessagesForRoute({
+      routeKey: routeRyoai3Key,
+      route: routeRyoai3,
+      routeState: {},
+      runtime: {
+        baseURL: telegramE2EServer.baseURL,
+        timeoutSeconds: 10,
+        token: e2eToken,
+        actor: {
+          user_id: e2eActorUserID,
+        },
+      },
+      bot: {
+        id: "88888888-8888-4888-8888-888888888883",
+        name: "RyoAI3_bot",
+        username: "RyoAI3_bot",
+        role: "monitor",
+      },
+      destination: {
+        chatID: e2eDestination.chat_id,
+      },
+      archiveThread: {
+        threadID: e2eThreadID,
+      },
+      managedConversationBots: [
+        {
+          username: "RyoAI_bot",
+          route: routeRyoai1,
+          bot: { username: "RyoAI_bot", name: "RyoAI_bot" },
+        },
+        {
+          username: "RyoAI2_bot",
+          route: routeRyoai2,
+          bot: { username: "RyoAI2_bot", name: "RyoAI2_bot" },
+        },
+        {
+          username: "RyoAI3_bot",
+          route: routeRyoai3,
+          bot: { username: "RyoAI3_bot", name: "RyoAI3_bot" },
+        },
+      ],
+      deps: buildRunnerRuntimeDeps(),
+    });
+    const ownershipState = loadBotRunnerState();
+    const ryoai2Receipt = safeObject(
+      safeObject(safeObject(ownershipState.routes)[routeRyoai2Key]).recent_local_inbound_receipts?.[`${String(e2eDestination.chat_id)}:83`],
+    );
+    const ryoai3Receipt = safeObject(
+      safeObject(safeObject(ownershipState.routes)[routeRyoai3Key]).recent_local_inbound_receipts?.[`${String(e2eDestination.chat_id)}:83`],
+    );
+    push(
+      "telegram_local_inbound_receipt_is_attributed_to_explicit_mention_owner_route",
+      String(ryoai2Receipt.receipt_route_key || "") === routeRyoai2Key
+        && String(ryoai2Receipt.receipt_bot_username || "") === "ryoai2_bot"
+        && !String(ryoai3Receipt.receipt_route_key || "").trim(),
+      `owner=${JSON.stringify(ryoai2Receipt)} foreign=${JSON.stringify(ryoai3Receipt)}`,
+    );
   } catch (err) {
     push("telegram_runner_e2e_local_mock", false, String(err?.message || err));
   } finally {

package/package.json

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