metheus-governance-mcp-cli 0.2.276 → 0.2.278

package/cli.mjs

@@ -135,6 +135,7 @@ import {
 } from "./lib/client-registration.mjs";
 import {
   applyPendingAgeSelection,
+  buildCanonicalHumanInboundKey as buildRunnerCanonicalHumanInboundKey,
   buildTelegramBotReplyEnvelope,
   buildTelegramMessageEnvelopeFromParsedArchive as buildRunnerTelegramMessageEnvelopeFromParsedArchive,
   buildRunnerRouteDuplicateStateFromComment,
@@ -3522,30 +3523,35 @@ function uniqueOrderedStrings(values, normalizer = (value) => String(value || ""
   return output;
 }
 
-function buildRunnerRequestKey({
-  normalizedRoute,
-  selectedRecord,
-  selectedBotUsernames = [],
-  normalizedIntent = "",
-  conversationID = "",
-}) {
-  const parsed = safeObject(selectedRecord?.parsedArchive);
-  const chatID = String(parsed.chatID || parsed.chatId || "").trim() || "-";
-  const messageID = intFromRawAllowZero(parsed.messageID, 0);
-  const kind = String(parsed.kind || "").trim().toLowerCase() || "-";
-  const responders = uniqueOrderedStrings(selectedBotUsernames, normalizeTelegramMentionUsername).join(",") || "-";
-  const intent = String(normalizedIntent || "").trim().toLowerCase() || "-";
-  const resolvedConversationID = String(conversationID || parsed.conversationID || "").trim() || "-";
-  return [
-    String(normalizedRoute?.projectID || "").trim() || "-",
-    String(normalizedRoute?.provider || "").trim() || "-",
-    chatID,
-    String(messageID || "-"),
-    kind,
-    responders,
-    intent,
-    resolvedConversationID,
-  ].join("::");
+function buildRunnerRequestKey({
+  normalizedRoute,
+  selectedRecord,
+  selectedBotUsernames = [],
+  normalizedIntent = "",
+  conversationID = "",
+}) {
+  const parsed = safeObject(selectedRecord?.parsedArchive);
+  const chatID = String(parsed.chatID || parsed.chatId || "").trim() || "-";
+  const messageID = intFromRawAllowZero(parsed.messageID, 0);
+  const kind = String(parsed.kind || "").trim().toLowerCase() || "-";
+  const canonicalHumanKey = buildRunnerCanonicalHumanInboundKey(parsed);
+  const responders = canonicalHumanKey
+    ? "-"
+    : uniqueOrderedStrings(selectedBotUsernames, normalizeTelegramMentionUsername).join(",") || "-";
+  const intent = canonicalHumanKey
+    ? "-"
+    : String(normalizedIntent || "").trim().toLowerCase() || "-";
+  const resolvedConversationID = String(conversationID || parsed.conversationID || "").trim() || "-";
+  return [
+    String(normalizedRoute?.projectID || "").trim() || "-",
+    String(normalizedRoute?.provider || "").trim() || "-",
+    chatID,
+    canonicalHumanKey ? `human:${canonicalHumanKey}` : String(messageID || "-"),
+    kind,
+    responders,
+    intent,
+    resolvedConversationID,
+  ].join("::");
 }
 
 function resolveRunnerRequestClaimIntent({
@@ -3614,15 +3620,19 @@ function buildSyntheticReplyChainConversationID(normalizedRoute, chatID, anchorM
   return `reply_chain:${provider}:${normalizedChatID}:${normalizedAnchorMessageID}`;
 }
 
-function buildSyntheticHumanOpeningConversationID(normalizedRoute, chatID, messageID) {
-  const provider = String(normalizedRoute?.provider || "").trim() || "unknown";
-  const normalizedChatID = String(chatID || "").trim() || "-";
-  const normalizedMessageID = intFromRawAllowZero(messageID, 0);
-  if (normalizedMessageID <= 0) {
-    return "";
-  }
-  return `human_opening:${provider}:${normalizedChatID}:${normalizedMessageID}`;
-}
+function buildSyntheticHumanOpeningConversationID(normalizedRoute, chatID, messageID, canonicalHumanMessageKey = "") {
+  const provider = String(normalizedRoute?.provider || "").trim() || "unknown";
+  const canonicalKey = String(canonicalHumanMessageKey || "").trim();
+  if (canonicalKey) {
+    return `human_opening:${provider}:${canonicalKey}`;
+  }
+  const normalizedChatID = String(chatID || "").trim() || "-";
+  const normalizedMessageID = intFromRawAllowZero(messageID, 0);
+  if (normalizedMessageID <= 0) {
+    return "";
+  }
+  return `human_opening:${provider}:${normalizedChatID}:${normalizedMessageID}`;
+}
 
 function findRunnerRequestsForScope(state, normalizedRoute, selectors = {}) {
   const requests = normalizeBotRunnerRequests(state?.requests);
@@ -4910,24 +4920,26 @@ function resolveRunnerHumanCommentAuthorityContext({
   const referenced = safeObject(referencedRequest);
   const sharedSource = safeObject(sharedConversationSource);
   const sharedIntent = safeObject(normalizedSharedHumanIntent);
-  const authoritySource = Object.keys(referenced).length
-    ? referenced
-    : Object.keys(sharedSource).length
-      ? sharedSource
-      : {};
-  const currentMessageID = intFromRawAllowZero(parsed.messageID, 0);
-  const resolvedConversationID = firstNonEmptyString([
-    parsed.conversationID,
-    replyChain.conversationID,
-    authoritySource.conversation_id,
-    Object.keys(sharedIntent).length > 0
-      ? buildSyntheticHumanOpeningConversationID(
-        normalizedRoute,
-        String(parsed.chatID || parsed.chatId || "").trim(),
-        currentMessageID,
-      )
-      : "",
-  ]);
+  const authoritySource = Object.keys(referenced).length
+    ? referenced
+    : Object.keys(sharedSource).length
+      ? sharedSource
+      : {};
+  const currentMessageID = intFromRawAllowZero(parsed.messageID, 0);
+  const canonicalHumanMessageKey = buildRunnerCanonicalHumanInboundKey(parsed);
+  const resolvedConversationID = firstNonEmptyString([
+    parsed.conversationID,
+    replyChain.conversationID,
+    authoritySource.conversation_id,
+    Object.keys(sharedIntent).length > 0
+      ? buildSyntheticHumanOpeningConversationID(
+        normalizedRoute,
+        String(parsed.chatID || parsed.chatId || "").trim(),
+        currentMessageID,
+        canonicalHumanMessageKey,
+      )
+      : "",
+  ]);
   const explicitSelectedBotUsernames = uniqueOrderedStrings(
     selectedBotUsernames,
     normalizeTelegramMentionUsername,
@@ -5770,7 +5782,21 @@ async function finalizePreparedRunnerSelectedRecordExecutionContext({
     };
   }
   if (mode === "continuation_finalize") {
-    const requestClaim = normalizePreparedRunnerRequestClaim(requestPreparation.requestClaim);
+    const requestClaim = normalizePreparedRunnerRequestClaim(resolveRunnerContinuationRequestForBotReplyImpl({
+      normalizedRoute,
+      routeKey,
+      selectedRecord,
+      persist: true,
+      deps: buildRunnerRecoveryDeps(),
+    }));
+    if (!requestClaim.ok) {
+      return finalizeRunnerRequestClaimFailureRecorderState({
+        normalizedRoute,
+        runtime,
+        requestClaim,
+        syncRunnerRequestLedgerForProjectToServer,
+      });
+    }
     const finalizedRequest = await finalizePreparedRunnerRequestForExecution({
       normalizedRoute,
       routeKey,
@@ -8125,6 +8151,16 @@ function buildTelegramArchiveStructuredPayload(normalized) {
       .map((value) => normalizeTelegramMentionUsername(value))
       .filter(Boolean),
     occurredAt: String(normalized?.occurredAt || "").trim(),
+    canonicalHumanMessageKey: buildRunnerCanonicalHumanInboundKey({
+      chatID: normalized?.chatID,
+      kind,
+      senderID: normalized?.fromID,
+      senderIsBot: normalized?.fromIsBot === true,
+      occurredAt: normalized?.occurredAt,
+      messageThreadID: normalized?.messageThreadID,
+      replyToMessageID: normalized?.replyToMessageID,
+      body: normalized?.text,
+    }),
     sourceOrigin: String(normalized?.archiveSourceOrigin || normalized?.sourceOrigin || "").trim().toLowerCase(),
     sourceRouteKey: String(normalized?.archiveSourceRouteKey || normalized?.sourceRouteKey || "").trim(),
     sourceBotUsername: normalizeTelegramMentionUsername(normalized?.archiveSourceBotUsername || normalized?.sourceBotUsername || ""),
@@ -8261,6 +8297,10 @@ function parseArchivedChatComment(rawBody) {
         .map((value) => normalizeTelegramMentionUsername(value))
         .filter(Boolean),
     occurredAt: firstNonEmptyString([safeObject(structuredPayload).occurredAt, metadata.occurred_at]),
+    canonicalHumanMessageKey: firstNonEmptyString([
+      safeObject(structuredPayload).canonicalHumanMessageKey,
+      metadata.canonical_human_message_key,
+    ]),
     sourceOrigin: firstNonEmptyString([safeObject(structuredPayload).sourceOrigin, metadata.archive_source_origin, metadata.source_origin]).toLowerCase(),
     sourceRouteKey: firstNonEmptyString([safeObject(structuredPayload).sourceRouteKey, metadata.archive_source_route_key, metadata.source_route_key]),
     sourceBotUsername: normalizeTelegramMentionUsername(
@@ -8595,9 +8635,35 @@ function normalizeLocalTelegramUpdate(rawUpdate) {
   };
 }
 
-function buildArchivedInboundMessageKey(chatID, messageID, sourceBotUsername = "") {
-  const baseKey = `${String(chatID || "").trim()}:${intFromRawAllowZero(messageID, 0)}`;
-  const normalizedBotUsername = normalizeTelegramMentionUsername(sourceBotUsername);
+function buildArchivedInboundMessageKey(chatIDOrEnvelope, messageID = undefined, sourceBotUsername = "") {
+  const rawEnvelope = messageID === undefined && typeof chatIDOrEnvelope === "object" && chatIDOrEnvelope !== null
+    ? safeObject(chatIDOrEnvelope)
+    : {
+        chatID: chatIDOrEnvelope,
+        messageID,
+        sourceBotUsername,
+      };
+  const canonicalHumanKey = buildRunnerCanonicalHumanInboundKey(rawEnvelope);
+  if (canonicalHumanKey) {
+    return `human:${canonicalHumanKey}`;
+  }
+  const chatID = String(
+    rawEnvelope.chatID
+    || rawEnvelope.chatId
+    || rawEnvelope.chat_id
+    || "",
+  ).trim();
+  const normalizedMessageID = intFromRawAllowZero(
+    rawEnvelope.messageID
+    || rawEnvelope.message_id,
+    0,
+  );
+  const baseKey = `${chatID}:${normalizedMessageID}`;
+  const normalizedBotUsername = normalizeTelegramMentionUsername(
+    rawEnvelope.sourceBotUsername
+    || rawEnvelope.source_bot_username
+    || sourceBotUsername,
+  );
   return normalizedBotUsername ? `${baseKey}::${normalizedBotUsername}` : baseKey;
 }
 
@@ -17917,7 +17983,8 @@ TELEGRAM_BOT_REVIEW_TOKEN=review-token
     saveRunnerRouteState,
     mergeServerRunnerRequestLedgerIntoLocalState,
     buildRunnerStatusQueryLookup,
-    tryJsonParse,
+    buildArchivedInboundMessageKey,
+    tryJsonParse,
     safeObject,
     normalizeRunnerTriggerPolicy,
     evaluateTelegramRunnerTrigger,

package/lib/runner-helpers.mjs

@@ -1,4 +1,5 @@
 import process from "node:process";
+import { createHash } from "node:crypto";
 
 function safeObject(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
@@ -11,6 +12,24 @@ function ensureArray(value) {
   return Array.isArray(value) ? value : [];
 }
 
+function normalizeBodyForCanonicalKey(value) {
+  return String(value || "")
+    .replace(/\s+/g, " ")
+    .trim();
+}
+
+function normalizeOccurredAtForCanonicalKey(value) {
+  const text = String(value || "").trim();
+  if (!text) {
+    return "";
+  }
+  const parsed = Date.parse(text);
+  if (!Number.isFinite(parsed)) {
+    return text;
+  }
+  return new Date(Math.floor(parsed / 1000) * 1000).toISOString();
+}
+
 function firstNonEmptyString(values) {
   for (const value of ensureArray(values)) {
     const text = String(value ?? "").trim();
@@ -31,6 +50,93 @@ function intFromRaw(raw, fallback) {
   return parsed > 0 ? parsed : fallback;
 }
 
+function buildCanonicalHumanInboundSource(rawValue) {
+  const value = safeObject(rawValue);
+  const kind = String(value.kind || "").trim().toLowerCase();
+  const senderIsBotRaw = value.sender_is_bot
+    ?? value.senderIsBot
+    ?? value.fromIsBot
+    ?? value.from_is_bot;
+  const senderIsBot = senderIsBotRaw === true
+    || senderIsBotRaw === "true"
+    || senderIsBotRaw === 1
+    || senderIsBotRaw === "1"
+    || kind === "bot_reply";
+  if (senderIsBot) {
+    return null;
+  }
+  const chatID = String(
+    value.chat_id
+    || value.chatID
+    || value.chatId
+    || "",
+  ).trim();
+  const senderID = String(
+    value.sender_id
+    || value.senderID
+    || value.fromID
+    || value.from_id
+    || value.user_id
+    || value.userID
+    || value.sender_username
+    || value.senderUsername
+    || value.fromUsername
+    || value.from_username
+    || value.username
+    || "",
+  ).trim().toLowerCase();
+  const occurredAt = String(
+    value.occurred_at
+    || value.occurredAt
+    || "",
+  ).trim();
+  const body = normalizeBodyForCanonicalKey(
+    value.body
+    || value.text
+    || "",
+  );
+  if (!chatID || !senderID || !occurredAt || !body) {
+    return null;
+  }
+  const messageThreadID = intFromRawAllowZero(
+    value.message_thread_id
+    || value.messageThreadID,
+    0,
+  );
+  const replyToMessageID = intFromRawAllowZero(
+    value.reply_to_message_id
+    || value.replyToMessageID,
+    0,
+  );
+  return {
+    chatID,
+    senderID,
+    occurredAt: normalizeOccurredAtForCanonicalKey(occurredAt),
+    body,
+    messageThreadID: messageThreadID > 0 ? messageThreadID : 0,
+    replyToMessageID: replyToMessageID > 0 ? replyToMessageID : 0,
+  };
+}
+
+export function buildCanonicalHumanInboundKey(rawValue) {
+  const value = safeObject(rawValue);
+  const explicitKey = String(
+    value.canonical_human_message_key
+    || value.canonicalHumanMessageKey
+    || "",
+  ).trim();
+  if (explicitKey) {
+    return explicitKey;
+  }
+  const source = buildCanonicalHumanInboundSource(value);
+  if (!source) {
+    return "";
+  }
+  return createHash("sha1")
+    .update(JSON.stringify(source))
+    .digest("hex");
+}
+
 export function normalizeTelegramMessageEnvelope(rawEnvelope) {
   const envelope = safeObject(rawEnvelope);
   const chatID = String(
@@ -61,6 +167,13 @@ export function normalizeTelegramMessageEnvelope(rawEnvelope) {
     envelope.sender,
     senderUsername ? `@${senderUsername}` : "",
   ]);
+  const senderID = String(
+    envelope.sender_id
+    || envelope.senderID
+    || envelope.fromID
+    || envelope.from_id
+    || "",
+  ).trim();
   const rawSenderIsBot = envelope.sender_is_bot ?? envelope.senderIsBot;
   const senderIsBot = rawSenderIsBot === true
     || rawSenderIsBot === "true"
@@ -68,6 +181,15 @@ export function normalizeTelegramMessageEnvelope(rawEnvelope) {
     || rawSenderIsBot === "1"
     || kind === "bot_reply";
   const body = String(envelope.body || envelope.text || "").trim();
+  const occurredAt = String(
+    envelope.occurred_at
+    || envelope.occurredAt
+    || "",
+  ).trim();
+  const mentionUsernames = uniqueNormalizedSelectors(
+    envelope.mention_usernames
+    || envelope.mentionUsernames,
+  );
   const sourceOrigin = String(
     envelope.source_origin
     || envelope.sourceOrigin
@@ -90,14 +212,29 @@ export function normalizeTelegramMessageEnvelope(rawEnvelope) {
     && !(replyToMessageID > 0)
     && !kind
     && !sender
+    && !senderID
     && !senderUsername
     && !body
+    && !occurredAt
+    && mentionUsernames.length === 0
     && !sourceOrigin
     && !sourceRouteKey
     && !sourceBotUsername
   ) {
     return {};
   }
+  const canonicalHumanMessageKey = buildCanonicalHumanInboundKey({
+    chat_id: chatID,
+    message_id: messageID,
+    message_thread_id: messageThreadID,
+    reply_to_message_id: replyToMessageID,
+    kind,
+    sender_id: senderID,
+    sender_username: senderUsername,
+    sender_is_bot: senderIsBot === true,
+    body,
+    occurred_at: occurredAt,
+  });
   return {
     ...(chatID ? { chat_id: chatID } : {}),
     ...(messageID > 0 ? { message_id: messageID } : {}),
@@ -105,9 +242,13 @@ export function normalizeTelegramMessageEnvelope(rawEnvelope) {
     ...(replyToMessageID > 0 ? { reply_to_message_id: replyToMessageID } : {}),
     ...(kind ? { kind } : {}),
     ...(sender ? { sender } : {}),
+    ...(senderID ? { sender_id: senderID } : {}),
     ...(senderUsername ? { sender_username: senderUsername } : {}),
     sender_is_bot: senderIsBot === true,
     ...(body ? { body } : {}),
+    ...(occurredAt ? { occurred_at: occurredAt } : {}),
+    ...(mentionUsernames.length > 0 ? { mention_usernames: mentionUsernames } : {}),
+    ...(canonicalHumanMessageKey ? { canonical_human_message_key: canonicalHumanMessageKey } : {}),
     ...(sourceOrigin ? { source_origin: sourceOrigin } : {}),
     ...(sourceRouteKey ? { source_route_key: sourceRouteKey } : {}),
     ...(sourceBotUsername ? { source_bot_username: sourceBotUsername } : {}),
@@ -126,6 +267,10 @@ export function buildTelegramMessageEnvelopeFromParsedArchive(parsedArchiveRaw,
     message_thread_id: overrides.message_thread_id ?? parsedArchive.messageThreadID,
     reply_to_message_id: overrides.reply_to_message_id ?? parsedArchive.replyToMessageID,
     kind: firstNonEmptyString([overrides.kind, parsedArchive.kind]),
+    sender_id: firstNonEmptyString([
+      overrides.sender_id,
+      parsedArchive.senderID,
+    ]),
     sender: firstNonEmptyString([
       overrides.sender,
       parsedArchive.sender,
@@ -140,6 +285,17 @@ export function buildTelegramMessageEnvelopeFromParsedArchive(parsedArchiveRaw,
     ]),
     sender_is_bot: overrides.sender_is_bot ?? parsedArchive.senderIsBot,
     body: firstNonEmptyString([overrides.body, parsedArchive.body]),
+    occurred_at: firstNonEmptyString([overrides.occurred_at, parsedArchive.occurredAt]),
+    mention_usernames: ensureArray(
+      overrides.mention_usernames
+      || overrides.mentionUsernames
+      || parsedArchive.mentionUsernames,
+    ),
+    canonical_human_message_key: firstNonEmptyString([
+      overrides.canonical_human_message_key,
+      overrides.canonicalHumanMessageKey,
+      parsedArchive.canonicalHumanMessageKey,
+    ]),
     source_origin: firstNonEmptyString([
       overrides.source_origin,
       parsedArchive.sourceOrigin,
@@ -451,6 +607,10 @@ export function buildProcessableArchiveLogicalKey(recordRaw) {
   if (!isRunnerProcessableArchiveKind(kind)) {
     return "";
   }
+  const canonicalHumanKey = buildCanonicalHumanInboundKey(parsed);
+  if (canonicalHumanKey) {
+    return `human:${canonicalHumanKey}`;
+  }
   const chatID = firstNonEmptyString([parsed.chatID, parsed.chatId]);
   const messageID = intFromRawAllowZero(parsed.messageID, 0);
   if (!chatID || !(messageID > 0)) {

package/lib/runner-orchestration-adjudication.mjs

@@ -16,6 +16,10 @@ function ensureArray(value) {
   return Array.isArray(value) ? value : [];
 }
 
+function normalizeMentionSelector(rawValue) {
+  return String(rawValue || "").trim().replace(/^@+/, "").toLowerCase();
+}
+
 function intFromRawAllowZero(raw, fallback = 0) {
   if (raw === null || raw === undefined || raw === "") {
     return fallback;
@@ -48,6 +52,45 @@ function buildRunnerContinuationContractTriggerDecision(triggerDecision) {
   };
 }
 
+function isRunnerBotReplyContinuationAuthorizedForCurrentBot({
+  selectedRecord,
+  persistedRequest = null,
+  currentBotSelector = "",
+}) {
+  const normalizedCurrentBotSelector = normalizeMentionSelector(currentBotSelector);
+  if (!normalizedCurrentBotSelector) {
+    return false;
+  }
+  const parsed = safeObject(selectedRecord?.parsedArchive);
+  const normalizedSenderSelectors = ensureArray([
+    parsed.botUsername,
+    parsed.senderUsername,
+    parsed.sender,
+  ])
+    .map((value) => normalizeMentionSelector(value))
+    .filter(Boolean);
+  if (normalizedSenderSelectors.includes(normalizedCurrentBotSelector)) {
+    return false;
+  }
+  const explicitReplyTargets = ensureArray([
+    ...(Array.isArray(parsed.mentionUsernames) ? parsed.mentionUsernames : []),
+    parsed.replyToBotUsername,
+    parsed.targetBotUsername,
+    parsed.assignBotUsername,
+    parsed.nextResponderBotUsername,
+  ])
+    .map((value) => normalizeMentionSelector(value))
+    .filter(Boolean);
+  if (explicitReplyTargets.includes(normalizedCurrentBotSelector)) {
+    return true;
+  }
+  const request = safeObject(persistedRequest);
+  const nextExpectedResponders = ensureArray(request.next_expected_responders)
+    .map((value) => normalizeMentionSelector(value))
+    .filter(Boolean);
+  return nextExpectedResponders.includes(normalizedCurrentBotSelector);
+}
+
 export async function resolveRunnerPrecomputedResponderAdjudication({
   selectedRecord,
   pendingOrdered,
@@ -189,6 +232,11 @@ export async function resolveRunnerPrecomputedBotReplyAuthorityContext({
     persistedRequest: resolveRunnerContinuationLinkedRequest(normalizedRequestClaim),
     triggerDecision,
   });
+  const continuationAuthorizedForCurrentBot = isRunnerBotReplyContinuationAuthorizedForCurrentBot({
+    selectedRecord,
+    persistedRequest: resolveRunnerContinuationLinkedRequest(normalizedRequestClaim),
+    currentBotSelector,
+  });
   const currentBotSelected = ensureArray(continuationAdjudication?.selected_bot_usernames)
     .map((value) => String(value || "").trim().replace(/^@+/, "").toLowerCase())
     .includes(currentBotSelector);
@@ -204,6 +252,18 @@ export async function resolveRunnerPrecomputedBotReplyAuthorityContext({
       sharedHumanIntentContext: null,
     };
   }
+  if (!continuationAuthorizedForCurrentBot) {
+    return {
+      shouldSkip: true,
+      requestless: false,
+      skipAction: "adjudication_skipped",
+      skipReason: "bot_reply_not_explicitly_handed_off",
+      skipTrigger: "request_contract",
+      skipRecordPatch: {},
+      adjudication: continuationAdjudication,
+      sharedHumanIntentContext: null,
+    };
+  }
   return {
     shouldSkip: false,
     requestless: false,

package/lib/runner-orchestration-entrypoints.mjs

@@ -1,4 +1,5 @@
 import {
+  buildCanonicalHumanInboundKey,
   buildRunnerContextWindow,
   compareArchiveCommentRecords,
   dedupeProcessableArchiveComments,
@@ -103,6 +104,10 @@ function resolveRunnerLocalInboundReceiptTargetSelector(receiptRaw) {
 
 function buildRunnerArchiveSourceMessageKey(recordRaw) {
   const parsed = safeObject(safeObject(recordRaw).parsedArchive);
+  const canonicalHumanKey = buildCanonicalHumanInboundKey(parsed);
+  if (canonicalHumanKey) {
+    return `human:${canonicalHumanKey}`;
+  }
   const chatID = String(parsed.chatID || parsed.chatId || "").trim();
   const messageID = intFromRawAllowZero(parsed.messageID || parsed.messageId, 0);
   if (!chatID || !(messageID > 0)) {
@@ -113,6 +118,21 @@ function buildRunnerArchiveSourceMessageKey(recordRaw) {
 
 function buildRunnerLocalInboundReceiptKey(receiptRaw) {
   const receipt = safeObject(receiptRaw);
+  const canonicalHumanKey = buildCanonicalHumanInboundKey({
+    chat_id: receipt.chat_id,
+    message_id: receipt.message_id,
+    message_thread_id: receipt.message_thread_id,
+    reply_to_message_id: receipt.reply_to_message_id,
+    kind: receipt.kind,
+    sender_id: receipt.sender_id,
+    sender_username: receipt.sender_username,
+    sender_is_bot: receipt.sender_is_bot === true,
+    body: receipt.body,
+    occurred_at: receipt.occurred_at,
+  });
+  if (canonicalHumanKey) {
+    return `human:${canonicalHumanKey}`;
+  }
   const chatID = String(receipt.chat_id || receipt.chatID || "").trim();
   const messageID = intFromRawAllowZero(receipt.message_id || receipt.messageID, 0);
   if (!chatID || !(messageID > 0)) {

package/lib/runner-recovery.mjs

@@ -431,6 +431,7 @@ export function peekRunnerContinuationRequestForBotReply({
 export function recoverRunnerContinuationRequestForBotReply({
   normalizedRoute,
   continuationPreview,
+  persist = true,
   deps = {},
 }) {
   const upsertRunnerRequest = requireDependency(deps, "upsertRunnerRequest");
@@ -506,6 +507,18 @@ export function recoverRunnerContinuationRequestForBotReply({
         || "",
       ).trim().toLowerCase(),
     };
+  if (persist !== true) {
+    return {
+      ok: true,
+      linkedRequestKey: fallbackRequestKey,
+      linkedRequest: seedRequest,
+      currentState,
+      conversationID: String(preview.conversationID || "").trim(),
+      commentKind: String(preview.commentKind || "").trim().toLowerCase(),
+      linkResolutionKind: "recovered_request_link",
+      linkRecovered: true,
+    };
+  }
   const seededRequest = upsertRunnerRequest(currentState, fallbackRequestKey, seedRequest);
   currentState.requests = seededRequest.requests;
   saveBotRunnerState({
@@ -531,6 +544,7 @@ export function resolveRunnerContinuationRequestForBotReply({
   normalizedRoute,
   routeKey,
   selectedRecord,
+  persist = true,
   deps = {},
 }) {
   const upsertRunnerConsumedComment = requireDependency(deps, "upsertRunnerConsumedComment");
@@ -547,12 +561,16 @@ export function resolveRunnerContinuationRequestForBotReply({
     continuation = recoverRunnerContinuationRequestForBotReply({
       normalizedRoute,
       continuationPreview: continuation,
+      persist,
       deps,
     });
   }
   if (!continuation.ok) {
     return continuation;
   }
+  if (persist !== true) {
+    return continuation;
+  }
   const {
     currentState,
     linkedRequest,
@@ -609,6 +627,7 @@ export function prepareRunnerBotReplyContinuationContext({
       normalizedRoute,
       routeKey,
       selectedRecord,
+      persist: false,
       deps,
     })
     : continuationPreview;

package/lib/runner-runtime.mjs

@@ -539,10 +539,12 @@ function buildRunnerLocalInboundEnvelopeFromReceipt(rawReceipt) {
     message_thread_id: receipt.message_thread_id,
     reply_to_message_id: receipt.reply_to_message_id,
     kind: receipt.kind,
+    sender_id: receipt.sender_id,
     sender: receipt.sender,
     sender_username: receipt.sender_username,
     sender_is_bot: receipt.sender_is_bot === true,
     body: receipt.body,
+    occurred_at: receipt.occurred_at,
     source_origin: receipt.receipt_origin,
     source_route_key: receipt.receipt_route_key,
     source_bot_username: receipt.receipt_bot_username,
@@ -670,16 +672,13 @@ function buildRunnerRecentLocalInboundReceipts(routeStateRaw, localInboundArtifa
 const RUNNER_INBOUND_ARCHIVE_RESERVATION_TTL_MS = 10 * 60 * 1000;
 const runnerInboundArchiveReservations = new Map();
 
-function buildRunnerInboundArchiveReservationKey(threadID, chatID, messageID, sourceBotUsername = "") {
+function buildRunnerInboundArchiveReservationKey(threadID, archiveMessageKey = "") {
   const normalizedThreadID = String(threadID || "").trim();
-  const normalizedChatID = String(chatID || "").trim();
-  const normalizedMessageID = intFromRawAllowZero(messageID, 0);
-  const normalizedSourceBotUsername = normalizeMentionSelector(sourceBotUsername);
-  if (!normalizedThreadID || !normalizedChatID || !(normalizedMessageID > 0)) {
+  const normalizedArchiveMessageKey = String(archiveMessageKey || "").trim();
+  if (!normalizedThreadID || !normalizedArchiveMessageKey) {
     return "";
   }
-  const baseKey = `${normalizedThreadID}::${normalizedChatID}:${normalizedMessageID}`;
-  return normalizedSourceBotUsername ? `${baseKey}::${normalizedSourceBotUsername}` : baseKey;
+  return `${normalizedThreadID}::${normalizedArchiveMessageKey}`;
 }
 
 function cleanupRunnerInboundArchiveReservations(nowMs = Date.now()) {
@@ -690,8 +689,8 @@ function cleanupRunnerInboundArchiveReservations(nowMs = Date.now()) {
   }
 }
 
-function reserveRunnerInboundArchiveMessage(threadID, chatID, messageID, sourceBotUsername = "") {
-  const reservationKey = buildRunnerInboundArchiveReservationKey(threadID, chatID, messageID, sourceBotUsername);
+function reserveRunnerInboundArchiveMessage(threadID, archiveMessageKey = "") {
+  const reservationKey = buildRunnerInboundArchiveReservationKey(threadID, archiveMessageKey);
   if (!reservationKey) {
     return {
       ok: false,
@@ -821,7 +820,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, parsed.sourceBotUsername)),
+      .map((parsed) => buildArchivedInboundMessageKey(parsed)),
   );
 }
 
@@ -884,16 +883,27 @@ async function archiveRunnerTelegramInboundUpdates({
       route,
       bot,
     });
-    const dedupeKey = buildArchivedInboundMessageKey(update.chatID, update.messageID, archiveSourceBotUsername);
+    const dedupeKey = buildArchivedInboundMessageKey({
+      chatID: update.chatID,
+      messageID: update.messageID,
+      messageThreadID: update.messageThreadID,
+      kind: update.fromIsBot ? "bot_reply" : "telegram_message",
+      senderID: update.fromID,
+      sender: update.fromName,
+      senderUsername: update.fromUsername,
+      senderIsBot: update.fromIsBot === true,
+      body: update.text,
+      occurredAt: update.occurredAt,
+      replyToMessageID: update.replyToMessageID,
+      sourceBotUsername: archiveSourceBotUsername,
+    });
     if (boolFromRaw(archivePolicy.dedupeInbound, true) && existingKeys.has(dedupeKey)) {
       continue;
     }
     const reservation = boolFromRaw(archivePolicy.dedupeInbound, true)
       ? reserveRunnerInboundArchiveMessage(
         archiveThread?.threadID,
-        update.chatID,
-        update.messageID,
-        archiveSourceBotUsername,
+        dedupeKey,
       )
       : { ok: true, reservationKey: "" };
     if (!reservation.ok) {

package/lib/selftest-runner-scenarios.mjs

@@ -299,6 +299,7 @@ export async function runSelftestRunnerScenarios(push, deps) {
   const mergeServerRunnerRequestLedgerIntoLocalState = requireDependency(deps, "mergeServerRunnerRequestLedgerIntoLocalState");
   const buildRunnerStatusQueryLookup = requireDependency(deps, "buildRunnerStatusQueryLookup");
   const claimRunnerRequestForHumanComment = requireDependency(deps, "claimRunnerRequestForHumanComment");
+  const buildArchivedInboundMessageKey = requireDependency(deps, "buildArchivedInboundMessageKey");
   const markRunnerRequestLifecycle = requireDependency(deps, "markRunnerRequestLifecycle");
   const resolveRunnerContinuationRequestForBotReply = requireDependency(deps, "resolveRunnerContinuationRequestForBotReply");
   const prepareRunnerSelectedRecordRecoveryContext = requireDependency(deps, "prepareRunnerSelectedRecordRecoveryContext");
@@ -2180,17 +2181,142 @@ export async function runSelftestRunnerScenarios(push, deps) {
     const authoritativeSourceRequest = safeObject(
       safeObject(loadBotRunnerState().requests)[authoritativeSourceClaim.requestKey],
     );
-    push(
-      "runner_request_claim_preserves_authoritative_source_message_envelope",
-      authoritativeSourceClaim.ok === true
-        && String(authoritativeSourceRequest.source_message_origin || "") === "local_telegram_inbound"
-        && String(authoritativeSourceRequest.source_message_route_key || "") === requestRouteKey
-        && String(authoritativeSourceRequest.source_message_bot_username || "") === "ryoai_bot"
-        && Number(safeObject(authoritativeSourceRequest.source_message_envelope).message_id || 0) === 503,
-      `origin=${String(authoritativeSourceRequest.source_message_origin || "(none)")} route=${String(authoritativeSourceRequest.source_message_route_key || "(none)")} bot=${String(authoritativeSourceRequest.source_message_bot_username || "(none)")} message=${String(safeObject(authoritativeSourceRequest.source_message_envelope).message_id || "(none)")}`,
-    );
-
-    const rootTaskRecord = {
+    push(
+      "runner_request_claim_preserves_authoritative_source_message_envelope",
+      authoritativeSourceClaim.ok === true
+        && String(authoritativeSourceRequest.source_message_origin || "") === "local_telegram_inbound"
+        && String(authoritativeSourceRequest.source_message_route_key || "") === requestRouteKey
+        && String(authoritativeSourceRequest.source_message_bot_username || "") === "ryoai_bot"
+        && Number(safeObject(authoritativeSourceRequest.source_message_envelope).message_id || 0) === 503,
+      `origin=${String(authoritativeSourceRequest.source_message_origin || "(none)")} route=${String(authoritativeSourceRequest.source_message_route_key || "(none)")} bot=${String(authoritativeSourceRequest.source_message_bot_username || "(none)")} message=${String(safeObject(authoritativeSourceRequest.source_message_envelope).message_id || "(none)")}`,
+    );
+
+    const canonicalHumanArchiveKeyPrimary = buildArchivedInboundMessageKey({
+      chatID: "-100123",
+      messageID: 1189,
+      messageThreadID: 0,
+      kind: "telegram_message",
+      senderID: "7001",
+      senderIsBot: false,
+      occurredAt: "2026-04-01T06:00:00.000Z",
+      body: "@RyoAI_bot @RyoAI2_bot @RyoAI3_bot 같이 논의 해죠",
+      sourceBotUsername: "ryoai_bot",
+    });
+    const canonicalHumanArchiveKeyPeer = buildArchivedInboundMessageKey({
+      chatID: "-100123",
+      messageID: 294,
+      messageThreadID: 0,
+      kind: "telegram_message",
+      senderID: "7001",
+      senderIsBot: false,
+      occurredAt: "2026-04-01T06:00:00.000Z",
+      body: "@RyoAI_bot @RyoAI2_bot @RyoAI3_bot 같이 논의 해죠",
+      sourceBotUsername: "ryoai3_bot",
+    });
+    push(
+      "runner_human_inbound_archive_identity_is_canonical_across_routes",
+      canonicalHumanArchiveKeyPrimary === canonicalHumanArchiveKeyPeer
+        && canonicalHumanArchiveKeyPrimary.startsWith("human:"),
+      `primary=${canonicalHumanArchiveKeyPrimary} peer=${canonicalHumanArchiveKeyPeer}`,
+    );
+
+    const sharedHumanRouteRyoai1 = normalizeRunnerRoute({
+      ...requestRoute,
+      name: "telegram-monitor-request-ledger-shared-human-ryoai1",
+    });
+    const sharedHumanRouteRyoai3 = normalizeRunnerRoute({
+      ...requestRoute,
+      name: "telegram-monitor-request-ledger-shared-human-ryoai3",
+    });
+    const sharedHumanRouteRyoai1Key = runnerRouteKey(sharedHumanRouteRyoai1);
+    const sharedHumanRouteRyoai3Key = runnerRouteKey(sharedHumanRouteRyoai3);
+    const sharedHumanBody = "@RyoAI_bot @RyoAI2_bot @RyoAI3_bot 같이 논의 해죠";
+    const sharedHumanRecordPrimary = {
+      id: "comment-request-shared-human-1",
+      createdAt: "2026-04-01T06:00:00.000Z",
+      updatedAt: "2026-04-01T06:00:00.000Z",
+      parsedArchive: {
+        kind: "telegram_message",
+        chatID: "-100123",
+        chatType: "supergroup",
+        body: sharedHumanBody,
+        messageID: 1189,
+        senderID: "7001",
+        senderIsBot: false,
+        occurredAt: "2026-04-01T06:00:00.000Z",
+        mentionUsernames: ["ryoai_bot", "ryoai2_bot", "ryoai3_bot"],
+      },
+    };
+    const sharedHumanRecordPeer = {
+      id: "comment-request-shared-human-2",
+      createdAt: "2026-04-01T06:00:00.000Z",
+      updatedAt: "2026-04-01T06:00:00.000Z",
+      parsedArchive: {
+        kind: "telegram_message",
+        chatID: "-100123",
+        chatType: "supergroup",
+        body: sharedHumanBody,
+        messageID: 294,
+        senderID: "7001",
+        senderIsBot: false,
+        occurredAt: "2026-04-01T06:00:00.000Z",
+        mentionUsernames: ["ryoai_bot", "ryoai2_bot", "ryoai3_bot"],
+      },
+    };
+    const sharedHumanClaimPrimary = await claimRunnerRequestForHumanComment({
+      normalizedRoute: sharedHumanRouteRyoai1,
+      routeKey: sharedHumanRouteRyoai1Key,
+      selectedRecord: sharedHumanRecordPrimary,
+      selectedBotUsernames: ["ryoai_bot", "ryoai2_bot", "ryoai3_bot"],
+      normalizedIntent: "discussion_request",
+      authoritativeSourceMessageEnvelope: {
+        chat_id: "-100123",
+        message_id: 1189,
+        sender_id: "7001",
+        sender_is_bot: false,
+        occurred_at: "2026-04-01T06:00:00.000Z",
+        body: sharedHumanBody,
+        source_origin: "local_telegram_inbound",
+        source_route_key: sharedHumanRouteRyoai1Key,
+        source_bot_username: "ryoai_bot",
+      },
+    });
+    const sharedHumanClaimPeer = await claimRunnerRequestForHumanComment({
+      normalizedRoute: sharedHumanRouteRyoai3,
+      routeKey: sharedHumanRouteRyoai3Key,
+      selectedRecord: sharedHumanRecordPeer,
+      selectedBotUsernames: ["ryoai_bot", "ryoai2_bot", "ryoai3_bot"],
+      normalizedIntent: "discussion_request",
+      authoritativeSourceMessageEnvelope: {
+        chat_id: "-100123",
+        message_id: 294,
+        sender_id: "7001",
+        sender_is_bot: false,
+        occurred_at: "2026-04-01T06:00:00.000Z",
+        body: sharedHumanBody,
+        source_origin: "local_telegram_inbound",
+        source_route_key: sharedHumanRouteRyoai3Key,
+        source_bot_username: "ryoai3_bot",
+      },
+    });
+    const sharedHumanState = loadBotRunnerState();
+    const sharedHumanRequestCount = Object.values(safeObject(sharedHumanState.requests))
+      .filter((entryRaw) => {
+        const entry = safeObject(entryRaw);
+        return String(entry.chat_id || "") === "-100123"
+          && String(entry.source_message_body || "") === sharedHumanBody;
+      })
+      .length;
+    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}`,
+    );
+
+    const rootTaskRecord = {
       id: "comment-request-root-task-1",
       createdAt: "2026-03-22T00:05:00.000Z",
       updatedAt: "2026-03-22T00:05:00.000Z",
@@ -16340,11 +16466,82 @@ export async function runSelftestRunnerScenarios(push, deps) {
           && !Object.prototype.hasOwnProperty.call(continuation, "request"),
         `linked_key=${String(continuation.linkedRequestKey || "(none)")} has_request=${String(Object.prototype.hasOwnProperty.call(continuation, "request"))}`,
       );
-    } finally {
-      process.env.HOME = previousHome;
-      process.env.USERPROFILE = previousUserProfile;
-      try {
-        fs.rmSync(provenanceTempRoot, { recursive: true, force: true });
+      saveBotRunnerState({
+        routes: {
+          [provenanceRouteKey]: {
+            conversation_sessions: {
+              "conversation-provenance-seed": {
+                status: "open",
+                started_at: "2026-03-27T00:00:00.000Z",
+                participants: ["ryoai_bot"],
+                initial_responders: ["ryoai_bot"],
+                allowed_responders: ["ryoai_bot"],
+                intent_mode: "single_bot",
+                allow_bot_to_bot: false,
+              },
+            },
+            recent_local_inbound_receipts: {
+              "-100123:779": {
+                chat_id: "-100123",
+                message_id: 779,
+                receipt_origin: "local_telegram_inbound",
+                receipt_route_key: provenanceRouteKey,
+                receipt_bot_username: "ryoai_bot",
+                source_origin: "local_telegram_inbound",
+                source_route_key: provenanceRouteKey,
+                source_bot_username: "ryoai_bot",
+                body: "hello provenance",
+                message_thread_id: 43,
+              },
+            },
+            last_followup_source_message_envelope: {
+              message_id: 779,
+              message_thread_id: 43,
+              body: "hello provenance",
+              source_origin: "local_telegram_inbound",
+              source_route_key: provenanceRouteKey,
+              source_bot_username: "ryoai_bot",
+            },
+          },
+        },
+        sharedInboxes: {},
+        excludedComments: {},
+        requests: {},
+        consumedComments: {},
+      });
+      const stateBeforePreviewOnlyContinuation = loadBotRunnerState();
+      const previewOnlyRecoveryContext = prepareRunnerSelectedRecordRecoveryContext({
+        normalizedRoute: provenanceRoute,
+        routeKey: provenanceRouteKey,
+        selectedRecord: {
+          id: "bot-reply-preview-only-seed",
+          parsedArchive: {
+            kind: "bot_reply",
+            chatID: "-100123",
+            messageID: 881,
+            senderIsBot: true,
+            conversationID: "conversation-provenance-seed",
+            botUsername: "@ryoai_bot",
+          },
+        },
+      });
+      const stateAfterPreviewOnlyContinuation = loadBotRunnerState();
+      const previewRequestsBefore = Object.keys(normalizeBotRunnerRequests(stateBeforePreviewOnlyContinuation.requests)).length;
+      const previewRequestsAfter = Object.keys(normalizeBotRunnerRequests(stateAfterPreviewOnlyContinuation.requests)).length;
+      const previewConsumedBefore = Object.keys(safeObject(stateBeforePreviewOnlyContinuation.consumedComments || stateBeforePreviewOnlyContinuation.consumed_comments)).length;
+      const previewConsumedAfter = Object.keys(safeObject(stateAfterPreviewOnlyContinuation.consumedComments || stateAfterPreviewOnlyContinuation.consumed_comments)).length;
+      push(
+        "runner_continuation_preview_does_not_write_request_or_consumed_state",
+        safeObject(previewOnlyRecoveryContext.botReplyContinuationContext).continuationLinkRecoverable === true
+          && previewRequestsBefore === previewRequestsAfter
+          && previewConsumedBefore === previewConsumedAfter,
+        `recoverable=${String(safeObject(previewOnlyRecoveryContext.botReplyContinuationContext).continuationLinkRecoverable)} requests=${String(previewRequestsBefore)}->${String(previewRequestsAfter)} consumed=${String(previewConsumedBefore)}->${String(previewConsumedAfter)}`,
+      );
+    } finally {
+      process.env.HOME = previousHome;
+      process.env.USERPROFILE = previousUserProfile;
+      try {
+        fs.rmSync(provenanceTempRoot, { recursive: true, force: true });
       } catch {}
     }
   } catch (err) {
@@ -17447,6 +17644,7 @@ export async function runSelftestRunnerScenarios(push, deps) {
                 linkedRequest: {
                   request_key: "req-1",
                   selected_bot_usernames: ["alpha_bot"],
+                  next_expected_responders: ["alpha_bot"],
                 },
               },
             },
@@ -17493,6 +17691,7 @@ export async function runSelftestRunnerScenarios(push, deps) {
             linkedRequest: {
               request_key: "req-1",
               selected_bot_usernames: ["alpha_bot"],
+              next_expected_responders: ["alpha_bot"],
             },
           },
         },
@@ -17529,6 +17728,69 @@ export async function runSelftestRunnerScenarios(push, deps) {
     push("runner_selected_record_execution_context_promotes_continuation_only_after_recovery", false, String(err?.message || err));
   }
 
+  try {
+    const preparation = await resolveRunnerPrecomputedSelectedRecordExecutionContext({
+      selectedRecord: {
+        id: "comment-continuation-no-explicit-handoff",
+        parsedArchive: {
+          kind: "bot_reply",
+          chatID: "-100123",
+          chatType: "supergroup",
+          messageID: 3504,
+          body: "foreign bot follow up",
+          sender: "other bot",
+          senderIsBot: true,
+          botUsername: "@other_bot",
+          mentionUsernames: [],
+        },
+      },
+      recoveryContext: {
+        selectedRecordKind: "bot_reply",
+        botReplyContinuationContext: {
+          continuationLinkRecoverable: true,
+          continuationLinkResolution: {
+            ok: true,
+            linkedRequestKey: "req-no-explicit-handoff",
+            linkedRequest: {
+              request_key: "req-no-explicit-handoff",
+              selected_bot_usernames: ["alpha_bot"],
+              next_expected_responders: [],
+            },
+          },
+        },
+      },
+      normalizedRoute: {
+        provider: "telegram",
+        triggerPolicy: {
+          replyToBotMessages: true,
+        },
+      },
+      routeKey: "telegram-monitor-alpha::project::telegram::monitor::dest::actor",
+      routeState: {},
+      fallbackRouteState: {},
+      bot: {
+        username: "alpha_bot",
+        name: "alpha_bot",
+      },
+      executionPlan: {},
+      pendingOrdered: [],
+      currentBotSelector: "alpha_bot",
+      routingExecutionDeps: {
+        managedConversationBots: [],
+      },
+    });
+    push(
+      "runner_selected_record_execution_context_requires_explicit_handoff_for_bot_reply_continuation",
+      preparation.kind === "skip"
+        && String(preparation?.skipAction || "") === "adjudication_skipped"
+        && String(preparation?.skipReason || "") === "bot_reply_not_explicitly_handed_off"
+        && String(preparation?.skipTrigger || "") === "request_contract",
+      `kind=${String(preparation?.kind || "(none)")} action=${String(preparation?.skipAction || "(none)")} reason=${String(preparation?.skipReason || "(none)")} trigger=${String(preparation?.skipTrigger || "(none)")}`,
+    );
+  } catch (err) {
+    push("runner_selected_record_execution_context_requires_explicit_handoff_for_bot_reply_continuation", false, String(err?.message || err));
+  }
+
   try {
     const preparation = await resolveRunnerPrecomputedSelectedRecordExecutionContext({
       selectedRecord: {

package/lib/selftest-telegram-e2e.mjs

@@ -1599,6 +1599,123 @@ export async function runSelftestTelegramE2E(push, deps) {
     });
     const routeRyoai2Key = runnerRouteKey(routeRyoai2);
     const routeRyoai3Key = runnerRouteKey(routeRyoai3);
+
+    telegramE2EServer.state.comments = [];
+    telegramE2EServer.state.updates = [
+      {
+        update_id: 402,
+        message: {
+          message_id: 84,
+          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: "@RyoAI_bot @RyoAI2_bot @RyoAI3_bot 같이 논의 해죠",
+          entities: buildTelegramMentionEntities("@RyoAI_bot @RyoAI2_bot @RyoAI3_bot 같이 논의 해죠"),
+        },
+      },
+    ];
+    const sharedHumanRouteRuntime = {
+      baseURL: telegramE2EServer.baseURL,
+      timeoutSeconds: 10,
+      token: e2eToken,
+      actor: {
+        user_id: e2eActorUserID,
+      },
+    };
+    const sharedHumanManagedBots = [
+      {
+        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" },
+      },
+    ];
+    await archiveLocalTelegramMessagesForRoute({
+      routeKey: runnerRouteKey(routeRyoai1),
+      route: routeRyoai1,
+      routeState: {},
+      runtime: sharedHumanRouteRuntime,
+      bot: {
+        id: "88888888-8888-4888-8888-888888888881",
+        name: "RyoAI_bot",
+        username: "RyoAI_bot",
+        role: "monitor",
+      },
+      destination: {
+        chatID: e2eDestination.chat_id,
+      },
+      archiveThread: {
+        threadID: e2eThreadID,
+      },
+      managedConversationBots: sharedHumanManagedBots,
+      deps: buildRunnerRuntimeDeps(),
+    });
+    await archiveLocalTelegramMessagesForRoute({
+      routeKey: routeRyoai2Key,
+      route: routeRyoai2,
+      routeState: {},
+      runtime: sharedHumanRouteRuntime,
+      bot: {
+        id: "88888888-8888-4888-8888-888888888882",
+        name: "RyoAI2_bot",
+        username: "RyoAI2_bot",
+        role: "monitor",
+      },
+      destination: {
+        chatID: e2eDestination.chat_id,
+      },
+      archiveThread: {
+        threadID: e2eThreadID,
+      },
+      managedConversationBots: sharedHumanManagedBots,
+      deps: buildRunnerRuntimeDeps(),
+    });
+    await archiveLocalTelegramMessagesForRoute({
+      routeKey: routeRyoai3Key,
+      route: routeRyoai3,
+      routeState: {},
+      runtime: sharedHumanRouteRuntime,
+      bot: {
+        id: "88888888-8888-4888-8888-888888888883",
+        name: "RyoAI3_bot",
+        username: "RyoAI3_bot",
+        role: "monitor",
+      },
+      destination: {
+        chatID: e2eDestination.chat_id,
+      },
+      archiveThread: {
+        threadID: e2eThreadID,
+      },
+      managedConversationBots: sharedHumanManagedBots,
+      deps: buildRunnerRuntimeDeps(),
+    });
+    const sharedHumanBodies = telegramE2EServer.state.comments.map((item) => String(item.body || ""));
+    push(
+      "telegram_multi_bot_human_opening_archives_once_across_routes",
+      sharedHumanBodies.filter((item) => item.includes("message_id: 84")).length === 1,
+      `count=${sharedHumanBodies.filter((item) => item.includes("message_id: 84")).length} bodies=${sharedHumanBodies.join(" || ")}`,
+    );
+
+    telegramE2EServer.state.comments = [];
     await archiveLocalTelegramMessagesForRoute({
       routeKey: routeRyoai3Key,
       route: routeRyoai3,

package/package.json

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