metheus-governance-mcp-cli 0.2.274 → 0.2.276

package/cli.mjs

@@ -133,15 +133,16 @@ import {
   tryRegister,
   withWorkspaceDirArg,
 } from "./lib/client-registration.mjs";
-import {
-  applyPendingAgeSelection,
-  buildTelegramBotReplyEnvelope,
-  buildTelegramMessageEnvelopeFromParsedArchive as buildRunnerTelegramMessageEnvelopeFromParsedArchive,
-  buildRunnerRouteStateFromComment,
-  buildProcessableArchiveLogicalKey,
-  findEarlierProcessableArchiveDuplicate,
-  findRecentTelegramMessageEnvelope,
-  isTelegramLocalInboundEnvelopeForRoute,
+import {
+  applyPendingAgeSelection,
+  buildTelegramBotReplyEnvelope,
+  buildTelegramMessageEnvelopeFromParsedArchive as buildRunnerTelegramMessageEnvelopeFromParsedArchive,
+  buildRunnerRouteDuplicateStateFromComment,
+  buildRunnerRouteStateFromComment,
+  buildProcessableArchiveLogicalKey,
+  findEarlierProcessableArchiveDuplicate,
+  findRecentTelegramMessageEnvelope,
+  isTelegramLocalInboundEnvelopeForRoute,
   isInboundArchiveKind,
   normalizeTelegramMessageEnvelope as normalizeRunnerTelegramMessageEnvelope,
   normalizeArchiveCommentRecord,
@@ -2100,12 +2101,15 @@ function mergeRunnerStateRecords(preferred, fallback) {
     }
     return safeObject(secondary[key]);
   };
-  return {
-    last_processed_comment_id: pickStringField("last_processed_comment_id"),
-    last_processed_created_at: pickStringField("last_processed_created_at"),
-    last_source_message_id: pickNumberField("last_source_message_id", { allowUndefined: true }),
-    last_source_kind: pickStringField("last_source_kind"),
-    last_error: pickStringField("last_error", { allowBlank: true }),
+  return {
+    last_processed_comment_id: pickStringField("last_processed_comment_id"),
+    last_processed_created_at: pickStringField("last_processed_created_at"),
+    last_dedupe_comment_id: pickStringField("last_dedupe_comment_id"),
+    last_source_message_id: pickNumberField("last_source_message_id", { allowUndefined: true }),
+    last_source_kind: pickStringField("last_source_kind"),
+    last_dedupe_source_message_id: pickNumberField("last_dedupe_source_message_id", { allowUndefined: true }),
+    last_dedupe_source_kind: pickStringField("last_dedupe_source_kind"),
+    last_error: pickStringField("last_error", { allowBlank: true }),
     updated_at: firstNonEmptyString([primary.updated_at, secondary.updated_at, new Date().toISOString()]),
     last_action: pickStringField("last_action"),
     last_reason: pickStringField("last_reason"),
@@ -5856,11 +5860,11 @@ function maybeBuildDuplicateArchivedSkipForRoute({
     };
   }
   const duplicateState = safeObject(routeStateForDuplicate);
-  const lastSourceMessageID = intFromRawAllowZero(duplicateState.last_source_message_id, 0);
-  const lastSourceKind = String(duplicateState.last_source_kind || "").trim().toLowerCase();
+  const lastSourceMessageID = intFromRawAllowZero(duplicateState.last_dedupe_source_message_id, 0);
+  const lastSourceKind = String(duplicateState.last_dedupe_source_kind || "").trim().toLowerCase();
   const selectedMessageID = intFromRawAllowZero(selectedParsed.messageID, 0);
   const selectedKind = String(selectedParsed.kind || "").trim().toLowerCase();
-  const lastCommentID = String(duplicateState.last_processed_comment_id || "").trim();
+  const lastCommentID = String(duplicateState.last_dedupe_comment_id || "").trim();
   if (
     selectedMessageID > 0
     && lastSourceMessageID > 0
@@ -8591,9 +8595,11 @@ function normalizeLocalTelegramUpdate(rawUpdate) {
   };
 }
 
-function buildArchivedInboundMessageKey(chatID, messageID) {
-  return `${String(chatID || "").trim()}:${intFromRawAllowZero(messageID, 0)}`;
-}
+function buildArchivedInboundMessageKey(chatID, messageID, sourceBotUsername = "") {
+  const baseKey = `${String(chatID || "").trim()}:${intFromRawAllowZero(messageID, 0)}`;
+  const normalizedBotUsername = normalizeTelegramMentionUsername(sourceBotUsername);
+  return normalizedBotUsername ? `${baseKey}::${normalizedBotUsername}` : baseKey;
+}
 
 function formatTelegramInboundArchiveComment(normalized) {
   const archiveSourceOrigin = String(normalized.archiveSourceOrigin || normalized.sourceOrigin || "").trim();
@@ -10575,6 +10581,7 @@ async function processRunnerRouteOnce(route, runtime, mode, options = {}) {
           }),
           requestKey: requestClaim.requestKey,
           claimedRequest,
+          dedupeStatePatch: buildRunnerRouteDuplicateStateFromComment(selectedRecord),
           visibilityStatePatch,
         });
         saveRunnerRouteState(routeKey, acceptedExecutionRoutePatch);
@@ -10739,6 +10746,7 @@ async function processRunnerRouteOnce(route, runtime, mode, options = {}) {
         }),
         requestKey: requestClaim.requestKey,
         claimedRequest,
