metheus-governance-mcp-cli 0.2.273 → 0.2.275

package/cli.mjs

@@ -3333,37 +3333,46 @@ function normalizeBotRunnerConsumedComments(rawConsumed, nowMs = Date.now()) {
   return normalized;
 }
 
-function buildRunnerConsumedCommentLedgerKey(commentIDRaw, routeKeyRaw = "", commentKindRaw = "") {
-  const commentID = String(commentIDRaw || "").trim();
-  if (!commentID) return "";
-  const routeKey = String(routeKeyRaw || "").trim();
-  const commentKind = String(commentKindRaw || "").trim().toLowerCase();
-  if (commentKind === "bot_reply" && routeKey) {
-    return `${commentID}::${routeKey}`;
-  }
-  return commentID;
-}
-
-function findRunnerConsumedCommentEntry(rawConsumed, commentIDRaw, { routeKey = "", commentKind = "" } = {}) {
-  const commentID = String(commentIDRaw || "").trim();
-  if (!commentID) return {};
-  const consumedComments = normalizeBotRunnerConsumedComments(rawConsumed);
-  const ledgerKey = buildRunnerConsumedCommentLedgerKey(commentID, routeKey, commentKind);
-  const directEntry = safeObject(consumedComments[ledgerKey]);
-  if (Object.keys(directEntry).length) {
-    return directEntry;
-  }
-  const normalizedKind = String(commentKind || "").trim().toLowerCase();
-  if (normalizedKind === "bot_reply" && String(routeKey || "").trim()) {
-    const routeEntry = Object.values(consumedComments).find((entryRaw) => {
-      const entry = safeObject(entryRaw);
-      return String(entry.comment_id || "").trim() === commentID
-        && String(entry.route_key || "").trim() === String(routeKey || "").trim();
-    });
-    return safeObject(routeEntry);
-  }
-  return safeObject(consumedComments[commentID]);
-}
+function buildRunnerConsumedCommentLedgerKey(commentIDRaw, routeKeyRaw = "", commentKindRaw = "") {
+  const commentID = String(commentIDRaw || "").trim();
+  if (!commentID) return "";
+  const routeKey = String(routeKeyRaw || "").trim();
+  if (routeKey) {
+    return `${commentID}::${routeKey}`;
+  }
+  return commentID;
+}
+
+function findRunnerConsumedCommentEntry(rawConsumed, commentIDRaw, { routeKey = "", commentKind = "" } = {}) {
+  const commentID = String(commentIDRaw || "").trim();
+  if (!commentID) return {};
+  const consumedComments = normalizeBotRunnerConsumedComments(rawConsumed);
+  const normalizedRouteKey = String(routeKey || "").trim();
+  const ledgerKey = buildRunnerConsumedCommentLedgerKey(commentID, normalizedRouteKey, commentKind);
+  const directEntry = safeObject(consumedComments[ledgerKey]);
+  if (Object.keys(directEntry).length) {
+    return directEntry;
+  }
+  if (normalizedRouteKey) {
+    const routeEntry = Object.values(consumedComments).find((entryRaw) => {
+      const entry = safeObject(entryRaw);
+      return String(entry.comment_id || "").trim() === commentID
+        && String(entry.route_key || "").trim() === normalizedRouteKey;
+    });
+    if (Object.keys(safeObject(routeEntry)).length > 0) {
+      return safeObject(routeEntry);
+    }
+  }
+  const legacyGlobalEntry = safeObject(consumedComments[commentID]);
+  if (!Object.keys(legacyGlobalEntry).length) {
+    return {};
+  }
+  const legacyRouteKey = String(legacyGlobalEntry.route_key || "").trim();
+  if (normalizedRouteKey && legacyRouteKey && legacyRouteKey !== normalizedRouteKey) {
+    return {};
+  }
+  return legacyGlobalEntry;
+}
 
 function runnerRouteMatchesProjectConversationScope(candidateRouteRaw, normalizedRouteRaw) {
   const candidateRoute = normalizeRunnerRoute(candidateRouteRaw);
@@ -8582,9 +8591,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();

package/lib/runner-orchestration-entrypoints.mjs

@@ -51,6 +51,150 @@ 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();
+  const messageID = intFromRawAllowZero(parsed.messageID || parsed.messageId, 0);
+  if (!chatID || !(messageID > 0)) {
+    return "";
+  }
+  return `${chatID}:${messageID}${buildRunnerInboundTargetSelectorSuffix(resolveRunnerArchiveSourceTargetSelector(recordRaw))}`;
+}
+
+function buildRunnerLocalInboundReceiptKey(receiptRaw) {
+  const receipt = safeObject(receiptRaw);
+  const chatID = String(receipt.chat_id || receipt.chatID || "").trim();
+  const messageID = intFromRawAllowZero(receipt.message_id || receipt.messageID, 0);
+  if (!chatID || !(messageID > 0)) {
+    return "";
+  }
+  return `${chatID}:${messageID}${buildRunnerInboundTargetSelectorSuffix(resolveRunnerLocalInboundReceiptTargetSelector(receiptRaw))}`;
+}
+
+function buildRunnerReceiptReplaySortTime(receiptRaw) {
+  const receipt = safeObject(receiptRaw);
+  const receiptTime = Date.parse(firstNonEmptyString([
+    receipt.occurred_at,
+    receipt.occurredAt,
+    receipt.received_at,
+    receipt.receivedAt,
+  ]));
+  return Number.isFinite(receiptTime) ? receiptTime : 0;
+}
+
+function buildRunnerReceiptBackedReplayRecord(recordRaw, receiptRaw, pendingSelectionOptions = {}) {
+  const record = safeObject(recordRaw);
+  const receipt = safeObject(receiptRaw);
+  const replayOccurredAt = firstNonEmptyString([
+    receipt.occurred_at,
+    receipt.occurredAt,
+    receipt.received_at,
+    receipt.receivedAt,
+    record.sourceOccurredAt,
+    safeObject(record.parsedArchive).occurredAt,
+    safeObject(record.parsedArchive).occurred_at,
+    record.createdAt,
+    record.updatedAt,
+  ]);
+  let staleAfterAt = String(record.staleAfterAt || "").trim();
+  const maxPendingAgeMs = intFromRawAllowZero(safeObject(pendingSelectionOptions).maxPendingAgeMs, 0);
+  const replayOccurredAtMs = Date.parse(replayOccurredAt);
+  if (!staleAfterAt && maxPendingAgeMs > 0 && Number.isFinite(replayOccurredAtMs)) {
+    staleAfterAt = new Date(replayOccurredAtMs + maxPendingAgeMs).toISOString();
+  }
+  return {
+    ...record,
+    sourceOccurredAt: replayOccurredAt,
+    staleAfterAt,
+    replayTriggeredByLocalReceipt: true,
+  };
+}
+
+function buildRunnerReceiptBackedPendingArchiveComments({
+  orderedComments,
+  currentPollLocalInboundReceipts,
+  existingPendingIDs,
+  pendingSelectionOptions,
+}) {
+  const pendingIDs = new Set(ensureArray(existingPendingIDs).map((value) => String(value || "").trim()).filter(Boolean));
+  const latestReceiptsByKey = new Map();
+  for (const receiptRaw of ensureArray(currentPollLocalInboundReceipts)) {
+    const receipt = safeObject(receiptRaw);
+    const receiptKey = buildRunnerLocalInboundReceiptKey(receipt);
+    if (!receiptKey) {
+      continue;
+    }
+    const previous = safeObject(latestReceiptsByKey.get(receiptKey));
+    if (buildRunnerReceiptReplaySortTime(receipt) >= buildRunnerReceiptReplaySortTime(previous)) {
+      latestReceiptsByKey.set(receiptKey, receipt);
+    }
+  }
+  const replayCandidates = [];
+  for (const [receiptKey, receipt] of latestReceiptsByKey.entries()) {
+    const matchedRecord = orderedComments.find((record) => buildRunnerArchiveSourceMessageKey(record) === receiptKey);
+    const matchedID = String(safeObject(matchedRecord).id || "").trim();
+    if (!matchedID || pendingIDs.has(matchedID)) {
+      continue;
+    }
+    replayCandidates.push(buildRunnerReceiptBackedReplayRecord(
+      matchedRecord,
+      receipt,
+      pendingSelectionOptions,
+    ));
+  }
+  return replayCandidates.sort(compareArchiveCommentRecords);
+}
+
 function buildContextSpeakerType(parsedArchiveRaw) {
   const parsed = safeObject(parsedArchiveRaw);
   const kind = String(parsed.kind || "").trim();
@@ -63,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 = [];
@@ -862,10 +1002,24 @@ export function selectRunnerPendingWork({
         pending: importedPendingAfterCursor,
       }, pendingSelectionOptions)
       : fullPending;
+  const receiptBackedPending = buildRunnerReceiptBackedPendingArchiveComments({
+    orderedComments,
+    currentPollLocalInboundReceipts: ensureArray(importOutcome?.currentPollLocalInboundReceipts),
+    existingPendingIDs: ensureArray(safeObject(pending).pending).map((record) => String(safeObject(record).id || "").trim()),
+    pendingSelectionOptions,
+  });
+  const finalPending = ensureArray(safeObject(pending).pending).length === 0 && receiptBackedPending.length > 0
+    ? applyPendingAgeSelection({
+      ...safeObject(pending),
+      shouldPrime: false,
+      pending: receiptBackedPending,
+    }, pendingSelectionOptions)
+    : pending;
   return {
     orderedComments,
     inboundComments,
     importedRecords,
-    pending,
+    receiptBackedPending,
+    pending: finalPending,
   };
 }

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,
@@ -575,6 +617,14 @@ function groupRunnerLocalInboundArtifactsByRoute(localInboundArtifacts) {
   return Object.fromEntries(grouped.entries());
 }
 
