metheus-governance-mcp-cli 0.2.277 → 0.2.279

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,
@@ -8139,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 || ""),
@@ -8275,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(
@@ -8609,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;
 }
 
@@ -17931,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-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-orchestration-selected-record-contract-context.mjs

@@ -9,6 +9,14 @@ function ensureArray(value) {
   return Array.isArray(value) ? value : [];
 }
 
+function intFromRawAllowZero(raw, fallback = 0) {
+  if (raw === null || raw === undefined || raw === "") {
+    return fallback;
+  }
+  const parsed = Number.parseInt(String(raw).trim(), 10);
+  return Number.isFinite(parsed) ? parsed : fallback;
+}
+
 function uniqueOrdered(values) {
   const seen = new Set();
   const ordered = [];
@@ -21,6 +29,104 @@ function uniqueOrdered(values) {
   return ordered;
 }
 
+function normalizeSelectorList(values, normalizeMentionSelector) {
+  return uniqueOrdered(
+    ensureArray(values)
+      .map((item) => normalizeMentionSelector(item))
+      .filter(Boolean),
+  );
+}
+
+function buildImplicitPublicMultiBotExecutionContract({
+  conversationContext = null,
+  executionContract = null,
+  currentBotSelector = "",
+  normalizeMentionSelector,
+}) {
+  const context = safeObject(conversationContext);
+  const normalizedCurrentBotSelector = normalizeMentionSelector(currentBotSelector);
+  if (
+    String(context.mode || "").trim() !== "public_multi_bot"
+    || String(context.intentMode || "").trim() !== "multi_bot_collab"
+    || context.allowBotToBot !== true
+    || !normalizedCurrentBotSelector
+  ) {
+    return safeObject(executionContract);
+  }
+  const normalizedAllowedResponders = normalizeSelectorList(
+    context.allowedResponderSelectors,
+    normalizeMentionSelector,
+  );
+  if (
+    normalizedAllowedResponders.length < 2
+    || !normalizedAllowedResponders.includes(normalizedCurrentBotSelector)
+  ) {
+    return safeObject(executionContract);
+  }
+
+  const explicitContract = safeObject(executionContract);
+  const explicitAssignments = normalizeSelectorList(
+    ensureArray(explicitContract.assignments).map((item) => (
+      safeObject(item).targetBot || safeObject(item).target_bot
+    )),
+    normalizeMentionSelector,
+  ).filter((item) => item !== normalizedCurrentBotSelector);
+  const explicitNextResponders = normalizeSelectorList(
+    explicitContract.nextResponders || explicitContract.next_responders || explicitContract.responders,
+    normalizeMentionSelector,
+  ).filter((item) => item !== normalizedCurrentBotSelector);
+  const explicitSummaryBot = normalizeMentionSelector(
+    explicitContract.summaryBot || explicitContract.summary_bot || context.summaryBotUsername,
+  );
+  const explicitType = String(explicitContract.type || "").trim().toLowerCase();
+  const hasExplicitFollowup = explicitAssignments.length > 0
+    || explicitNextResponders.length > 0
+    || (explicitType === "summary_request" && explicitSummaryBot && explicitSummaryBot !== normalizedCurrentBotSelector);
+  if (hasExplicitFollowup) {
+    return explicitContract;
+  }
+
+  const sessionSpeakerCounts = safeObject(safeObject(context.session).speaker_counts);
+  const projectedSpeakerCounts = {
+    ...sessionSpeakerCounts,
+    [normalizedCurrentBotSelector]: intFromRawAllowZero(sessionSpeakerCounts[normalizedCurrentBotSelector], 0) + 1,
+  };
+  const remainingPeerResponders = normalizedAllowedResponders.filter((selector) => (
+    selector
+    && selector !== normalizedCurrentBotSelector
+    && intFromRawAllowZero(projectedSpeakerCounts[selector], 0) <= 0
+  ));
+  if (remainingPeerResponders.length > 0) {
+    return {
+      type: "delegation",
+      actionable: true,
+      assignments: remainingPeerResponders.map((targetBot) => ({ targetBot })),
+      summaryBot: explicitSummaryBot,
+      nextResponders: remainingPeerResponders,
+      implicitFollowup: true,
+    };
+  }
+
+  const stage = String(context.stage || "").trim().toLowerCase();
+  if (
+    stage === "bot_reply"
+    && explicitSummaryBot
+    && explicitSummaryBot !== normalizedCurrentBotSelector
+    && normalizedAllowedResponders.includes(explicitSummaryBot)
+  ) {
+    return {
+      type: "summary_request",
+      actionable: true,
+      assignments: [],
+      summaryBot: explicitSummaryBot,
+      nextResponders: [explicitSummaryBot],
+      implicitFollowup: true,
+    };
+  }
+
+  return explicitContract;
+}
+
 export async function prepareRunnerSelectedRecordContractContext({
   selectedRecord,
   routeState,
@@ -64,7 +170,7 @@ export async function prepareRunnerSelectedRecordContractContext({
   }
 
   const effectiveResponseContractPayload = safeObject(aiPayload?.response_contract);
-  const executionContract = conversationContext?.mode === "public_multi_bot"
+  const normalizedExecutionContract = conversationContext?.mode === "public_multi_bot"
     ? normalizeConversationExecutionContract(
         aiResult?.contract,
         {
@@ -78,6 +184,12 @@ export async function prepareRunnerSelectedRecordContractContext({
         effectiveResponseContractPayload,
         { currentBotSelector },
       );
+  const executionContract = buildImplicitPublicMultiBotExecutionContract({
+    conversationContext,
+    executionContract: normalizedExecutionContract,
+    currentBotSelector,
+    normalizeMentionSelector,
+  });
   let allowedActionableTypes = new Set(
     ensureArray(effectiveResponseContractPayload.allowed_contract_types)
       .map((item) => String(item || "").trim().toLowerCase())
@@ -99,7 +211,6 @@ export async function prepareRunnerSelectedRecordContractContext({
     && String(conversationContext?.stage || "").trim() === "human_opening"
     && conversationContext?.allowBotToBot === true
     && Boolean(currentBotSelector)
-    && normalizedConversationInitialResponders.length === 1
     && normalizedConversationInitialResponders.includes(currentBotSelector)
     && peerAllowedResponders.length > 0;
   const directHumanPeerMap = humanIntentContext?.peerMap instanceof Map

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",
@@ -2825,6 +2951,50 @@ export async function runSelftestRunnerScenarios(push, deps) {
       `status=${String(continuedRequest?.status || "(none)")}`,
     );
 
+    saveBotRunnerState({
+      routes: {
+        [requestRouteKey]: {},
+      },
+      sharedInboxes: {},
+      excludedComments: {},
+      requests: {
+        "request-key-2c": {
+          request_key: "request-key-2c",
+          project_id: selftestProjectID,
+          provider: "telegram",
+          chat_id: "-100123",
+          source_message_id: 721,
+          conversation_id: "conv-request-2c",
+          status: "running",
+          claimed_by_route: requestRouteKey,
+        },
+      },
+      consumedComments: {},
+    });
+    const continuedByNextExpected = markRunnerRequestLifecycle({
+      normalizedRoute: requestRoute,
+      requestKey: "request-key-2c",
+      selectedRecord: {
+        id: "comment-request-finish-2c",
+        parsedArchive: {
+          kind: "bot_reply",
+          chatID: "-100123",
+          messageID: 722,
+          conversationID: "conv-request-2c",
+        },
+      },
+      routeKey: requestRouteKey,
+      outcome: "replied",
+      currentBotSelector: "@RyoAI_bot",
+      executionContractTargets: [],
+      nextExpectedResponders: ["@RyoAI2_bot", "@RyoAI3_bot"],
+    });
+    push(
+      "runner_request_lifecycle_reply_remains_running_with_next_expected_responders",
+      String(continuedByNextExpected?.status || "") === "running",
+      `status=${String(continuedByNextExpected?.status || "(none)")}`,
+    );
+
     saveBotRunnerState({
       routes: {
         [requestRouteKey]: {},
@@ -5324,16 +5494,162 @@ export async function runSelftestRunnerScenarios(push, deps) {
         && String(deliveredConversation[0]?.summaryBotUsername || "") === "ryoai_bot",
       `kind=${String(processed.kind || "(none)")} intent=${String(deliveredConversation[0]?.intentMode || "(none)")} summary=${String(deliveredConversation[0]?.summaryBotUsername || "(none)")}`,
     );
-  } catch (err) {
-    push("intent_fallback_uses_repeated_managed_mention_for_summary_target", false, String(err?.message || err));
-  }
-
-  try {
-    const deliveredConversation = [];
-    const processed = await processRunnerSelectedRecord({
-      routeKey: "delegated-single-lead-human-open-key",
-      normalizedRoute: normalizeRunnerRoute({
-        name: "telegram-monitor-delegated-single-lead-open",
+  } catch (err) {
+    push("intent_fallback_uses_repeated_managed_mention_for_summary_target", false, String(err?.message || err));
+  }
+
+  try {
+    let aiCalls = 0;
+    const deliveredConversation = [];
+    const processed = await processRunnerSelectedRecord({
+      routeKey: "multi-bot-collab-human-opening-synthesizes-next-turn-contract-key",
+      normalizedRoute: normalizeRunnerRoute({
+        name: "telegram-monitor-multi-bot-collab-human-opening-synthesizes-next-turn-contract",
+        project_id: selftestProjectID,
+        provider: "telegram",
+        role: "monitor",
+        role_profile: "monitor",
+        destination_id: "dest-1",
+        destination_label: "Main Room",
+        server_bot_name: "RyoAI_bot",
+        server_bot_id: "bot-lead-1",
+        trigger_policy: {
+          mentions_only: true,
+          direct_messages: true,
+          reply_to_bot_messages: true,
+        },
+        archive_policy: {
+          mirror_replies: true,
+          dedupe_inbound: true,
+          dedupe_outbound: true,
+          skip_bot_messages: true,
+        },
+        dry_run_delivery: true,
+      }),
+      selectedRecord: {
+        id: "comment-multi-bot-collab-human-opening",
+        body: "@RyoAI_bot @RyoAI2_bot @RyoAI3_bot 같이 논의해줘.",
+        threadID: "thread-1",
+        createdAt: "2026-03-17T00:00:00.000Z",
+        updatedAt: "2026-03-17T00:00:00.000Z",
+        parsedArchive: {
+          kind: "telegram_message",
+          body: "@RyoAI_bot @RyoAI2_bot @RyoAI3_bot 같이 논의해줘.",
+          sender: "User",
+          senderName: "User",
+          senderIsBot: false,
+          username: "user1",
+          chatType: "supergroup",
+          mentionUsernames: ["ryoai_bot", "ryoai2_bot", "ryoai3_bot"],
+          messageID: 1901,
+          chatID: "-100123",
+        },
+      },
+      routeState: {},
+      pendingOrdered: [],
+      bot: {
+        id: "bot-lead-1",
+        name: "RyoAI_bot",
+        username: "RyoAI_bot",
+      },
+      destination: {
+        id: "dest-1",
+        label: "Main Room",
+        provider: "telegram",
+        chatID: "-100123",
+      },
+      archiveThread: {
+        threadID: "thread-1",
+        workItemID: "work-item-1",
+      },
+      executionPlan: {
+        mode: "role_profile",
+        roleProfileName: "monitor",
+        roleProfile: {
+          client: "sample",
+          model: "",
+          permissionMode: "read_only",
+          reasoningEffort: "low",
+        },
+        workspaceDir: path.join(os.tmpdir(), "metheus-runner-selftest-multi-bot-collab-kickoff"),
+        workspaceSource: "selftest",
+        usedCommandFallback: false,
+      },
+      runtime: {
+        baseURL: "https://example.test",
+        token: "selftest-token",
+        timeoutSeconds: 30,
+        actor: { user_id: "user-1" },
+      },
+      deps: {
+        saveRunnerRouteState: () => {},
+        startRunnerTypingHeartbeat: () => ({ async stop() {} }),
+        runRunnerAIExecution: async () => {
+          aiCalls += 1;
+          return {
+            skip: false,
+            reply: "좋아요. 먼저 제 관점을 짧게 정리하고, 다른 봇 의견도 이어서 받겠습니다.",
+            replyToMessageID: 0,
+          };
+        },
+        performLocalBotDelivery: async ({ archiveConversation, archiveConversationContext, archiveExecutionContract }) => {
+          deliveredConversation.push(buildSelftestArchiveConversation({
+            archiveConversation,
+            archiveConversationContext,
+            archiveExecutionContract,
+          }));
+          return {
+            delivery: { dryRun: true, body: {} },
+            archive: {},
+          };
+        },
+        serializeRunnerTriggerPolicy: (value) => value,
+        serializeRunnerArchivePolicy: (value) => value,
+        buildRunnerExecutionDeps: () => ({
+          analyzeHumanConversationIntentWithAI: async () => ({
+            mode: "multi_bot_collab",
+            intent_type: "explanation_query",
+            lead_bot: "ryoai_bot",
+            participants: ["ryoai_bot", "ryoai2_bot", "ryoai3_bot"],
+            initial_responders: ["ryoai_bot", "ryoai2_bot", "ryoai3_bot"],
+            allowed_responders: ["ryoai_bot", "ryoai2_bot", "ryoai3_bot"],
+            summary_bot: "ryoai_bot",
+            allow_bot_to_bot: true,
+            reply_expectation: "informational",
+          }),
+        }),
+        buildRunnerDeliveryDeps: () => ({}),
+        buildRunnerRuntimeDeps: () => ({}),
+        resolveConversationPeerBots: () => [
+          { id: "bot-lead-1", name: "RyoAI_bot" },
+          { id: "bot-peer-1", name: "RyoAI2_bot" },
+          { id: "bot-peer-2", name: "RyoAI3_bot" },
+        ],
+      },
+    });
+    push(
+      "multi_bot_collab_human_opening_synthesizes_shared_next_turn_contract",
+      processed.kind === "replied"
+        && aiCalls === 1
+        && String(deliveredConversation[0]?.mode || "") === "public_multi_bot"
+        && String(deliveredConversation[0]?.executionContract?.type || "") === "delegation"
+        && ensureArray(deliveredConversation[0]?.executionContract?.nextResponders).includes("ryoai2_bot")
+        && ensureArray(deliveredConversation[0]?.executionContract?.nextResponders).includes("ryoai3_bot")
+        && ensureArray(processed.result?.next_expected_responders).includes("ryoai2_bot")
+        && ensureArray(processed.result?.next_expected_responders).includes("ryoai3_bot")
+        && String(processed.result?.response_contract_validation_status || "") === "valid",
+      `kind=${String(processed.kind || "(none)")} ai_calls=${aiCalls} contract=${String(deliveredConversation[0]?.executionContract?.type || "(none)")} next=${JSON.stringify(processed.result?.next_expected_responders || [])} validation=${String(processed.result?.response_contract_validation_status || "(none)")}`,
+    );
+  } catch (err) {
+    push("multi_bot_collab_human_opening_synthesizes_shared_next_turn_contract", false, String(err?.message || err));
+  }
+
+  try {
+    const deliveredConversation = [];
+    const processed = await processRunnerSelectedRecord({
+      routeKey: "delegated-single-lead-human-open-key",
+      normalizedRoute: normalizeRunnerRoute({
+        name: "telegram-monitor-delegated-single-lead-open",
         project_id: selftestProjectID,
         provider: "telegram",
         role: "monitor",

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.277",
+  "version": "0.2.279",
   "description": "Metheus Governance MCP CLI (setup + stdio proxy)",
   "type": "module",
   "files": [