+        dedupeStatePatch: buildRunnerRouteDuplicateStateFromComment(selectedRecord),
         visibilityStatePatch,
       });
       saveRunnerRouteState(routeKey, acceptedExecutionRoutePatch);

package/lib/runner-helpers.mjs

@@ -534,6 +534,16 @@ export function buildRunnerRouteStateFromComment(record, patch = {}) {
   };
 }
 
+export function buildRunnerRouteDuplicateStateFromComment(record, patch = {}) {
+  const parsed = safeObject(record?.parsedArchive);
+  return {
+    last_dedupe_comment_id: String(record?.id || "").trim(),
+    last_dedupe_source_message_id: intFromRawAllowZero(parsed.messageID, 0) || undefined,
+    last_dedupe_source_kind: String(parsed.kind || "").trim(),
+    ...safeObject(patch),
+  };
+}
+
 export function normalizeArchiveCommentRecord(rawComment, parseArchivedChatComment) {
   const comment = safeObject(rawComment);
   const body = String(comment.body || "").trim();

package/lib/runner-orchestration-entrypoints.mjs

@@ -51,6 +51,56 @@ function intFromRawAllowZero(raw, fallback = 0) {
   return Number.isFinite(parsed) ? parsed : fallback;
 }
 
+function escapeRegex(text) {
+  return String(text || "").replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+function normalizeMentionSelector(value) {
+  return String(value || "").trim().replace(/^@+/, "").toLowerCase();
+}
+
+function buildRunnerInboundTargetSelectorSuffix(selector) {
+  const normalizedSelector = normalizeMentionSelector(selector);
+  return normalizedSelector ? `::${normalizedSelector}` : "";
+}
+
+function resolveRunnerArchiveSourceTargetSelector(recordRaw) {
+  const parsed = safeObject(safeObject(recordRaw).parsedArchive);
+  return normalizeMentionSelector(parsed.sourceBotUsername || parsed.source_bot_username);
+}
+
+function resolveRunnerLocalInboundReceiptTargetSelector(receiptRaw) {
+  const receipt = safeObject(receiptRaw);
+  const receiptBotSelector = normalizeMentionSelector(
+    receipt.receipt_bot_username
+    || receipt.receiptBotUsername
+    || receipt.source_bot_username
+    || receipt.sourceBotUsername,
+  );
+  if (!receiptBotSelector) {
+    return "";
+  }
+  const replyTargetSelector = normalizeMentionSelector(
+    receipt.reply_to_from_username
+    || receipt.replyToFromUsername
+    || receipt.reply_to_username
+    || receipt.replyToUsername,
+  );
+  const replyTargetIsBot = receipt.reply_to_from_is_bot === true
+    || receipt.replyToFromIsBot === true
+    || receipt.reply_to_sender_is_bot === true
+    || receipt.replyToSenderIsBot === true;
+  if (replyTargetIsBot && replyTargetSelector && replyTargetSelector === receiptBotSelector) {
+    return receiptBotSelector;
+  }
+  const body = String(receipt.body || receipt.text || "").trim();
+  if (!body) {
+    return "";
+  }
+  const mentionPattern = new RegExp(`(^|\\s)@${escapeRegex(receiptBotSelector)}(?=\\b|\\s|$)`, "i");
+  return mentionPattern.test(body) ? receiptBotSelector : "";
+}
+
 function buildRunnerArchiveSourceMessageKey(recordRaw) {
   const parsed = safeObject(safeObject(recordRaw).parsedArchive);
   const chatID = String(parsed.chatID || parsed.chatId || "").trim();
@@ -58,7 +108,7 @@ function buildRunnerArchiveSourceMessageKey(recordRaw) {
   if (!chatID || !(messageID > 0)) {
     return "";
   }
-  return `${chatID}:${messageID}`;
+  return `${chatID}:${messageID}${buildRunnerInboundTargetSelectorSuffix(resolveRunnerArchiveSourceTargetSelector(recordRaw))}`;
 }
 
 function buildRunnerLocalInboundReceiptKey(receiptRaw) {
@@ -68,7 +118,7 @@ function buildRunnerLocalInboundReceiptKey(receiptRaw) {
   if (!chatID || !(messageID > 0)) {
     return "";
   }
-  return `${chatID}:${messageID}`;
+  return `${chatID}:${messageID}${buildRunnerInboundTargetSelectorSuffix(resolveRunnerLocalInboundReceiptTargetSelector(receiptRaw))}`;
 }
 
 function buildRunnerReceiptReplaySortTime(receiptRaw) {
@@ -157,10 +207,6 @@ function buildContextSpeakerType(parsedArchiveRaw) {
   return parsed.senderIsBot === true ? "bot" : "system";
 }
 
-function normalizeMentionSelector(value) {
-  return String(value || "").trim().replace(/^@+/, "").toLowerCase();
-}
-
 function uniqueOrdered(values) {
   const seen = new Set();
   const output = [];

package/lib/runner-recorder-active-execution-handoff.mjs

@@ -10,6 +10,7 @@ export function buildRunnerAcceptedExecutionRoutePatch({
   requestKey = "",
   claimedRequest = {},
   visibilityStatePatch = {},
+  dedupeStatePatch = {},
 }) {
   const normalizedActiveExecutionPatch = safeObject(activeExecutionPatch);
   const normalizedClaimedRequest = safeObject(claimedRequest);
@@ -19,6 +20,7 @@ export function buildRunnerAcceptedExecutionRoutePatch({
     last_root_work_item_id: String(normalizedClaimedRequest.root_work_item_id || "").trim(),
     last_root_work_item_title: String(normalizedClaimedRequest.root_work_item_title || "").trim(),
     last_root_work_item_status: String(normalizedClaimedRequest.root_work_item_status || "").trim(),
+    ...safeObject(dedupeStatePatch),
     ...safeObject(visibilityStatePatch),
   };
 }

package/lib/runner-runtime.mjs

@@ -280,6 +280,34 @@ function currentRouteOwnsRunnerInboundUpdate({
   }).some((owner) => String(safeObject(owner).routeKey || "").trim() === normalizedRouteKey);
 }
 
+function resolveRunnerInboundArchiveSourceBotUsername({
+  update,
+  route,
+  bot,
+}) {
+  const normalizedUpdate = safeObject(update);
+  const currentBotSelectors = buildRouteBotUsernameCandidates(bot, route);
+  const currentBotSelector = ensureArray(currentBotSelectors)[0] || "";
+  if (!currentBotSelector) {
+    return "";
+  }
+  const explicitMentions = ensureArray(normalizedUpdate.mentionUsernames)
+    .map((value) => normalizeMentionSelector(value))
+    .filter(Boolean);
+  if (explicitMentions.includes(currentBotSelector)) {
+    return currentBotSelector;
+  }
+  const replyTargetSelector = normalizeMentionSelector(normalizedUpdate.replyToFromUsername);
+  if (
+    normalizedUpdate.replyToFromIsBot === true
+    && replyTargetSelector
+    && currentBotSelectors.includes(replyTargetSelector)
+  ) {
+    return replyTargetSelector;
+  }
+  return "";
+}
+
 function managedConversationBotTargetsCurrentRoute({
   update,
   bot,
@@ -480,6 +508,18 @@ function normalizeRunnerRecentLocalInboundReceipt(rawReceipt, fallbackKey = "")
   if (replyToMessageID > 0) {
     normalized.reply_to_message_id = replyToMessageID;
   }
+  const replyToFromUsername = firstNonEmptyString([
+    receipt.reply_to_from_username,
+    receipt.replyToFromUsername,
+    receipt.reply_to_username,
+    receipt.replyToUsername,
+  ]);
+  if (replyToFromUsername) {
+    normalized.reply_to_from_username = replyToFromUsername;
+  }
+  if (receipt.reply_to_from_is_bot === true || receipt.replyToFromIsBot === true) {
+    normalized.reply_to_from_is_bot = true;
+  }
   const chatType = firstNonEmptyString([receipt.chat_type, receipt.chatType]);
   if (chatType) {
     normalized.chat_type = chatType;
@@ -535,6 +575,8 @@ function buildRunnerLocalInboundArtifacts(updates, routeKey, route, bot, destina
           message_id: messageID,
           message_thread_id: intFromRawAllowZero(update.messageThreadID, 0),
           reply_to_message_id: intFromRawAllowZero(update.replyToMessageID, 0),
+          reply_to_from_username: update.replyToFromUsername,
+          reply_to_from_is_bot: update.replyToFromIsBot === true,
           kind: update.fromIsBot ? "bot_reply" : "telegram_message",
           sender_id: update.fromID,
           sender: update.fromName,
@@ -628,14 +670,16 @@ function buildRunnerRecentLocalInboundReceipts(routeStateRaw, localInboundArtifa
 const RUNNER_INBOUND_ARCHIVE_RESERVATION_TTL_MS = 10 * 60 * 1000;
 const runnerInboundArchiveReservations = new Map();
 
-function buildRunnerInboundArchiveReservationKey(threadID, chatID, messageID) {
+function buildRunnerInboundArchiveReservationKey(threadID, chatID, messageID, sourceBotUsername = "") {
   const normalizedThreadID = String(threadID || "").trim();
   const normalizedChatID = String(chatID || "").trim();
   const normalizedMessageID = intFromRawAllowZero(messageID, 0);
+  const normalizedSourceBotUsername = normalizeMentionSelector(sourceBotUsername);
   if (!normalizedThreadID || !normalizedChatID || !(normalizedMessageID > 0)) {
     return "";
   }
-  return `${normalizedThreadID}::${normalizedChatID}:${normalizedMessageID}`;
+  const baseKey = `${normalizedThreadID}::${normalizedChatID}:${normalizedMessageID}`;
+  return normalizedSourceBotUsername ? `${baseKey}::${normalizedSourceBotUsername}` : baseKey;
 }
 
 function cleanupRunnerInboundArchiveReservations(nowMs = Date.now()) {
@@ -646,8 +690,8 @@ function cleanupRunnerInboundArchiveReservations(nowMs = Date.now()) {
   }
 }
 
-function reserveRunnerInboundArchiveMessage(threadID, chatID, messageID) {
-  const reservationKey = buildRunnerInboundArchiveReservationKey(threadID, chatID, messageID);
+function reserveRunnerInboundArchiveMessage(threadID, chatID, messageID, sourceBotUsername = "") {
+  const reservationKey = buildRunnerInboundArchiveReservationKey(threadID, chatID, messageID, sourceBotUsername);
   if (!reservationKey) {
     return {
       ok: false,
@@ -777,7 +821,7 @@ async function loadRunnerExistingInboundArchiveKeys({
       .map((record) => normalizeArchiveCommentRecord(record, parseArchivedChatComment))
       .map((record) => record.parsedArchive)
       .filter((parsed) => parsed && isInboundArchiveKind(parsed.kind) && parsed.chatID)
-      .map((parsed) => buildArchivedInboundMessageKey(parsed.chatID, parsed.messageID)),
+      .map((parsed) => buildArchivedInboundMessageKey(parsed.chatID, parsed.messageID, parsed.sourceBotUsername)),
   );
 }
 
@@ -835,12 +879,22 @@ async function archiveRunnerTelegramInboundUpdates({
     ) {
       continue;
     }
-    const dedupeKey = buildArchivedInboundMessageKey(update.chatID, update.messageID);
+    const archiveSourceBotUsername = resolveRunnerInboundArchiveSourceBotUsername({
+      update,
+      route,
+      bot,
+    });
+    const dedupeKey = buildArchivedInboundMessageKey(update.chatID, update.messageID, archiveSourceBotUsername);
     if (boolFromRaw(archivePolicy.dedupeInbound, true) && existingKeys.has(dedupeKey)) {
       continue;
     }
     const reservation = boolFromRaw(archivePolicy.dedupeInbound, true)
-      ? reserveRunnerInboundArchiveMessage(archiveThread?.threadID, update.chatID, update.messageID)
+      ? reserveRunnerInboundArchiveMessage(
+        archiveThread?.threadID,
+        update.chatID,
+        update.messageID,
+        archiveSourceBotUsername,
+      )
       : { ok: true, reservationKey: "" };
     if (!reservation.ok) {
       continue;
@@ -851,6 +905,8 @@ async function archiveRunnerTelegramInboundUpdates({
       archiveBody = formatTelegramInboundArchiveComment({
         ...update,
         archiveSourceOrigin: "telegram_archive_context",
+        archiveSourceRouteKey: archiveSourceBotUsername ? String(routeKey || "").trim() : "",
+        archiveSourceBotUsername,
       });
       createdComment = await createThreadComment({
         siteBaseURL: runtime.baseURL,

package/lib/selftest-runner-scenarios.mjs

@@ -88,6 +88,10 @@ import {
 import {
   resolveCodexRawTextProcessResult,
 } from "./local-ai-adapters.mjs";
+import {
+  buildRunnerRouteDuplicateStateFromComment,
+  buildRunnerRouteStateFromComment,
+} from "./runner-helpers.mjs";
 import {
   buildRunnerInheritedRootReferenceRecorderResult,
   buildRunnerRootThreadRecorderFailure,
@@ -17735,6 +17739,17 @@ export async function runSelftestRunnerScenarios(push, deps) {
   }
 
   try {
+    const foreignSkipState = buildRunnerRouteStateFromComment({
+      id: "comment-foreign-skip-1",
+      createdAt: "2026-04-01T00:00:00.000Z",
+      parsedArchive: {
+        kind: "telegram_message",
+        messageID: 1178,
+      },
+    }, {
+      last_action: "trigger_skipped",
+      last_reason: "group message mentioned a different bot",
+    });
     const acceptedRoutePatch = buildRunnerAcceptedExecutionRoutePatch({
       activeExecutionPatch: {
         active_comment_id: "comment-active-handoff-1",
@@ -17747,6 +17762,13 @@ export async function runSelftestRunnerScenarios(push, deps) {
         root_work_item_title: "Runner Accepted Handoff",
         root_work_item_status: "doing",
       },
+      dedupeStatePatch: buildRunnerRouteDuplicateStateFromComment({
+        id: "comment-active-handoff-1",
+        parsedArchive: {
+          kind: "telegram_message",
+          messageID: 1180,
+        },
+      }),
       visibilityStatePatch: {
         last_visibility_mode: "reply",
         last_visibility_status: "visible",
@@ -17757,11 +17779,15 @@ export async function runSelftestRunnerScenarios(push, deps) {
       String(acceptedRoutePatch.active_comment_id || "") === "comment-active-handoff-1"
         && String(acceptedRoutePatch.last_request_key || "") === "request-active-handoff-1"
         && String(acceptedRoutePatch.last_root_work_item_title || "") === "Runner Accepted Handoff"
+        && String(acceptedRoutePatch.last_dedupe_comment_id || "") === "comment-active-handoff-1"
+        && String(acceptedRoutePatch.last_dedupe_source_kind || "") === "telegram_message"
+        && Number(acceptedRoutePatch.last_dedupe_source_message_id || 0) === 1180
+        && String(foreignSkipState.last_dedupe_comment_id || "") === ""
         && String(acceptedRoutePatch.last_visibility_status || "") === "visible"
         && !Object.prototype.hasOwnProperty.call(acceptedRoutePatch, "text")
         && !Object.prototype.hasOwnProperty.call(acceptedRoutePatch, "archiveConversation")
         && !Object.prototype.hasOwnProperty.call(acceptedRoutePatch, "delivery"),
-      `request=${String(acceptedRoutePatch.last_request_key || "(none)")} root=${String(acceptedRoutePatch.last_root_work_item_id || "(none)")} visibility=${String(acceptedRoutePatch.last_visibility_status || "(none)")}`,
+      `request=${String(acceptedRoutePatch.last_request_key || "(none)")} root=${String(acceptedRoutePatch.last_root_work_item_id || "(none)")} dedupe=${String(acceptedRoutePatch.last_dedupe_source_message_id || "(none)")} foreign_skip_dedupe=${String(foreignSkipState.last_dedupe_comment_id || "(none)")} visibility=${String(acceptedRoutePatch.last_visibility_status || "(none)")}`,
     );
   } catch (err) {
     push("runner_recorder_active_execution_handoff_stays_within_module_5_boundary", false, String(err?.message || err));
@@ -19691,6 +19717,66 @@ export async function runSelftestRunnerScenarios(push, deps) {
     push("runner_entrypoint_pending_selection_stays_within_module_4_7_boundary", false, String(err?.message || err));
   }
 
+  try {
+    const foreignArchiveComment = {
+      id: "comment-foreign-owner-1",
+      createdAt: "2026-03-30T00:00:00.000Z",
+      updatedAt: "2026-03-30T00:00:00.000Z",
+      body: "@woobn_bot hi",
+      parsedArchive: {
+        kind: "telegram_message",
+        messageID: 280,
+        chatID: "-100999",
+        chatType: "supergroup",
+        sender: "tester",
+        senderIsBot: false,
+        body: "@woobn_bot hi",
+        sourceBotUsername: "woobn_bot",
+      },
+    };
+    const pendingWork = selectRunnerPendingWorkEntrypoint({
+      comments: [foreignArchiveComment],
+      importOutcome: {
+        importedCommentIDs: [],
+        importedComments: [],
+        currentPollLocalInboundReceipts: [
+          {
+            chat_id: "-100999",
+            message_id: 280,
+            body: "@RyoAI3_bot 하이",
+            receipt_bot_username: "ryoai3_bot",
+            occurred_at: "2026-03-31T00:10:00.000Z",
+          },
+        ],
+      },
+      refreshedState: {
+        last_processed_comment_id: "comment-foreign-owner-1",
+        last_processed_created_at: "2026-03-30T00:00:00.000Z",
+      },
+      mode: "continue",
+      parseArchivedChatComment,
+      deps: {
+        normalizeArchiveCommentRecord: (record) => ({
+          id: String(record?.id || "").trim(),
+          body: String(record?.body || "").trim(),
+          createdAt: String(record?.created_at || record?.createdAt || record?.updated_at || record?.updatedAt || "").trim(),
+          updatedAt: String(record?.updated_at || record?.updatedAt || "").trim(),
+          parsedArchive: safeObject(record?.parsedArchive),
+        }),
+        applyPendingAgeSelection: (selection) => selection,
+      },
+      pendingSelectionOptions: {},
+    });
+    push(
+      "runner_entrypoint_receipt_replay_skips_foreign_bot_archive_collision",
+      ensureArray(pendingWork.receiptBackedPending).length === 0
+        && ensureArray(safeObject(pendingWork.pending).pending).length === 0,
+      `replay=${String(ensureArray(pendingWork.receiptBackedPending).length)} pending=${String(ensureArray(safeObject(pendingWork.pending).pending).length)}`,
+    );
+  } catch (err) {
+    push("runner_entrypoint_receipt_replay_skips_foreign_bot_archive_collision", false, String(err?.message || err));
+  }
+
   try {
     const deliveryContext = await prepareLocalBotDeliveryContext({
       siteBaseURL: "https://example.test",

package/lib/selftest-telegram-e2e.mjs

@@ -923,10 +923,10 @@ export async function runSelftestTelegramE2E(push, deps) {
       `envelope=${JSON.stringify(progressEnvelope)}`,
     );
     push(
-      "telegram_archive_comment_is_context_only_without_route_ownership_fields",
+      "telegram_archive_comment_preserves_route_ownership_fields_for_explicit_targeting",
       progressCommentBody.includes("archive_source_origin: telegram_archive_context")
-        && !progressCommentBody.includes("archive_source_route_key:")
-        && !progressCommentBody.includes("archive_source_bot_username:"),
+        && progressCommentBody.includes("archive_source_route_key:")
+        && progressCommentBody.includes("archive_source_bot_username:"),
       `body=${progressCommentBody}`,
     );
     const progressParsedArchive = parseArchivedChatComment(progressCommentBody);
@@ -1657,6 +1657,93 @@ export async function runSelftestTelegramE2E(push, deps) {
         && ownershipBodies.length === 0,
       `owner=${JSON.stringify(ryoai2Receipt)} foreign=${JSON.stringify(ryoai3Receipt)} comments=${ownershipBodies.join(" || ")}`,
     );
+
+    telegramE2EServer.state.comments = [
+      {
+        id: "foreign-owner-archive-280",
+        body: buildRunnerRuntimeDeps().formatTelegramInboundArchiveComment({
+          eventName: "telegram.message.created",
+          chatID: e2eDestination.chat_id,
+          chatType: "supergroup",
+          messageID: 280,
+          fromID: "7001",
+          fromName: "Operator",
+          fromUsername: "operator_user",
+          fromIsBot: false,
+          mentionUsernames: ["woobn_bot"],
+          text: "@WooBN_bot 하이",
+          occurredAt: "2026-03-31T00:00:00.000Z",
+          archiveSourceOrigin: "telegram_archive_context",
+          archiveSourceRouteKey: "telegram-monitor-woobn-bot::project::telegram::monitor::dest::actor",
+          archiveSourceBotUsername: "woobn_bot",
+        }),
+        created_at: "2026-03-31T00:00:01.000Z",
+        updated_at: "2026-03-31T00:00:01.000Z",
+        author_user_id: e2eActorUserID,
+      },
+    ];
+    telegramE2EServer.state.updates = [
+      {
+        update_id: 404,
+        message: {
+          message_id: 280,
+          date: Math.floor(Date.now() / 1000),
+          chat: {
+            id: Number(e2eDestination.chat_id),
+            type: "supergroup",
+            title: e2eDestination.label,
+          },
+          from: {
+            id: 7002,
+            is_bot: false,
+            first_name: "Operator",
+            username: "operator_user",
+          },
+          text: "@RyoAI3_bot 하이",
+          entities: buildTelegramMentionEntities("@RyoAI3_bot 하이"),
+        },
+      },
+    ];
+    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: "RyoAI3_bot",
+          route: routeRyoai3,
+          bot: { username: "RyoAI3_bot", name: "RyoAI3_bot" },
+        },
+      ],
+      deps: buildRunnerRuntimeDeps(),
+    });
+    const foreignCollisionBodies = telegramE2EServer.state.comments.map((item) => String(item.body || ""));
+    push(
+      "telegram_explicit_self_mention_reimports_when_same_message_id_exists_for_foreign_bot_archive",
+      foreignCollisionBodies.filter((item) => item.includes("message_id: 280")).length === 2
+        && foreignCollisionBodies.some((item) => item.includes("archive_source_bot_username: @ryoai3_bot")),
+      `count=${foreignCollisionBodies.filter((item) => item.includes("message_id: 280")).length} bodies=${foreignCollisionBodies.join(" || ")}`,
+    );
   } 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.274",
+  "version": "0.2.276",
   "description": "Metheus Governance MCP CLI (setup + stdio proxy)",
   "type": "module",
   "files": [