metheus-governance-mcp-cli 0.2.261 → 0.2.263

package/cli.mjs

@@ -13302,21 +13302,27 @@ async function maybeDeliverRunnerExecutionFailureAfterRecord({
 
 async function finalizeRunnerDeferredExecutionProcessed(deferredExecution, processed) {
   if (String(deferredExecution?.requestKey || "").trim()) {
-    const resolvedIntentType = String(
-      safeObject(loadBotRunnerState().routes[deferredExecution.routeKey]).last_intent_type || "",
-    ).trim();
-    markRunnerRequestLifecycle({
-      normalizedRoute: deferredExecution.normalizedRoute,
-      requestKey: deferredExecution.requestKey,
-      selectedRecord: deferredExecution.selectedRecord,
-      routeKey: deferredExecution.routeKey,
-      outcome: processed.kind === "delivery_failed"
-        ? "delivery_failed_after_generation"
-        : String(processed.result?.outcome || "replied").trim().toLowerCase(),
-      conversationIDRaw: String(processed.result?.conversation_id || "").trim(),
-      conversationParticipants: ensureArray(processed.result?.conversation_participants),
-      conversationInitialResponders: ensureArray(processed.result?.conversation_initial_responders),
-      allowedResponders: ensureArray(processed.result?.conversation_allowed_responders),
+    const resolvedIntentType = String(
+      safeObject(loadBotRunnerState().routes[deferredExecution.routeKey]).last_intent_type || "",
+    ).trim();
+    const normalizedDeferredOutcome = processed.kind === "delivery_failed"
+      ? "delivery_failed_after_generation"
+      : processed.kind === "skipped"
+        ? "skipped"
+        : String(processed.result?.outcome || "replied").trim().toLowerCase();
+    markRunnerRequestLifecycle({
+      normalizedRoute: deferredExecution.normalizedRoute,
+      requestKey: deferredExecution.requestKey,
+      selectedRecord: deferredExecution.selectedRecord,
+      routeKey: deferredExecution.routeKey,
+      outcome: normalizedDeferredOutcome,
+      closedReason: processed.kind === "skipped"
+        ? String(processed.skippedRecord?.reason || processed.result?.detail || "skipped").trim()
+        : "",
+      conversationIDRaw: String(processed.result?.conversation_id || "").trim(),
+      conversationParticipants: ensureArray(processed.result?.conversation_participants),
+      conversationInitialResponders: ensureArray(processed.result?.conversation_initial_responders),
+      allowedResponders: ensureArray(processed.result?.conversation_allowed_responders),
       conversationLeadBot: String(processed.result?.conversation_lead_bot || "").trim(),
       conversationSummaryBot: String(processed.result?.conversation_summary_bot || "").trim(),
       conversationAllowBotToBot: processed.result?.conversation_allow_bot_to_bot === true,
@@ -13349,17 +13355,17 @@ async function finalizeRunnerDeferredExecutionProcessed(deferredExecution, proce
       lastReplyMessageID: intFromRawAllowZero(processed.result?.last_reply_message_id, 0),
       lastReplyMessageThreadID: intFromRawAllowZero(processed.result?.last_reply_message_thread_id, 0),
       replyToMessageID: intFromRawAllowZero(processed.result?.reply_to_message_id, 0),
-      replyFallbackUsed: processed.result?.reply_fallback_used === true,
-      authoritativeSourceMessageEnvelope: safeObject(
-        safeObject(deferredExecution.humanInboundVisibility).sourceMessageEnvelope,
-      ),
-    });
-    if (processed.kind !== "delivery_failed") {
-      await ensureRunnerRootWorkItemForRequest({
-        normalizedRoute: deferredExecution.normalizedRoute,
-        routeKey: deferredExecution.routeKey,
-        selectedRecord: deferredExecution.selectedRecord,
-        runtime: deferredExecution.runtime,
+      replyFallbackUsed: processed.result?.reply_fallback_used === true,
+      authoritativeSourceMessageEnvelope: safeObject(
+        safeObject(deferredExecution.humanInboundVisibility).sourceMessageEnvelope,
+      ),
+    });
+    if (processed.kind !== "delivery_failed" && processed.kind !== "skipped") {
+      await ensureRunnerRootWorkItemForRequest({
+        normalizedRoute: deferredExecution.normalizedRoute,
+        routeKey: deferredExecution.routeKey,
+        selectedRecord: deferredExecution.selectedRecord,
+        runtime: deferredExecution.runtime,
         requestKey: deferredExecution.requestKey,
       });
     }

package/lib/runner-delivery.mjs

@@ -187,6 +187,17 @@ function assertLocalTelegramReplyAnchor({
   }
 }
 
+function buildLocalDeliveryError(message, code, extra = {}) {
+  const error = new Error(message);
+  error.code = String(code || "").trim();
+  Object.assign(error, safeObject(extra));
+  return error;
+}
+
+function isTelegramReplyTargetMissingError(detail) {
+  return /message to be replied not found/i.test(String(detail || ""));
+}
+
 function throwLocalDeliveryFailure({
   provider,
   delivery,
@@ -198,6 +209,17 @@ function throwLocalDeliveryFailure({
   const errorDetail =
     String(responseJSON.description || responseJSON.error || JSON.stringify(delivery.body || "")).trim()
     || `${normalizedProvider} api status ${delivery.statusCode}`;
+  if (normalizedProvider === "telegram" && isTelegramReplyTargetMissingError(errorDetail)) {
+    throw buildLocalDeliveryError(
+      `local ${normalizedProvider} delivery skipped stale reply anchor (${errorDetail})`,
+      "TELEGRAM_STALE_REPLY_ANCHOR",
+      {
+        staleReplyAnchor: true,
+        provider: normalizedProvider,
+        detail: errorDetail,
+      },
+    );
+  }
   if (delivery.statusCode === 401 || /unauthorized|invalid_auth/i.test(errorDetail)) {
     throw new Error(
       `local ${normalizedProvider} delivery failed (Unauthorized). Check ${String(providerEnv.tokenKey || providerEnvConfig(normalizedProvider).tokenKey)} in ${providerEnv.filePath}`,

package/lib/runner-orchestration.mjs

@@ -7362,6 +7362,91 @@ export async function processRunnerSelectedRecord({
     });
   } catch (err) {
     const transportError = String(err?.message || err).trim() || "delivery_failed";
+    const staleReplyAnchor = err?.staleReplyAnchor === true
+      || String(err?.code || "").trim() === "TELEGRAM_STALE_REPLY_ANCHOR";
+    if (staleReplyAnchor) {
+      saveRunnerRouteState(
+        routeKey,
+        buildRunnerRouteStateFromComment(selectedRecord, {
+          last_action: "stale_reply_anchor_skipped",
+          last_reason: transportError,
+          last_trigger: String(effectiveTriggerDecision.trigger || "").trim(),
+          last_conversation_id: String(effectiveConversationContext?.id || "").trim(),
+          last_conversation_stage: String(effectiveConversationContext?.stage || "").trim(),
+          last_contract_validation_status: String(responseContractValidation.status || "").trim(),
+          last_contract_validation_reason: String(responseContractValidation.reason || "").trim(),
+          last_contract_validation_targets: ensureArray(responseContractValidation.targets),
+          last_assignment_validation_status: String(assignmentExecutionValidation.status || "").trim(),
+          last_assignment_validation_reason: String(assignmentExecutionValidation.reason || "").trim(),
+          last_speaker_bot_username: normalizeMentionSelector(bot?.username || bot?.name),
+          last_workspace_dir: String(effectiveExecutionPlan.workspaceDir || "").trim(),
+          ...responderStatePatch,
+          ...intentStatePatch,
+          ...visibilityStatePatch,
+        }),
+      );
+      return {
+        kind: "skipped",
+        skippedRecord: {
+          id: selectedRecord.id,
+          reason: "stale_reply_anchor",
+          messageID: intFromRawAllowZero(selectedRecord?.parsedArchive?.messageID, 0),
+          diagnosticType: "delivery",
+        },
+        result: {
+          route_key: routeKey,
+          route_name: normalizedRoute.name,
+          outcome: "skipped",
+          detail: `skipped stale reply anchor (${transportError})`,
+          thread_id: archiveThread.threadID,
+          comment_id: selectedRecord.id,
+          trigger_kind: String(effectiveTriggerDecision.trigger || "").trim(),
+          conversation_id: String(effectiveConversationContext?.id || "").trim(),
+          conversation_stage: String(effectiveConversationContext?.stage || "").trim(),
+          conversation_intent_mode: String(effectiveConversationContext?.intentMode || "").trim(),
+          conversation_lead_bot: String(effectiveConversationContext?.leadBotUsername || "").trim(),
+          conversation_summary_bot: String(effectiveConversationContext?.summaryBotUsername || "").trim(),
+          conversation_participants: ensureArray(effectiveConversationContext?.participantSelectors),
+          conversation_initial_responders: ensureArray(effectiveConversationContext?.initialResponderSelectors),
+          conversation_allowed_responders: ensureArray(effectiveConversationContext?.allowedResponderSelectors),
+          conversation_allow_bot_to_bot: effectiveConversationContext?.allowBotToBot === true,
+          conversation_reply_expectation: String(effectiveConversationContext?.replyExpectation || "").trim(),
+          execution_contract_type: String(executionContract?.type || "").trim(),
+          execution_contract_actionable: executionContract?.actionable === true,
+          execution_contract_targets: ensureArray(executionContract?.assignments).map((item) => normalizeMentionSelector(item.targetBot)).filter(Boolean),
+          next_expected_responders: collectExecutionContractNextResponders(executionContract),
+          normalized_execution_contract_type: normalizedExecutionContractType,
+          normalized_execution_contract_targets: normalizedExecutionTargets,
+          normalized_execution_next_responders: normalizedExecutionNextResponders,
+          artifact_validation: String(artifactValidation.status || "").trim() || "none",
+          artifact_paths: summarizeValidatedArtifactPaths(artifactValidation),
+          ai_reply_generated: true,
+          ai_reply_generated_at: aiReplyGeneratedAt,
+          ai_reply_preview: aiReplyPreview,
+          source_message_envelope: sourceMessageEnvelope,
+          attempted_delivery_envelope: attemptedDeliveryEnvelope,
+          visibility_status: String(humanInboundVisibility.visibilityStatus || "").trim(),
+          visibility_reason: String(humanInboundVisibility.visibilityReason || "").trim(),
+          visibility_source: String(humanInboundVisibility.visibilitySource || "").trim(),
+          reply_to_message_id: replyToMessageID,
+          reply_message_thread_id: replyMessageThreadID,
+          delivery_status: "skipped_stale_reply_anchor",
+          archive_status: "not_attempted",
+          transport_error: transportError,
+          archive_error: "",
+          response_contract_validation_status: String(responseContractValidation.status || "").trim(),
+          response_contract_validation_reason: String(responseContractValidation.reason || "").trim(),
+          response_contract_validation_targets: ensureArray(responseContractValidation.targets),
+          assignment_validation_status: String(assignmentExecutionValidation.status || "").trim(),
+          assignment_validation_reason: String(assignmentExecutionValidation.reason || "").trim(),
+          assignment_validation_modes: ensureArray(assignmentExecutionValidation.assignmentModes),
+          reply_chars: String(sanitizedReplyText || "").length,
+          execution_mode: effectiveExecutionPlan.mode,
+          role_profile: effectiveExecutionPlan.roleProfileName,
+          executed_role_plan: executedRolePlan && Object.keys(executedRolePlan).length > 0 ? executedRolePlan : undefined,
+        },
+      };
+    }
     saveRunnerRouteState(
       routeKey,
       buildRunnerRouteStateFromComment(selectedRecord, {

package/lib/runner-runtime.mjs

@@ -51,6 +51,38 @@ function normalizeMentionSelector(rawValue) {
   return String(rawValue || "").trim().replace(/^@+/, "").toLowerCase();
 }
 
+function buildRunnerRouteOwnershipKey(routeRaw) {
+  const route = safeObject(routeRaw);
+  const name = String(route.name || "").trim() || "-";
+  const projectID = String(route.projectID || route.project_id || "").trim() || "-";
+  const provider = String(route.provider || "").trim().toLowerCase() || "-";
+  const role = String(route.role || route.bot_role || route.botRole || "").trim().toLowerCase() || "-";
+  const botID = String(
+    route.botID
+    || route.bot_id
+    || route.server_bot_id
+    || route.serverBotID
+    || "",
+  ).trim();
+  const botName = String(
+    route.botName
+    || route.bot_name
+    || route.server_bot_name
+    || route.serverBotName
+    || "",
+  ).trim();
+  const destinationID = String(route.destinationID || route.destination_id || "").trim();
+  const destinationLabel = String(route.destinationLabel || route.destination_label || "").trim();
+  return [
+    name,
+    projectID,
+    provider,
+    role,
+    botID || botName || "-",
+    destinationID || destinationLabel || "-",
+  ].join("::");
+}
+
 function normalizeRunnerSharedInboxKey({ provider, bot, route }) {
   const normalizedProvider = String(provider || route?.provider || "").trim().toLowerCase() || "telegram";
   const botSelector = firstNonEmptyString([
@@ -98,6 +130,130 @@ function buildManagedConversationBotSelectors(managedConversationBots) {
   );
 }
 
+function buildRunnerLocalInboundOwnerMap({
+  routeKey,
+  route,
+  bot,
+  managedConversationBots,
+}) {
+  const owners = new Map();
+  const appendOwner = (selectorRaw, ownerRaw = {}) => {
+    const selector = normalizeMentionSelector(selectorRaw);
+    const ownerRouteKey = String(
+      ownerRaw.routeKey
+      || ownerRaw.route_key
+      || buildRunnerRouteOwnershipKey(ownerRaw.route),
+    ).trim();
+    const ownerBotUsername = normalizeMentionSelector(
+      ownerRaw.botUsername
+      || ownerRaw.bot_username
+      || ownerRaw.username
+      || safeObject(ownerRaw.bot).username
+      || safeObject(ownerRaw.bot).name
+      || safeObject(ownerRaw.route).botName
+      || safeObject(ownerRaw.route).bot_name
+      || safeObject(ownerRaw.route).serverBotName
+      || safeObject(ownerRaw.route).server_bot_name
+      || selector,
+    );
+    if (!selector || !ownerRouteKey) {
+      return;
+    }
+    owners.set(selector, {
+      selector,
+      routeKey: ownerRouteKey,
+      botUsername: ownerBotUsername || selector,
+    });
+  };
+
+  appendOwner(
+    bot?.username
+    || bot?.name
+    || route?.botName
+    || route?.bot_name
+    || route?.serverBotName
+    || route?.server_bot_name,
+    {
+      routeKey,
+      botUsername:
+        bot?.username
+        || bot?.name
+        || route?.botName
+        || route?.bot_name
+        || route?.serverBotName
+        || route?.server_bot_name,
+    },
+  );
+
+  for (const entryRaw of ensureArray(managedConversationBots)) {
+    const entry = safeObject(entryRaw);
+    appendOwner(
+      entry.username
+      || entry.display_name
+      || safeObject(entry.bot).username
+      || safeObject(entry.bot).name
+      || safeObject(entry.route).botName
+      || safeObject(entry.route).bot_name
+      || safeObject(entry.route).serverBotName
+      || safeObject(entry.route).server_bot_name,
+      entry,
+    );
+  }
+
+  return owners;
+}
+
+function resolveRunnerLocalInboundArtifactOwners({
+  update,
+  routeKey,
+  route,
+  bot,
+  managedConversationBots,
+}) {
+  const normalizedUpdate = safeObject(update);
+  const ownersBySelector = buildRunnerLocalInboundOwnerMap({
+    routeKey,
+    route,
+    bot,
+    managedConversationBots,
+  });
+  const currentBotSelector = normalizeMentionSelector(
+    bot?.username
+    || bot?.name
+    || route?.botName
+    || route?.bot_name
+    || route?.serverBotName
+    || route?.server_bot_name,
+  );
+  const currentOwner = currentBotSelector ? ownersBySelector.get(currentBotSelector) : null;
+
+  const explicitMentions = Array.from(new Set(
+    ensureArray(normalizedUpdate.mentionUsernames)
+      .map((value) => normalizeMentionSelector(value))
+      .filter(Boolean),
+  ));
+  if (explicitMentions.length > 0) {
+    const explicitOwners = explicitMentions
+      .map((selector) => ownersBySelector.get(selector))
+      .filter((owner) => owner && owner.routeKey);
+    if (explicitOwners.length > 0) {
+      return explicitOwners;
+    }
+    return [];
+  }
+
+  const replyTargetSelector = normalizeMentionSelector(normalizedUpdate.replyToFromUsername);
+  if (
+    normalizedUpdate.replyToFromIsBot === true
+    && replyTargetSelector
+    && ownersBySelector.has(replyTargetSelector)
+  ) {
+    return [ownersBySelector.get(replyTargetSelector)];
+  }
+
+  return currentOwner ? [currentOwner] : [];
+}
+
 function managedConversationBotTargetsCurrentRoute({
   update,
   bot,
@@ -327,49 +483,72 @@ function buildRunnerLocalInboundEnvelopeFromReceipt(rawReceipt) {
   });
 }
 
-function buildRunnerLocalInboundArtifacts(updates, routeKey, bot, destination) {
-  const currentBotSelector = normalizeMentionSelector(
-    bot?.username
-    || bot?.name
-    || "",
-  );
+function buildRunnerLocalInboundArtifacts(updates, routeKey, route, bot, destination, managedConversationBots = []) {
   const normalizedRouteKey = String(routeKey || "").trim();
   const destinationChatID = String(destination?.chatID || "").trim();
   return ensureArray(updates)
     .filter((update) => String(update.chatID || "").trim() === destinationChatID)
     .filter((update) => String(update.text || "").trim())
-    .map((update) => {
-      const chatID = String(update.chatID || "").trim();
-      const messageID = intFromRawAllowZero(update.messageID, 0);
-      const receiptKey = buildRunnerRecentLocalInboundReceiptKey(chatID, messageID);
-      const receiptEntry = normalizeRunnerRecentLocalInboundReceipt({
-        update_id: intFromRawAllowZero(update.updateID, 0),
-        chat_id: chatID,
-        chat_type: update.chatType,
-        chat_title: update.chatTitle,
-        message_id: messageID,
-        message_thread_id: intFromRawAllowZero(update.messageThreadID, 0),
-        reply_to_message_id: intFromRawAllowZero(update.replyToMessageID, 0),
-        kind: update.fromIsBot ? "bot_reply" : "telegram_message",
-        sender_id: update.fromID,
-        sender: update.fromName,
-        sender_username: update.fromUsername,
-        sender_is_bot: update.fromIsBot === true,
-        body: update.text,
-        occurred_at: update.occurredAt,
-        receipt_origin: "local_telegram_inbound",
-        receipt_route_key: normalizedRouteKey,
-        receipt_bot_username: currentBotSelector,
-        received_at: firstNonEmptyString([update.occurredAt, new Date().toISOString()]),
-      }, receiptKey);
-      return { receiptEntry };
+    .flatMap((update) => {
+      const owners = resolveRunnerLocalInboundArtifactOwners({
+        update,
+        routeKey: normalizedRouteKey,
+        route,
+        bot,
+        managedConversationBots,
+      });
+      return owners.map((owner) => {
+        const chatID = String(update.chatID || "").trim();
+        const messageID = intFromRawAllowZero(update.messageID, 0);
+        const receiptKey = buildRunnerRecentLocalInboundReceiptKey(chatID, messageID);
+        const receiptEntry = normalizeRunnerRecentLocalInboundReceipt({
+          update_id: intFromRawAllowZero(update.updateID, 0),
+          chat_id: chatID,
+          chat_type: update.chatType,
+          chat_title: update.chatTitle,
+          message_id: messageID,
+          message_thread_id: intFromRawAllowZero(update.messageThreadID, 0),
+          reply_to_message_id: intFromRawAllowZero(update.replyToMessageID, 0),
+          kind: update.fromIsBot ? "bot_reply" : "telegram_message",
+          sender_id: update.fromID,
+          sender: update.fromName,
+          sender_username: update.fromUsername,
+          sender_is_bot: update.fromIsBot === true,
+          body: update.text,
+          occurred_at: update.occurredAt,
+          receipt_origin: "local_telegram_inbound",
+          receipt_route_key: owner.routeKey,
+          receipt_bot_username: owner.botUsername,
+          received_at: firstNonEmptyString([update.occurredAt, new Date().toISOString()]),
+        }, receiptKey);
+        return {
+          ownerRouteKey: String(owner.routeKey || "").trim(),
+          receiptEntry,
+        };
+      });
     })
     .filter((artifact) => {
       const normalizedEntry = ensureArray(safeObject(artifact).receiptEntry);
-      return normalizedEntry.length === 2;
+      return normalizedEntry.length === 2 && String(safeObject(artifact).ownerRouteKey || "").trim();
     });
 }
 
+function groupRunnerLocalInboundArtifactsByRoute(localInboundArtifacts) {
+  const grouped = new Map();
+  for (const artifactRaw of ensureArray(localInboundArtifacts)) {
+    const artifact = safeObject(artifactRaw);
+    const ownerRouteKey = String(artifact.ownerRouteKey || "").trim();
+    const normalizedEntry = ensureArray(artifact.receiptEntry);
+    if (!ownerRouteKey || normalizedEntry.length !== 2) {
+      continue;
+    }
+    const routeArtifacts = grouped.get(ownerRouteKey) || [];
+    routeArtifacts.push({ receiptEntry: normalizedEntry });
+    grouped.set(ownerRouteKey, routeArtifacts);
+  }
+  return Object.fromEntries(grouped.entries());
+}
+
 function buildRunnerRecentLocalInboundEnvelopes(routeStateRaw, recentLocalInboundReceipts) {
   const routeState = safeObject(routeStateRaw);
   const relevantEnvelopes = Object.values(safeObject(recentLocalInboundReceipts))
@@ -904,12 +1083,15 @@ export async function archiveLocalTelegramMessagesForRoute({
   const localInboundArtifacts = buildRunnerLocalInboundArtifacts(
     updates,
     routeKey,
+    route,
     bot,
     destination,
+    managedConversationBots,
   );
+  const localInboundArtifactsByRoute = groupRunnerLocalInboundArtifactsByRoute(localInboundArtifacts);
   const recentLocalInboundReceipts = buildRunnerRecentLocalInboundReceipts(
     routeState,
-    localInboundArtifacts,
+    ensureArray(localInboundArtifactsByRoute[routeKey]),
   );
   const recentLocalInboundEnvelopes = buildRunnerRecentLocalInboundEnvelopes(
     routeState,
@@ -926,13 +1108,36 @@ export async function archiveLocalTelegramMessagesForRoute({
     if (sharedInboxPatch && saveBotRunnerState) {
       saveBotRunnerState(sharedInboxPatch);
     }
-    saveRunnerRouteState(
+    const inputRouteKeys = Array.from(new Set([
       routeKey,
-      buildRunnerRouteInputStatePatch({
-        recentLocalInboundEnvelopes,
-        recentLocalInboundReceipts,
-      }),
-    );
+      ...Object.keys(safeObject(localInboundArtifactsByRoute)),
+    ]));
+    for (const targetRouteKey of inputRouteKeys) {
+      const fullState = loadBotRunnerState ? safeObject(loadBotRunnerState()) : {};
+      const targetRouteState = safeObject(
+        safeObject(fullState.routes)[targetRouteKey]
+        || (targetRouteKey === routeKey ? routeState : {}),
+      );
+      const targetRecentLocalInboundReceipts = targetRouteKey === routeKey
+        ? recentLocalInboundReceipts
+        : buildRunnerRecentLocalInboundReceipts(
+          targetRouteState,
+          ensureArray(localInboundArtifactsByRoute[targetRouteKey]),
+        );
+      const targetRecentLocalInboundEnvelopes = targetRouteKey === routeKey
+        ? recentLocalInboundEnvelopes
+        : buildRunnerRecentLocalInboundEnvelopes(
+          targetRouteState,
+          targetRecentLocalInboundReceipts,
+        );
+      saveRunnerRouteState(
+        targetRouteKey,
+        buildRunnerRouteInputStatePatch({
+          recentLocalInboundEnvelopes: targetRecentLocalInboundEnvelopes,
+          recentLocalInboundReceipts: targetRecentLocalInboundReceipts,
+        }),
+      );
+    }
     saveRunnerRouteState(
       routeKey,
       buildRunnerRoutePollingStatePatch({

package/lib/selftest-runner-scenarios.mjs

@@ -13246,14 +13246,139 @@ export async function runSelftestRunnerScenarios(push, deps) {
         && /ECONNRESET/i.test(String(processed.result?.transport_error || "")),
       `kind=${String(processed.kind || "(none)")} outcome=${String(processed.result?.outcome || "(none)")} ai_generated=${String(processed.result?.ai_reply_generated || false)} delivery=${String(processed.result?.delivery_status || "(none)")} transport=${String(processed.result?.transport_error || "(none)")}`,
     );
-  } catch (err) {
-    push("runner_delivery_failure_after_generation_records_ai_state_without_execution_error", false, String(err?.message || err));
-  }
-
+  } catch (err) {
+    push("runner_delivery_failure_after_generation_records_ai_state_without_execution_error", false, String(err?.message || err));
+  }
+
+  try {
+    const processed = await processRunnerSelectedRecord({
+      routeKey: "delivery-stale-reply-anchor-key",
+      normalizedRoute: normalizeRunnerRoute({
+        name: "telegram-monitor-delivery-stale-reply-anchor",
+        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,
+      }),
+      selectedRecord: {
+        id: "comment-delivery-stale-reply-anchor",
+        createdAt: "2026-03-17T00:00:22.000Z",
+        parsedArchive: {
+          kind: "telegram_message",
+          chatID: "-100123",
+          chatType: "supergroup",
+          body: "@RyoAI_bot hi",
+          messageID: 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 () => {
+          const err = new Error("local telegram delivery skipped stale reply anchor (Bad Request: message to be replied not found)");
+          err.code = "TELEGRAM_STALE_REPLY_ANCHOR";
+          err.staleReplyAnchor = true;
+          throw err;
+        },
+        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_stale_reply_anchor_skips_generated_reply_without_delivery_failure",
+      processed.kind === "skipped"
+        && String(processed.skippedRecord?.reason || "") === "stale_reply_anchor"
+        && String(processed.result?.outcome || "") === "skipped"
+        && processed.result?.ai_reply_generated === true
+        && String(processed.result?.delivery_status || "") === "skipped_stale_reply_anchor"
+        && /message to be replied not found/i.test(String(processed.result?.transport_error || "")),
+      `kind=${String(processed.kind || "(none)")} reason=${String(processed.skippedRecord?.reason || "(none)")} outcome=${String(processed.result?.outcome || "(none)")} delivery=${String(processed.result?.delivery_status || "(none)")} transport=${String(processed.result?.transport_error || "(none)")}`,
+    );
+  } catch (err) {
+    push("runner_stale_reply_anchor_skips_generated_reply_without_delivery_failure", false, String(err?.message || err));
+  }
+
   try {
     let capturedReplyToMessageID = 0;
     let capturedMessageThreadID = 0;
-    let capturedSourceMessageEnvelope = {};
+    let capturedSourceMessageEnvelope = {};
     const processed = await processRunnerSelectedRecord({
       routeKey: "delivery-prefers-route-local-inbound-envelope-key",
       normalizedRoute: normalizeRunnerRoute({

package/lib/selftest-telegram-e2e.mjs

@@ -17,6 +17,10 @@ function safeObject(value) {
   return value;
 }
 
+function ensureArray(value) {
+  return Array.isArray(value) ? value : [];
+}
+
 function buildTelegramMentionEntities(text) {
   const entities = [];
   const source = String(text || "");
@@ -58,7 +62,8 @@ async function startLocalTelegramRunnerSelftestServer({
     // on Windows CI shells.
     sendMessageTransientFailuresRemaining: 0,
     sendChatActionTransientFailuresRemaining: 0,
-    updates: [
+    missingReplyTargetMessageIDs: [],
+    updates: [
       {
         update_id: 11,
         message: {
@@ -294,13 +299,24 @@ async function startLocalTelegramRunnerSelftestServer({
             state.sendMessageTransientFailuresRemaining -= 1;
             req.socket.destroy(new Error("socket hang up"));
             return;
-          }
-          const payload = await readJSONBody(req);
-          const messageID = state.nextTelegramMessageID++;
-          state.sentMessages.push({
-            ...payload,
-            message_id: messageID,
-          });
+          }
+          const payload = await readJSONBody(req);
+          const replyToMessageID = intFromRawAllowZero(payload.reply_to_message_id, 0);
+          if (
+            replyToMessageID > 0
+            && ensureArray(state.missingReplyTargetMessageIDs).includes(replyToMessageID)
+          ) {
+            writeJSON(res, 400, {
+              ok: false,
+              description: "Bad Request: message to be replied not found",
+            });
+            return;
+          }
+          const messageID = state.nextTelegramMessageID++;
+          state.sentMessages.push({
+            ...payload,
+            message_id: messageID,
+          });
           writeJSON(res, 200, {
             ok: true,
             result: {
@@ -581,6 +597,45 @@ export async function runSelftestTelegramE2E(push, deps) {
       `error=${unsafeAnchorError || "(none)"} sent=${telegramE2EServer.state.sentMessages.length}`,
     );
 
+    telegramE2EServer.state.missingReplyTargetMessageIDs = [999];
+    const sentCountBeforeStaleAnchor = telegramE2EServer.state.sentMessages.length;
+    let staleAnchorError = "";
+    try {
+      await performLocalBotDelivery({
+        siteBaseURL: telegramE2EServer.baseURL,
+        token: e2eToken,
+        timeoutSeconds: 10,
+        actorUserID: e2eActorUserID,
+        bot: e2eBot,
+        projectID: selftestProjectID,
+        provider: "telegram",
+        destinationSelectors: {
+          destinationLabel: e2eDestination.label,
+        },
+        text: "stale reply anchor",
+        replyToMessageID: 999,
+        sourceMessageEnvelope: {
+          chat_id: e2eDestination.chat_id,
+          message_id: 999,
+          source_origin: "local_telegram_inbound",
+        },
+        archiveReplies: false,
+        dryRun: false,
+        deps: buildRunnerDeliveryDeps(),
+      });
+    } catch (err) {
+      staleAnchorError = String(err?.message || err);
+    } finally {
+      telegramE2EServer.state.missingReplyTargetMessageIDs = [];
+    }
+    push(
+      "telegram_delivery_classifies_missing_reply_target_as_stale_anchor",
+      /stale reply anchor/i.test(staleAnchorError)
+        && /message to be replied not found/i.test(staleAnchorError)
+        && telegramE2EServer.state.sentMessages.length === sentCountBeforeStaleAnchor,
+      `error=${staleAnchorError || "(none)"} sent=${telegramE2EServer.state.sentMessages.length}`,
+    );
+
     const sentCountBeforeDirectDelivery = telegramE2EServer.state.sentMessages.length;
     const commentCountBeforeDirectDelivery = telegramE2EServer.state.comments.length;
     const requestCountBeforeDirectDelivery = telegramE2EServer.state.runnerRequests.length;
@@ -1436,6 +1491,113 @@ export async function runSelftestTelegramE2E(push, deps) {
       telegramE2EServer.state.comments.length === 0,
       `comments=${telegramE2EServer.state.comments.length}`,
     );
+
+    telegramE2EServer.state.comments = [];
+    telegramE2EServer.state.updates = [
+      {
+        update_id: 403,
+        message: {
+          message_id: 83,
+          date: Math.floor(Date.now() / 1000),
+          chat: {
+            id: Number(e2eDestination.chat_id),
+            type: "supergroup",
+            title: e2eDestination.label,
+          },
+          from: {
+            id: 7001,
+            is_bot: false,
+            first_name: "Operator",
+            username: "operator_user",
+          },
+          text: "@RyoAI2_bot 하이",
+          entities: buildTelegramMentionEntities("@RyoAI2_bot 하이"),
+        },
+      },
+    ];
+    const routeRyoai1 = normalizeRunnerRoute({
+      ...e2eRoute,
+      name: "selftest-runner-e2e-ownership-ryoai1",
+      server_bot_name: "RyoAI_bot",
+      server_bot_id: "88888888-8888-4888-8888-888888888881",
+      destination_id: "dest-telegram",
+      destination_label: e2eDestination.label,
+    });
+    const routeRyoai2 = normalizeRunnerRoute({
+      ...e2eRoute,
+      name: "selftest-runner-e2e-ownership-ryoai2",
+      server_bot_name: "RyoAI2_bot",
+      server_bot_id: "88888888-8888-4888-8888-888888888882",
+      destination_id: "dest-telegram",
+      destination_label: e2eDestination.label,
+    });
+    const routeRyoai3 = normalizeRunnerRoute({
+      ...e2eRoute,
+      name: "selftest-runner-e2e-ownership-ryoai3",
+      server_bot_name: "RyoAI3_bot",
+      server_bot_id: "88888888-8888-4888-8888-888888888883",
+      destination_id: "dest-telegram",
+      destination_label: e2eDestination.label,
+    });
+    const routeRyoai2Key = runnerRouteKey(routeRyoai2);
+    const routeRyoai3Key = runnerRouteKey(routeRyoai3);
+    await archiveLocalTelegramMessagesForRoute({
+      routeKey: routeRyoai3Key,
+      route: routeRyoai3,
+      routeState: {},
+      runtime: {
+        baseURL: telegramE2EServer.baseURL,
+        timeoutSeconds: 10,
+        token: e2eToken,
+        actor: {
+          user_id: e2eActorUserID,
+        },
+      },
+      bot: {
+        id: "88888888-8888-4888-8888-888888888883",
+        name: "RyoAI3_bot",
+        username: "RyoAI3_bot",
+        role: "monitor",
+      },
+      destination: {
+        chatID: e2eDestination.chat_id,
+      },
+      archiveThread: {
+        threadID: e2eThreadID,
+      },
+      managedConversationBots: [
+        {
+          username: "RyoAI_bot",
+          route: routeRyoai1,
+          bot: { username: "RyoAI_bot", name: "RyoAI_bot" },
+        },
+        {
+          username: "RyoAI2_bot",
+          route: routeRyoai2,
+          bot: { username: "RyoAI2_bot", name: "RyoAI2_bot" },
+        },
+        {
+          username: "RyoAI3_bot",
+          route: routeRyoai3,
+          bot: { username: "RyoAI3_bot", name: "RyoAI3_bot" },
+        },
+      ],
+      deps: buildRunnerRuntimeDeps(),
+    });
+    const ownershipState = loadBotRunnerState();
+    const ryoai2Receipt = safeObject(
+      safeObject(safeObject(ownershipState.routes)[routeRyoai2Key]).recent_local_inbound_receipts?.[`${String(e2eDestination.chat_id)}:83`],
+    );
+    const ryoai3Receipt = safeObject(
+      safeObject(safeObject(ownershipState.routes)[routeRyoai3Key]).recent_local_inbound_receipts?.[`${String(e2eDestination.chat_id)}:83`],
+    );
+    push(
+      "telegram_local_inbound_receipt_is_attributed_to_explicit_mention_owner_route",
+      String(ryoai2Receipt.receipt_route_key || "") === routeRyoai2Key
+        && String(ryoai2Receipt.receipt_bot_username || "") === "ryoai2_bot"
+        && !String(ryoai3Receipt.receipt_route_key || "").trim(),
+      `owner=${JSON.stringify(ryoai2Receipt)} foreign=${JSON.stringify(ryoai3Receipt)}`,
+    );
   } catch (err) {
     push("telegram_runner_e2e_local_mock", false, String(err?.message || err));
   } finally {

package/package.json

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