+function buildRunnerCurrentPollLocalInboundReceipts(localInboundArtifactsByRoute, routeKey) {
+  return ensureArray(safeObject(localInboundArtifactsByRoute)[String(routeKey || "").trim()])
+    .map((artifactRaw) => ensureArray(safeObject(artifactRaw).receiptEntry))
+    .filter((entry) => entry.length === 2)
+    .map((entry) => safeObject(entry[1]))
+    .filter((receipt) => Object.keys(receipt).length > 0);
+}
+
 function buildRunnerRecentLocalInboundEnvelopes(routeStateRaw, recentLocalInboundReceipts) {
   const routeState = safeObject(routeStateRaw);
   const relevantEnvelopes = Object.values(safeObject(recentLocalInboundReceipts))
@@ -620,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()) {
@@ -638,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,
@@ -769,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)),
   );
 }
 
@@ -827,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;
@@ -843,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,
@@ -1144,6 +1208,10 @@ export async function archiveLocalTelegramMessagesForRoute({
     managedConversationBots,
   );
   const localInboundArtifactsByRoute = groupRunnerLocalInboundArtifactsByRoute(localInboundArtifacts);
+  const currentPollLocalInboundReceipts = buildRunnerCurrentPollLocalInboundReceipts(
+    localInboundArtifactsByRoute,
+    routeKey,
+  );
   const recentLocalInboundReceipts = buildRunnerRecentLocalInboundReceipts(
     routeState,
     ensureArray(localInboundArtifactsByRoute[routeKey]),
@@ -1205,7 +1273,9 @@ export async function archiveLocalTelegramMessagesForRoute({
     persistPollingProgress([], lastUpdateID);
     return {
       importedCommentIDs: [],
+      importedComments: [],
       importedCount: 0,
+      currentPollLocalInboundReceipts,
       lastUpdateID,
     };
   }
@@ -1249,6 +1319,7 @@ export async function archiveLocalTelegramMessagesForRoute({
     importedCommentIDs,
     importedComments,
     importedCount: importedCommentIDs.length,
+    currentPollLocalInboundReceipts,
     lastUpdateID: Math.max(lastUpdateID, handledUpdateID),
   };
 }

package/lib/selftest-runner-scenarios.mjs

@@ -1007,6 +1007,63 @@ export async function runSelftestRunnerScenarios(push, deps) {
     );
   }
 
+  try {
+    const pendingWork = selectRunnerPendingWork({
+      comments: [
+        {
+          id: "archived-current-message",
+          createdAt: "2026-03-18T00:00:01.000Z",
+          updatedAt: "2026-03-18T00:00:01.000Z",
+          parsedArchive: { kind: "telegram_message", chatID: "-1001", messageID: 280, body: "@RyoAI3_bot 하이" },
+        },
+        {
+          id: "cursor-comment",
+          createdAt: "2026-03-18T00:04:00.000Z",
+          updatedAt: "2026-03-18T00:04:00.000Z",
+          parsedArchive: { kind: "telegram_message", chatID: "-1001", messageID: 281, body: "@RyoAI_bot already processed" },
+        },
+      ],
+      importOutcome: {
+        importedCommentIDs: [],
+        currentPollLocalInboundReceipts: [
+          {
+            chat_id: "-1001",
+            message_id: 280,
+            occurred_at: "2026-03-18T00:05:00.000Z",
+            received_at: "2026-03-18T00:05:00.000Z",
+            update_id: 2001,
+          },
+        ],
+      },
+      refreshedState: {
+        last_processed_comment_id: "cursor-comment",
+        last_processed_created_at: "2026-03-18T00:04:00.000Z",
+      },
+      mode: "start",
+      parseArchivedChatComment: () => null,
+      deps: {
+        normalizeArchiveCommentRecord: (record) => record,
+        applyPendingAgeSelection: (selection) => selection,
+      },
+      pendingSelectionOptions: {
+        maxPendingAgeMs: 15 * 60 * 1000,
+      },
+    });
+    push(
+      "runner_pending_selection_replays_current_poll_local_receipt_against_existing_archive_comment",
+      pendingWork.pending.pending.length === 1
+        && String(pendingWork.pending.pending[0]?.id || "").trim() === "archived-current-message"
+        && pendingWork.pending.pending[0]?.replayTriggeredByLocalReceipt === true,
+      `pending=${pendingWork.pending.pending.map((item) => `${item.id}:${String(item.replayTriggeredByLocalReceipt === true)}`).join(",") || "(none)"}`,
+    );
+  } catch (err) {
+    push(
+      "runner_pending_selection_replays_current_poll_local_receipt_against_existing_archive_comment",
+      false,
+      String(err?.message || err),
+    );
+  }
+
   try {
     const selected = selectProjectChatDestination(
       [
@@ -2042,10 +2099,16 @@ export async function runSelftestRunnerScenarios(push, deps) {
       selectedRecord: humanRecord,
       selectedBotUsernames: ["ryoai_bot"],
       normalizedIntent: "coordination_request",
-    });
-    const claimedState = loadBotRunnerState();
-    const claimedRequest = safeObject(safeObject(claimedState.requests)[claimed.requestKey]);
-    const claimedConsumed = safeObject(safeObject(claimedState.consumedComments)[humanRecord.id]);
+    });
+    const claimedState = loadBotRunnerState();
+    const claimedRequest = safeObject(safeObject(claimedState.requests)[claimed.requestKey]);
+    const claimedConsumed = safeObject(
+      Object.values(safeObject(claimedState.consumedComments)).find((entryRaw) => {
+        const entry = safeObject(entryRaw);
+        return String(entry.comment_id || "").trim() === humanRecord.id
+          && String(entry.route_key || "").trim() === requestRouteKey;
+      }),
+    );
     push(
       "runner_request_claim_persists_request_and_consumed_comment",
       claimed.ok === true
@@ -19628,6 +19691,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.273",
+  "version": "0.2.275",
   "description": "Metheus Governance MCP CLI (setup + stdio proxy)",
   "type": "module",
   "files": [