metheus-governance-mcp-cli 0.2.281 → 0.2.282

package/cli.mjs

@@ -3111,20 +3111,25 @@ function normalizeBotRunnerRequests(rawRequests, nowMs = Date.now()) {
         entry.sourceMessageBotUsername,
       ]),
     });
-    normalized[requestKey] = {
-      request_key: requestKey,
-      project_id: String(entry.project_id || entry.projectID || "").trim(),
-      provider: String(entry.provider || "").trim(),
-      chat_id: firstNonEmptyString([
-        entry.chat_id,
-        entry.chatID,
-        normalizedSourceMessageEnvelope.chat_id,
-      ]),
-      source_message_id: intFromRawAllowZero(
-        entry.source_message_id
-        || entry.sourceMessageID
-        || normalizedSourceMessageEnvelope.message_id,
-        0,
+    normalized[requestKey] = {
+      request_key: requestKey,
+      project_id: String(entry.project_id || entry.projectID || "").trim(),
+      provider: String(entry.provider || "").trim(),
+      chat_id: firstNonEmptyString([
+        entry.chat_id,
+        entry.chatID,
+        normalizedSourceMessageEnvelope.chat_id,
+      ]),
+      canonical_human_message_key: firstNonEmptyString([
+        entry.canonical_human_message_key,
+        entry.canonicalHumanMessageKey,
+        normalizedSourceMessageEnvelope.canonical_human_message_key,
+      ]),
+      source_message_id: intFromRawAllowZero(
+        entry.source_message_id
+        || entry.sourceMessageID
+        || normalizedSourceMessageEnvelope.message_id,
+        0,
       ) || undefined,
       source_message_thread_id: intFromRawAllowZero(
         entry.source_message_thread_id
@@ -3813,18 +3818,35 @@ function shouldBypassRunnerStartupLoopForContractFollowup({
   return true;
 }
 
-function findRunnerRequestsForMessageID(state, normalizedRoute, selectors = {}) {
-  const chatID = String(selectors.chatID || "").trim();
-  const messageID = intFromRawAllowZero(selectors.messageID, 0);
-  if (!chatID || messageID <= 0) {
-    return [];
-  }
-  return findRunnerRequestsForScope(state, normalizedRoute, { chatID })
-    .filter((entry) => (
-      intFromRawAllowZero(entry.source_message_id, 0) === messageID
-      || intFromRawAllowZero(entry.last_source_message_id, 0) === messageID
-    ));
-}
+function findRunnerRequestsForMessageID(state, normalizedRoute, selectors = {}) {
+  const chatID = String(selectors.chatID || "").trim();
+  const messageID = intFromRawAllowZero(selectors.messageID, 0);
+  const canonicalHumanMessageKey = String(selectors.canonicalHumanMessageKey || "").trim();
+  if (!chatID || (messageID <= 0 && !canonicalHumanMessageKey)) {
+    return [];
+  }
+  return findRunnerRequestsForScope(state, normalizedRoute, { chatID })
+    .filter((entryRaw) => {
+      const entry = safeObject(entryRaw);
+      if (canonicalHumanMessageKey) {
+        const requestCanonicalHumanMessageKey = firstNonEmptyString([
+          entry.canonical_human_message_key,
+          safeObject(entry.source_message_envelope).canonical_human_message_key,
+          buildRunnerCanonicalHumanInboundKey(safeObject(entry.source_message_envelope)),
+        ]);
+        if (requestCanonicalHumanMessageKey === canonicalHumanMessageKey) {
+          return true;
+        }
+      }
+      return (
+        messageID > 0
+        && (
+          intFromRawAllowZero(entry.source_message_id, 0) === messageID
+          || intFromRawAllowZero(entry.last_source_message_id, 0) === messageID
+        )
+      );
+    });
+}
 
 function sortRunnerRequestEntriesNewestFirst(entries = []) {
   return ensureArray(entries).slice().sort((leftRaw, rightRaw) => {
@@ -3839,24 +3861,26 @@ function sortRunnerRequestEntriesNewestFirst(entries = []) {
   });
 }
 
-async function findServerRunnerRequestForMessageID({
-  normalizedRoute,
-  runtime,
-  chatID,
-  messageID,
-}) {
+async function findServerRunnerRequestForMessageID({
+  normalizedRoute,
+  runtime,
+  chatID,
+  messageID,
+  canonicalHumanMessageKey = "",
+}) {
   const projectID = String(normalizedRoute?.projectID || "").trim();
   const provider = String(normalizedRoute?.provider || "").trim();
-  const normalizedChatID = String(chatID || "").trim();
-  const normalizedMessageID = intFromRawAllowZero(messageID, 0);
-  if (
-    !projectID
-    || !provider
-    || !normalizedChatID
-    || normalizedMessageID <= 0
-    || !runtime?.baseURL
-    || !runtime?.token
-  ) {
+  const normalizedChatID = String(chatID || "").trim();
+  const normalizedMessageID = intFromRawAllowZero(messageID, 0);
+  const normalizedCanonicalHumanMessageKey = String(canonicalHumanMessageKey || "").trim();
+  if (
+    !projectID
+    || !provider
+    || !normalizedChatID
+    || (normalizedMessageID <= 0 && !normalizedCanonicalHumanMessageKey)
+    || !runtime?.baseURL
+    || !runtime?.token
+  ) {
     return null;
   }
   try {
@@ -3869,18 +3893,29 @@ async function findServerRunnerRequestForMessageID({
       limit: 500,
       offset: 0,
     });
-    const matched = sortRunnerRequestEntriesNewestFirst(serverRequests.filter((entryRaw) => {
-      const entry = safeObject(entryRaw);
-      return (
-        String(entry.project_id || "").trim() === projectID
-        && String(entry.provider || "").trim() === provider
-        && String(entry.chat_id || "").trim() === normalizedChatID
-        && (
-          intFromRawAllowZero(entry.source_message_id, 0) === normalizedMessageID
-          || intFromRawAllowZero(entry.last_source_message_id, 0) === normalizedMessageID
-        )
-      );
-    }));
+    const matched = sortRunnerRequestEntriesNewestFirst(serverRequests.filter((entryRaw) => {
+      const entry = safeObject(entryRaw);
+      const requestCanonicalHumanMessageKey = firstNonEmptyString([
+        entry.canonical_human_message_key,
+        safeObject(entry.source_message_envelope).canonical_human_message_key,
+        buildRunnerCanonicalHumanInboundKey(safeObject(entry.source_message_envelope)),
+      ]);
+      return (
+        String(entry.project_id || "").trim() === projectID
+        && String(entry.provider || "").trim() === provider
+        && String(entry.chat_id || "").trim() === normalizedChatID
+        && (
+          (normalizedCanonicalHumanMessageKey && requestCanonicalHumanMessageKey === normalizedCanonicalHumanMessageKey)
+          || (
+            normalizedMessageID > 0
+            && (
+              intFromRawAllowZero(entry.source_message_id, 0) === normalizedMessageID
+              || intFromRawAllowZero(entry.last_source_message_id, 0) === normalizedMessageID
+            )
+          )
+        )
+      );
+    }));
     return safeObject(matched[0]);
   } catch {
     return null;
@@ -4321,25 +4356,27 @@ function pickRunnerSharedConversationSourceRequest(entries = [], excludeRequestK
   return safeObject(matched[0]);
 }
 
-async function findServerRunnerConversationSourceRequestForMessageID({
-  normalizedRoute,
-  runtime,
-  chatID,
-  messageID,
-  excludeRequestKey = "",
-}) {
+async function findServerRunnerConversationSourceRequestForMessageID({
+  normalizedRoute,
+  runtime,
+  chatID,
+  messageID,
+  canonicalHumanMessageKey = "",
+  excludeRequestKey = "",
+}) {
   const projectID = String(normalizedRoute?.projectID || "").trim();
   const provider = String(normalizedRoute?.provider || "").trim();
-  const normalizedChatID = String(chatID || "").trim();
-  const normalizedMessageID = intFromRawAllowZero(messageID, 0);
-  if (
-    !projectID
-    || !provider
-    || !normalizedChatID
-    || normalizedMessageID <= 0
-    || !runtime?.baseURL
-    || !runtime?.token
-  ) {
+  const normalizedChatID = String(chatID || "").trim();
+  const normalizedMessageID = intFromRawAllowZero(messageID, 0);
+  const normalizedCanonicalHumanMessageKey = String(canonicalHumanMessageKey || "").trim();
+  if (
+    !projectID
+    || !provider
+    || !normalizedChatID
+    || (normalizedMessageID <= 0 && !normalizedCanonicalHumanMessageKey)
+    || !runtime?.baseURL
+    || !runtime?.token
+  ) {
     return null;
   }
   try {
@@ -4352,18 +4389,29 @@ async function findServerRunnerConversationSourceRequestForMessageID({
       limit: 500,
       offset: 0,
     });
-    const matched = serverRequests.filter((entryRaw) => {
-      const entry = safeObject(entryRaw);
-      return (
-        String(entry.project_id || "").trim() === projectID
-        && String(entry.provider || "").trim() === provider
-        && String(entry.chat_id || "").trim() === normalizedChatID
-        && (
-          intFromRawAllowZero(entry.source_message_id, 0) === normalizedMessageID
-          || intFromRawAllowZero(entry.last_source_message_id, 0) === normalizedMessageID
-        )
-      );
-    });
+    const matched = serverRequests.filter((entryRaw) => {
+      const entry = safeObject(entryRaw);
+      const requestCanonicalHumanMessageKey = firstNonEmptyString([
+        entry.canonical_human_message_key,
+        safeObject(entry.source_message_envelope).canonical_human_message_key,
+        buildRunnerCanonicalHumanInboundKey(safeObject(entry.source_message_envelope)),
+      ]);
+      return (
+        String(entry.project_id || "").trim() === projectID
+        && String(entry.provider || "").trim() === provider
+        && String(entry.chat_id || "").trim() === normalizedChatID
+        && (
+          (normalizedCanonicalHumanMessageKey && requestCanonicalHumanMessageKey === normalizedCanonicalHumanMessageKey)
+          || (
+            normalizedMessageID > 0
+            && (
+              intFromRawAllowZero(entry.source_message_id, 0) === normalizedMessageID
+              || intFromRawAllowZero(entry.last_source_message_id, 0) === normalizedMessageID
+            )
+          )
+        )
+      );
+    });
     return pickRunnerSharedConversationSourceRequest(matched, excludeRequestKey);
   } catch {
     return null;
@@ -5026,13 +5074,14 @@ async function claimRunnerRequestForHumanComment({
     runtime,
     archiveThreadID,
   });
-  const replyChainContext = safeObject(replyChainResolution.replyChainContext);
+  const replyChainContext = safeObject(replyChainResolution.replyChainContext);
   const referencedRequest = safeObject(replyChainContext.referencedRequest);
   const resolvedNormalizedIntent = resolveRunnerRequestClaimIntent({
     normalizedIntent,
   });
-  let stateForClaim = safeObject(replyChainResolution.state);
-  const normalizedSharedHumanIntent = safeObject(sharedHumanIntent);
+  const canonicalHumanMessageKey = buildRunnerCanonicalHumanInboundKey(parsed);
+  let stateForClaim = safeObject(replyChainResolution.state);
+  const normalizedSharedHumanIntent = safeObject(sharedHumanIntent);
   const provisionalConversationID = String(
     parsed.conversationID
     || replyChainContext.conversationID
@@ -5067,29 +5116,31 @@ async function claimRunnerRequestForHumanComment({
     };
   }
   const currentMessageID = intFromRawAllowZero(parsed.messageID, 0);
-  let sharedConversationSource = currentMessageID > 0
-    ? pickRunnerSharedConversationSourceRequest(
-      findRunnerRequestsForMessageID(stateForClaim, normalizedRoute, {
-        chatID: String(parsed.chatID || parsed.chatId || "").trim(),
-        messageID: currentMessageID,
-      }),
-      provisionalRequestKey,
-    )
-    : {};
+  let sharedConversationSource = currentMessageID > 0
+    ? pickRunnerSharedConversationSourceRequest(
+      findRunnerRequestsForMessageID(stateForClaim, normalizedRoute, {
+        chatID: String(parsed.chatID || parsed.chatId || "").trim(),
+        messageID: currentMessageID,
+        canonicalHumanMessageKey,
+      }),
+      provisionalRequestKey,
+    )
+    : {};
   if (
     !Object.keys(sharedConversationSource).length
     && currentMessageID > 0
     && runtime?.baseURL
     && runtime?.token
   ) {
-    sharedConversationSource = safeObject(await findServerRunnerConversationSourceRequestForMessageID({
-      normalizedRoute,
-      runtime,
-      chatID: String(parsed.chatID || parsed.chatId || "").trim(),
-      messageID: currentMessageID,
-      excludeRequestKey: provisionalRequestKey,
-    }));
-  }
+    sharedConversationSource = safeObject(await findServerRunnerConversationSourceRequestForMessageID({
+      normalizedRoute,
+      runtime,
+      chatID: String(parsed.chatID || parsed.chatId || "").trim(),
+      messageID: currentMessageID,
+      canonicalHumanMessageKey,
+      excludeRequestKey: provisionalRequestKey,
+    }));
+  }
   const authorityContext = resolveRunnerHumanCommentAuthorityContext({
     normalizedRoute,
     selectedRecord,
@@ -5183,9 +5234,10 @@ async function claimRunnerRequestForHumanComment({
     provider: String(normalizedRoute?.provider || "").trim(),
     chat_id: String(parsed.chatID || parsed.chatId || "").trim(),
     source_message_id: intFromRawAllowZero(parsed.messageID, 0) || undefined,
-    source_message_thread_id: intFromRawAllowZero(parsed.messageThreadID, 0) || undefined,
-    source_message_body: String(parsed.body || "").trim(),
-    source_message_origin: String(sourceMessageEnvelope.source_origin || "").trim().toLowerCase(),
+    source_message_thread_id: intFromRawAllowZero(parsed.messageThreadID, 0) || undefined,
+    source_message_body: String(parsed.body || "").trim(),
+    canonical_human_message_key: canonicalHumanMessageKey,
+    source_message_origin: String(sourceMessageEnvelope.source_origin || "").trim().toLowerCase(),
     source_message_route_key: String(sourceMessageEnvelope.source_route_key || "").trim(),
     source_message_bot_username: normalizeTelegramMentionUsername(sourceMessageEnvelope.source_bot_username),
     source_message_envelope: sourceMessageEnvelope,

package/lib/runner-orchestration-visibility.mjs

@@ -1,4 +1,5 @@
 import {
+  buildCanonicalHumanInboundKey,
   buildTelegramMessageEnvelopeFromParsedArchive,
   findRecentTelegramMessageEnvelope,
   isTelegramLocalInboundEnvelopeForRoute,
@@ -27,6 +28,20 @@ function normalizeMentionSelector(value) {
   return String(value || "").trim().replace(/^@+/, "").toLowerCase();
 }
 
+function firstNonEmptyString(values) {
+  for (const value of ensureArray(values)) {
+    const normalized = String(value ?? "").trim();
+    if (normalized) {
+      return normalized;
+    }
+  }
+  return "";
+}
+
+function normalizeCanonicalHumanMessageKey(rawValue) {
+  return String(rawValue || "").trim();
+}
+
 function uniqueOrdered(values) {
   const ordered = [];
   const seen = new Set();
@@ -82,6 +97,15 @@ function doesTelegramEnvelopeMatchMessage(rawEnvelope, {
     && intFromRawAllowZero(envelope.message_id, 0) === normalizedMessageID;
 }
 
+function doesTelegramEnvelopeMatchCanonicalHumanMessage(rawEnvelope, canonicalHumanMessageKey = "") {
+  const normalizedCanonicalHumanMessageKey = normalizeCanonicalHumanMessageKey(canonicalHumanMessageKey);
+  if (!normalizedCanonicalHumanMessageKey) {
+    return false;
+  }
+  const envelope = normalizeTelegramMessageEnvelope(rawEnvelope);
+  return String(envelope.canonical_human_message_key || "").trim() === normalizedCanonicalHumanMessageKey;
+}
+
 function normalizeRunnerRecentLocalInboundReceipt(rawReceipt) {
   const receipt = safeObject(rawReceipt);
   const chatID = String(receipt.chat_id || receipt.chatID || "").trim();
@@ -89,7 +113,7 @@ function normalizeRunnerRecentLocalInboundReceipt(rawReceipt) {
   if (!chatID || !(messageID > 0)) {
     return {};
   }
-  return {
+  const normalized = {
     chat_id: chatID,
     message_id: messageID,
     ...(intFromRawAllowZero(receipt.message_thread_id ?? receipt.messageThreadID, 0) > 0
@@ -107,10 +131,16 @@ function normalizeRunnerRecentLocalInboundReceipt(rawReceipt) {
     ...(normalizeMentionSelector(receipt.sender_username || receipt.senderUsername || "")
       ? { sender_username: normalizeMentionSelector(receipt.sender_username || receipt.senderUsername || "") }
       : {}),
+    ...(String(receipt.sender_id || receipt.senderID || "").trim()
+      ? { sender_id: String(receipt.sender_id || receipt.senderID || "").trim() }
+      : {}),
     sender_is_bot: receipt.sender_is_bot === true || receipt.senderIsBot === true,
     ...(String(receipt.body || "").trim()
       ? { body: String(receipt.body || "").trim() }
       : {}),
+    ...(String(receipt.occurred_at || receipt.occurredAt || "").trim()
+      ? { occurred_at: String(receipt.occurred_at || receipt.occurredAt || "").trim() }
+      : {}),
     ...(String(receipt.receipt_origin || receipt.receiptOrigin || "").trim()
       ? { receipt_origin: String(receipt.receipt_origin || receipt.receiptOrigin || "").trim().toLowerCase() }
       : {}),
@@ -121,16 +151,59 @@ function normalizeRunnerRecentLocalInboundReceipt(rawReceipt) {
       ? { receipt_bot_username: normalizeMentionSelector(receipt.receipt_bot_username || receipt.receiptBotUsername || "") }
       : {}),
   };
+  const canonicalHumanMessageKey = buildCanonicalHumanInboundKey({
+    chat_id: normalized.chat_id,
+    message_id: normalized.message_id,
+    message_thread_id: normalized.message_thread_id,
+    reply_to_message_id: normalized.reply_to_message_id,
+    kind: normalized.kind,
+    sender_id: normalized.sender_id,
+    sender_username: normalized.sender_username,
+    sender_is_bot: normalized.sender_is_bot === true,
+    body: normalized.body,
+    occurred_at: normalized.occurred_at,
+    canonical_human_message_key: firstNonEmptyString([
+      receipt.canonical_human_message_key,
+      receipt.canonicalHumanMessageKey,
+    ]),
+  });
+  if (canonicalHumanMessageKey) {
+    normalized.canonical_human_message_key = canonicalHumanMessageKey;
+  }
+  return normalized;
 }
 
-function findRecentTelegramInboundReceipt(rawMap, { chatID = "", messageID = 0 } = {}) {
+function findRecentTelegramInboundReceipt(rawMap, {
+  chatID = "",
+  messageID = 0,
+  canonicalHumanMessageKey = "",
+} = {}) {
   const normalizedChatID = String(chatID || "").trim();
   const normalizedMessageID = intFromRawAllowZero(messageID, 0);
-  if (!normalizedChatID || !(normalizedMessageID > 0)) {
+  const normalizedCanonicalHumanMessageKey = normalizeCanonicalHumanMessageKey(canonicalHumanMessageKey);
+  if (!normalizedChatID || (!(normalizedMessageID > 0) && !normalizedCanonicalHumanMessageKey)) {
+    return {};
+  }
+  if (normalizedMessageID > 0) {
+    const key = `${normalizedChatID}:${normalizedMessageID}`;
+    const exactReceipt = normalizeRunnerRecentLocalInboundReceipt(safeObject(safeObject(rawMap)[key]));
+    if (Object.keys(exactReceipt).length > 0) {
+      return exactReceipt;
+    }
+  }
+  if (!normalizedCanonicalHumanMessageKey) {
     return {};
   }
-  const key = `${normalizedChatID}:${normalizedMessageID}`;
-  return normalizeRunnerRecentLocalInboundReceipt(safeObject(safeObject(rawMap)[key]));
+  for (const value of Object.values(safeObject(rawMap))) {
+    const normalizedReceipt = normalizeRunnerRecentLocalInboundReceipt(value);
+    if (
+      String(normalizedReceipt.chat_id || "").trim() === normalizedChatID
+      && String(normalizedReceipt.canonical_human_message_key || "").trim() === normalizedCanonicalHumanMessageKey
+    ) {
+      return normalizedReceipt;
+    }
+  }
+  return {};
 }
 
 function buildTelegramMessageEnvelopeFromRecentReceipt(rawReceipt) {
@@ -154,6 +227,35 @@ function buildTelegramMessageEnvelopeFromRecentReceipt(rawReceipt) {
   });
 }
 
+function findRecentTelegramMessageEnvelopeWithCanonicalFallback(rawMap, {
+  chatID = "",
+  messageID = 0,
+  canonicalHumanMessageKey = "",
+} = {}) {
+  const exactEnvelope = findRecentTelegramMessageEnvelope(rawMap, {
+    chatID,
+    messageID,
+  });
+  if (Object.keys(safeObject(exactEnvelope)).length > 0) {
+    return exactEnvelope;
+  }
+  const normalizedChatID = String(chatID || "").trim();
+  const normalizedCanonicalHumanMessageKey = normalizeCanonicalHumanMessageKey(canonicalHumanMessageKey);
+  if (!normalizedChatID || !normalizedCanonicalHumanMessageKey) {
+    return {};
+  }
+  for (const rawEnvelope of Object.values(safeObject(rawMap))) {
+    const normalizedEnvelope = normalizeTelegramMessageEnvelope(rawEnvelope);
+    if (
+      String(normalizedEnvelope.chat_id || "").trim() === normalizedChatID
+      && String(normalizedEnvelope.canonical_human_message_key || "").trim() === normalizedCanonicalHumanMessageKey
+    ) {
+      return normalizedEnvelope;
+    }
+  }
+  return {};
+}
+
 function resolveRunnerTelegramSourceEnvelopeCandidates({
   routeState,
   persistedRequest,
@@ -173,19 +275,26 @@ function resolveRunnerTelegramSourceEnvelopeCandidates({
     archivedSourceEnvelope.message_id || archiveEnvelope.message_id,
     0,
   );
+  const archiveCanonicalHumanMessageKey = firstNonEmptyString([
+    archivedSourceEnvelope.canonical_human_message_key,
+    archiveEnvelope.canonical_human_message_key,
+    buildCanonicalHumanInboundKey(selectedRecord?.parsedArchive),
+  ]);
   const routeLocalReceipt = findRecentTelegramInboundReceipt(
     safeObject(routeState).recent_local_inbound_receipts,
     {
       chatID: archiveChatID,
       messageID: archiveMessageID,
+      canonicalHumanMessageKey: archiveCanonicalHumanMessageKey,
     },
   );
   const routeLocalReceiptEnvelope = buildTelegramMessageEnvelopeFromRecentReceipt(routeLocalReceipt);
-  const routeLocalEnvelope = findRecentTelegramMessageEnvelope(
+  const routeLocalEnvelope = findRecentTelegramMessageEnvelopeWithCanonicalFallback(
     safeObject(routeState).recent_local_inbound_envelopes,
     {
       chatID: archiveChatID,
       messageID: archiveMessageID,
+      canonicalHumanMessageKey: archiveCanonicalHumanMessageKey,
     },
   );
   const persistedSourceEnvelope = normalizeTelegramMessageEnvelope(
@@ -197,6 +306,7 @@ function resolveRunnerTelegramSourceEnvelopeCandidates({
     archiveEnvelope,
     archiveChatID,
     archiveMessageID,
+    archiveCanonicalHumanMessageKey,
     routeLocalReceipt,
     routeLocalReceiptEnvelope,
     routeLocalEnvelope,
@@ -222,6 +332,7 @@ function resolveRunnerLocalSourceEnvelopeForRoute({
     archivedSourceEnvelope,
     archiveChatID,
     archiveMessageID,
+    archiveCanonicalHumanMessageKey,
     routeLocalReceiptEnvelope,
     routeLocalEnvelope,
     persistedSourceEnvelope,
@@ -251,10 +362,16 @@ function resolveRunnerLocalSourceEnvelopeForRoute({
       routeKey,
       botUsername: currentBotSelector,
     })
-    && doesTelegramEnvelopeMatchMessage(persistedSourceEnvelope, {
-      chatID: archiveChatID,
-      messageID: archiveMessageID,
-    })
+    && (
+      doesTelegramEnvelopeMatchMessage(persistedSourceEnvelope, {
+        chatID: archiveChatID,
+        messageID: archiveMessageID,
+      })
+      || doesTelegramEnvelopeMatchCanonicalHumanMessage(
+        persistedSourceEnvelope,
+        archiveCanonicalHumanMessageKey,
+      )
+    )
   ) {
     return {
       envelope: persistedSourceEnvelope,
@@ -267,10 +384,16 @@ function resolveRunnerLocalSourceEnvelopeForRoute({
       routeKey,
       botUsername: currentBotSelector,
     })
-    && doesTelegramEnvelopeMatchMessage(archivedSourceEnvelope, {
-      chatID: archiveChatID,
-      messageID: archiveMessageID,
-    })
+    && (
+      doesTelegramEnvelopeMatchMessage(archivedSourceEnvelope, {
+        chatID: archiveChatID,
+        messageID: archiveMessageID,
+      })
+      || doesTelegramEnvelopeMatchCanonicalHumanMessage(
+        archivedSourceEnvelope,
+        archiveCanonicalHumanMessageKey,
+      )
+    )
   ) {
     return {
       envelope: archivedSourceEnvelope,
@@ -289,14 +412,21 @@ function hasForeignRouteLocalEnvelopeForMessage({
   envelopes,
   archiveChatID,
   archiveMessageID,
+  archiveCanonicalHumanMessageKey,
   routeKey,
   currentBotSelector,
 }) {
   return ensureArray(envelopes).some((rawEnvelope) => (
-    doesTelegramEnvelopeMatchMessage(rawEnvelope, {
-      chatID: archiveChatID,
-      messageID: archiveMessageID,
-    })
+    (
+      doesTelegramEnvelopeMatchMessage(rawEnvelope, {
+        chatID: archiveChatID,
+        messageID: archiveMessageID,
+      })
+      || doesTelegramEnvelopeMatchCanonicalHumanMessage(
+        rawEnvelope,
+        archiveCanonicalHumanMessageKey,
+      )
+    )
     && String(safeObject(normalizeTelegramMessageEnvelope(rawEnvelope)).source_origin || "").trim().toLowerCase() === "local_telegram_inbound"
     && !isTelegramLocalInboundEnvelopeForRoute(rawEnvelope, {
       routeKey,
@@ -352,6 +482,7 @@ function resolveRunnerReceiptBackedHumanInboundVisibility({
     archivedSourceEnvelope,
     archiveChatID,
     archiveMessageID,
+    archiveCanonicalHumanMessageKey,
     routeLocalReceipt,
     persistedSourceEnvelope,
   } = safeObject(localMatch.candidates);
@@ -367,6 +498,7 @@ function resolveRunnerReceiptBackedHumanInboundVisibility({
     envelopes: [persistedSourceEnvelope, archivedSourceEnvelope],
     archiveChatID,
     archiveMessageID,
+    archiveCanonicalHumanMessageKey,
     routeKey,
     currentBotSelector,
   });
@@ -413,6 +545,7 @@ function buildRunnerDiagnosticTraceSummary({
     archivedSourceEnvelope,
     archiveChatID,
     archiveMessageID,
+    archiveCanonicalHumanMessageKey,
     persistedSourceEnvelope,
     routeLocalEnvelope,
     routeLocalReceipt,
@@ -436,6 +569,7 @@ function buildRunnerDiagnosticTraceSummary({
     envelopes: [persistedSourceEnvelope, archivedSourceEnvelope],
     archiveChatID,
     archiveMessageID,
+    archiveCanonicalHumanMessageKey,
     routeKey,
     currentBotSelector,
   });

package/lib/runner-runtime.mjs

@@ -528,6 +528,27 @@ function normalizeRunnerRecentLocalInboundReceipt(rawReceipt, fallbackKey = "")
   if (chatTitle) {
     normalized.chat_title = chatTitle;
   }
+  const canonicalHumanMessageKey = String(
+    safeObject(normalizeTelegramMessageEnvelope({
+      chat_id: normalized.chat_id,
+      message_id: normalized.message_id,
+      message_thread_id: normalized.message_thread_id,
+      reply_to_message_id: normalized.reply_to_message_id,
+      kind: normalized.kind,
+      sender_id: normalized.sender_id,
+      sender_username: normalized.sender_username,
+      sender_is_bot: normalized.sender_is_bot === true,
+      body: normalized.body,
+      occurred_at: normalized.occurred_at,
+      canonical_human_message_key: firstNonEmptyString([
+        receipt.canonical_human_message_key,
+        receipt.canonicalHumanMessageKey,
+      ]),
+    })).canonical_human_message_key || "",
+  ).trim();
+  if (canonicalHumanMessageKey) {
+    normalized.canonical_human_message_key = canonicalHumanMessageKey;
+  }
   return [receiptKey, normalized];
 }
 

package/lib/selftest-runner-scenarios.mjs

@@ -2303,20 +2303,31 @@ export async function runSelftestRunnerScenarios(push, deps) {
       },
     });
     const sharedHumanState = loadBotRunnerState();
-    const sharedHumanRequestCount = Object.values(safeObject(sharedHumanState.requests))
+    const sharedHumanRequests = Object.values(safeObject(sharedHumanState.requests))
       .filter((entryRaw) => {
         const entry = safeObject(entryRaw);
         return String(entry.chat_id || "") === "-100123"
           && String(entry.source_message_body || "") === sharedHumanBody;
-      })
-      .length;
+      });
+    const sharedHumanRequestCount = sharedHumanRequests.length;
+    const sharedHumanCanonicalKey = buildArchivedInboundMessageKey({
+      chatID: "-100123",
+      messageID: 1189,
+      messageThreadID: 0,
+      kind: "telegram_message",
+      senderID: "7001",
+      senderIsBot: false,
+      occurredAt: "2026-04-01T06:00:00.000Z",
+      body: sharedHumanBody,
+    }).replace(/^human:/, "");
     push(
       "runner_human_opening_request_identity_is_canonical_across_routes",
       sharedHumanClaimPrimary.ok === true
         && (sharedHumanClaimPeer.ok === true || String(sharedHumanClaimPeer.reason || "") === "request_already_claimed")
         && String(sharedHumanClaimPrimary.requestKey || "") === String(sharedHumanClaimPeer.requestKey || "")
-        && sharedHumanRequestCount === 1,
-      `primary=${String(sharedHumanClaimPrimary.requestKey || "(none)")} peer=${String(sharedHumanClaimPeer.requestKey || "(none)")} peer_reason=${String(sharedHumanClaimPeer.reason || "(none)")} count=${sharedHumanRequestCount}`,
+        && sharedHumanRequestCount === 1
+        && String(safeObject(sharedHumanRequests[0]).canonical_human_message_key || "") === sharedHumanCanonicalKey,
+      `primary=${String(sharedHumanClaimPrimary.requestKey || "(none)")} peer=${String(sharedHumanClaimPeer.requestKey || "(none)")} peer_reason=${String(sharedHumanClaimPeer.reason || "(none)")} count=${sharedHumanRequestCount} canonical=${String(safeObject(sharedHumanRequests[0]).canonical_human_message_key || "(none)")}`,
     );
 
     const rootTaskRecord = {
@@ -16534,6 +16545,97 @@ export async function runSelftestRunnerScenarios(push, deps) {
     }
   }
 
+  try {
+    const canonicalVisibility = resolveRunnerHumanInboundVisibility({
+      routeState: {
+        recent_local_inbound_envelopes: {},
+        recent_local_inbound_receipts: {
+          "-100123:5201": {
+            chat_id: "-100123",
+            message_id: 5201,
+            sender_id: "7001",
+            body: "@ryoai_bot canonical hello",
+            occurred_at: "2026-04-02T00:00:00.000Z",
+            receipt_origin: "local_telegram_inbound",
+            receipt_route_key: "telegram-monitor-canonical-owner::project::telegram::monitor::dest::actor",
+            receipt_bot_username: "ryoai_bot",
+            received_at: "2026-04-02T00:00:01.000Z",
+          },
+        },
+      },
+      persistedRequest: null,
+      selectedRecord: {
+        id: "comment-canonical-visibility-1",
+        parsedArchive: {
+          kind: "telegram_message",
+          chatID: "-100123",
+          chatType: "supergroup",
+          body: "@ryoai_bot canonical hello",
+          messageID: 6301,
+          senderID: "7001",
+          senderIsBot: false,
+          occurredAt: "2026-04-02T00:00:00.000Z",
+          mentionUsernames: ["ryoai_bot"],
+        },
+      },
+      routeKey: "telegram-monitor-canonical-owner::project::telegram::monitor::dest::actor",
+      currentBotSelector: "ryoai_bot",
+      triggerDecision: {
+        shouldRespond: true,
+        triggerEligible: true,
+        candidateHintOnly: true,
+        trigger: "mention",
+        reason: "canonical receipt-backed mention trigger",
+        candidateBotUsernames: ["ryoai_bot"],
+      },
+    });
+    const canonicalSourceEnvelope = resolveRunnerDeliverySourceMessageEnvelope({
+      routeState: {
+        recent_local_inbound_envelopes: {},
+        recent_local_inbound_receipts: {
+          "-100123:5201": {
+            chat_id: "-100123",
+            message_id: 5201,
+            sender_id: "7001",
+            body: "@ryoai_bot canonical hello",
+            occurred_at: "2026-04-02T00:00:00.000Z",
+            receipt_origin: "local_telegram_inbound",
+            receipt_route_key: "telegram-monitor-canonical-owner::project::telegram::monitor::dest::actor",
+            receipt_bot_username: "ryoai_bot",
+            received_at: "2026-04-02T00:00:01.000Z",
+          },
+        },
+      },
+      persistedRequest: null,
+      selectedRecord: {
+        id: "comment-canonical-visibility-1",
+        parsedArchive: {
+          kind: "telegram_message",
+          chatID: "-100123",
+          chatType: "supergroup",
+          body: "@ryoai_bot canonical hello",
+          messageID: 6301,
+          senderID: "7001",
+          senderIsBot: false,
+          occurredAt: "2026-04-02T00:00:00.000Z",
+          mentionUsernames: ["ryoai_bot"],
+        },
+      },
+      routeKey: "telegram-monitor-canonical-owner::project::telegram::monitor::dest::actor",
+      currentBotSelector: "ryoai_bot",
+    });
+    push(
+      "runner_visibility_receipt_backed_human_opening_matches_canonical_key_across_route_local_copies",
+      canonicalVisibility.applies === true
+        && canonicalVisibility.executable === true
+        && String(canonicalVisibility.visibilitySource || "") === "route_local_inbound_receipt"
+        && Number(safeObject(canonicalSourceEnvelope).message_id || 0) === 5201,
+      `mode=${String(canonicalVisibility.visibilityMode || "(none)")} status=${String(canonicalVisibility.visibilityStatus || "(none)")} source=${String(canonicalVisibility.visibilitySource || "(none)")} reply_message_id=${String(safeObject(canonicalSourceEnvelope).message_id || "(none)")}`,
+    );
+  } catch (err) {
+    push("runner_visibility_receipt_backed_human_opening_matches_canonical_key_across_route_local_copies", false, String(err?.message || err));
+  }
+
   for (const [testName, triggerKind, messageID] of [
     [
       "runner_visibility_receipt_first_mention_without_exact_receipt_is_blocked",

package/package.json

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