metheus-governance-mcp-cli 0.2.262 → 0.2.264

package/cli.mjs

@@ -831,9 +831,17 @@ function botRunnerWorkspaceRegistryFilePath() {
   return resolveHomeFilePath(BOT_RUNNER_WORKSPACE_REGISTRY_RELATIVE_PATH);
 }
 
-function botRunnerStateFilePath() {
-  return resolveHomeFilePath(BOT_RUNNER_STATE_RELATIVE_PATH);
-}
+function botRunnerStateFilePath() {
+  return resolveHomeFilePath(BOT_RUNNER_STATE_RELATIVE_PATH);
+}
+
+function botRunnerStateBackupFilePath(filePath = botRunnerStateFilePath()) {
+  const normalizedPath = String(filePath || "").trim();
+  if (!normalizedPath) {
+    return "";
+  }
+  return `${normalizedPath}.bak`;
+}
 
 function botRunnerProcessesFilePath() {
   return resolveHomeFilePath(BOT_RUNNER_PROCESSES_RELATIVE_PATH);
@@ -2200,25 +2208,37 @@ function migrateBotRunnerStateRoutes(routes, runnerConfig) {
   };
 }
 
-function loadBotRunnerState() {
-  const filePath = botRunnerStateFilePath();
-  waitForBotRunnerStateLockRelease(filePath);
-  try {
-    if (!fs.existsSync(filePath)) {
-      return {
-        filePath,
-        routes: {},
-        sharedInboxes: {},
-        excludedComments: {},
-        requests: {},
-        consumedComments: {},
-        migrated: false,
-        migratedKeys: [],
-        remainingAnonymousKeys: [],
-      };
-    }
-    const parsed = tryJsonParse(fs.readFileSync(filePath, "utf8"));
-    const runnerConfig = loadBotRunnerConfig({ persistIfNeeded: true });
+function loadBotRunnerState() {
+  const filePath = botRunnerStateFilePath();
+  const backupPath = botRunnerStateBackupFilePath(filePath);
+  waitForBotRunnerStateLockRelease(filePath);
+  const emptyState = {
+    filePath,
+    routes: {},
+    sharedInboxes: {},
+    excludedComments: {},
+    requests: {},
+    consumedComments: {},
+    migrated: false,
+    migratedKeys: [],
+    remainingAnonymousKeys: [],
+  };
+  try {
+    if (!fs.existsSync(filePath)) {
+      return emptyState;
+    }
+    let parsed = tryJsonParse(fs.readFileSync(filePath, "utf8"));
+    if ((!parsed || typeof parsed !== "object" || Array.isArray(parsed)) && backupPath && fs.existsSync(backupPath)) {
+      const backupParsed = tryJsonParse(fs.readFileSync(backupPath, "utf8"));
+      if (backupParsed && typeof backupParsed === "object" && !Array.isArray(backupParsed)) {
+        parsed = backupParsed;
+        writeTextFileAtomic(filePath, `${JSON.stringify(backupParsed, null, 2)}\n`);
+      }
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return emptyState;
+    }
+    const runnerConfig = loadBotRunnerConfig({ persistIfNeeded: true });
     const migratedState = migrateBotRunnerStateRoutes(safeObject(parsed?.routes), runnerConfig);
     if (migratedState.changed) {
       saveBotRunnerState({
@@ -2241,24 +2261,14 @@ function loadBotRunnerState() {
       excludedComments: normalizeBotRunnerExcludedComments(parsed?.excluded_comments || parsed?.excludedComments),
       requests: normalizeBotRunnerRequests(parsed?.requests),
       consumedComments: normalizeBotRunnerConsumedComments(parsed?.consumed_comments || parsed?.consumedComments),
-      migrated: migratedState.changed,
-      migratedKeys: migratedState.migratedKeys,
-      remainingAnonymousKeys: migratedState.remainingAnonymousKeys,
-    };
-  } catch {
-    return {
-      filePath,
-      routes: {},
-      sharedInboxes: {},
-      excludedComments: {},
-      requests: {},
-      consumedComments: {},
-      migrated: false,
-      migratedKeys: [],
-      remainingAnonymousKeys: [],
-    };
-  }
-}
+      migrated: migratedState.changed,
+      migratedKeys: migratedState.migratedKeys,
+      remainingAnonymousKeys: migratedState.remainingAnonymousKeys,
+    };
+  } catch {
+    return emptyState;
+  }
+}
 
 function sleepSyncMs(delayMs) {
   const ms = Number(delayMs) || 0;
@@ -2408,13 +2418,19 @@ function writeTextFileAtomic(filePath, text) {
   }
 }
 
-function saveBotRunnerState(nextState) {
-  const filePath = botRunnerStateFilePath();
-  return withBotRunnerStateFileLock(filePath, () => {
-    let current = {};
-    try {
-      current = safeObject(tryJsonParse(fs.readFileSync(filePath, "utf8")));
-    } catch {}
+function saveBotRunnerState(nextState) {
+  const filePath = botRunnerStateFilePath();
+  const backupPath = botRunnerStateBackupFilePath(filePath);
+  return withBotRunnerStateFileLock(filePath, () => {
+    let current = {};
+    try {
+      current = safeObject(tryJsonParse(fs.readFileSync(filePath, "utf8")));
+    } catch {}
+    if (!Object.keys(current).length && backupPath && fs.existsSync(backupPath)) {
+      try {
+        current = safeObject(tryJsonParse(fs.readFileSync(backupPath, "utf8")));
+      } catch {}
+    }
     const stateEntryTimestampMs = (...values) => {
       for (const value of values) {
         const ms = Date.parse(String(value || "").trim());
@@ -2562,7 +2578,7 @@ function saveBotRunnerState(nextState) {
       }
       return normalizeBotRunnerConsumedComments(merged);
     };
-    const payload = {
+    const payload = {
       version: 1,
       updated_at: new Date().toISOString(),
       routes: mergeRunnerStateRoutes(
@@ -2581,15 +2597,30 @@ function saveBotRunnerState(nextState) {
         current.requests,
         nextState?.requests ?? current.requests,
       ),
-      consumed_comments: mergeRunnerStateConsumedComments(
-        current.consumed_comments ?? current.consumedComments,
-        nextState?.consumedComments ?? nextState?.consumed_comments ?? current.consumed_comments ?? current.consumedComments,
-      ),
-    };
-    writeTextFileAtomic(filePath, `${JSON.stringify(payload, null, 2)}\n`);
-    return filePath;
-  });
-}
+      consumed_comments: mergeRunnerStateConsumedComments(
+        current.consumed_comments ?? current.consumedComments,
+        nextState?.consumedComments ?? nextState?.consumed_comments ?? current.consumed_comments ?? current.consumedComments,
+      ),
+    };
+    const serialized = `${JSON.stringify(payload, null, 2)}\n`;
+    writeTextFileAtomic(filePath, serialized);
+    const verifiedPayload = tryJsonParse(fs.readFileSync(filePath, "utf8"));
+    if (!verifiedPayload || typeof verifiedPayload !== "object" || Array.isArray(verifiedPayload)) {
+      if (backupPath && fs.existsSync(backupPath)) {
+        const backupRaw = fs.readFileSync(backupPath, "utf8");
+        const backupParsed = tryJsonParse(backupRaw);
+        if (backupParsed && typeof backupParsed === "object" && !Array.isArray(backupParsed)) {
+          writeTextFileAtomic(filePath, backupRaw);
+        }
+      }
+      throw new Error("bot runner state write verification failed");
+    }
+    if (backupPath) {
+      writeTextFileAtomic(backupPath, serialized);
+    }
+    return filePath;
+  });
+}
 
 function normalizeBotRunnerExcludedComments(rawExcluded, nowMs = Date.now()) {
   const normalized = {};
@@ -13302,21 +13333,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 +13386,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

@@ -1809,7 +1809,7 @@ export async function resolveRunnerPrecomputedSelectedRecordExecutionContext({
   };
 }
 
-function resolveRunnerDeliverySourceMessageEnvelope({
+export function resolveRunnerDeliverySourceMessageEnvelope({
   routeState,
   persistedRequest,
   selectedRecord,
@@ -1826,7 +1826,7 @@ function resolveRunnerDeliverySourceMessageEnvelope({
   if (Object.keys(safeObject(localMatch.envelope)).length > 0) {
     return localMatch.envelope;
   }
-  return safeObject(localMatch.candidates).archiveEnvelope || {};
+  return {};
 }
 
 function escapeRegExp(text) {
@@ -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/selftest-runner-scenarios.mjs

@@ -2,7 +2,10 @@
 import http from "node:http";
 import os from "node:os";
 import path from "node:path";
-import process from "node:process";
+import process from "node:process";
+import {
+  resolveRunnerDeliverySourceMessageEnvelope,
+} from "./runner-orchestration.mjs";
 
 function requireDependency(deps, key) {
   const candidate = deps?.[key];
@@ -2745,6 +2748,66 @@ export async function runSelftestRunnerScenarios(push, deps) {
     }
   }
 
+  const originalStateBackupHome = process.env.HOME;
+  const originalStateBackupUserProfile = process.env.USERPROFILE;
+  let stateBackupTempRoot = "";
+  try {
+    stateBackupTempRoot = fs.mkdtempSync(path.join(os.tmpdir(), "metheus-runner-selftest-state-backup-"));
+    process.env.HOME = stateBackupTempRoot;
+    process.env.USERPROFILE = stateBackupTempRoot;
+    const metheusDir = path.join(stateBackupTempRoot, ".metheus");
+    fs.mkdirSync(metheusDir, { recursive: true });
+    const statePath = path.join(metheusDir, "bot-runner-state.json");
+    const backupPath = `${statePath}.bak`;
+    fs.writeFileSync(
+      backupPath,
+      `${JSON.stringify({
+        version: 1,
+        updated_at: "2026-03-29T00:00:00.000Z",
+        routes: {
+          "telegram-monitor-state-backup::project::telegram::monitor::dest::actor": {
+            last_action: "idle",
+          },
+        },
+        shared_inboxes: {},
+        excluded_comments: {},
+        requests: {},
+        consumed_comments: {},
+      }, null, 2)}\n`,
+      "utf8",
+    );
+    fs.writeFileSync(statePath, "{ malformed json", "utf8");
+    const recoveredState = loadBotRunnerState();
+    const recoveredRouteState = safeObject(
+      safeObject(recoveredState.routes)["telegram-monitor-state-backup::project::telegram::monitor::dest::actor"],
+    );
+    const repairedPrimary = safeObject(tryJsonParse(fs.readFileSync(statePath, "utf8")));
+    push(
+      "runner_state_load_restores_primary_from_backup_when_primary_is_malformed",
+      String(recoveredRouteState.last_action || "") === "idle"
+        && String(safeObject(safeObject(repairedPrimary.routes)["telegram-monitor-state-backup::project::telegram::monitor::dest::actor"]).last_action || "") === "idle",
+      `recovered=${String(recoveredRouteState.last_action || "(none)")} repaired=${String(safeObject(safeObject(repairedPrimary.routes)["telegram-monitor-state-backup::project::telegram::monitor::dest::actor"]).last_action || "(none)")}`,
+    );
+  } catch (err) {
+    push("runner_state_load_restores_primary_from_backup_when_primary_is_malformed", false, String(err?.message || err));
+  } finally {
+    if (typeof originalStateBackupHome === "string") {
+      process.env.HOME = originalStateBackupHome;
+    } else {
+      delete process.env.HOME;
+    }
+    if (typeof originalStateBackupUserProfile === "string") {
+      process.env.USERPROFILE = originalStateBackupUserProfile;
+    } else {
+      delete process.env.USERPROFILE;
+    }
+    if (stateBackupTempRoot) {
+      try {
+        fs.rmSync(stateBackupTempRoot, { recursive: true, force: true });
+      } catch {}
+    }
+  }
+
   const defaultMonitorTriggerPolicy = normalizeRunnerTriggerPolicy({}, { role: "monitor" });
   push(
     "bot_runner_default_monitor_trigger_policy",
@@ -13246,14 +13309,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({
@@ -15075,9 +15263,43 @@ export async function runSelftestRunnerScenarios(push, deps) {
         && String(capturedSourceMessageEnvelope.source_route_key || "") === "telegram-monitor-ryoai2-bot-2::project::telegram::monitor::dest::actor",
       `kind=${String(processed.kind || "(none)")} reply_to=${capturedReplyToMessageID} origin=${String(capturedSourceMessageEnvelope.source_origin || "(none)")} route=${String(capturedSourceMessageEnvelope.source_route_key || "(none)")}`,
     );
-  } catch (err) {
-    push("runner_delivery_accepts_archived_local_route_provenance", false, String(err?.message || err));
-  }
+  } catch (err) {
+    push("runner_delivery_accepts_archived_local_route_provenance", false, String(err?.message || err));
+  }
+
+  try {
+    const envelope = resolveRunnerDeliverySourceMessageEnvelope({
+      routeState: {
+        recent_local_inbound_receipts: {},
+        recent_local_inbound_envelopes: {},
+      },
+      persistedRequest: {},
+      selectedRecord: {
+        parsedArchive: {
+          kind: "telegram_message",
+          chatID: "-100123",
+          chatType: "supergroup",
+          body: "@RyoAI2_bot hi without local provenance",
+          messageID: 331,
+          sender: "human",
+          senderIsBot: false,
+          mentionUsernames: ["ryoai2_bot"],
+          sourceOrigin: "archive_reconstructed",
+          sourceRouteKey: "telegram-monitor-ryoai2-bot-2::project::telegram::monitor::dest::actor",
+          sourceBotUsername: "ryoai2_bot",
+        },
+      },
+      routeKey: "telegram-monitor-ryoai2-bot-2::project::telegram::monitor::dest::actor",
+      currentBotSelector: "ryoai2_bot",
+    });
+    push(
+      "runner_delivery_drops_archive_reconstructed_reply_anchor_before_delivery",
+      Object.keys(safeObject(envelope)).length === 0,
+      `origin=${String(safeObject(envelope).source_origin || "(none)")} message=${String(safeObject(envelope).message_id || "(none)")}`,
+    );
+  } catch (err) {
+    push("runner_delivery_drops_archive_reconstructed_reply_anchor_before_delivery", false, String(err?.message || err));
+  }
 
   try {
     const provenanceTempRoot = fs.mkdtempSync(path.join(os.tmpdir(), "metheus-runner-provenance-selftest-"));

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;

package/package.json

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