metheus-governance-mcp-cli 0.2.249 → 0.2.252

package/cli.mjs

@@ -140,6 +140,8 @@ import {
   buildRunnerRouteStateFromComment,
   buildProcessableArchiveLogicalKey,
   findEarlierProcessableArchiveDuplicate,
+  findRecentTelegramMessageEnvelope,
+  isTelegramLocalInboundEnvelopeForRoute,
   isInboundArchiveKind,
   normalizeTelegramMessageEnvelope as normalizeRunnerTelegramMessageEnvelope,
   normalizeArchiveCommentRecord,
@@ -1989,6 +1991,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 +2645,45 @@ 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);
+  const fallbackBotSelector = normalizeTelegramMentionUsername(
+    normalizedRoute?.botName
+      || normalizedRoute?.serverBotName
+      || "",
+  );
+  if (isTelegramLocalInboundEnvelopeForRoute(localEnvelope, {
+    routeKey,
+    botUsername: fallbackBotSelector,
+  })) {
+    return localEnvelope;
+  }
+  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 +2718,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 +4451,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 +4574,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 +7601,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 +7618,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),
@@ -7817,30 +7869,23 @@ function extractTelegramEntityText(text, entity) {
   return body.slice(offset, offset + length);
 }
 
-function extractTelegramMentionUsernames(text, entities) {
-  const set = new Set();
-  for (const entityRaw of ensureArray(entities)) {
-    const entity = safeObject(entityRaw);
+function extractTelegramMentionUsernames(text, entities) {
+  const set = new Set();
+  for (const entityRaw of ensureArray(entities)) {
+    const entity = safeObject(entityRaw);
     const type = String(entity.type || "").trim().toLowerCase();
     if (type === "mention") {
       const username = normalizeTelegramMentionUsername(extractTelegramEntityText(text, entity));
       if (username) set.add(username);
       continue;
     }
-    if (type === "text_mention") {
-      const username = normalizeTelegramMentionUsername(entity.user?.username);
-      if (username) set.add(username);
-    }
-  }
-  const regex = /(^|[^A-Za-z0-9_])@([A-Za-z0-9_]{3,})\b/g;
-  let match = regex.exec(String(text || ""));
-  while (match) {
-    const username = normalizeTelegramMentionUsername(match[2]);
-    if (username) set.add(username);
-    match = regex.exec(String(text || ""));
-  }
-  return Array.from(set);
-}
+    if (type === "text_mention") {
+      const username = normalizeTelegramMentionUsername(entity.user?.username);
+      if (username) set.add(username);
+    }
+  }
+  return Array.from(set);
+}
 
 function normalizeLocalTelegramUpdate(rawUpdate) {
   const update = safeObject(rawUpdate);
@@ -7886,18 +7931,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) {
@@ -17482,11 +17536,12 @@ TELEGRAM_BOT_REVIEW_TOKEN=review-token
     mergeServerRunnerRequestLedgerIntoLocalState,
     buildRunnerStatusQueryLookup,
     tryJsonParse,
-    safeObject,
-    normalizeRunnerTriggerPolicy,
-    evaluateTelegramRunnerTrigger,
-    resolveRunnerResponderAdjudication,
-    selectPendingArchiveComments,
+    safeObject,
+    normalizeRunnerTriggerPolicy,
+    evaluateTelegramRunnerTrigger,
+    resolveHumanIntentContext,
+    resolveRunnerResponderAdjudication,
+    selectPendingArchiveComments,
     selectRunnerPendingWork,
     processRunnerSelectedRecord,
     resolveRunnerStartupLoopAdjudication,

package/lib/bot-commands.mjs

@@ -2669,7 +2669,7 @@ function suggestedAIModelsForClient(clientName) {
       { value: "Opus 4.6", label: "Opus 4.6", description: "display label; runs as opus" },
     ];
     }
