metheus-governance-mcp-cli 0.2.281 → 0.2.283

package/cli.mjs

@@ -25,9 +25,10 @@ import {
   resolveRolePlannerAuditorModelDisplayName,
   resolveRolePlannerModelDisplayName,
   resolveRolePlannerRepairModelDisplayName,
-  resolveResponderAdjudicatorModelDisplayName,
-  resolveGeminiReasoningConfig,
-  suggestLocalAIModelDisplayName,
+  resolveResponderAdjudicatorModelDisplayName,
+  resolveGeminiHeadlessExecutionModel,
+  resolveGeminiReasoningConfig,
+  suggestLocalAIModelDisplayName,
   SUPPORTED_LOCAL_AI_CLIENTS,
   normalizeLocalAIClientName,
   normalizeLocalAIPermissionMode,
@@ -3111,20 +3112,25 @@ function normalizeBotRunnerRequests(rawRequests, nowMs = Date.now()) {
         entry.sourceMessageBotUsername,
       ]),
     });
-    normalized[requestKey] = {
-      request_key: requestKey,
-      project_id: String(entry.project_id || entry.projectID || "").trim(),
-      provider: String(entry.provider || "").trim(),
-      chat_id: firstNonEmptyString([
-        entry.chat_id,
-        entry.chatID,
-        normalizedSourceMessageEnvelope.chat_id,
-      ]),
-      source_message_id: intFromRawAllowZero(
-        entry.source_message_id
-        || entry.sourceMessageID
-        || normalizedSourceMessageEnvelope.message_id,
-        0,
+    normalized[requestKey] = {
+      request_key: requestKey,
+      project_id: String(entry.project_id || entry.projectID || "").trim(),
+      provider: String(entry.provider || "").trim(),
+      chat_id: firstNonEmptyString([
+        entry.chat_id,
+        entry.chatID,
+        normalizedSourceMessageEnvelope.chat_id,
+      ]),
+      canonical_human_message_key: firstNonEmptyString([
+        entry.canonical_human_message_key,
+        entry.canonicalHumanMessageKey,
+        normalizedSourceMessageEnvelope.canonical_human_message_key,
+      ]),
+      source_message_id: intFromRawAllowZero(
+        entry.source_message_id
+        || entry.sourceMessageID
+        || normalizedSourceMessageEnvelope.message_id,
+        0,
       ) || undefined,
       source_message_thread_id: intFromRawAllowZero(
         entry.source_message_thread_id
@@ -3813,18 +3819,35 @@ function shouldBypassRunnerStartupLoopForContractFollowup({
   return true;
 }
 
-function findRunnerRequestsForMessageID(state, normalizedRoute, selectors = {}) {
-  const chatID = String(selectors.chatID || "").trim();
-  const messageID = intFromRawAllowZero(selectors.messageID, 0);
-  if (!chatID || messageID <= 0) {
-    return [];
-  }
-  return findRunnerRequestsForScope(state, normalizedRoute, { chatID })
-    .filter((entry) => (
-      intFromRawAllowZero(entry.source_message_id, 0) === messageID
-      || intFromRawAllowZero(entry.last_source_message_id, 0) === messageID
-    ));
-}
+function findRunnerRequestsForMessageID(state, normalizedRoute, selectors = {}) {
+  const chatID = String(selectors.chatID || "").trim();
+  const messageID = intFromRawAllowZero(selectors.messageID, 0);
+  const canonicalHumanMessageKey = String(selectors.canonicalHumanMessageKey || "").trim();
+  if (!chatID || (messageID <= 0 && !canonicalHumanMessageKey)) {
+    return [];
+  }
+  return findRunnerRequestsForScope(state, normalizedRoute, { chatID })
+    .filter((entryRaw) => {
+      const entry = safeObject(entryRaw);
+      if (canonicalHumanMessageKey) {
+        const requestCanonicalHumanMessageKey = firstNonEmptyString([
+          entry.canonical_human_message_key,
+          safeObject(entry.source_message_envelope).canonical_human_message_key,
+          buildRunnerCanonicalHumanInboundKey(safeObject(entry.source_message_envelope)),
+        ]);
+        if (requestCanonicalHumanMessageKey === canonicalHumanMessageKey) {
+          return true;
+        }
+      }
+      return (
+        messageID > 0
+        && (
+          intFromRawAllowZero(entry.source_message_id, 0) === messageID
+          || intFromRawAllowZero(entry.last_source_message_id, 0) === messageID
+        )
+      );
+    });
+}
 
 function sortRunnerRequestEntriesNewestFirst(entries = []) {
   return ensureArray(entries).slice().sort((leftRaw, rightRaw) => {
@@ -3839,24 +3862,26 @@ function sortRunnerRequestEntriesNewestFirst(entries = []) {
   });
 }
 
-async function findServerRunnerRequestForMessageID({
-  normalizedRoute,
-  runtime,
-  chatID,
-  messageID,
-}) {
+async function findServerRunnerRequestForMessageID({
+  normalizedRoute,
+  runtime,
+  chatID,
+  messageID,
+  canonicalHumanMessageKey = "",
+}) {
   const projectID = String(normalizedRoute?.projectID || "").trim();
   const provider = String(normalizedRoute?.provider || "").trim();
-  const normalizedChatID = String(chatID || "").trim();
-  const normalizedMessageID = intFromRawAllowZero(messageID, 0);
-  if (
-    !projectID
-    || !provider
-    || !normalizedChatID
-    || normalizedMessageID <= 0
-    || !runtime?.baseURL
-    || !runtime?.token
-  ) {
+  const normalizedChatID = String(chatID || "").trim();
+  const normalizedMessageID = intFromRawAllowZero(messageID, 0);
+  const normalizedCanonicalHumanMessageKey = String(canonicalHumanMessageKey || "").trim();
+  if (
+    !projectID
+    || !provider
+    || !normalizedChatID
+    || (normalizedMessageID <= 0 && !normalizedCanonicalHumanMessageKey)
+    || !runtime?.baseURL
+    || !runtime?.token
+  ) {
     return null;
   }
   try {
@@ -3869,18 +3894,29 @@ async function findServerRunnerRequestForMessageID({
       limit: 500,
       offset: 0,
     });
-    const matched = sortRunnerRequestEntriesNewestFirst(serverRequests.filter((entryRaw) => {
-      const entry = safeObject(entryRaw);
-      return (
-        String(entry.project_id || "").trim() === projectID
-        && String(entry.provider || "").trim() === provider
-        && String(entry.chat_id || "").trim() === normalizedChatID
-        && (
-          intFromRawAllowZero(entry.source_message_id, 0) === normalizedMessageID
-          || intFromRawAllowZero(entry.last_source_message_id, 0) === normalizedMessageID
-        )
-      );
-    }));
+    const matched = sortRunnerRequestEntriesNewestFirst(serverRequests.filter((entryRaw) => {
+      const entry = safeObject(entryRaw);
+      const requestCanonicalHumanMessageKey = firstNonEmptyString([
+        entry.canonical_human_message_key,
+        safeObject(entry.source_message_envelope).canonical_human_message_key,
+        buildRunnerCanonicalHumanInboundKey(safeObject(entry.source_message_envelope)),
+      ]);
+      return (
+        String(entry.project_id || "").trim() === projectID
+        && String(entry.provider || "").trim() === provider
+        && String(entry.chat_id || "").trim() === normalizedChatID
+        && (
+          (normalizedCanonicalHumanMessageKey && requestCanonicalHumanMessageKey === normalizedCanonicalHumanMessageKey)
+          || (
+            normalizedMessageID > 0
+            && (
+              intFromRawAllowZero(entry.source_message_id, 0) === normalizedMessageID
+              || intFromRawAllowZero(entry.last_source_message_id, 0) === normalizedMessageID
+            )
+          )
+        )
+      );
+    }));
     return safeObject(matched[0]);
   } catch {
     return null;
@@ -4109,12 +4145,14 @@ function buildRunnerValidationAndDeliverySummary({
   responseContractValidationStatus = "",
   responseContractValidationReason = "",
   responseContractValidationTargets = [],
-  assignmentValidationStatus = "",
-  assignmentValidationReason = "",
-  assignmentValidationModes = [],
-  deliveryStatus = "",
-  archiveStatus = "",
-  transportError = "",
+  assignmentValidationStatus = "",
+  assignmentValidationReason = "",
+  assignmentValidationModes = [],
+  failureReplyClassification = "",
+  failureFacts = {},
+  deliveryStatus = "",
+  archiveStatus = "",
+  transportError = "",
   archiveError = "",
   sourceMessageEnvelope = {},
   lastReplyMessageEnvelope = {},
@@ -4321,25 +4359,27 @@ function pickRunnerSharedConversationSourceRequest(entries = [], excludeRequestK
   return safeObject(matched[0]);
 }
 
-async function findServerRunnerConversationSourceRequestForMessageID({
-  normalizedRoute,
-  runtime,
-  chatID,
-  messageID,
-  excludeRequestKey = "",
-}) {
+async function findServerRunnerConversationSourceRequestForMessageID({
+  normalizedRoute,
+  runtime,
+  chatID,
+  messageID,
+  canonicalHumanMessageKey = "",
+  excludeRequestKey = "",
+}) {
   const projectID = String(normalizedRoute?.projectID || "").trim();
   const provider = String(normalizedRoute?.provider || "").trim();
-  const normalizedChatID = String(chatID || "").trim();
-  const normalizedMessageID = intFromRawAllowZero(messageID, 0);
-  if (
-    !projectID
-    || !provider
-    || !normalizedChatID
-    || normalizedMessageID <= 0
-    || !runtime?.baseURL
-    || !runtime?.token
-  ) {
+  const normalizedChatID = String(chatID || "").trim();
+  const normalizedMessageID = intFromRawAllowZero(messageID, 0);
+  const normalizedCanonicalHumanMessageKey = String(canonicalHumanMessageKey || "").trim();
+  if (
+    !projectID
+    || !provider
+    || !normalizedChatID
+    || (normalizedMessageID <= 0 && !normalizedCanonicalHumanMessageKey)
+    || !runtime?.baseURL
+    || !runtime?.token
+  ) {
     return null;
   }
   try {
@@ -4352,18 +4392,29 @@ async function findServerRunnerConversationSourceRequestForMessageID({
       limit: 500,
       offset: 0,
     });
-    const matched = serverRequests.filter((entryRaw) => {
-      const entry = safeObject(entryRaw);
-      return (
-        String(entry.project_id || "").trim() === projectID
-        && String(entry.provider || "").trim() === provider
-        && String(entry.chat_id || "").trim() === normalizedChatID
-        && (
-          intFromRawAllowZero(entry.source_message_id, 0) === normalizedMessageID
-          || intFromRawAllowZero(entry.last_source_message_id, 0) === normalizedMessageID
-        )
-      );
-    });
+    const matched = serverRequests.filter((entryRaw) => {
+      const entry = safeObject(entryRaw);
+      const requestCanonicalHumanMessageKey = firstNonEmptyString([
+        entry.canonical_human_message_key,
+        safeObject(entry.source_message_envelope).canonical_human_message_key,
+        buildRunnerCanonicalHumanInboundKey(safeObject(entry.source_message_envelope)),
+      ]);
+      return (
+        String(entry.project_id || "").trim() === projectID
+        && String(entry.provider || "").trim() === provider
+        && String(entry.chat_id || "").trim() === normalizedChatID
+        && (
+          (normalizedCanonicalHumanMessageKey && requestCanonicalHumanMessageKey === normalizedCanonicalHumanMessageKey)
+          || (
+            normalizedMessageID > 0
+            && (
+              intFromRawAllowZero(entry.source_message_id, 0) === normalizedMessageID
+              || intFromRawAllowZero(entry.last_source_message_id, 0) === normalizedMessageID
+            )
+          )
+        )
+      );
+    });
     return pickRunnerSharedConversationSourceRequest(matched, excludeRequestKey);
   } catch {
     return null;
@@ -5026,13 +5077,14 @@ async function claimRunnerRequestForHumanComment({
     runtime,
     archiveThreadID,
   });
-  const replyChainContext = safeObject(replyChainResolution.replyChainContext);
+  const replyChainContext = safeObject(replyChainResolution.replyChainContext);
   const referencedRequest = safeObject(replyChainContext.referencedRequest);
   const resolvedNormalizedIntent = resolveRunnerRequestClaimIntent({
     normalizedIntent,
   });
-  let stateForClaim = safeObject(replyChainResolution.state);
-  const normalizedSharedHumanIntent = safeObject(sharedHumanIntent);
+  const canonicalHumanMessageKey = buildRunnerCanonicalHumanInboundKey(parsed);
+  let stateForClaim = safeObject(replyChainResolution.state);
+  const normalizedSharedHumanIntent = safeObject(sharedHumanIntent);
   const provisionalConversationID = String(
     parsed.conversationID
     || replyChainContext.conversationID
@@ -5067,29 +5119,31 @@ async function claimRunnerRequestForHumanComment({
     };
   }
   const currentMessageID = intFromRawAllowZero(parsed.messageID, 0);
-  let sharedConversationSource = currentMessageID > 0
-    ? pickRunnerSharedConversationSourceRequest(
-      findRunnerRequestsForMessageID(stateForClaim, normalizedRoute, {
-        chatID: String(parsed.chatID || parsed.chatId || "").trim(),
-        messageID: currentMessageID,
-      }),
-      provisionalRequestKey,
-    )
-    : {};
+  let sharedConversationSource = currentMessageID > 0
+    ? pickRunnerSharedConversationSourceRequest(
+      findRunnerRequestsForMessageID(stateForClaim, normalizedRoute, {
+        chatID: String(parsed.chatID || parsed.chatId || "").trim(),
+        messageID: currentMessageID,
+        canonicalHumanMessageKey,
+      }),
+      provisionalRequestKey,
+    )
+    : {};
   if (
     !Object.keys(sharedConversationSource).length
     && currentMessageID > 0
     && runtime?.baseURL
     && runtime?.token
   ) {
-    sharedConversationSource = safeObject(await findServerRunnerConversationSourceRequestForMessageID({
-      normalizedRoute,
-      runtime,
-      chatID: String(parsed.chatID || parsed.chatId || "").trim(),
-      messageID: currentMessageID,
-      excludeRequestKey: provisionalRequestKey,
-    }));
-  }
+    sharedConversationSource = safeObject(await findServerRunnerConversationSourceRequestForMessageID({
+      normalizedRoute,
+      runtime,
+      chatID: String(parsed.chatID || parsed.chatId || "").trim(),
+      messageID: currentMessageID,
+      canonicalHumanMessageKey,
+      excludeRequestKey: provisionalRequestKey,
+    }));
+  }
   const authorityContext = resolveRunnerHumanCommentAuthorityContext({
     normalizedRoute,
     selectedRecord,
@@ -5183,9 +5237,10 @@ async function claimRunnerRequestForHumanComment({
     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_origin: String(sourceMessageEnvelope.source_origin || "").trim().toLowerCase(),
+    source_message_thread_id: intFromRawAllowZero(parsed.messageThreadID, 0) || undefined,
+    source_message_body: String(parsed.body || "").trim(),
+    canonical_human_message_key: canonicalHumanMessageKey,
+    source_message_origin: String(sourceMessageEnvelope.source_origin || "").trim().toLowerCase(),
     source_message_route_key: String(sourceMessageEnvelope.source_route_key || "").trim(),
     source_message_bot_username: normalizeTelegramMentionUsername(sourceMessageEnvelope.source_bot_username),
     source_message_envelope: sourceMessageEnvelope,
@@ -6329,12 +6384,14 @@ function markRunnerRequestLifecycle({
   responseContractValidationStatus = "",
   responseContractValidationReason = "",
   responseContractValidationTargets = [],
-  assignmentValidationStatus = "",
-  assignmentValidationReason = "",
-  assignmentValidationModes = [],
-  deliveryStatus = "",
-  archiveStatus = "",
-  transportError = "",
+  assignmentValidationStatus = "",
+  assignmentValidationReason = "",
+  assignmentValidationModes = [],
+  failureReplyClassification = "",
+  failureFacts = {},
+  deliveryStatus = "",
+  archiveStatus = "",
+  transportError = "",
   archiveError = "",
   lastReplyMessageID = 0,
   lastReplyMessageThreadID = 0,
@@ -6445,6 +6502,8 @@ function markRunnerRequestLifecycle({
     || "",
   ).trim().toLowerCase();
   const normalizedOutcome = String(outcome || "").trim().toLowerCase();
+  const normalizedFailureReplyClassification = String(failureReplyClassification || "").trim().toLowerCase();
+  const normalizedFailureFacts = safeObject(failureFacts);
   const shouldRemainRunningAfterReply = authoritativeDecisionBundle.should_close_after_reply === true
     ? false
     : authoritativeDecisionBundle.should_close_after_reply === false
@@ -6459,6 +6518,18 @@ function markRunnerRequestLifecycle({
       || rootEffectiveNextExpectedResponders.length > 0
       || continuationSelectors.length > 0
     );
+  const shouldRemainRunningAfterError = ["error", "execution_failed"].includes(normalizedOutcome)
+    && (
+      normalizedFailureFacts.retryable === true
+      || normalizedFailureReplyClassification === "retryable_failure"
+    )
+    && authoritativeDecisionBundle.should_close_after_reply !== true
+    && (
+      nextExecutionContractType === "delegation"
+      || rootEffectiveExecutionContractTargets.length > 0
+      || rootEffectiveNextExpectedResponders.length > 0
+      || continuationSelectors.length > 0
+    );
   const nextConversationIntentMode = String(
     authoritativeDecisionBundle.conversation_intent_mode
     || conversationIntentMode
@@ -6495,7 +6566,7 @@ function markRunnerRequestLifecycle({
       || normalizedOutcome === "execution_failed"
       || normalizedOutcome === "policy_violation"
     ) {
-      return "closed";
+      return shouldRemainRunningAfterError ? "running" : "closed";
     }
     return normalizeRunnerRequestStatus(existing.status);
   })();
@@ -19502,12 +19573,13 @@ TELEGRAM_BOT_REVIEW_TOKEN=review-token
     push("runner_tui_frame_renders_route_statuses", false, String(err?.message || err));
   }
 
-  await runSelftestBotCommands(push, {
-    cliPath: fileURLToPath(import.meta.url),
-    parseSimpleEnvText,
-    resolveLocalAIExecutionModel,
-    suggestLocalAIModelDisplayName,
-    resolveGeminiReasoningConfig,
+  await runSelftestBotCommands(push, {
+    cliPath: fileURLToPath(import.meta.url),
+    parseSimpleEnvText,
+    resolveLocalAIExecutionModel,
+    resolveGeminiHeadlessExecutionModel,
+    suggestLocalAIModelDisplayName,
+    resolveGeminiReasoningConfig,
     stripLocalOnlyToolArgs: (requestObj, toolName) =>
       stripLocalOnlyToolArgs(requestObj, toolName),
     applyProxyResponsePatches: (params, deps = buildProxyResponsePipelineDeps()) =>

package/lib/local-ai-adapters.mjs

@@ -19,6 +19,7 @@ const GEMINI_HOME_SYNC_FILES = [
 ];
 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 GEMINI_RUNNER_STABLE_EXECUTION_MODEL = "gemini-3-flash-preview";
 const LOCAL_AI_MODEL_MAPPINGS = {
   gpt: [
     {
@@ -880,7 +881,12 @@ function runLocalAIPromptRawText({
   const normalizedClient = normalizeLocalAIClientName(client);
   const normalizedPermissionMode = normalizeLocalAIPermissionMode(permissionMode);
   const normalizedReasoningEffort = normalizeLocalAIReasoningEffort(reasoningEffort, "low");
-  const resolvedExecutionModel = resolveLocalAIExecutionModel(normalizedClient, model);
+  const resolvedExecutionModel = normalizedClient === "gemini"
+    ? resolveGeminiHeadlessExecutionModel(model, {
+      permissionMode: normalizedPermissionMode,
+      reasoningEffort: normalizedReasoningEffort,
+    })
+    : resolveLocalAIExecutionModel(normalizedClient, model);
   const resolvedWorkspaceDir = ensureWorkspaceDir(workspaceDir);
   const nextEnv = {
     ...process.env,
@@ -1386,6 +1392,23 @@ export function resolveLocalAIExecutionModel(clientName, rawModelValue = "") {
   return match ? String(match.execution || "").trim() : modelValue;
 }
 
+export function resolveGeminiHeadlessExecutionModel(
+  rawModelValue = "",
+  { permissionMode = "read_only", reasoningEffort = "low" } = {},
+) {
+  const resolvedExecutionModel = resolveLocalAIExecutionModel("gemini", rawModelValue);
+  const normalizedExecutionModel = normalizeModelAliasText(resolvedExecutionModel);
+  void normalizeLocalAIPermissionMode(permissionMode);
+  void normalizeLocalAIReasoningEffort(reasoningEffort, "low");
+  if (normalizedExecutionModel !== "auto-gemini-3") {
+    return resolvedExecutionModel;
+  }
+  // Headless runner turns should not depend on Gemini CLI's internal auto-router.
+  // Under heavier prompts it can escalate to capacity-constrained preview models,
+  // which makes one bot path look flaky even though the routing logic is correct.
+  return GEMINI_RUNNER_STABLE_EXECUTION_MODEL;
+}
+
 function buildCodexArgs({ workspaceDir, model, permissionMode, reasoningEffort, outputPath }) {
   const args = ["exec"];
   if (model) {
@@ -1513,7 +1536,10 @@ function buildGeminiThinkingConfig(model, reasoningEffort) {
 }
 
 export function resolveGeminiReasoningConfig(rawModelValue = "", reasoningEffort = "medium") {
-  const executionModel = resolveLocalAIExecutionModel("gemini", rawModelValue);
+  const executionModel = resolveGeminiHeadlessExecutionModel(rawModelValue, {
+    permissionMode: "read_only",
+    reasoningEffort,
+  });
   if (!executionModel) {
     return null;
   }
@@ -3256,7 +3282,12 @@ export function runLocalAIClient({
   const normalizedClient = normalizeLocalAIClientName(client);
   const normalizedPermissionMode = normalizeLocalAIPermissionMode(permissionMode);
   const normalizedReasoningEffort = normalizeLocalAIReasoningEffort(reasoningEffort);
-  const resolvedExecutionModel = resolveLocalAIExecutionModel(normalizedClient, model);
+  const resolvedExecutionModel = normalizedClient === "gemini"
+    ? resolveGeminiHeadlessExecutionModel(model, {
+      permissionMode: normalizedPermissionMode,
+      reasoningEffort: normalizedReasoningEffort,
+    })
+    : resolveLocalAIExecutionModel(normalizedClient, model);
   const resolvedWorkspaceDir = ensureWorkspaceDir(workspaceDir);
   const promptText = buildLocalBotPrompt(inputPayload);
   if (normalizedClient === "sample") {

package/lib/runner-orchestration-failure.mjs

@@ -26,11 +26,14 @@ export function classifyExecutionFailureFacts(detail) {
   const normalizedDetail = String(detail || "").trim();
   const networkReset = /ECONNRESET|socket hang up|read ECONNRESET/i.test(normalizedDetail);
   const networkTimeout = /ETIMEDOUT|http timeout|ECONNABORTED|aborted/i.test(normalizedDetail);
-  const retryable = networkReset || networkTimeout;
+  const providerCapacityExhausted = /MODEL_CAPACITY_EXHAUSTED|RESOURCE_EXHAUSTED|No capacity available for model|rateLimitExceeded/i.test(normalizedDetail);
+  const retryable = networkReset || networkTimeout || providerCapacityExhausted;
   const base = {
     stage: "execution",
     operation: "runner_execution",
-    errorType: retryable
+    errorType: providerCapacityExhausted
+      ? "provider_capacity_exhausted"
+      : retryable
       ? (networkTimeout ? "network_timeout" : "network_reset")
       : "execution_failed",
     retryable,
@@ -42,6 +45,15 @@ export function classifyExecutionFailureFacts(detail) {
   if (!normalizedDetail) {
     return base;
   }
+  if (providerCapacityExhausted) {
+    return {
+      ...base,
+      stage: "provider_call",
+      operation: "local_ai_model_request",
+      errorType: "provider_capacity_exhausted",
+      retryable: true,
+    };
+  }
   if (/permission_mode=read_only|read[_ -]?only/i.test(normalizedDetail)) {
     return {
       ...base,

package/lib/runner-orchestration-visibility.mjs

@@ -1,4 +1,5 @@
 import {
+  buildCanonicalHumanInboundKey,
   buildTelegramMessageEnvelopeFromParsedArchive,
   findRecentTelegramMessageEnvelope,
   isTelegramLocalInboundEnvelopeForRoute,
@@ -27,6 +28,20 @@ function normalizeMentionSelector(value) {
   return String(value || "").trim().replace(/^@+/, "").toLowerCase();
 }
 
+function firstNonEmptyString(values) {
+  for (const value of ensureArray(values)) {
+    const normalized = String(value ?? "").trim();
+    if (normalized) {
+      return normalized;
+    }
+  }
+  return "";
+}
+
+function normalizeCanonicalHumanMessageKey(rawValue) {
+  return String(rawValue || "").trim();
+}
+
 function uniqueOrdered(values) {
   const ordered = [];
   const seen = new Set();
@@ -82,6 +97,15 @@ function doesTelegramEnvelopeMatchMessage(rawEnvelope, {
     && intFromRawAllowZero(envelope.message_id, 0) === normalizedMessageID;
 }
 
+function doesTelegramEnvelopeMatchCanonicalHumanMessage(rawEnvelope, canonicalHumanMessageKey = "") {
+  const normalizedCanonicalHumanMessageKey = normalizeCanonicalHumanMessageKey(canonicalHumanMessageKey);
+  if (!normalizedCanonicalHumanMessageKey) {
+    return false;
+  }
+  const envelope = normalizeTelegramMessageEnvelope(rawEnvelope);
+  return String(envelope.canonical_human_message_key || "").trim() === normalizedCanonicalHumanMessageKey;
+}
+
 function normalizeRunnerRecentLocalInboundReceipt(rawReceipt) {
   const receipt = safeObject(rawReceipt);
   const chatID = String(receipt.chat_id || receipt.chatID || "").trim();
@@ -89,7 +113,7 @@ function normalizeRunnerRecentLocalInboundReceipt(rawReceipt) {
   if (!chatID || !(messageID > 0)) {
     return {};
   }
-  return {
+  const normalized = {
     chat_id: chatID,
     message_id: messageID,
     ...(intFromRawAllowZero(receipt.message_thread_id ?? receipt.messageThreadID, 0) > 0
@@ -107,10 +131,16 @@ function normalizeRunnerRecentLocalInboundReceipt(rawReceipt) {
     ...(normalizeMentionSelector(receipt.sender_username || receipt.senderUsername || "")
       ? { sender_username: normalizeMentionSelector(receipt.sender_username || receipt.senderUsername || "") }
       : {}),
+    ...(String(receipt.sender_id || receipt.senderID || "").trim()
+      ? { sender_id: String(receipt.sender_id || receipt.senderID || "").trim() }
+      : {}),
     sender_is_bot: receipt.sender_is_bot === true || receipt.senderIsBot === true,
     ...(String(receipt.body || "").trim()
       ? { body: String(receipt.body || "").trim() }
       : {}),
+    ...(String(receipt.occurred_at || receipt.occurredAt || "").trim()
+      ? { occurred_at: String(receipt.occurred_at || receipt.occurredAt || "").trim() }
+      : {}),
     ...(String(receipt.receipt_origin || receipt.receiptOrigin || "").trim()
       ? { receipt_origin: String(receipt.receipt_origin || receipt.receiptOrigin || "").trim().toLowerCase() }
       : {}),
@@ -121,16 +151,59 @@ function normalizeRunnerRecentLocalInboundReceipt(rawReceipt) {
       ? { receipt_bot_username: normalizeMentionSelector(receipt.receipt_bot_username || receipt.receiptBotUsername || "") }
       : {}),
   };
+  const canonicalHumanMessageKey = buildCanonicalHumanInboundKey({
+    chat_id: normalized.chat_id,
+    message_id: normalized.message_id,
+    message_thread_id: normalized.message_thread_id,
+    reply_to_message_id: normalized.reply_to_message_id,
+    kind: normalized.kind,
+    sender_id: normalized.sender_id,
+    sender_username: normalized.sender_username,
+    sender_is_bot: normalized.sender_is_bot === true,
+    body: normalized.body,
+    occurred_at: normalized.occurred_at,
+    canonical_human_message_key: firstNonEmptyString([
+      receipt.canonical_human_message_key,
+      receipt.canonicalHumanMessageKey,
+    ]),
+  });
+  if (canonicalHumanMessageKey) {
+    normalized.canonical_human_message_key = canonicalHumanMessageKey;
+  }
+  return normalized;
 }
 
-function findRecentTelegramInboundReceipt(rawMap, { chatID = "", messageID = 0 } = {}) {
+function findRecentTelegramInboundReceipt(rawMap, {
+  chatID = "",
+  messageID = 0,
+  canonicalHumanMessageKey = "",
+} = {}) {
   const normalizedChatID = String(chatID || "").trim();
   const normalizedMessageID = intFromRawAllowZero(messageID, 0);
-  if (!normalizedChatID || !(normalizedMessageID > 0)) {
+  const normalizedCanonicalHumanMessageKey = normalizeCanonicalHumanMessageKey(canonicalHumanMessageKey);
+  if (!normalizedChatID || (!(normalizedMessageID > 0) && !normalizedCanonicalHumanMessageKey)) {
+    return {};
+  }
+  if (normalizedMessageID > 0) {
+    const key = `${normalizedChatID}:${normalizedMessageID}`;
+    const exactReceipt = normalizeRunnerRecentLocalInboundReceipt(safeObject(safeObject(rawMap)[key]));
+    if (Object.keys(exactReceipt).length > 0) {
+      return exactReceipt;
+    }
+  }
+  if (!normalizedCanonicalHumanMessageKey) {
     return {};
   }
-  const key = `${normalizedChatID}:${normalizedMessageID}`;
-  return normalizeRunnerRecentLocalInboundReceipt(safeObject(safeObject(rawMap)[key]));
+  for (const value of Object.values(safeObject(rawMap))) {
+    const normalizedReceipt = normalizeRunnerRecentLocalInboundReceipt(value);
+    if (
+      String(normalizedReceipt.chat_id || "").trim() === normalizedChatID
+      && String(normalizedReceipt.canonical_human_message_key || "").trim() === normalizedCanonicalHumanMessageKey
+    ) {
+      return normalizedReceipt;
+    }
+  }
+  return {};
 }
 
 function buildTelegramMessageEnvelopeFromRecentReceipt(rawReceipt) {
@@ -154,6 +227,35 @@ function buildTelegramMessageEnvelopeFromRecentReceipt(rawReceipt) {
   });
 }
 
+function findRecentTelegramMessageEnvelopeWithCanonicalFallback(rawMap, {
+  chatID = "",
+  messageID = 0,
+  canonicalHumanMessageKey = "",
+} = {}) {
+  const exactEnvelope = findRecentTelegramMessageEnvelope(rawMap, {
+    chatID,
+    messageID,
+  });
+  if (Object.keys(safeObject(exactEnvelope)).length > 0) {
+    return exactEnvelope;
+  }
+  const normalizedChatID = String(chatID || "").trim();
+  const normalizedCanonicalHumanMessageKey = normalizeCanonicalHumanMessageKey(canonicalHumanMessageKey);
+  if (!normalizedChatID || !normalizedCanonicalHumanMessageKey) {
+    return {};
+  }
+  for (const rawEnvelope of Object.values(safeObject(rawMap))) {
+    const normalizedEnvelope = normalizeTelegramMessageEnvelope(rawEnvelope);
+    if (
+      String(normalizedEnvelope.chat_id || "").trim() === normalizedChatID
+      && String(normalizedEnvelope.canonical_human_message_key || "").trim() === normalizedCanonicalHumanMessageKey
+    ) {
+      return normalizedEnvelope;
+    }
+  }
+  return {};
+}
+
 function resolveRunnerTelegramSourceEnvelopeCandidates({
   routeState,
   persistedRequest,
@@ -173,19 +275,26 @@ function resolveRunnerTelegramSourceEnvelopeCandidates({
     archivedSourceEnvelope.message_id || archiveEnvelope.message_id,
     0,
   );
+  const archiveCanonicalHumanMessageKey = firstNonEmptyString([
+    archivedSourceEnvelope.canonical_human_message_key,
+    archiveEnvelope.canonical_human_message_key,
+    buildCanonicalHumanInboundKey(selectedRecord?.parsedArchive),
+  ]);
   const routeLocalReceipt = findRecentTelegramInboundReceipt(
     safeObject(routeState).recent_local_inbound_receipts,
     {
       chatID: archiveChatID,
       messageID: archiveMessageID,
+      canonicalHumanMessageKey: archiveCanonicalHumanMessageKey,
     },
   );
   const routeLocalReceiptEnvelope = buildTelegramMessageEnvelopeFromRecentReceipt(routeLocalReceipt);
-  const routeLocalEnvelope = findRecentTelegramMessageEnvelope(
+  const routeLocalEnvelope = findRecentTelegramMessageEnvelopeWithCanonicalFallback(
     safeObject(routeState).recent_local_inbound_envelopes,
     {
       chatID: archiveChatID,
       messageID: archiveMessageID,
+      canonicalHumanMessageKey: archiveCanonicalHumanMessageKey,
     },
   );
   const persistedSourceEnvelope = normalizeTelegramMessageEnvelope(
@@ -197,6 +306,7 @@ function resolveRunnerTelegramSourceEnvelopeCandidates({
     archiveEnvelope,
     archiveChatID,
     archiveMessageID,
+    archiveCanonicalHumanMessageKey,
     routeLocalReceipt,
     routeLocalReceiptEnvelope,
     routeLocalEnvelope,
@@ -222,6 +332,7 @@ function resolveRunnerLocalSourceEnvelopeForRoute({
     archivedSourceEnvelope,
     archiveChatID,
     archiveMessageID,
+    archiveCanonicalHumanMessageKey,
     routeLocalReceiptEnvelope,
     routeLocalEnvelope,
     persistedSourceEnvelope,
@@ -251,10 +362,16 @@ function resolveRunnerLocalSourceEnvelopeForRoute({
       routeKey,
       botUsername: currentBotSelector,
     })
-    && doesTelegramEnvelopeMatchMessage(persistedSourceEnvelope, {
-      chatID: archiveChatID,
-      messageID: archiveMessageID,
-    })
+    && (
+      doesTelegramEnvelopeMatchMessage(persistedSourceEnvelope, {
+        chatID: archiveChatID,
+        messageID: archiveMessageID,
+      })
+      || doesTelegramEnvelopeMatchCanonicalHumanMessage(
+        persistedSourceEnvelope,
+        archiveCanonicalHumanMessageKey,
+      )
+    )
   ) {
     return {
       envelope: persistedSourceEnvelope,
@@ -267,10 +384,16 @@ function resolveRunnerLocalSourceEnvelopeForRoute({
       routeKey,
       botUsername: currentBotSelector,
     })
-    && doesTelegramEnvelopeMatchMessage(archivedSourceEnvelope, {
-      chatID: archiveChatID,
-      messageID: archiveMessageID,
-    })
+    && (
+      doesTelegramEnvelopeMatchMessage(archivedSourceEnvelope, {
+        chatID: archiveChatID,
+        messageID: archiveMessageID,
+      })
+      || doesTelegramEnvelopeMatchCanonicalHumanMessage(
+        archivedSourceEnvelope,
+        archiveCanonicalHumanMessageKey,
+      )
+    )
   ) {
     return {
       envelope: archivedSourceEnvelope,
@@ -289,14 +412,21 @@ function hasForeignRouteLocalEnvelopeForMessage({
   envelopes,
   archiveChatID,
   archiveMessageID,
+  archiveCanonicalHumanMessageKey,
   routeKey,
   currentBotSelector,
 }) {
   return ensureArray(envelopes).some((rawEnvelope) => (
-    doesTelegramEnvelopeMatchMessage(rawEnvelope, {
-      chatID: archiveChatID,
-      messageID: archiveMessageID,
-    })
+    (
+      doesTelegramEnvelopeMatchMessage(rawEnvelope, {
+        chatID: archiveChatID,
+        messageID: archiveMessageID,
+      })
+      || doesTelegramEnvelopeMatchCanonicalHumanMessage(
+        rawEnvelope,
+        archiveCanonicalHumanMessageKey,
+      )
+    )
     && String(safeObject(normalizeTelegramMessageEnvelope(rawEnvelope)).source_origin || "").trim().toLowerCase() === "local_telegram_inbound"
     && !isTelegramLocalInboundEnvelopeForRoute(rawEnvelope, {
       routeKey,
@@ -352,6 +482,7 @@ function resolveRunnerReceiptBackedHumanInboundVisibility({
     archivedSourceEnvelope,
     archiveChatID,
     archiveMessageID,
+    archiveCanonicalHumanMessageKey,
     routeLocalReceipt,
     persistedSourceEnvelope,
   } = safeObject(localMatch.candidates);
@@ -367,6 +498,7 @@ function resolveRunnerReceiptBackedHumanInboundVisibility({
     envelopes: [persistedSourceEnvelope, archivedSourceEnvelope],
     archiveChatID,
     archiveMessageID,
+    archiveCanonicalHumanMessageKey,
     routeKey,
     currentBotSelector,
   });
@@ -413,6 +545,7 @@ function buildRunnerDiagnosticTraceSummary({
     archivedSourceEnvelope,
     archiveChatID,
     archiveMessageID,
+    archiveCanonicalHumanMessageKey,
     persistedSourceEnvelope,
     routeLocalEnvelope,
     routeLocalReceipt,
@@ -436,6 +569,7 @@ function buildRunnerDiagnosticTraceSummary({
     envelopes: [persistedSourceEnvelope, archivedSourceEnvelope],
     archiveChatID,
     archiveMessageID,
+    archiveCanonicalHumanMessageKey,
     routeKey,
     currentBotSelector,
   });

package/lib/runner-recorder-lifecycle-handoff.mjs

@@ -88,6 +88,7 @@ export function buildRunnerProcessedLifecycleInput({
   const processed = safeObject(processedRaw);
   const result = safeObject(processed.result);
   const normalizedOutcome = normalizeRunnerProcessedLifecycleOutcome(processed);
+  const normalizedFailureFacts = safeObject(result.failure_facts);
   return {
     requestKey,
     selectedRecord,
@@ -95,6 +96,8 @@ export function buildRunnerProcessedLifecycleInput({
     outcome: normalizedOutcome,
     closedReason: normalizedOutcome === "skipped"
       ? String(processed.skippedRecord?.reason || result.detail || "skipped").trim() || "skipped"
+      : ["error", "execution_failed", "policy_violation"].includes(normalizedOutcome)
+        ? String(result.detail || "execution_error").trim() || "execution_error"
       : "",
     conversationIDRaw: String(result.conversation_id || "").trim(),
     conversationParticipants: ensureArray(result.conversation_participants),
@@ -126,6 +129,8 @@ export function buildRunnerProcessedLifecycleInput({
     assignmentValidationStatus: String(result.assignment_validation_status || "").trim(),
     assignmentValidationReason: String(result.assignment_validation_reason || "").trim(),
     assignmentValidationModes: ensureArray(result.assignment_validation_modes),
+    failureReplyClassification: String(result.failure_reply_classification || "").trim(),
+    failureFacts: normalizedFailureFacts,
     deliveryStatus: String(result.delivery_status || "").trim(),
     archiveStatus: String(result.archive_status || "").trim(),
     transportError: String(result.transport_error || "").trim(),

package/lib/runner-runtime.mjs

@@ -528,6 +528,27 @@ function normalizeRunnerRecentLocalInboundReceipt(rawReceipt, fallbackKey = "")
   if (chatTitle) {
     normalized.chat_title = chatTitle;
   }
+  const canonicalHumanMessageKey = String(
+    safeObject(normalizeTelegramMessageEnvelope({
+      chat_id: normalized.chat_id,
+      message_id: normalized.message_id,
+      message_thread_id: normalized.message_thread_id,
+      reply_to_message_id: normalized.reply_to_message_id,
+      kind: normalized.kind,
+      sender_id: normalized.sender_id,
+      sender_username: normalized.sender_username,
+      sender_is_bot: normalized.sender_is_bot === true,
+      body: normalized.body,
+      occurred_at: normalized.occurred_at,
+      canonical_human_message_key: firstNonEmptyString([
+        receipt.canonical_human_message_key,
+        receipt.canonicalHumanMessageKey,
+      ]),
+    })).canonical_human_message_key || "",
+  ).trim();
+  if (canonicalHumanMessageKey) {
+    normalized.canonical_human_message_key = canonicalHumanMessageKey;
+  }
   return [receiptKey, normalized];
 }
 

package/lib/selftest-bot-commands.mjs

@@ -361,6 +361,7 @@ export async function runSelftestBotCommands(push, deps) {
   const cliPath = String(requireDependency(deps, "cliPath") || "").trim();
   const parseSimpleEnvText = requireDependency(deps, "parseSimpleEnvText");
   const resolveLocalAIExecutionModel = requireDependency(deps, "resolveLocalAIExecutionModel");
+  const resolveGeminiHeadlessExecutionModel = requireDependency(deps, "resolveGeminiHeadlessExecutionModel");
   const suggestLocalAIModelDisplayName = requireDependency(deps, "suggestLocalAIModelDisplayName");
   const resolveGeminiReasoningConfig = requireDependency(deps, "resolveGeminiReasoningConfig");
   const stripLocalOnlyToolArgs = requireDependency(deps, "stripLocalOnlyToolArgs");
@@ -392,6 +393,18 @@ export async function runSelftestBotCommands(push, deps) {
       ].join(" "),
     );
 
+    push(
+      "gemini_headless_runner_uses_explicit_stable_execution_model",
+      resolveGeminiHeadlessExecutionModel("gemini-3.1-pro", {
+        permissionMode: "read_only",
+        reasoningEffort: "low",
+      }) === "gemini-3-flash-preview",
+      `gemini_headless=${resolveGeminiHeadlessExecutionModel("gemini-3.1-pro", {
+        permissionMode: "read_only",
+        reasoningEffort: "low",
+      })}`,
+    );
+
     push(
       "blank_model_defaults_to_first_display_model_for_each_client",
       suggestLocalAIModelDisplayName("gpt", "") === "gpt-5.4"
@@ -409,7 +422,7 @@ export async function runSelftestBotCommands(push, deps) {
     const geminiHighReasoning = resolveGeminiReasoningConfig("gemini-3.1-pro", "high");
     push(
       "gemini_reasoning_effort_maps_to_runtime_settings_override",
-      String(geminiLowReasoning?.model || "") === "auto-gemini-3"
+      String(geminiLowReasoning?.model || "") === "gemini-3-flash-preview"
         && String(safeObject(geminiLowReasoning?.thinkingConfig).thinkingLevel || "") === "LOW"
         && String(safeObject(geminiMediumReasoning?.thinkingConfig).thinkingLevel || "") === "THINKING_LEVEL_UNSPECIFIED"
         && String(safeObject(geminiHighReasoning?.thinkingConfig).thinkingLevel || "") === "HIGH",

package/lib/selftest-runner-scenarios.mjs

@@ -2303,20 +2303,31 @@ export async function runSelftestRunnerScenarios(push, deps) {
       },
     });
     const sharedHumanState = loadBotRunnerState();
-    const sharedHumanRequestCount = Object.values(safeObject(sharedHumanState.requests))
+    const sharedHumanRequests = Object.values(safeObject(sharedHumanState.requests))
       .filter((entryRaw) => {
         const entry = safeObject(entryRaw);
         return String(entry.chat_id || "") === "-100123"
           && String(entry.source_message_body || "") === sharedHumanBody;
-      })
-      .length;
+      });
+    const sharedHumanRequestCount = sharedHumanRequests.length;
+    const sharedHumanCanonicalKey = buildArchivedInboundMessageKey({
+      chatID: "-100123",
+      messageID: 1189,
+      messageThreadID: 0,
+      kind: "telegram_message",
+      senderID: "7001",
+      senderIsBot: false,
+      occurredAt: "2026-04-01T06:00:00.000Z",
+      body: sharedHumanBody,
+    }).replace(/^human:/, "");
     push(
       "runner_human_opening_request_identity_is_canonical_across_routes",
       sharedHumanClaimPrimary.ok === true
         && (sharedHumanClaimPeer.ok === true || String(sharedHumanClaimPeer.reason || "") === "request_already_claimed")
         && String(sharedHumanClaimPrimary.requestKey || "") === String(sharedHumanClaimPeer.requestKey || "")
-        && sharedHumanRequestCount === 1,
-      `primary=${String(sharedHumanClaimPrimary.requestKey || "(none)")} peer=${String(sharedHumanClaimPeer.requestKey || "(none)")} peer_reason=${String(sharedHumanClaimPeer.reason || "(none)")} count=${sharedHumanRequestCount}`,
+        && sharedHumanRequestCount === 1
+        && String(safeObject(sharedHumanRequests[0]).canonical_human_message_key || "") === sharedHumanCanonicalKey,
+      `primary=${String(sharedHumanClaimPrimary.requestKey || "(none)")} peer=${String(sharedHumanClaimPeer.requestKey || "(none)")} peer_reason=${String(sharedHumanClaimPeer.reason || "(none)")} count=${sharedHumanRequestCount} canonical=${String(safeObject(sharedHumanRequests[0]).canonical_human_message_key || "(none)")}`,
     );
 
     const rootTaskRecord = {
@@ -3234,6 +3245,73 @@ export async function runSelftestRunnerScenarios(push, deps) {
       `status=${String(failedRequest?.status || "(none)")} reason=${String(failedRequest?.closed_reason || "(none)")} closed_at=${String(failedRequest?.closed_at || "(none)")}`,
     );
 
+    saveBotRunnerState({
+      routes: {
+        [requestRouteKey]: {},
+      },
+      sharedInboxes: {},
+      excludedComments: {},
+      requests: {
+        "request-key-2f": {
+          request_key: "request-key-2f",
+          project_id: selftestProjectID,
+          provider: "telegram",
+          chat_id: "-100123",
+          source_message_id: 751,
+          conversation_id: "conv-request-2f",
+          execution_contract_type: "delegation",
+          execution_contract_targets: ["ryoai3_bot"],
+          next_expected_responders: ["ryoai3_bot"],
+          authoritative_decision_bundle: {
+            schema_version: "runner_conversation_decision.v1",
+            decision_type: "reply_outcome",
+            conversation_intent_mode: "delegated_single_lead",
+            allowed_responders: ["ryoai_bot", "ryoai2_bot", "ryoai3_bot"],
+            initial_responders: ["ryoai_bot"],
+            selected_bot_usernames: ["ryoai2_bot"],
+            allow_bot_to_bot: true,
+            execution_contract_type: "delegation",
+            execution_contract_targets: ["ryoai3_bot"],
+            next_expected_responders: ["ryoai3_bot"],
+            should_close_after_reply: false,
+          },
+          decision_bundle_validation_status: "valid",
+          status: "running",
+          claimed_by_route: requestRouteKey,
+        },
+      },
+      consumedComments: {},
+    });
+    const retryableFailedDelegation = markRunnerRequestLifecycle({
+      normalizedRoute: requestRoute,
+      requestKey: "request-key-2f",
+      selectedRecord: {
+        id: "comment-request-finish-2f",
+        parsedArchive: {
+          kind: "bot_reply",
+          chatID: "-100123",
+          messageID: 752,
+          conversationID: "conv-request-2f",
+        },
+      },
+      routeKey: requestRouteKey,
+      outcome: "error",
+      closedReason: "Gemini CLI timed out after 90s while waiting for a model response (No capacity available for model gemini-3.1-pro-preview on the server)",
+      currentBotSelector: "@RyoAI2_bot",
+      failureReplyClassification: "retryable_failure",
+      failureFacts: {
+        retryable: true,
+        error_type: "provider_capacity_exhausted",
+      },
+    });
+    push(
+      "runner_request_lifecycle_retryable_delegated_error_stays_running",
+      String(retryableFailedDelegation?.status || "") === "running"
+        && ensureArray(retryableFailedDelegation?.next_expected_responders).includes("ryoai3_bot")
+        && String(retryableFailedDelegation?.closed_reason || "").trim() === "",
+      `status=${String(retryableFailedDelegation?.status || "(none)")} next=${ensureArray(retryableFailedDelegation?.next_expected_responders).join(",")} closed_reason=${String(retryableFailedDelegation?.closed_reason || "(none)")}`,
+    );
+
     saveBotRunnerState({
       routes: {
         [requestRouteKey]: {},
@@ -16534,6 +16612,97 @@ export async function runSelftestRunnerScenarios(push, deps) {
     }
   }
 
+  try {
+    const canonicalVisibility = resolveRunnerHumanInboundVisibility({
+      routeState: {
+        recent_local_inbound_envelopes: {},
+        recent_local_inbound_receipts: {
+          "-100123:5201": {
+            chat_id: "-100123",
+            message_id: 5201,
+            sender_id: "7001",
+            body: "@ryoai_bot canonical hello",
+            occurred_at: "2026-04-02T00:00:00.000Z",
+            receipt_origin: "local_telegram_inbound",
+            receipt_route_key: "telegram-monitor-canonical-owner::project::telegram::monitor::dest::actor",
+            receipt_bot_username: "ryoai_bot",
+            received_at: "2026-04-02T00:00:01.000Z",
+          },
+        },
+      },
+      persistedRequest: null,
+      selectedRecord: {
+        id: "comment-canonical-visibility-1",
+        parsedArchive: {
+          kind: "telegram_message",
+          chatID: "-100123",
+          chatType: "supergroup",
+          body: "@ryoai_bot canonical hello",
+          messageID: 6301,
+          senderID: "7001",
+          senderIsBot: false,
+          occurredAt: "2026-04-02T00:00:00.000Z",
+          mentionUsernames: ["ryoai_bot"],
+        },
+      },
+      routeKey: "telegram-monitor-canonical-owner::project::telegram::monitor::dest::actor",
+      currentBotSelector: "ryoai_bot",
+      triggerDecision: {
+        shouldRespond: true,
+        triggerEligible: true,
+        candidateHintOnly: true,
+        trigger: "mention",
+        reason: "canonical receipt-backed mention trigger",
+        candidateBotUsernames: ["ryoai_bot"],
+      },
+    });
+    const canonicalSourceEnvelope = resolveRunnerDeliverySourceMessageEnvelope({
+      routeState: {
+        recent_local_inbound_envelopes: {},
+        recent_local_inbound_receipts: {
+          "-100123:5201": {
+            chat_id: "-100123",
+            message_id: 5201,
+            sender_id: "7001",
+            body: "@ryoai_bot canonical hello",
+            occurred_at: "2026-04-02T00:00:00.000Z",
+            receipt_origin: "local_telegram_inbound",
+            receipt_route_key: "telegram-monitor-canonical-owner::project::telegram::monitor::dest::actor",
+            receipt_bot_username: "ryoai_bot",
+            received_at: "2026-04-02T00:00:01.000Z",
+          },
+        },
+      },
+      persistedRequest: null,
+      selectedRecord: {
+        id: "comment-canonical-visibility-1",
+        parsedArchive: {
+          kind: "telegram_message",
+          chatID: "-100123",
+          chatType: "supergroup",
+          body: "@ryoai_bot canonical hello",
+          messageID: 6301,
+          senderID: "7001",
+          senderIsBot: false,
+          occurredAt: "2026-04-02T00:00:00.000Z",
+          mentionUsernames: ["ryoai_bot"],
+        },
+      },
+      routeKey: "telegram-monitor-canonical-owner::project::telegram::monitor::dest::actor",
+      currentBotSelector: "ryoai_bot",
+    });
+    push(
+      "runner_visibility_receipt_backed_human_opening_matches_canonical_key_across_route_local_copies",
+      canonicalVisibility.applies === true
+        && canonicalVisibility.executable === true
+        && String(canonicalVisibility.visibilitySource || "") === "route_local_inbound_receipt"
+        && Number(safeObject(canonicalSourceEnvelope).message_id || 0) === 5201,
+      `mode=${String(canonicalVisibility.visibilityMode || "(none)")} status=${String(canonicalVisibility.visibilityStatus || "(none)")} source=${String(canonicalVisibility.visibilitySource || "(none)")} reply_message_id=${String(safeObject(canonicalSourceEnvelope).message_id || "(none)")}`,
+    );
+  } catch (err) {
+    push("runner_visibility_receipt_backed_human_opening_matches_canonical_key_across_route_local_copies", false, String(err?.message || err));
+  }
+
   for (const [testName, triggerKind, messageID] of [
     [
       "runner_visibility_receipt_first_mention_without_exact_receipt_is_blocked",

package/package.json

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