metheus-governance-mcp-cli 0.2.294 → 0.2.296

package/cli.mjs

@@ -10632,10 +10632,10 @@ async function processRunnerRouteOnce(route, runtime, mode, options = {}) {
       latestRunnerState.consumedComments || latestRunnerState.consumed_comments,
     );
     const requests = normalizeBotRunnerRequests(latestRunnerState.requests);
-    const commentsForPending = ensureArray(comments).filter((comment) => {
-      const normalizedComment = normalizeArchiveCommentRecord(comment, parseArchivedChatComment);
-      const commentID = String(normalizedComment.id || "").trim();
-      const parsed = safeObject(normalizedComment.parsedArchive);
+    const commentsForPending = ensureArray(comments).filter((comment) => {
+      const normalizedComment = normalizeArchiveCommentRecord(comment, parseArchivedChatComment);
+      const commentID = String(normalizedComment.id || "").trim();
+      const parsed = safeObject(normalizedComment.parsedArchive);
       const commentKind = String(parsed.kind || "").trim().toLowerCase();
       if (commentID && safeObject(excludedComments)[commentID]) {
         return false;
@@ -10663,22 +10663,45 @@ async function processRunnerRouteOnce(route, runtime, mode, options = {}) {
         }
         const sessionMatch = findScopedConversationSessionState(latestRunnerState, normalizedRoute, conversationID);
         return sessionAllowsConversationResponder(sessionMatch.session, currentBotSelector);
-      }
-      return true;
-    });
+      }
+      return true;
+    });
+    const followupRequestsForPending = Object.values(requests).filter((entryRaw) => {
+      const entry = safeObject(entryRaw);
+      const nextExpectedResponders = ensureArray(entry.next_expected_responders)
+        .map((value) => normalizeTelegramMentionUsername(value))
+        .filter(Boolean);
+      if (!nextExpectedResponders.includes(currentBotSelector)) {
+        return false;
+      }
+      if (!isActiveRunnerRequestStatus(entry.status)) {
+        return false;
+      }
+      if (
+        String(entry.project_id || "").trim() !== String(normalizedRoute.projectID || "").trim()
+        || String(entry.provider || "").trim() !== String(normalizedRoute.provider || "").trim()
+        || String(entry.chat_id || "").trim() !== String(destination.chatID || "").trim()
+      ) {
+        return false;
+      }
+      const lastReplyEnvelope = safeObject(entry.last_reply_message_envelope);
+      return intFromRawAllowZero(lastReplyEnvelope.message_id || lastReplyEnvelope.messageID, 0) > 0;
+    });
     const pendingWork = selectRunnerPendingWork({
       comments: commentsForPending,
       importOutcome,
       refreshedState,
-      mode,
+      mode,
       parseArchivedChatComment,
       pendingSelectionOptions: {
         maxPendingAgeMs: BOT_RUNNER_PENDING_COMMENT_MAX_AGE_MS,
       },
-      deps: {
-        applyPendingAgeSelection,
-        normalizeArchiveCommentRecord,
-      },
+      deps: {
+        applyPendingAgeSelection,
+        normalizeArchiveCommentRecord,
+      },
+      followupRequests: followupRequestsForPending,
+      currentBotSelector,
     });
     const pending = pendingWork.pending;
     if (pending.staleSkippedLatest) {

package/lib/runner-orchestration-entrypoints.mjs

@@ -5,6 +5,7 @@ import {
   dedupeProcessableArchiveComments,
   isArchiveRecordAfterState,
   isInboundArchiveKind,
+  normalizeTelegramMessageEnvelope,
   selectPendingArchiveComments,
 } from "./runner-helpers.mjs";
 import {
@@ -13,6 +14,7 @@ import {
 } from "./runner-trigger.mjs";
 import {
   buildRunnerLocalInboundReceiptKey,
+  normalizeRunnerRecentLocalInboundReceiptMap,
 } from "./runner-local-inbound-receipts.mjs";
 
 function safeObject(value) {
@@ -130,6 +132,101 @@ function buildRunnerReceiptReplaySortTime(receiptRaw) {
   return Number.isFinite(receiptTime) ? receiptTime : 0;
 }
 
+function extractReceiptMentionSelectors(text) {
+  const matches = Array.from(String(text || "").matchAll(/@([A-Za-z0-9_]+)/g));
+  return Array.from(new Set(matches.map((match) => normalizeMentionSelector(match[1] || "")).filter(Boolean)));
+}
+
+function buildRunnerReceiptReplayRouteState(routeStateRaw) {
+  const routeState = safeObject(routeStateRaw);
+  return {
+    ...routeState,
+    last_processed_comment_id: String(routeState.active_comment_id || "").trim()
+      || String(routeState.last_processed_comment_id || "").trim(),
+    last_processed_created_at: String(routeState.active_comment_created_at || "").trim()
+      || String(routeState.last_processed_created_at || "").trim(),
+  };
+}
+
+function buildRunnerReceiptBackedSyntheticRecord(receiptRaw, receiptKey) {
+  const receipt = safeObject(receiptRaw);
+  const chatID = String(receipt.chat_id || "").trim();
+  const messageID = intFromRawAllowZero(receipt.message_id, 0);
+  const occurredAt = firstNonEmptyString([
+    receipt.occurred_at,
+    receipt.occurredAt,
+    receipt.received_at,
+    receipt.receivedAt,
+  ]);
+  if (!chatID || !(messageID > 0) || !occurredAt) {
+    return null;
+  }
+  const body = String(receipt.body || receipt.text || "").trim();
+  const parsedArchive = {
+    kind: firstNonEmptyString([receipt.kind, "telegram_message"]),
+    chatID,
+    messageID,
+    sender: String(receipt.sender || "").trim(),
+    senderID: String(receipt.sender_id || "").trim(),
+    senderIsBot: receipt.sender_is_bot === true,
+    username: String(receipt.sender_username || "").trim(),
+    mentionUsernames: extractReceiptMentionSelectors(body),
+    occurredAt,
+    canonicalHumanMessageKey: String(receipt.canonical_human_message_key || "").trim(),
+    sourceOrigin: firstNonEmptyString([receipt.receipt_origin, "local_telegram_inbound"]).toLowerCase(),
+    sourceRouteKey: String(receipt.receipt_route_key || "").trim(),
+    sourceBotUsername: normalizeMentionSelector(receipt.receipt_bot_username || ""),
+    body,
+  };
+  const messageThreadID = intFromRawAllowZero(receipt.message_thread_id, 0);
+  if (messageThreadID > 0) {
+    parsedArchive.messageThreadID = messageThreadID;
+  }
+  const replyToMessageID = intFromRawAllowZero(receipt.reply_to_message_id, 0);
+  if (replyToMessageID > 0) {
+    parsedArchive.replyToMessageID = replyToMessageID;
+  }
+  const replyToUsername = String(receipt.reply_to_from_username || "").trim();
+  if (replyToUsername) {
+    parsedArchive.replyToUsername = replyToUsername;
+  }
+  if (receipt.reply_to_from_is_bot === true) {
+    parsedArchive.replyToSenderIsBot = true;
+  }
+  const chatType = String(receipt.chat_type || "").trim();
+  if (chatType) {
+    parsedArchive.chatType = chatType;
+  }
+  return {
+    id: `receipt-replay:${receiptKey}`,
+    body,
+    createdAt: occurredAt,
+    updatedAt: occurredAt,
+    sourceOccurredAt: occurredAt,
+    parsedArchive,
+  };
+}
+
+function findRunnerReceiptArchiveCollisionRecord(orderedComments, receiptRaw, expectedReceiptKey = "") {
+  const receipt = safeObject(receiptRaw);
+  const chatID = String(receipt.chat_id || "").trim();
+  const messageID = intFromRawAllowZero(receipt.message_id, 0);
+  if (!chatID || !(messageID > 0)) {
+    return null;
+  }
+  return ensureArray(orderedComments).find((recordRaw) => {
+    const record = safeObject(recordRaw);
+    const parsed = safeObject(record.parsedArchive);
+    if (
+      firstNonEmptyString([parsed.chatID, parsed.chatId]) !== chatID
+      || intFromRawAllowZero(parsed.messageID, 0) !== messageID
+    ) {
+      return false;
+    }
+    return buildRunnerArchiveSourceMessageKey(record) !== String(expectedReceiptKey || "").trim();
+  }) || null;
+}
+
 function buildRunnerReceiptBackedReplayRecord(recordRaw, receiptRaw, pendingSelectionOptions = {}) {
   const record = safeObject(recordRaw);
   const receipt = safeObject(receiptRaw);
@@ -161,33 +258,75 @@ function buildRunnerReceiptBackedReplayRecord(recordRaw, receiptRaw, pendingSele
 function buildRunnerReceiptBackedPendingArchiveComments({
   orderedComments,
   currentPollLocalInboundReceipts,
+  routeStateLocalInboundReceipts,
+  routeState,
   existingPendingIDs,
   pendingSelectionOptions,
 }) {
   const pendingIDs = new Set(ensureArray(existingPendingIDs).map((value) => String(value || "").trim()).filter(Boolean));
   const latestReceiptsByKey = new Map();
-  for (const receiptRaw of ensureArray(currentPollLocalInboundReceipts)) {
+  const registerReceipt = (receiptRaw, source) => {
     const receipt = safeObject(receiptRaw);
     const receiptKey = buildRunnerLocalInboundReceiptKey(receipt, {
       resolveTargetSelector: resolveRunnerLocalInboundReceiptTargetSelector,
     });
     if (!receiptKey) {
-      continue;
+      return;
     }
-    const previous = safeObject(latestReceiptsByKey.get(receiptKey));
-    if (buildRunnerReceiptReplaySortTime(receipt) >= buildRunnerReceiptReplaySortTime(previous)) {
-      latestReceiptsByKey.set(receiptKey, receipt);
+    const previousEntry = safeObject(latestReceiptsByKey.get(receiptKey));
+    const previousReceipt = safeObject(previousEntry.receipt);
+    const previousSource = String(previousEntry.source || "").trim();
+    const nextSortTime = buildRunnerReceiptReplaySortTime(receipt);
+    const previousSortTime = buildRunnerReceiptReplaySortTime(previousReceipt);
+    if (
+      nextSortTime > previousSortTime
+      || (
+        nextSortTime === previousSortTime
+        && source === "current_poll"
+        && previousSource !== "current_poll"
+      )
+    ) {
+      latestReceiptsByKey.set(receiptKey, { receipt, source });
     }
+  };
+  for (const receiptRaw of ensureArray(currentPollLocalInboundReceipts)) {
+    registerReceipt(receiptRaw, "current_poll");
+  }
+  for (const receiptRaw of Object.values(normalizeRunnerRecentLocalInboundReceiptMap(routeStateLocalInboundReceipts))) {
+    registerReceipt(receiptRaw, "route_state");
   }
+  const replayRouteState = buildRunnerReceiptReplayRouteState(routeState);
   const replayCandidates = [];
-  for (const [receiptKey, receipt] of latestReceiptsByKey.entries()) {
+  for (const [receiptKey, receiptEntryRaw] of latestReceiptsByKey.entries()) {
+    const receiptEntry = safeObject(receiptEntryRaw);
+    const receipt = safeObject(receiptEntry.receipt);
+    const receiptSource = String(receiptEntry.source || "").trim();
     const matchedRecord = orderedComments.find((record) => buildRunnerArchiveSourceMessageKey(record) === receiptKey);
-    const matchedID = String(safeObject(matchedRecord).id || "").trim();
+    const collisionRecord = matchedRecord
+      ? null
+      : findRunnerReceiptArchiveCollisionRecord(orderedComments, receipt, receiptKey);
+    const selectedRecord = matchedRecord || buildRunnerReceiptBackedSyntheticRecord(receipt, receiptKey);
+    if (
+      collisionRecord
+      || !selectedRecord
+      || (
+        !matchedRecord
+        && !String(safeObject(selectedRecord.parsedArchive).canonicalHumanMessageKey || "").trim()
+        && !String(safeObject(selectedRecord.parsedArchive).canonical_human_message_key || "").trim()
+      )
+      || (
+        receiptSource !== "current_poll"
+        && !isArchiveRecordAfterState(selectedRecord, replayRouteState)
+      )
+    ) {
+      continue;
+    }
+    const matchedID = String(safeObject(selectedRecord).id || "").trim();
     if (!matchedID || pendingIDs.has(matchedID)) {
       continue;
     }
     replayCandidates.push(buildRunnerReceiptBackedReplayRecord(
-      matchedRecord,
+      selectedRecord,
       receipt,
       pendingSelectionOptions,
     ));
@@ -195,6 +334,175 @@ function buildRunnerReceiptBackedPendingArchiveComments({
   return replayCandidates.sort(compareArchiveCommentRecords);
 }
 
+function buildRunnerRequestFollowupSyntheticRecord(requestRaw, currentBotSelector, pendingSelectionOptions = {}) {
+  const request = safeObject(requestRaw);
+  const replyEnvelope = safeObject(normalizeTelegramMessageEnvelope(request.last_reply_message_envelope));
+  const chatID = String(request.chat_id || replyEnvelope.chat_id || "").trim();
+  const messageID = intFromRawAllowZero(replyEnvelope.message_id, 0);
+  const occurredAt = firstNonEmptyString([
+    replyEnvelope.occurred_at,
+    request.updated_at,
+    request.claimed_at,
+    request.created_at,
+  ]);
+  if (!chatID || !(messageID > 0) || !occurredAt) {
+    return null;
+  }
+  const normalizedCurrentBotSelector = normalizeMentionSelector(currentBotSelector);
+  const senderSelector = normalizeMentionSelector(
+    replyEnvelope.sender_username
+    || replyEnvelope.bot_username
+    || replyEnvelope.username
+    || replyEnvelope.sender,
+  );
+  if (normalizedCurrentBotSelector && senderSelector && normalizedCurrentBotSelector === senderSelector) {
+    return null;
+  }
+  const participants = Array.from(new Set(
+    ensureArray(request.conversation_participants)
+      .map((value) => normalizeMentionSelector(value))
+      .filter(Boolean),
+  ));
+  const initialResponders = Array.from(new Set(
+    ensureArray(request.conversation_initial_responders)
+      .map((value) => normalizeMentionSelector(value))
+      .filter(Boolean),
+  ));
+  const allowedResponders = Array.from(new Set(
+    ensureArray(request.conversation_allowed_responders)
+      .map((value) => normalizeMentionSelector(value))
+      .filter(Boolean),
+  ));
+  const nextResponders = Array.from(new Set(
+    ensureArray(request.next_expected_responders)
+      .map((value) => normalizeMentionSelector(value))
+      .filter(Boolean),
+  ));
+  const executionTargets = Array.from(new Set(
+    ensureArray(request.execution_contract_targets)
+      .map((value) => normalizeMentionSelector(value))
+      .filter(Boolean),
+  ));
+  const normalizedExecutionContractType = String(
+    request.execution_contract_type || request.normalized_execution_contract_type || "",
+  ).trim().toLowerCase() || "direct_result";
+  const normalizedSummaryBotSelector = normalizeMentionSelector(request.conversation_summary_bot);
+  const executionContract = {
+    type: normalizedExecutionContractType,
+    actionable: request.execution_contract_actionable === true,
+    assignments: executionTargets.map((targetBot) => ({
+      target_bot: targetBot,
+    })),
+    ...(normalizedSummaryBotSelector ? { summary_bot: normalizedSummaryBotSelector } : {}),
+    ...(nextResponders.length > 0 ? { next_responders: nextResponders } : {}),
+  };
+  const replyOccurredAtMs = Date.parse(occurredAt);
+  const maxPendingAgeMs = intFromRawAllowZero(safeObject(pendingSelectionOptions).maxPendingAgeMs, 0);
+  const staleAfterAt = maxPendingAgeMs > 0 && Number.isFinite(replyOccurredAtMs)
+    ? new Date(replyOccurredAtMs + maxPendingAgeMs).toISOString()
+    : "";
+  const syntheticID = `request-followup:${String(request.request_key || "").trim()}:${messageID}:${normalizedCurrentBotSelector || "route"}`;
+  return {
+    id: syntheticID,
+    body: String(replyEnvelope.body || "").trim(),
+    createdAt: occurredAt,
+    updatedAt: occurredAt,
+    sourceOccurredAt: occurredAt,
+    ...(staleAfterAt ? { staleAfterAt } : {}),
+    replayTriggeredByRequestFollowup: true,
+    parsedArchive: {
+      kind: "bot_reply",
+      chatID,
+      messageID,
+      ...(intFromRawAllowZero(replyEnvelope.message_thread_id, 0) > 0
+        ? { messageThreadID: intFromRawAllowZero(replyEnvelope.message_thread_id, 0) }
+        : {}),
+      ...(intFromRawAllowZero(replyEnvelope.reply_to_message_id, 0) > 0
+        ? { replyToMessageID: intFromRawAllowZero(replyEnvelope.reply_to_message_id, 0) }
+        : {}),
+      sender: String(replyEnvelope.sender || (senderSelector ? `@${senderSelector}` : "@bot")).trim(),
+      senderID: String(replyEnvelope.sender_id || "").trim(),
+      senderIsBot: true,
+      username: senderSelector,
+      botUsername: senderSelector,
+      mentionUsernames: uniqueOrdered([
+        ...ensureArray(replyEnvelope.mention_usernames)
+          .map((value) => normalizeMentionSelector(value))
+          .filter(Boolean),
+        ...nextResponders,
+      ]),
+      occurredAt,
+      body: String(replyEnvelope.body || "").trim(),
+      conversationID: String(request.conversation_id || "").trim(),
+      conversationMode: "public_multi_bot",
+      conversationStage: "bot_reply",
+      conversationIntentMode: String(request.conversation_intent_mode || "").trim(),
+      conversationAllowBotToBot: request.conversation_allow_bot_to_bot === true,
+      conversationLeadBotUsername: normalizeMentionSelector(request.conversation_lead_bot),
+      conversationSummaryBotUsername: normalizedSummaryBotSelector,
+      conversationTargetBotUsername: nextResponders.length === 1 ? nextResponders[0] : "",
+      conversationParticipants: participants,
+      conversationInitialResponders: initialResponders,
+      conversationAllowedResponders: allowedResponders,
+      conversationReplyExpectation: String(request.conversation_reply_expectation || "").trim().toLowerCase(),
+      executionContract,
+      executionContractType: normalizedExecutionContractType,
+      executionContractActionable: request.execution_contract_actionable === true,
+      executionContractAssignments: executionTargets.map((targetBot) => ({
+        targetBot,
+      })),
+      executionContractSummaryBot: normalizedSummaryBotSelector,
+      executionContractNextResponders: nextResponders,
+      sourceOrigin: "request_followup_replay",
+      sourceRouteKey: String(request.claimed_by_route || "").trim(),
+      sourceBotUsername: senderSelector,
+      canonicalHumanMessageKey: String(request.canonical_human_message_key || "").trim(),
+    },
+  };
+}
+
+function buildRunnerRequestFollowupPendingArchiveComments({
+  orderedComments,
+  routeState,
+  existingPendingIDs,
+  followupRequests,
+  currentBotSelector,
+  pendingSelectionOptions,
+}) {
+  const pendingIDs = new Set(ensureArray(existingPendingIDs).map((value) => String(value || "").trim()).filter(Boolean));
+  const replayCandidates = [];
+  for (const requestRaw of ensureArray(followupRequests)) {
+    const request = safeObject(requestRaw);
+    const syntheticRecord = buildRunnerRequestFollowupSyntheticRecord(
+      request,
+      currentBotSelector,
+      pendingSelectionOptions,
+    );
+    if (!syntheticRecord) {
+      continue;
+    }
+    if (pendingIDs.has(String(syntheticRecord.id || "").trim())) {
+      continue;
+    }
+    const parsedSynthetic = safeObject(syntheticRecord.parsedArchive);
+    const archiveCollision = ensureArray(orderedComments).some((recordRaw) => {
+      const parsed = safeObject(safeObject(recordRaw).parsedArchive);
+      return String(parsed.kind || "").trim().toLowerCase() === "bot_reply"
+        && String(parsed.chatID || parsed.chatId || "").trim() === String(parsedSynthetic.chatID || "").trim()
+        && intFromRawAllowZero(parsed.messageID || parsed.messageId, 0) === intFromRawAllowZero(parsedSynthetic.messageID, 0);
+    });
+    if (archiveCollision) {
+      continue;
+    }
+    if (!isArchiveRecordAfterState(syntheticRecord, routeState)) {
+      continue;
+    }
+    pendingIDs.add(String(syntheticRecord.id || "").trim());
+    replayCandidates.push(syntheticRecord);
+  }
+  return replayCandidates.sort(compareArchiveCommentRecords);
+}
+
 function buildContextSpeakerType(parsedArchiveRaw) {
   const parsed = safeObject(parsedArchiveRaw);
   const kind = String(parsed.kind || "").trim();
@@ -944,6 +1252,8 @@ export function selectRunnerPendingWork({
   parseArchivedChatComment,
   deps,
   pendingSelectionOptions,
+  followupRequests = [],
+  currentBotSelector = "",
 }) {
   const normalizeArchiveCommentRecord = requireDependency(deps, "normalizeArchiveCommentRecord");
   const applyPendingAgeSelection = requireDependency(deps, "applyPendingAgeSelection");
@@ -1007,14 +1317,31 @@ export function selectRunnerPendingWork({
   const receiptBackedPending = buildRunnerReceiptBackedPendingArchiveComments({
     orderedComments,
     currentPollLocalInboundReceipts: ensureArray(importOutcome?.currentPollLocalInboundReceipts),
+    routeStateLocalInboundReceipts: safeObject(refreshedState).recent_local_inbound_receipts,
+    routeState: refreshedState,
     existingPendingIDs: ensureArray(safeObject(pending).pending).map((record) => String(safeObject(record).id || "").trim()),
     pendingSelectionOptions,
   });
-  const finalPending = ensureArray(safeObject(pending).pending).length === 0 && receiptBackedPending.length > 0
+  const requestFollowupPending = buildRunnerRequestFollowupPendingArchiveComments({
+    orderedComments,
+    routeState: refreshedState,
+    existingPendingIDs: [
+      ...ensureArray(safeObject(pending).pending).map((record) => String(safeObject(record).id || "").trim()),
+      ...ensureArray(receiptBackedPending).map((record) => String(safeObject(record).id || "").trim()),
+    ],
+    followupRequests,
+    currentBotSelector,
+    pendingSelectionOptions,
+  });
+  const replayFallbackPending = [
+    ...ensureArray(receiptBackedPending),
+    ...ensureArray(requestFollowupPending),
+  ].sort(compareArchiveCommentRecords);
+  const finalPending = ensureArray(safeObject(pending).pending).length === 0 && replayFallbackPending.length > 0
     ? applyPendingAgeSelection({
       ...safeObject(pending),
       shouldPrime: false,
-      pending: receiptBackedPending,
+      pending: replayFallbackPending,
     }, pendingSelectionOptions)
     : pending;
   return {
@@ -1022,6 +1349,7 @@ export function selectRunnerPendingWork({
     inboundComments,
     importedRecords,
     receiptBackedPending,
+    requestFollowupPending,
     pending: finalPending,
   };
 }

package/lib/selftest-runner-scenarios.mjs

@@ -22062,6 +22062,425 @@ export async function runSelftestRunnerScenarios(push, deps) {
     push("runner_entrypoint_receipt_replay_skips_foreign_bot_archive_collision", false, String(err?.message || err));
   }
 
+  try {
+    const pendingWork = selectRunnerPendingWorkEntrypoint({
+      comments: [
+        {
+          id: "comment-earlier-cursor-1",
+          createdAt: "2026-04-06T00:00:00.000Z",
+          updatedAt: "2026-04-06T00:00:00.000Z",
+          body: "@RyoAI_bot earlier",
+          parsedArchive: {
+            kind: "telegram_message",
+            messageID: 485,
+            chatID: "-100999",
+            chatType: "supergroup",
+            sender: "tester",
+            senderIsBot: false,
+            body: "@RyoAI_bot earlier",
+          },
+        },
+      ],
+      importOutcome: {
+        importedCommentIDs: [],
+        importedComments: [],
+        currentPollLocalInboundReceipts: [],
+      },
+      refreshedState: {
+        last_processed_comment_id: "comment-earlier-cursor-1",
+        last_processed_created_at: "2026-04-06T00:00:00.000Z",
+        recent_local_inbound_receipts: {
+          "-100999:486": {
+            chat_id: "-100999",
+            message_id: 486,
+            body: "@RyoAI_bot @RyoAI2_bot @RyoAI3_bot 하이",
+            receipt_bot_username: "ryoai_bot",
+            occurred_at: "2026-04-06T00:00:06.000Z",
+            canonical_human_message_key: "shared-human-key-486",
+          },
+        },
+      },
+      mode: "continue",
+      parseArchivedChatComment,
+      deps: {
+        normalizeArchiveCommentRecord: (record) => ({
+          id: String(record?.id || "").trim(),
+          body: String(record?.body || "").trim(),
+          createdAt: String(record?.created_at || record?.createdAt || record?.updated_at || record?.updatedAt || "").trim(),
+          updatedAt: String(record?.updated_at || record?.updatedAt || "").trim(),
+          parsedArchive: safeObject(record?.parsedArchive),
+        }),
+        applyPendingAgeSelection: (selection) => selection,
+      },
+      pendingSelectionOptions: {},
+    });
+    push(
+      "runner_entrypoint_replays_route_state_local_receipt_after_shared_human_fanout",
+      ensureArray(pendingWork.receiptBackedPending).length === 1
+        && String(safeObject(ensureArray(pendingWork.receiptBackedPending)[0]).id || "").startsWith("receipt-replay:human:shared-human-key-486")
+        && safeObject(safeObject(ensureArray(pendingWork.receiptBackedPending)[0]).parsedArchive).messageID === 486
+        && ensureArray(safeObject(pendingWork.pending).pending).length === 1
+        && String(safeObject(ensureArray(safeObject(pendingWork.pending).pending)[0]).id || "").startsWith("receipt-replay:human:shared-human-key-486"),
+      `replay=${ensureArray(pendingWork.receiptBackedPending).map((item) => String(safeObject(item).id || "")).join(",") || "(none)"} pending=${ensureArray(safeObject(pendingWork.pending).pending).map((item) => String(safeObject(item).id || "")).join(",") || "(none)"}`,
+    );
+  } catch (err) {
+    push("runner_entrypoint_replays_route_state_local_receipt_after_shared_human_fanout", false, String(err?.message || err));
+  }
+
+  try {
+    const pendingWork = selectRunnerPendingWorkEntrypoint({
+      comments: [],
+      importOutcome: {
+        importedCommentIDs: [],
+        importedComments: [],
+        currentPollLocalInboundReceipts: [],
+      },
+      refreshedState: {
+        last_processed_comment_id: "comment-shared-human-opening-processed",
+        last_processed_created_at: "2026-04-06T00:00:07.000Z",
+        recent_local_inbound_receipts: {
+          "-100999:487": {
+            chat_id: "-100999",
+            message_id: 487,
+            body: "@RyoAI_bot @RyoAI2_bot @RyoAI3_bot 하이",
+            receipt_bot_username: "ryoai3_bot",
+            occurred_at: "2026-04-06T00:00:06.000Z",
+            canonical_human_message_key: "shared-human-key-487",
+          },
+        },
+      },
+      mode: "continue",
+      parseArchivedChatComment,
+      deps: {
+        normalizeArchiveCommentRecord: (record) => ({
+          id: String(record?.id || "").trim(),
+          body: String(record?.body || "").trim(),
+          createdAt: String(record?.created_at || record?.createdAt || record?.updated_at || record?.updatedAt || "").trim(),
+          updatedAt: String(record?.updated_at || record?.updatedAt || "").trim(),
+          parsedArchive: safeObject(record?.parsedArchive),
+        }),
+        applyPendingAgeSelection: (selection) => selection,
+      },
+      pendingSelectionOptions: {},
+    });
+    push(
+      "runner_entrypoint_does_not_replay_route_state_local_receipt_after_route_cursor",
+      ensureArray(pendingWork.receiptBackedPending).length === 0
+        && ensureArray(safeObject(pendingWork.pending).pending).length === 0,
+      `replay=${ensureArray(pendingWork.receiptBackedPending).length} pending=${ensureArray(safeObject(pendingWork.pending).pending).length}`,
+    );
+  } catch (err) {
+    push("runner_entrypoint_does_not_replay_route_state_local_receipt_after_route_cursor", false, String(err?.message || err));
+  }
+
+  try {
+    const pendingWork = selectRunnerPendingWorkEntrypoint({
+      comments: [],
+      importOutcome: {
+        importedCommentIDs: [],
+        importedComments: [],
+        currentPollLocalInboundReceipts: [],
+      },
+      refreshedState: {
+        last_processed_comment_id: "comment-before-followup-1",
+        last_processed_created_at: "2026-04-06T00:00:00.000Z",
+      },
+      mode: "continue",
+      parseArchivedChatComment,
+      deps: {
+        normalizeArchiveCommentRecord: (record) => ({
+          id: String(record?.id || "").trim(),
+          body: String(record?.body || "").trim(),
+          createdAt: String(record?.created_at || record?.createdAt || record?.updated_at || record?.updatedAt || "").trim(),
+          updatedAt: String(record?.updated_at || record?.updatedAt || "").trim(),
+          parsedArchive: safeObject(record?.parsedArchive),
+        }),
+        applyPendingAgeSelection: (selection) => selection,
+      },
+      pendingSelectionOptions: {},
+      followupRequests: [
+        {
+          request_key: "request-followup-1",
+          status: "running",
+          project_id: "project-followup-1",
+          provider: "telegram",
+          chat_id: "-100999",
+          conversation_id: "conversation-followup-1",
+          conversation_intent_mode: "multi_bot_direct",
+          conversation_participants: ["ryoai_bot", "ryoai2_bot"],
+          conversation_initial_responders: ["ryoai_bot", "ryoai2_bot"],
+          conversation_allowed_responders: ["ryoai_bot", "ryoai2_bot"],
+          execution_contract_type: "direct_result",
+          execution_contract_actionable: true,
+          execution_contract_targets: ["ryoai2_bot"],
+          next_expected_responders: ["ryoai_bot"],
+          updated_at: "2026-04-06T00:10:00.000Z",
+          last_reply_message_envelope: {
+            chat_id: "-100999",
+            message_id: 498,
+            reply_to_message_id: 497,
+            body: "하이!",
+            sender: "@RyoAI2_bot",
+            sender_username: "ryoai2_bot",
+            sender_is_bot: true,
+            occurred_at: "2026-04-06T00:10:00.000Z",
+            canonical_human_message_key: "shared-human-key-497",
+          },
+        },
+      ],
+      currentBotSelector: "ryoai_bot",
+    });
+    push(
+      "runner_entrypoint_replays_request_followup_for_next_expected_responder",
+      ensureArray(pendingWork.requestFollowupPending).length === 1
+        && ensureArray(safeObject(pendingWork.pending).pending).length === 1
+        && String(safeObject(ensureArray(pendingWork.requestFollowupPending)[0]).id || "").startsWith("request-followup:request-followup-1:498:ryoai_bot")
+        && safeObject(safeObject(ensureArray(pendingWork.requestFollowupPending)[0]).parsedArchive).kind === "bot_reply"
+        && String(safeObject(safeObject(ensureArray(pendingWork.requestFollowupPending)[0]).parsedArchive).conversationMode || "") === "public_multi_bot"
+        && String(safeObject(safeObject(ensureArray(pendingWork.requestFollowupPending)[0]).parsedArchive).conversationIntentMode || "") === "multi_bot_direct"
+        && ensureArray(safeObject(safeObject(ensureArray(pendingWork.requestFollowupPending)[0]).parsedArchive).executionContractNextResponders).includes("ryoai_bot")
+        && ensureArray(safeObject(safeObject(safeObject(ensureArray(pendingWork.requestFollowupPending)[0]).parsedArchive).executionContract).next_responders).includes("ryoai_bot"),
+      `replay=${ensureArray(pendingWork.requestFollowupPending).map((item) => String(safeObject(item).id || "")).join(",") || "(none)"} pending=${ensureArray(safeObject(pendingWork.pending).pending).map((item) => String(safeObject(item).id || "")).join(",") || "(none)"}`,
+    );
+  } catch (err) {
+    push("runner_entrypoint_replays_request_followup_for_next_expected_responder", false, String(err?.message || err));
+  }
+
+  try {
+    const pendingWork = selectRunnerPendingWorkEntrypoint({
+      comments: [],
+      importOutcome: {
+        importedCommentIDs: [],
+        importedComments: [],
+        currentPollLocalInboundReceipts: [],
+      },
+      refreshedState: {
+        last_processed_comment_id: "request-followup:request-followup-2:499:ryoai_bot",
+        last_processed_created_at: "2026-04-06T00:11:00.000Z",
+      },
+      mode: "continue",
+      parseArchivedChatComment,
+      deps: {
+        normalizeArchiveCommentRecord: (record) => ({
+          id: String(record?.id || "").trim(),
+          body: String(record?.body || "").trim(),
+          createdAt: String(record?.created_at || record?.createdAt || record?.updated_at || record?.updatedAt || "").trim(),
+          updatedAt: String(record?.updated_at || record?.updatedAt || "").trim(),
+          parsedArchive: safeObject(record?.parsedArchive),
+        }),
+        applyPendingAgeSelection: (selection) => selection,
+      },
+      pendingSelectionOptions: {},
+      followupRequests: [
+        {
+          request_key: "request-followup-2",
+          status: "running",
+          project_id: "project-followup-1",
+          provider: "telegram",
+          chat_id: "-100999",
+          conversation_id: "conversation-followup-2",
+          conversation_intent_mode: "multi_bot_direct",
+          conversation_participants: ["ryoai_bot", "ryoai2_bot"],
+          conversation_initial_responders: ["ryoai_bot", "ryoai2_bot"],
+          conversation_allowed_responders: ["ryoai_bot", "ryoai2_bot"],
+          execution_contract_type: "direct_result",
+          execution_contract_actionable: true,
+          execution_contract_targets: ["ryoai2_bot"],
+          next_expected_responders: ["ryoai_bot"],
+          updated_at: "2026-04-06T00:11:00.000Z",
+          last_reply_message_envelope: {
+            chat_id: "-100999",
+            message_id: 499,
+            reply_to_message_id: 497,
+            body: "하이!",
+            sender: "@RyoAI2_bot",
+            sender_username: "ryoai2_bot",
+            sender_is_bot: true,
+            occurred_at: "2026-04-06T00:11:00.000Z",
+            canonical_human_message_key: "shared-human-key-499",
+          },
+        },
+      ],
+      currentBotSelector: "ryoai_bot",
+    });
+    push(
+      "runner_entrypoint_does_not_replay_request_followup_after_route_cursor",
+      ensureArray(pendingWork.requestFollowupPending).length === 0
+        && ensureArray(safeObject(pendingWork.pending).pending).length === 0,
+      `replay=${ensureArray(pendingWork.requestFollowupPending).length} pending=${ensureArray(safeObject(pendingWork.pending).pending).length}`,
+    );
+  } catch (err) {
+    push("runner_entrypoint_does_not_replay_request_followup_after_route_cursor", false, String(err?.message || err));
+  }
+
+  try {
+    const pendingWork = selectRunnerPendingWorkEntrypoint({
+      comments: [],
+      importOutcome: {
+        importedCommentIDs: [],
+        importedComments: [],
+        currentPollLocalInboundReceipts: [],
+      },
+      refreshedState: {
+        last_processed_comment_id: "comment-before-followup-3",
+        last_processed_created_at: "2026-04-06T00:12:00.000Z",
+      },
+      mode: "continue",
+      parseArchivedChatComment,
+      deps: {
+        normalizeArchiveCommentRecord: (record) => ({
+          id: String(record?.id || "").trim(),
+          body: String(record?.body || "").trim(),
+          createdAt: String(record?.created_at || record?.createdAt || record?.updated_at || record?.updatedAt || "").trim(),
+          updatedAt: String(record?.updated_at || record?.updatedAt || "").trim(),
+          parsedArchive: safeObject(record?.parsedArchive),
+        }),
+        applyPendingAgeSelection: (selection) => selection,
+      },
+      pendingSelectionOptions: {},
+      followupRequests: [
+        {
+          request_key: "request-followup-3",
+          status: "running",
+          project_id: selftestProjectID,
+          provider: "telegram",
+          chat_id: "-100126",
+          conversation_id: "conversation-followup-3",
+          conversation_intent_mode: "multi_bot_direct",
+          conversation_allow_bot_to_bot: true,
+          conversation_participants: ["ryoai2_bot", "ryoai3_bot"],
+          conversation_initial_responders: ["ryoai2_bot", "ryoai3_bot"],
+          conversation_allowed_responders: ["ryoai2_bot", "ryoai3_bot"],
+          execution_contract_type: "direct_result",
+          execution_contract_actionable: true,
+          execution_contract_targets: ["ryoai2_bot", "ryoai3_bot"],
+          next_expected_responders: ["ryoai3_bot"],
+          updated_at: "2026-04-06T00:12:00.000Z",
+          last_reply_message_envelope: {
+            chat_id: "-100126",
+            message_id: 515,
+            reply_to_message_id: 514,
+            body: "안녕하세요, RyoAI2_bot입니다.",
+            sender: "@RyoAI2_bot",
+            sender_username: "ryoai2_bot",
+            sender_is_bot: true,
+            occurred_at: "2026-04-06T00:12:00.000Z",
+            canonical_human_message_key: "shared-human-key-515",
+          },
+        },
+      ],
+      currentBotSelector: "ryoai3_bot",
+    });
+    let aiCalls = 0;
+    const deliveredConversation = [];
+    const processed = await processRunnerSelectedRecord({
+      routeKey: "runner-followup-public-multi-bot-peer-key",
+      normalizedRoute: normalizeRunnerRoute({
+        name: "telegram-monitor-runner-followup-public-multi-bot-peer",
+        project_id: selftestProjectID,
+        provider: "telegram",
+        role: "monitor",
+        role_profile: "monitor",
+        destination_id: "dest-1",
+        destination_label: "Main Room",
+        server_bot_name: "RyoAI3_bot",
+        server_bot_id: "bot-peer-2",
+        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: ensureArray(pendingWork.requestFollowupPending)[0],
+      pendingOrdered: ensureArray(pendingWork.pending?.pending),
+      bot: {
+        id: "bot-peer-2",
+        name: "RyoAI3_bot",
+        username: "RyoAI3_bot",
+        role: "monitor",
+        provider: "telegram",
+      },
+      destination: {
+        id: "dest-1",
+        label: "Main Room",
+        provider: "telegram",
+        chatID: "-100126",
+      },
+      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-followup-public-multi-bot-peer"),
+        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: "안녕하세요, RyoAI3_bot입니다.",
+          };
+        },
+        performLocalBotDelivery: async ({ archiveConversation, archiveConversationContext, archiveExecutionContract }) => {
+          deliveredConversation.push(buildSelftestArchiveConversation({
+            archiveConversation,
+            archiveConversationContext,
+            archiveExecutionContract,
+          }));
+          return {
+            delivery: { dryRun: true, body: {} },
+            archive: {},
+          };
+        },
+        serializeRunnerTriggerPolicy: (value) => value,
+        serializeRunnerArchivePolicy: (value) => value,
+        buildRunnerExecutionDeps: () => ({}),
+        buildRunnerDeliveryDeps: () => ({}),
+        buildRunnerRuntimeDeps: () => ({}),
+        resolveConversationPeerBots: () => [
+          { id: "bot-peer-1", name: "RyoAI2_bot" },
+          { id: "bot-peer-2", name: "RyoAI3_bot" },
+        ],
+      },
+    });
+    push(
+      "runner_request_followup_public_multi_bot_continuation_is_authorized",
+      processed.kind === "replied"
+        && aiCalls === 1
+        && String(deliveredConversation[0]?.mode || "") === "public_multi_bot"
+        && String(deliveredConversation[0]?.intentMode || "") === "multi_bot_direct"
+        && ensureArray(deliveredConversation[0]?.allowedResponderSelectors).includes("ryoai3_bot"),
+      `kind=${String(processed.kind || "(none)")} ai_calls=${aiCalls} mode=${String(deliveredConversation[0]?.mode || "(none)")} intent=${String(deliveredConversation[0]?.intentMode || "(none)")} reason=${String(processed.skippedRecord?.reason || "(none)")}`,
+    );
+  } catch (err) {
+    push("runner_request_followup_public_multi_bot_continuation_is_authorized", false, String(err?.message || err));
+  }
+
   try {
     const deliveryContext = await prepareLocalBotDeliveryContext({
       siteBaseURL: "https://example.test",

package/package.json

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