-    if (normalizedClient === "gemini") {
+  if (normalizedClient === "gemini") {
       return [
         { value: "gemini-3.1-pro", label: "gemini-3.1-pro", description: "display label; runs as auto-gemini-3" },
       ];

package/lib/local-ai-adapters.mjs

@@ -18,6 +18,7 @@ const GEMINI_HOME_SYNC_FILES = [
   "settings.json",
 ];
 const GEMINI_STDIN_BRIDGE_PROMPT = "Use the full task provided on standard input as the authoritative prompt. Follow it exactly and output only the final answer.";
+const GEMINI_CLI_TIMEOUT_MS = 90 * 1000;
 const LOCAL_AI_MODEL_MAPPINGS = {
   gpt: [
     {
@@ -769,13 +770,36 @@ function runGeminiRawText({ promptText, workspaceDir, model, permissionMode, rea
         env: runtime.env,
         input: String(promptText || ""),
         maxBuffer: 8 * 1024 * 1024,
+        timeout: GEMINI_CLI_TIMEOUT_MS,
       },
     );
     if (result.error) {
+      const errorCode = String(result.error?.code || "").trim().toUpperCase();
+      if (errorCode === "ETIMEDOUT") {
+        const stderrText = String(result.stderr || "").trim();
+        const stdoutText = String(result.stdout || "").trim();
+        const details = [stderrText, stdoutText]
+          .filter(Boolean)
+          .map((value) => value.replace(/\s+/g, " ").trim())
+          .filter(Boolean)
+          .slice(0, 2)
+          .join(" | ");
+        throw new Error(
+          details
+            ? `Gemini CLI timed out after ${Math.round(GEMINI_CLI_TIMEOUT_MS / 1000)}s while waiting for a model response (${details})`
+            : `Gemini CLI timed out after ${Math.round(GEMINI_CLI_TIMEOUT_MS / 1000)}s while waiting for a model response`,
+        );
+      }
       throw new Error(String(result.error?.message || result.error));
     }
     if (result.status !== 0) {
-      throw new Error(String(result.stderr || result.stdout || `gemini exited with status ${result.status}`));
+      const stderrText = String(result.stderr || "");
+      const stdoutText = String(result.stdout || "");
+      const combinedText = `${stderrText}\n${stdoutText}`.trim();
+      if (/MODEL_CAPACITY_EXHAUSTED|No capacity available for model/i.test(combinedText)) {
+        throw new Error(`Gemini model capacity is currently unavailable for ${String(model || "").trim() || "the configured model"}`);
+      }
+      throw new Error(combinedText || `gemini exited with status ${result.status}`);
     }
     return String(result.stdout || "");
   } finally {
@@ -1377,7 +1401,8 @@ function buildGeminiArgs({ model, permissionMode }) {
     "--allowed-mcp-server-names",
     "none",
   ];
-  if (model) {
+  const normalizedModel = normalizeModelAliasText(model);
+  if (model && normalizedModel !== "auto-gemini-3") {
     args.push("--model", model);
   }
   return args;
@@ -1433,6 +1458,9 @@ function buildGeminiThinkingConfig(model, reasoningEffort) {
 
 export function resolveGeminiReasoningConfig(rawModelValue = "", reasoningEffort = "medium") {
   const executionModel = resolveLocalAIExecutionModel("gemini", rawModelValue);
+  if (!executionModel || executionModel === "auto-gemini-3") {
+    return null;
+  }
   const thinkingConfig = buildGeminiThinkingConfig(executionModel, reasoningEffort);
   if (!thinkingConfig) {
     return null;

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);
@@ -194,6 +284,28 @@ function normalizeMentionSelector(rawValue) {
   return String(rawValue || "").trim().replace(/^@+/, "").toLowerCase();
 }
 
+export function isTelegramLocalInboundEnvelopeForRoute(rawEnvelope, {
+  routeKey = "",
+  botUsername = "",
+} = {}) {
+  const envelope = normalizeTelegramMessageEnvelope(rawEnvelope);
+  const sourceOrigin = String(envelope.source_origin || "").trim().toLowerCase();
+  if (sourceOrigin !== "local_telegram_inbound") {
+    return false;
+  }
+  const expectedRouteKey = String(routeKey || "").trim();
+  const actualRouteKey = String(envelope.source_route_key || "").trim();
+  if (expectedRouteKey && expectedRouteKey !== actualRouteKey) {
+    return false;
+  }
+  const expectedBotUsername = normalizeMentionSelector(botUsername);
+  const actualBotUsername = normalizeMentionSelector(envelope.source_bot_username || "");
+  if (expectedBotUsername && expectedBotUsername !== actualBotUsername) {
+    return false;
+  }
+  return true;
+}
+
 function uniqueNormalizedSelectors(values) {
   return Array.from(new Set(
     ensureArray(values)

package/lib/runner-orchestration.mjs

@@ -7,6 +7,8 @@ import {
   buildRunnerRouteStateFromComment,
   compareArchiveCommentRecords,
   dedupeProcessableArchiveComments,
+  findRecentTelegramMessageEnvelope,
+  isTelegramLocalInboundEnvelopeForRoute,
   isInboundArchiveKind,
   normalizeTelegramMessageEnvelope,
   selectPendingArchiveComments,
@@ -376,11 +378,59 @@ 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 (isTelegramLocalInboundEnvelopeForRoute(routeLocalEnvelope, {
+    routeKey,
+    botUsername: currentBotSelector,
+  })) {
+    return routeLocalEnvelope;
+  }
+  const persistedSourceEnvelope = normalizeTelegramMessageEnvelope(
+    safeObject(persistedRequest).source_message_envelope
+      || safeObject(persistedRequest).sourceMessageEnvelope,
+  );
+  const persistedChatID = String(persistedSourceEnvelope.chat_id || "").trim();
+  const persistedMessageID = intFromRawAllowZero(persistedSourceEnvelope.message_id, 0);
+  if (
+    isTelegramLocalInboundEnvelopeForRoute(persistedSourceEnvelope, {
+      routeKey,
+      botUsername: currentBotSelector,
+    })
+    && archiveChatID
+    && archiveChatID === persistedChatID
+    && archiveMessageID > 0
+    && archiveMessageID === persistedMessageID
+  ) {
+    return persistedSourceEnvelope;
+  }
+  return archiveEnvelope;
+}
+
+function escapeRegExp(text) {
   return String(text || "").replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 
@@ -3338,21 +3388,22 @@ async function maybeExecuteDynamicRolePlan({
   };
 }
 
-function buildConversationPeerMap(bot, normalizedRoute, deps) {
-  const peers = typeof deps?.resolveConversationPeerBots === "function"
-    ? ensureArray(deps.resolveConversationPeerBots(normalizedRoute))
-    : [];
-  const output = new Map();
-  const register = (peerRaw) => {
-    const peer = safeObject(peerRaw);
-    const displayName = String(peer.name || peer.username || peer.id || "").trim();
-    const selectors = uniqueOrdered([
-      normalizeMentionSelector(peer.username),
-      normalizeMentionSelector(peer.name),
-    ]);
-    for (const selector of selectors) {
-      output.set(selector, {
-        selector,
+function buildConversationPeerMap(bot, normalizedRoute, deps) {
+  const peers = typeof deps?.resolveConversationPeerBots === "function"
+    ? ensureArray(deps.resolveConversationPeerBots(normalizedRoute))
+    : [];
+  const output = new Map();
+  const register = (peerRaw) => {
+    const peer = safeObject(peerRaw);
+    const displayName = String(peer.name || peer.username || peer.id || "").trim();
+    const explicitUsername = normalizeMentionSelector(peer.username);
+    const selectors = uniqueOrdered([
+      explicitUsername,
+      explicitUsername ? "" : normalizeMentionSelector(peer.name),
+    ]);
+    for (const selector of selectors) {
+      output.set(selector, {
+        selector,
         displayName: displayName || selector,
         id: String(peer.id || "").trim(),
       });
@@ -4720,10 +4771,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 +4793,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
@@ -4884,7 +4942,10 @@ export async function processRunnerSelectedRecord({
     && !precomputedConversationResponderSelection;
   if (!currentBotSelected && !shouldDeferBotReplyConversationAuthorization) {
     const adjudicationDecision = String(responderAdjudication.decision || "").trim() || "no_responder";
-    const adjudicationReason = String(responderAdjudication.reason_code || "").trim() || "not_selected_by_adjudicator";
+    const rawAdjudicationReason = String(responderAdjudication.reason_code || "").trim() || "not_selected_by_adjudicator";
+    const adjudicationReason = rawAdjudicationReason === "precomputed_human_intent_contract" && selectedResponderSelectors.length > 0
+      ? "precomputed_human_intent_contract_selected_other_responder"
+      : rawAdjudicationReason;
     saveRunnerRouteState(
       routeKey,
       buildRunnerRouteStateFromComment(selectedRecord, {
@@ -5592,6 +5653,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/runner-trigger.mjs

@@ -35,19 +35,11 @@ function normalizeTelegramMentionUsername(rawValue) {
 }
 
 function listTelegramMentionUsernames(parsedArchive) {
-  const usernames = new Set(
+  return uniqueOrdered(
     ensureArray(parsedArchive?.mentionUsernames)
       .map((value) => normalizeTelegramMentionUsername(value))
       .filter(Boolean),
   );
-  const text = String(parsedArchive?.body || "").trim().toLowerCase();
-  for (const match of text.matchAll(/@([a-z0-9_]{3,})/gi)) {
-    const normalized = normalizeTelegramMentionUsername(match?.[1]);
-    if (normalized) {
-      usernames.add(normalized);
-    }
-  }
-  return Array.from(usernames);
 }
 
 function inferTelegramArchiveChatType(parsedArchive) {
@@ -60,10 +52,13 @@ function inferTelegramArchiveChatType(parsedArchive) {
 
 function buildTelegramBotUsernameCandidates(bot, route) {
   const set = new Set();
+  const explicitUsername = normalizeTelegramMentionUsername(bot?.username);
+  const fallbackDisplayCandidates = explicitUsername
+    ? []
+    : [bot?.name, route?.botName];
   for (const candidate of [
-    bot?.username,
-    bot?.name,
-    route?.botName,
+    explicitUsername,
+    ...fallbackDisplayCandidates,
   ]) {
     const normalized = normalizeTelegramMentionUsername(candidate);
     if (normalized) {
@@ -74,13 +69,11 @@ function buildTelegramBotUsernameCandidates(bot, route) {
 }
 
 function doesTelegramArchiveMentionBot(parsedArchive, bot, route) {
-  const text = String(parsedArchive?.body || "").trim().toLowerCase();
   const mentions = new Set(listTelegramMentionUsernames(parsedArchive));
   const candidates = buildTelegramBotUsernameCandidates(bot, route);
   for (const username of candidates) {
     if (!username) continue;
     if (mentions.has(username)) return true;
-    if (text.includes(`@${username}`)) return true;
   }
   return false;
 }

package/lib/selftest-runner-scenarios.mjs

@@ -117,7 +117,8 @@ export async function runSelftestRunnerScenarios(push, deps) {
   const tryJsonParse = requireDependency(deps, "tryJsonParse");
   const safeObject = requireDependency(deps, "safeObject");
   const normalizeRunnerTriggerPolicy = requireDependency(deps, "normalizeRunnerTriggerPolicy");
-  const evaluateTelegramRunnerTrigger = requireDependency(deps, "evaluateTelegramRunnerTrigger");
+  const evaluateTelegramRunnerTrigger = requireDependency(deps, "evaluateTelegramRunnerTrigger");
+  const resolveHumanIntentContext = requireDependency(deps, "resolveHumanIntentContext");
   const resolveRunnerResponderAdjudication = requireDependency(deps, "resolveRunnerResponderAdjudication");
   const selectPendingArchiveComments = requireDependency(deps, "selectPendingArchiveComments");
   const selectRunnerPendingWork = requireDependency(deps, "selectRunnerPendingWork");
@@ -2464,13 +2465,80 @@ export async function runSelftestRunnerScenarios(push, deps) {
     mentionOnlyRoute,
     { name: "ServerProtocolMonitorBot", role: "monitor" },
   );
-  push(
-    "telegram_trigger_mentions_only_accepts_bot_mention",
-    mentionOnlyMatched.shouldRespond === true && mentionOnlyMatched.trigger === "mention",
-    `shouldRespond=${mentionOnlyMatched.shouldRespond} trigger=${mentionOnlyMatched.trigger}`,
-  );
-
-  const mentionOverridesReplyForUnmentionedBot = evaluateTelegramRunnerTrigger(
+  push(
+    "telegram_trigger_mentions_only_accepts_bot_mention",
+    mentionOnlyMatched.shouldRespond === true && mentionOnlyMatched.trigger === "mention",
+    `shouldRespond=${mentionOnlyMatched.shouldRespond} trigger=${mentionOnlyMatched.trigger}`,
+  );
+
+  const mentionOnlyAliasCandidate = evaluateTelegramRunnerTrigger(
+    {
+      id: "comment-2a",
+      parsedArchive: {
+        kind: "telegram_message",
+        chatID: "-100123",
+        chatType: "supergroup",
+        body: "hello @RyoAI_bot2",
+        mentionUsernames: [],
+        replyToSenderIsBot: false,
+      },
+    },
+    mentionOnlyRoute,
+    { username: "ryoai2_bot", name: "RyoAI_bot2", role: "monitor" },
+  );
+  push(
+    "telegram_trigger_does_not_treat_raw_alias_text_as_authoritative_mention",
+    mentionOnlyAliasCandidate.shouldRespond === true
+      && mentionOnlyAliasCandidate.trigger === "mentions_only_unaddressed_candidate",
+    `shouldRespond=${mentionOnlyAliasCandidate.shouldRespond} trigger=${mentionOnlyAliasCandidate.trigger}`,
+  );
+
+  try {
+    const aliasHumanIntentContext = await resolveHumanIntentContext({
+      selectedRecord: {
+        id: "comment-alias-managed-mention",
+        parsedArchive: {
+          kind: "telegram_message",
+          body: "@RyoAI_bot2 hi",
+          senderIsBot: false,
+        },
+      },
+      normalizedRoute: {
+        name: "telegram-monitor-ryoai2-bot-2",
+      },
+      bot: {
+        username: "ryoai2_bot",
+        name: "RyoAI_bot2",
+      },
+      executionPlan: {},
+      deps: {
+        resolveConversationPeerBots: () => [],
+      },
+      persistedRequest: {
+        conversation_intent_mode: "single_bot",
+        conversation_reply_expectation: "informational",
+        conversation_initial_responders: ["ryoai2_bot"],
+        conversation_allowed_responders: ["ryoai2_bot"],
+        conversation_participants: ["ryoai2_bot"],
+        conversation_lead_bot: "ryoai2_bot",
+        conversation_summary_bot: "ryoai2_bot",
+      },
+    });
+    push(
+      "runner_human_intent_context_ignores_raw_alias_selector_for_managed_mentions",
+      ensureArray(aliasHumanIntentContext?.managedMentions).length === 0
+        && aliasHumanIntentContext?.reusedPersistedContract === true,
+      `managedMentions=${JSON.stringify(ensureArray(aliasHumanIntentContext?.managedMentions))} reused=${String(aliasHumanIntentContext?.reusedPersistedContract)}`,
+    );
+  } catch (err) {
+    push(
+      "runner_human_intent_context_ignores_raw_alias_selector_for_managed_mentions",
+      false,
+      String(err?.message || err),
+    );
+  }
+
+  const mentionOverridesReplyForUnmentionedBot = evaluateTelegramRunnerTrigger(
     {
       id: "comment-2b",
       parsedArchive: {
@@ -12829,6 +12897,298 @@ 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 {
+    let capturedSourceMessageEnvelope = {};
+    const processed = await processRunnerSelectedRecord({
+      routeKey: "telegram-monitor-ryoai2-bot-2::project::telegram::monitor::dest::actor",
+      normalizedRoute: {
+        name: "telegram-monitor-ryoai2-bot-2",
+        provider: "telegram",
+        role: "monitor",
+        roleProfile: "monitor",
+        botName: "RyoAI2_bot",
+        archivePolicy: { mirrorReplies: true, dedupeOutbound: true },
+        triggerPolicy: {
+          directMessages: true,
+          mentionsOnly: false,
+          replyToBotMessages: true,
+          ignoreEditedMessages: true,
+        },
+      },
+      routeState: {
+        recent_local_inbound_envelopes: {},
+      },
+      selectedRecord: {
+        id: "comment-foreign-provenance",
+        threadID: "thread-1",
+        parsedArchive: {
+          kind: "telegram_message",
+          chatID: "-100123",
+          chatType: "supergroup",
+          body: "@RyoAI2_bot hi",
+          messageID: 228,
+          sender: "human",
+          senderIsBot: false,
+          mentionUsernames: ["ryoai2_bot"],
+        },
+      },
+      persistedHumanIntentRequest: {
+        source_message_envelope: {
+          chat_id: "-100123",
+          message_id: 228,
+          source_origin: "local_telegram_inbound",
+          source_route_key: "telegram-monitor-ryoai-bot-2::project::telegram::monitor::dest::actor",
+          source_bot_username: "ryoai_bot",
+        },
+      },
+      pendingOrdered: [],
+      bot: {
+        id: "bot-2",
+        name: "RyoAI2_bot",
+        username: "RyoAI2_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 RyoAI2_bot.",
+        }),
+        performLocalBotDelivery: async ({ sourceMessageEnvelope }) => {
+          capturedSourceMessageEnvelope = safeObject(sourceMessageEnvelope);
+          return {
+            delivery: {
+              dryRun: false,
+              body: {
+                result: {
+                  message_id: 9002,
+                },
+              },
+            },
+            archive: {},
+          };
+        },
+        serializeRunnerTriggerPolicy: (value) => value,
+        serializeRunnerArchivePolicy: (value) => value,
+        buildRunnerExecutionDeps: () => ({
+          validateWorkspaceArtifacts,
+          analyzeHumanConversationIntentWithAI: async () => ({
+            mode: "single_bot",
+            lead_bot: "ryoai2_bot",
+            participants: ["ryoai2_bot"],
+            initial_responders: ["ryoai2_bot"],
+            allowed_responders: ["ryoai2_bot"],
+            summary_bot: "",
+            allow_bot_to_bot: false,
+            reply_expectation: "informational",
+            intent_type: "small_talk",
+          }),
+        }),
+        buildRunnerDeliveryDeps: () => ({}),
+        buildRunnerRuntimeDeps: () => ({}),
+        resolveConversationPeerBots: () => [],
+      },
+    });
+    push(
+      "runner_delivery_rejects_foreign_route_local_provenance",
+      processed.kind === "replied"
+        && String(capturedSourceMessageEnvelope.source_origin || "") === "archive_reconstructed"
+        && String(capturedSourceMessageEnvelope.source_route_key || "").includes("telegram-monitor-ryoai2-bot-2")
+        && String(capturedSourceMessageEnvelope.source_bot_username || "") === "ryoai2_bot",
+      `kind=${String(processed.kind || "(none)")} origin=${String(capturedSourceMessageEnvelope.source_origin || "(none)")} route=${String(capturedSourceMessageEnvelope.source_route_key || "(none)")} bot=${String(capturedSourceMessageEnvelope.source_bot_username || "(none)")}`,
+    );
+  } catch (err) {
+    push("runner_delivery_rejects_foreign_route_local_provenance", 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.252",
   "description": "Metheus Governance MCP CLI (setup + stdio proxy)",
   "type": "module",
   "files": [