metheus-governance-mcp-cli 0.2.249 → 0.2.250

package/cli.mjs

@@ -140,6 +140,7 @@ import {
   buildRunnerRouteStateFromComment,
   buildProcessableArchiveLogicalKey,
   findEarlierProcessableArchiveDuplicate,
+  findRecentTelegramMessageEnvelope,
   isInboundArchiveKind,
   normalizeTelegramMessageEnvelope as normalizeRunnerTelegramMessageEnvelope,
   normalizeArchiveCommentRecord,
@@ -1989,6 +1990,7 @@ function mergeRunnerStateRecords(preferred, fallback) {
     last_followup_source_message_envelope: pickObjectField("last_followup_source_message_envelope"),
     last_followup_last_reply_message_envelope: pickObjectField("last_followup_last_reply_message_envelope"),
     last_followup_attempted_delivery_envelope: pickObjectField("last_followup_attempted_delivery_envelope"),
+    recent_local_inbound_envelopes: pickObjectField("recent_local_inbound_envelopes"),
     last_contract_validation_targets: pickArrayField("last_contract_validation_targets", normalizeTelegramMentionUsername),
     last_normalized_execution_contract_targets: pickArrayField("last_normalized_execution_contract_targets", normalizeTelegramMentionUsername),
     last_normalized_execution_next_responders: pickArrayField("last_normalized_execution_next_responders", normalizeTelegramMentionUsername),
@@ -2642,6 +2644,42 @@ function normalizeRunnerReplyChainContext(rawContext) {
   return normalized;
 }
 
+function findRunnerRouteLocalInboundEnvelope(routeStateRaw, parsedArchiveRaw) {
+  const routeState = safeObject(routeStateRaw);
+  const parsedArchive = safeObject(parsedArchiveRaw);
+  const chatID = String(parsedArchive.chatID || parsedArchive.chatId || "").trim();
+  const messageID = intFromRawAllowZero(parsedArchive.messageID, 0);
+  if (!chatID || !(messageID > 0)) {
+    return {};
+  }
+  return findRecentTelegramMessageEnvelope(routeState.recent_local_inbound_envelopes, {
+    chatID,
+    messageID,
+  });
+}
+
+function buildRunnerSourceMessageEnvelope({
+  routeState = {},
+  routeKey = "",
+  normalizedRoute = null,
+  parsedArchive = null,
+}) {
+  const localEnvelope = findRunnerRouteLocalInboundEnvelope(routeState, parsedArchive);
+  if (String(localEnvelope.source_origin || "").trim().toLowerCase() === "local_telegram_inbound") {
+    return localEnvelope;
+  }
+  const fallbackBotSelector = normalizeTelegramMentionUsername(
+    normalizedRoute?.botName
+      || normalizedRoute?.serverBotName
+      || "",
+  );
+  return buildRunnerTelegramMessageEnvelopeFromParsedArchive(parsedArchive, {
+    source_origin: "archive_reconstructed",
+    source_route_key: String(routeKey || "").trim(),
+    source_bot_username: fallbackBotSelector,
+  });
+}
+
 function normalizeBotRunnerRequests(rawRequests, nowMs = Date.now()) {
   const normalized = {};
   for (const [requestKeyRaw, entryRaw] of Object.entries(safeObject(rawRequests))) {
@@ -2676,6 +2714,7 @@ function normalizeBotRunnerRequests(rawRequests, nowMs = Date.now()) {
               body: entry.source_message_body || entry.sourceMessageBody,
               sender: "human",
               sender_is_bot: false,
+              source_origin: "archive_reconstructed",
             }
           : {}),
       ),
@@ -4408,9 +4447,10 @@ async function claimRunnerRequestForHumanComment({
       reason: "non_human_comment_cannot_create_request",
     };
   }
-  const currentState = loadBotRunnerState();
-  const replyChainResolution = await resolveRunnerReplyChainConversationContextWithServerFallback({
-    state: currentState,
+  const currentState = loadBotRunnerState();
+  const currentRouteState = safeObject(safeObject(currentState.routes)[String(routeKey || "").trim()]);
+  const replyChainResolution = await resolveRunnerReplyChainConversationContextWithServerFallback({
+    state: currentState,
     normalizedRoute,
     selectedRecord,
     runtime,
@@ -4530,14 +4570,19 @@ async function claimRunnerRequestForHumanComment({
     };
   }
   const nowISO = new Date().toISOString();
-  const { requests: nextRequests, request } = upsertRunnerRequest(stateForClaim, requestKey, {
+  const { requests: nextRequests, request } = upsertRunnerRequest(stateForClaim, requestKey, {
     project_id: String(normalizedRoute?.projectID || "").trim(),
     provider: String(normalizedRoute?.provider || "").trim(),
     chat_id: String(parsed.chatID || parsed.chatId || "").trim(),
     source_message_id: intFromRawAllowZero(parsed.messageID, 0) || undefined,
     source_message_thread_id: intFromRawAllowZero(parsed.messageThreadID, 0) || undefined,
     source_message_body: String(parsed.body || "").trim(),
-    source_message_envelope: buildRunnerTelegramMessageEnvelopeFromParsedArchive(parsed),
+    source_message_envelope: buildRunnerSourceMessageEnvelope({
+      routeState: currentRouteState,
+      routeKey,
+      normalizedRoute,
+      parsedArchive: parsed,
+    }),
     root_comment_id: String(selectedRecord?.id || "").trim(),
     root_comment_kind: commentKind,
     conversation_id: resolvedConversationID,
@@ -7552,11 +7597,11 @@ function parseArchivedChatComment(rawBody) {
           .filter(Boolean),
       }
     : null;
-  return {
-    kind,
-    header,
-    metadata,
-    body,
+  return {
+    kind,
+    header,
+    metadata,
+    body,
     chatID: String(metadata.chat_id || "").trim(),
     chatType: String(metadata.chat_type || "").trim().toLowerCase(),
     messageID: intFromRawAllowZero(metadata.message_id, 0),
@@ -7569,8 +7614,11 @@ function parseArchivedChatComment(rawBody) {
       .split(",")
       .map((value) => normalizeTelegramMentionUsername(value))
       .filter(Boolean),
-    occurredAt: String(metadata.occurred_at || "").trim(),
-    replyToMessageID: intFromRawAllowZero(metadata.reply_to_message_id, 0),
+    occurredAt: String(metadata.occurred_at || "").trim(),
+    sourceOrigin: String(metadata.source_origin || "").trim().toLowerCase(),
+    sourceRouteKey: String(metadata.source_route_key || "").trim(),
+    sourceBotUsername: normalizeTelegramMentionUsername(metadata.source_bot_username || ""),
+    replyToMessageID: intFromRawAllowZero(metadata.reply_to_message_id, 0),
     replyToSender: String(metadata.reply_to_sender || "").trim(),
     replyToUsername: String(metadata.reply_to_telegram_username || "").trim(),
     replyToSenderIsBot: boolFromRaw(metadata.reply_to_sender_is_bot, false),
@@ -7886,18 +7934,27 @@ function buildArchivedInboundMessageKey(chatID, messageID) {
   return `${String(chatID || "").trim()}:${intFromRawAllowZero(messageID, 0)}`;
 }
 
-function formatTelegramInboundArchiveComment(normalized) {
-  const headerLines = [
+function formatTelegramInboundArchiveComment(normalized) {
+  const headerLines = [
     `[Telegram ${normalized.eventName === "telegram.message.updated" ? "edited" : "message"}]`,
     `chat_id: ${normalized.chatID || "<missing>"}`,
     `chat_type: ${normalized.chatType || "unknown"}`,
     `message_id: ${normalized.messageID || "<missing>"}`,
     `occurred_at: ${normalized.occurredAt || new Date().toISOString()}`,
     `sender_id: ${normalized.fromID || "<missing>"}`,
-    `sender: ${normalized.fromName || normalized.fromUsername || normalized.fromID || "unknown"}`,
-    `sender_is_bot: ${normalized.fromIsBot ? "true" : "false"}`,
-  ];
-  if (normalized.fromUsername) {
+    `sender: ${normalized.fromName || normalized.fromUsername || normalized.fromID || "unknown"}`,
+    `sender_is_bot: ${normalized.fromIsBot ? "true" : "false"}`,
+  ];
+  if (String(normalized.sourceOrigin || "").trim()) {
+    headerLines.push(`source_origin: ${String(normalized.sourceOrigin || "").trim()}`);
+  }
+  if (String(normalized.sourceRouteKey || "").trim()) {
+    headerLines.push(`source_route_key: ${String(normalized.sourceRouteKey || "").trim()}`);
+  }
+  if (String(normalized.sourceBotUsername || "").trim()) {
+    headerLines.push(`source_bot_username: @${String(normalized.sourceBotUsername || "").trim().replace(/^@+/, "")}`);
+  }
+  if (normalized.fromUsername) {
     headerLines.push(`telegram_username: @${normalized.fromUsername.replace(/^@+/, "")}`);
   }
   if (normalized.mentionUsernames.length > 0) {

package/lib/runner-delivery.mjs

@@ -1,5 +1,6 @@
 import { deliverLocalProviderMessage } from "./provider-local-transport.mjs";
 import { normalizeBotProviderName } from "./provider-support.mjs";
+import { normalizeTelegramMessageEnvelope } from "./runner-helpers.mjs";
 
 function safeObject(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
@@ -71,6 +72,12 @@ function normalizeArchiveCommentRecord(rawComment, parseArchivedChatComment) {
   };
 }
 
+function telegramReplySourceEnvelopeIsLocal(rawEnvelope) {
+  const envelope = normalizeTelegramMessageEnvelope(rawEnvelope);
+  return String(envelope.source_origin || "").trim().toLowerCase() === "local_telegram_inbound"
+    && intFromRawAllowZero(envelope.message_id, 0) > 0;
+}
+
 function normalizeExecutionContractForArchive(rawContract) {
   const contract = safeObject(rawContract);
   if (!Object.keys(contract).length) {
@@ -274,6 +281,7 @@ export async function performLocalBotDelivery({
   disableWebPagePreview,
   messageThreadID,
   replyToMessageID,
+  sourceMessageEnvelope = {},
   archiveReplies = true,
   archiveDedupeOutbound = true,
   archiveThreadID = "",
@@ -295,6 +303,7 @@ export async function performLocalBotDelivery({
   const parseArchivedChatComment = requireDependency(deps, "parseArchivedChatComment");
 
   const normalizedProvider = normalizeBotProviderName(provider, "telegram");
+  const normalizedSourceMessageEnvelope = normalizeTelegramMessageEnvelope(sourceMessageEnvelope);
   const destinations = await listProjectChatDestinations({
     siteBaseURL,
     projectID,
@@ -332,6 +341,14 @@ export async function performLocalBotDelivery({
       replySupported: normalizedProvider === "telegram",
     };
   } else {
+    if (
+      normalizedProvider === "telegram"
+      && intFromRawAllowZero(replyToMessageID, 0) > 0
+      && !telegramReplySourceEnvelopeIsLocal(normalizedSourceMessageEnvelope)
+    ) {
+      const origin = String(normalizedSourceMessageEnvelope.source_origin || "unknown").trim() || "unknown";
+      throw new Error(`telegram reply anchor is not local to this route (${origin})`);
+    }
     delivery = await deliverLocalProviderMessage({
       provider: normalizedProvider,
       token: providerEnv.token,

package/lib/runner-helpers.mjs

@@ -68,6 +68,21 @@ export function normalizeTelegramMessageEnvelope(rawEnvelope) {
     || rawSenderIsBot === "1"
     || kind === "bot_reply";
   const body = String(envelope.body || envelope.text || "").trim();
+  const sourceOrigin = String(
+    envelope.source_origin
+    || envelope.sourceOrigin
+    || "",
+  ).trim().toLowerCase();
+  const sourceRouteKey = String(
+    envelope.source_route_key
+    || envelope.sourceRouteKey
+    || "",
+  ).trim();
+  const sourceBotUsername = normalizeMentionSelector(
+    envelope.source_bot_username
+    || envelope.sourceBotUsername
+    || "",
+  );
   if (
     !chatID
     && !(messageID > 0)
@@ -77,6 +92,9 @@ export function normalizeTelegramMessageEnvelope(rawEnvelope) {
     && !sender
     && !senderUsername
     && !body
+    && !sourceOrigin
+    && !sourceRouteKey
+    && !sourceBotUsername
   ) {
     return {};
   }
@@ -90,6 +108,9 @@ export function normalizeTelegramMessageEnvelope(rawEnvelope) {
     ...(senderUsername ? { sender_username: senderUsername } : {}),
     sender_is_bot: senderIsBot === true,
     ...(body ? { body } : {}),
+    ...(sourceOrigin ? { source_origin: sourceOrigin } : {}),
+    ...(sourceRouteKey ? { source_route_key: sourceRouteKey } : {}),
+    ...(sourceBotUsername ? { source_bot_username: sourceBotUsername } : {}),
   };
 }
 
@@ -119,6 +140,21 @@ export function buildTelegramMessageEnvelopeFromParsedArchive(parsedArchiveRaw,
     ]),
     sender_is_bot: overrides.sender_is_bot ?? parsedArchive.senderIsBot,
     body: firstNonEmptyString([overrides.body, parsedArchive.body]),
+    source_origin: firstNonEmptyString([
+      overrides.source_origin,
+      parsedArchive.sourceOrigin,
+      parsedArchive.metadata?.source_origin,
+    ]),
+    source_route_key: firstNonEmptyString([
+      overrides.source_route_key,
+      parsedArchive.sourceRouteKey,
+      parsedArchive.metadata?.source_route_key,
+    ]),
+    source_bot_username: firstNonEmptyString([
+      overrides.source_bot_username,
+      parsedArchive.sourceBotUsername,
+      parsedArchive.metadata?.source_bot_username,
+    ]),
   });
 }
 
@@ -155,6 +191,60 @@ export function buildTelegramBotReplyEnvelope({
   });
 }
 
+export function buildTelegramMessageEnvelopeKey(rawEnvelopeOrChatID, rawMessageID = undefined) {
+  const envelope = rawMessageID === undefined
+    ? normalizeTelegramMessageEnvelope(rawEnvelopeOrChatID)
+    : normalizeTelegramMessageEnvelope({
+      chat_id: rawEnvelopeOrChatID,
+      message_id: rawMessageID,
+    });
+  const chatID = String(envelope.chat_id || "").trim();
+  const messageID = intFromRawAllowZero(envelope.message_id, 0);
+  if (!chatID || !(messageID > 0)) {
+    return "";
+  }
+  return `${chatID}:${messageID}`;
+}
+
+export function findRecentTelegramMessageEnvelope(rawMap, { chatID = "", messageID = 0 } = {}) {
+  const envelopeKey = buildTelegramMessageEnvelopeKey(chatID, messageID);
+  if (!envelopeKey) {
+    return {};
+  }
+  return normalizeTelegramMessageEnvelope(safeObject(safeObject(rawMap)[envelopeKey]));
+}
+
+export function mergeRecentTelegramMessageEnvelopes(rawMap, incomingEnvelopes, limit = 128) {
+  const merged = new Map();
+  for (const [key, value] of Object.entries(safeObject(rawMap))) {
+    const normalized = normalizeTelegramMessageEnvelope(value);
+    const normalizedKey = buildTelegramMessageEnvelopeKey(normalized) || String(key || "").trim();
+    if (!normalizedKey || !Object.keys(normalized).length) {
+      continue;
+    }
+    merged.set(normalizedKey, normalized);
+  }
+  for (const rawEnvelope of ensureArray(incomingEnvelopes)) {
+    const normalized = normalizeTelegramMessageEnvelope(rawEnvelope);
+    const normalizedKey = buildTelegramMessageEnvelopeKey(normalized);
+    if (!normalizedKey || !Object.keys(normalized).length) {
+      continue;
+    }
+    if (merged.has(normalizedKey)) {
+      merged.delete(normalizedKey);
+    }
+    merged.set(normalizedKey, normalized);
+  }
+  while (merged.size > Math.max(1, intFromRawAllowZero(limit, 128))) {
+    const oldestKey = merged.keys().next().value;
+    if (!oldestKey) {
+      break;
+    }
+    merged.delete(oldestKey);
+  }
+  return Object.fromEntries(merged.entries());
+}
+
 function normalizePendingSelectionOptions(rawOptions) {
   const options = safeObject(rawOptions);
   const maxPendingAgeMs = intFromRawAllowZero(options.maxPendingAgeMs, 0);

package/lib/runner-orchestration.mjs

@@ -7,6 +7,7 @@ import {
   buildRunnerRouteStateFromComment,
   compareArchiveCommentRecords,
   dedupeProcessableArchiveComments,
+  findRecentTelegramMessageEnvelope,
   isInboundArchiveKind,
   normalizeTelegramMessageEnvelope,
   selectPendingArchiveComments,
@@ -376,11 +377,54 @@ function normalizeBoundaryViolations(rawViolations) {
     .filter(Boolean);
 }
 
-function normalizeMentionSelector(value) {
-  return String(value || "").trim().replace(/^@+/, "").toLowerCase();
-}
-
-function escapeRegExp(text) {
+function normalizeMentionSelector(value) {
+  return String(value || "").trim().replace(/^@+/, "").toLowerCase();
+}
+
+function resolveRunnerDeliverySourceMessageEnvelope({
+  routeState,
+  persistedRequest,
+  selectedRecord,
+  routeKey,
+  currentBotSelector,
+}) {
+  const archiveEnvelope = buildTelegramMessageEnvelopeFromParsedArchive(selectedRecord?.parsedArchive, {
+    source_origin: "archive_reconstructed",
+    source_route_key: String(routeKey || "").trim(),
+    source_bot_username: currentBotSelector,
+  });
+  const archiveChatID = String(archiveEnvelope.chat_id || "").trim();
+  const archiveMessageID = intFromRawAllowZero(archiveEnvelope.message_id, 0);
+  const routeLocalEnvelope = findRecentTelegramMessageEnvelope(
+    safeObject(routeState).recent_local_inbound_envelopes,
+    {
+      chatID: archiveChatID,
+      messageID: archiveMessageID,
+    },
+  );
+  if (String(routeLocalEnvelope.source_origin || "").trim().toLowerCase() === "local_telegram_inbound") {
+    return routeLocalEnvelope;
+  }
+  const persistedSourceEnvelope = normalizeTelegramMessageEnvelope(
+    safeObject(persistedRequest).source_message_envelope
+      || safeObject(persistedRequest).sourceMessageEnvelope,
+  );
+  const persistedOrigin = String(persistedSourceEnvelope.source_origin || "").trim().toLowerCase();
+  const persistedChatID = String(persistedSourceEnvelope.chat_id || "").trim();
+  const persistedMessageID = intFromRawAllowZero(persistedSourceEnvelope.message_id, 0);
+  if (
+    persistedOrigin === "local_telegram_inbound"
+    && archiveChatID
+    && archiveChatID === persistedChatID
+    && archiveMessageID > 0
+    && archiveMessageID === persistedMessageID
+  ) {
+    return persistedSourceEnvelope;
+  }
+  return archiveEnvelope;
+}
+
+function escapeRegExp(text) {
   return String(text || "").replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 
@@ -4720,10 +4764,18 @@ export async function processRunnerSelectedRecord({
     safeObject(persistedHumanIntentRequest).reply_chain_context
     || safeObject(persistedHumanIntentRequest).replyChainContext,
   );
-  const sourceMessageEnvelope = buildTelegramMessageEnvelopeFromParsedArchive(selectedRecord?.parsedArchive);
+  const currentBotSelector = normalizeMentionSelector(bot?.username || bot?.name);
+  const sourceMessageEnvelope = resolveRunnerDeliverySourceMessageEnvelope({
+    routeState,
+    persistedRequest: persistedHumanIntentRequest,
+    selectedRecord,
+    routeKey,
+    currentBotSelector,
+  });
   const replyMessageThreadID = intFromRawAllowZero(sourceMessageEnvelope.message_thread_id, 0);
   const replyToMessageID = intFromRawAllowZero(sourceMessageEnvelope.message_id, 0);
-  const replyAnchorSource = replyToMessageID > 0 ? "source_message_envelope" : "";
+  const replyAnchorSource = String(sourceMessageEnvelope.source_origin || "").trim()
+    || (replyToMessageID > 0 ? "source_message_envelope" : "");
   const normalizedPrecomputedHumanIntentContext = safeObject(precomputedHumanIntentContext);
   const validateWorkspaceArtifacts = typeof executionDeps.validateWorkspaceArtifacts === "function"
     ? executionDeps.validateWorkspaceArtifacts
@@ -4734,7 +4786,6 @@ export async function processRunnerSelectedRecord({
   const resolveInformationalQueryReply = typeof executionDeps.resolveInformationalQueryReply === "function"
     ? executionDeps.resolveInformationalQueryReply
     : null;
-  const currentBotSelector = normalizeMentionSelector(bot?.username || bot?.name);
   const triggerDecision = safeObject(precomputedTriggerDecision);
   const effectiveTriggerDecision = typeof triggerDecision.shouldRespond === "boolean"
     ? triggerDecision
@@ -5592,6 +5643,7 @@ export async function processRunnerSelectedRecord({
       disableWebPagePreview: true,
       messageThreadID: replyMessageThreadID,
       replyToMessageID,
+      sourceMessageEnvelope: sourceMessageEnvelope,
       archiveReplies: normalizedRoute.archivePolicy.mirrorReplies,
       archiveDedupeOutbound: normalizedRoute.archivePolicy.dedupeOutbound,
       archiveThreadID: archiveThread.threadID,

package/lib/runner-runtime.mjs

@@ -1,3 +1,8 @@
+import {
+  mergeRecentTelegramMessageEnvelopes,
+  normalizeTelegramMessageEnvelope,
+} from "./runner-helpers.mjs";
+
 function safeObject(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
     return {};
@@ -198,6 +203,40 @@ function mergeRunnerSharedInboxUpdates(existingUpdates, incomingUpdates) {
     .slice(-500);
 }
 
+const RUNNER_RECENT_LOCAL_INBOUND_ENVELOPE_LIMIT = 200;
+
+function buildRunnerRecentLocalInboundEnvelopes(routeStateRaw, updates, routeKey, bot, destination) {
+  const routeState = safeObject(routeStateRaw);
+  const currentBotSelector = normalizeMentionSelector(
+    bot?.username
+    || bot?.name
+    || "",
+  );
+  const relevantEnvelopes = ensureArray(updates)
+    .filter((update) => String(update.chatID || "").trim() === String(destination?.chatID || "").trim())
+    .filter((update) => String(update.text || "").trim())
+    .map((update) => normalizeTelegramMessageEnvelope({
+      chat_id: update.chatID,
+      message_id: update.messageID,
+      message_thread_id: update.messageThreadID,
+      reply_to_message_id: update.replyToMessageID,
+      kind: update.fromIsBot ? "bot_reply" : "telegram_message",
+      sender: update.fromName,
+      sender_username: update.fromUsername,
+      sender_is_bot: update.fromIsBot === true,
+      body: update.text,
+      source_origin: "local_telegram_inbound",
+      source_route_key: String(routeKey || "").trim(),
+      source_bot_username: currentBotSelector,
+    }))
+    .filter((envelope) => Object.keys(envelope).length > 0);
+  return mergeRecentTelegramMessageEnvelopes(
+    routeState.recent_local_inbound_envelopes,
+    relevantEnvelopes,
+    RUNNER_RECENT_LOCAL_INBOUND_ENVELOPE_LIMIT,
+  );
+}
+
 const RUNNER_INBOUND_ARCHIVE_RESERVATION_TTL_MS = 10 * 60 * 1000;
 const runnerInboundArchiveReservations = new Map();
 
@@ -470,6 +509,13 @@ export async function archiveLocalTelegramMessagesForRoute({
     .sort((left, right) => intFromRawAllowZero(left.updateID, 0) - intFromRawAllowZero(right.updateID, 0));
   let handledUpdateID = lastUpdateID;
   const mergedSharedUpdates = mergeRunnerSharedInboxUpdates(sharedInbox.updates, updates);
+  const recentLocalInboundEnvelopes = buildRunnerRecentLocalInboundEnvelopes(
+    routeState,
+    mergedSharedUpdates,
+    routeKey,
+    bot,
+    destination,
+  );
 
   const persistPollingProgress = (remainingSharedUpdates = []) => {
     if (sharedInboxKey && saveBotRunnerState) {
@@ -489,6 +535,7 @@ export async function archiveLocalTelegramMessagesForRoute({
       local_telegram_polling_ready: true,
       last_provider_update_id: handledUpdateID,
       last_local_poll_at: new Date().toISOString(),
+      recent_local_inbound_envelopes: recentLocalInboundEnvelopes,
     });
   };
 
@@ -564,7 +611,12 @@ export async function archiveLocalTelegramMessagesForRoute({
         timeoutSeconds: runtime.timeoutSeconds,
         threadID: archiveThread.threadID,
         actorUserID: runtime.actor.user_id,
-        body: formatTelegramInboundArchiveComment(update),
+        body: formatTelegramInboundArchiveComment({
+          ...update,
+          sourceOrigin: "local_telegram_inbound",
+          sourceRouteKey: String(routeKey || "").trim(),
+          sourceBotUsername: normalizeMentionSelector(bot?.username || bot?.name),
+        }),
       });
     } catch (err) {
       releaseRunnerInboundArchiveMessageReservation(reservation.reservationKey);

package/lib/selftest-runner-scenarios.mjs

@@ -12829,6 +12829,163 @@ export async function runSelftestRunnerScenarios(push, deps) {
     push("runner_delivery_failure_after_generation_records_ai_state_without_execution_error", false, String(err?.message || err));
   }
 
+  try {
+    let capturedReplyToMessageID = 0;
+    let capturedMessageThreadID = 0;
+    let capturedSourceMessageEnvelope = {};
+    const processed = await processRunnerSelectedRecord({
+      routeKey: "delivery-prefers-route-local-inbound-envelope-key",
+      normalizedRoute: normalizeRunnerRoute({
+        name: "telegram-monitor-delivery-prefers-route-local-inbound-envelope",
+        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-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: false,
+      }),
+      routeState: {
+        recent_local_inbound_envelopes: {
+          "-100123:128": {
+            chat_id: "-100123",
+            message_id: 128,
+            message_thread_id: 912,
+            reply_to_message_id: 127,
+            kind: "telegram_message",
+            sender: "human",
+            sender_is_bot: false,
+            body: "@RyoAI_bot hi",
+            source_origin: "local_telegram_inbound",
+            source_route_key: "delivery-prefers-route-local-inbound-envelope-key",
+            source_bot_username: "ryoai_bot",
+          },
+        },
+      },
+      selectedRecord: {
+        id: "comment-delivery-prefers-route-local-inbound-envelope",
+        createdAt: "2026-03-27T00:00:00.000Z",
+        parsedArchive: {
+          kind: "telegram_message",
+          chatID: "-100123",
+          chatType: "supergroup",
+          body: "@RyoAI_bot hi",
+          messageID: 128,
+          messageThreadID: 912,
+          replyToMessageID: 127,
+          sender: "human",
+          senderIsBot: false,
+          mentionUsernames: ["ryoai_bot"],
+        },
+      },
+      pendingOrdered: [],
+      bot: {
+        id: "bot-1",
+        name: "RyoAI_bot",
+        username: "RyoAI_bot",
+        role: "monitor",
+        provider: "telegram",
+      },
+      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: "",
+        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 () => ({
+          skip: false,
+          reply: "Hello from RyoAI_bot.",
+        }),
+        performLocalBotDelivery: async ({ replyToMessageID, messageThreadID, sourceMessageEnvelope }) => {
+          capturedReplyToMessageID = Number(replyToMessageID || 0);
+          capturedMessageThreadID = Number(messageThreadID || 0);
+          capturedSourceMessageEnvelope = safeObject(sourceMessageEnvelope);
+          return {
+            delivery: {
+              dryRun: false,
+              body: {
+                result: {
+                  message_id: 9001,
+                  message_thread_id: Number(messageThreadID || 0) || undefined,
+                },
+              },
+            },
+            archive: {},
+          };
+        },
+        serializeRunnerTriggerPolicy: (value) => value,
+        serializeRunnerArchivePolicy: (value) => value,
+        buildRunnerExecutionDeps: () => ({
+          validateWorkspaceArtifacts,
+          analyzeHumanConversationIntentWithAI: async () => ({
+            mode: "single_bot",
+            lead_bot: "ryoai_bot",
+            participants: ["ryoai_bot"],
+            initial_responders: ["ryoai_bot"],
+            allowed_responders: ["ryoai_bot"],
+            summary_bot: "",
+            allow_bot_to_bot: false,
+            reply_expectation: "informational",
+            intent_type: "small_talk",
+          }),
+        }),
+        buildRunnerDeliveryDeps: () => ({}),
+        buildRunnerRuntimeDeps: () => ({}),
+        resolveConversationPeerBots: () => [],
+      },
+    });
+    push(
+      "runner_delivery_prefers_route_local_inbound_provenance_envelope",
+      processed.kind === "replied"
+        && capturedReplyToMessageID === 128
+        && capturedMessageThreadID === 912
+        && String(capturedSourceMessageEnvelope.source_origin || "") === "local_telegram_inbound"
+        && Number(capturedSourceMessageEnvelope.message_id || 0) === 128,
+      `kind=${String(processed.kind || "(none)")} reply_to=${String(capturedReplyToMessageID || 0)} thread=${String(capturedMessageThreadID || 0)} origin=${String(capturedSourceMessageEnvelope.source_origin || "(none)")} message=${String(capturedSourceMessageEnvelope.message_id || "(none)")}`,
+    );
+  } catch (err) {
+    push("runner_delivery_prefers_route_local_inbound_provenance_envelope", false, String(err?.message || err));
+  }
+
   try {
     const workspaceDir = fs.mkdtempSync(path.join(os.tmpdir(), "metheus-runner-selftest-observed-artifacts-"));
     const scriptDir = path.join(workspaceDir, ".metheus", "runner-runtime", "local-ai-scratch");

package/lib/selftest-telegram-e2e.mjs

@@ -503,17 +503,51 @@ export async function runSelftestTelegramE2E(push, deps) {
       dryRun: true,
       deps: buildRunnerDeliveryDeps(),
     });
-    push(
-      "telegram_delivery_dry_run_skips_send_and_archive",
-      Boolean(dryRunResult.delivery?.dryRun)
-        && String(dryRunResult.archive?.reason || "") === "dry_run_delivery"
-        && telegramE2EServer.state.sentMessages.length === sentCountBeforeDryRun
-        && telegramE2EServer.state.comments.length === commentCountBeforeDryRun,
-      `dry_run=${String(dryRunResult.delivery?.dryRun || false)} sent=${telegramE2EServer.state.sentMessages.length} comments=${telegramE2EServer.state.comments.length}`,
-    );
-
-    telegramE2EServer.state.comments = [];
-    telegramE2EServer.state.updates = [
+    push(
+      "telegram_delivery_dry_run_skips_send_and_archive",
+      Boolean(dryRunResult.delivery?.dryRun)
+        && String(dryRunResult.archive?.reason || "") === "dry_run_delivery"
+        && telegramE2EServer.state.sentMessages.length === sentCountBeforeDryRun
+        && telegramE2EServer.state.comments.length === commentCountBeforeDryRun,
+      `dry_run=${String(dryRunResult.delivery?.dryRun || false)} sent=${telegramE2EServer.state.sentMessages.length} comments=${telegramE2EServer.state.comments.length}`,
+    );
+    const sentCountBeforeUnsafeAnchor = telegramE2EServer.state.sentMessages.length;
+    let unsafeAnchorError = "";
+    try {
+      await performLocalBotDelivery({
+        siteBaseURL: telegramE2EServer.baseURL,
+        token: e2eToken,
+        timeoutSeconds: 10,
+        actorUserID: e2eActorUserID,
+        bot: e2eBot,
+        projectID: selftestProjectID,
+        provider: "telegram",
+        destinationSelectors: {
+          destinationLabel: e2eDestination.label,
+        },
+        text: "unsafe archive anchor",
+        replyToMessageID: 41,
+        sourceMessageEnvelope: {
+          chat_id: e2eDestination.chat_id,
+          message_id: 41,
+          source_origin: "archive_reconstructed",
+        },
+        archiveReplies: false,
+        dryRun: false,
+        deps: buildRunnerDeliveryDeps(),
+      });
+    } catch (err) {
+      unsafeAnchorError = String(err?.message || err);
+    }
+    push(
+      "telegram_delivery_rejects_archive_reconstructed_reply_anchor",
+      /telegram reply anchor is not local to this route/i.test(unsafeAnchorError)
+        && telegramE2EServer.state.sentMessages.length === sentCountBeforeUnsafeAnchor,
+      `error=${unsafeAnchorError || "(none)"} sent=${telegramE2EServer.state.sentMessages.length}`,
+    );
+
+    telegramE2EServer.state.comments = [];
+    telegramE2EServer.state.updates = [
       {
         update_id: 201,
         message: {

package/package.json

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