metheus-governance-mcp-cli 0.2.283 → 0.2.284

package/cli.mjs

@@ -145,10 +145,10 @@ import {
   findEarlierProcessableArchiveDuplicate,
   findRecentTelegramMessageEnvelope,
   isTelegramLocalInboundEnvelopeForRoute,
-  isInboundArchiveKind,
-  normalizeTelegramMessageEnvelope as normalizeRunnerTelegramMessageEnvelope,
-  normalizeArchiveCommentRecord,
-  selectPendingArchiveComments,
+  isInboundArchiveKind,
+  normalizeTelegramMessageEnvelope as normalizeRunnerTelegramMessageEnvelope,
+  normalizeArchiveCommentRecord,
+  selectPendingArchiveComments,
   printRunnerResult,
 } from "./lib/runner-helpers.mjs";
 import {
@@ -6430,10 +6430,7 @@ function markRunnerRequestLifecycle({
   const authoritativeDecisionBundle = resolvedDecisionBundleValidation.ok === true
     ? safeObject(resolvedDecisionBundleValidation.bundle)
     : runnerRequestAuthoritativeDecisionBundle(existing);
-  const effectiveReplyToMessageID = intFromRawAllowZero(
-    replyToMessageID,
-    intFromRawAllowZero(existing.last_reply_to_message_id, 0),
-  );
+  const effectiveReplyToMessageID = intFromRawAllowZero(replyToMessageID, 0);
   const lastReplyMessageEnvelope = buildTelegramBotReplyEnvelope({
     sourceEnvelope: sourceMessageEnvelope,
     chatID: existing.chat_id,
@@ -6454,14 +6451,14 @@ function markRunnerRequestLifecycle({
     senderUsername: normalizedCurrentBotSelector,
     body: aiReplyPreview,
   });
-  const shouldRefreshAttemptedDeliveryEnvelope = (
-    aiReplyGenerated === true
-    || String(aiReplyPreview || "").trim().length > 0
-    || String(deliveryStatus || "").trim().length > 0
-    || String(transportError || "").trim().length > 0
-    || intFromRawAllowZero(replyToMessageID, 0) > 0
-    || intFromRawAllowZero(lastReplyMessageThreadID, 0) > 0
-  );
+  const shouldRefreshAttemptedDeliveryEnvelope = (
+    aiReplyGenerated === true
+    || String(aiReplyPreview || "").trim().length > 0
+    || String(deliveryStatus || "").trim().length > 0
+    || String(transportError || "").trim().length > 0
+    || intFromRawAllowZero(replyToMessageID, 0) > 0
+    || intFromRawAllowZero(lastReplyMessageThreadID, 0) > 0
+  );
   const rootEffectiveExecutionContractTargets = uniqueOrderedStrings(
     [
       ...ensureArray(authoritativeDecisionBundle.execution_contract_targets),
@@ -6504,6 +6501,13 @@ function markRunnerRequestLifecycle({
   const normalizedOutcome = String(outcome || "").trim().toLowerCase();
   const normalizedFailureReplyClassification = String(failureReplyClassification || "").trim().toLowerCase();
   const normalizedFailureFacts = safeObject(failureFacts);
+  const shouldPersistReplyAnchor = (
+    aiReplyGenerated === true
+    || intFromRawAllowZero(lastReplyMessageID, 0) > 0
+    || ["delivered", "dry_run", "archive_error", "failed_transport"].includes(normalizedDeliveryStatus)
+    || String(transportError || "").trim().length > 0
+    || ["replied", "delivery_failed_after_generation"].includes(normalizedOutcome)
+  );
   const shouldRemainRunningAfterReply = authoritativeDecisionBundle.should_close_after_reply === true
     ? false
     : authoritativeDecisionBundle.should_close_after_reply === false
@@ -6907,7 +6911,9 @@ function markRunnerRequestLifecycle({
     last_source_message_thread_id: intFromRawAllowZero(parsed.messageThreadID, 0) || existing.last_source_message_thread_id,
     last_reply_message_id: intFromRawAllowZero(lastReplyMessageID, 0) || existing.last_reply_message_id,
     last_reply_message_thread_id: intFromRawAllowZero(lastReplyMessageThreadID, 0) || existing.last_reply_message_thread_id,
-    last_reply_to_message_id: intFromRawAllowZero(replyToMessageID, 0) || existing.last_reply_to_message_id,
+    last_reply_to_message_id: shouldPersistReplyAnchor
+      ? effectiveReplyToMessageID
+      : existing.last_reply_to_message_id,
     last_reply_message_envelope: persistSuccessfulReplyEnvelope
       ? lastReplyMessageEnvelope
       : safeObject(existing.last_reply_message_envelope),

package/lib/runner-delivery-archive-handoff.mjs

@@ -13,6 +13,14 @@ function intFromRawAllowZero(value, fallback = 0) {
   return Number.isFinite(parsed) ? parsed : fallback;
 }
 
+function buildReplyAnchorMismatchError(expectedReplyToMessageID, observedReplyToMessageID) {
+  return `reply anchor mismatch: expected ${String(expectedReplyToMessageID || 0)}, observed ${String(observedReplyToMessageID || 0)}`;
+}
+
+function buildMessageThreadMismatchError(expectedMessageThreadID, observedMessageThreadID) {
+  return `message thread mismatch: expected ${String(expectedMessageThreadID || 0)}, observed ${String(observedMessageThreadID || 0)}`;
+}
+
 function requireArchiveDependency(deps, key) {
   const candidate = deps?.[key];
   if (typeof candidate !== "function") {
@@ -83,11 +91,41 @@ export async function finalizeLocalBotDeliveryArchive({
       deliveredResult.message_id ?? deliveredBody.message_id ?? deliveredBody.ts,
       0,
     );
-    const deliveredMessageThreadID = intFromRawAllowZero(
+    const observedMessageThreadID = intFromRawAllowZero(
       deliveredResult.message_thread_id ?? deliveredBody.message_thread_id ?? delivery.effectiveMessageThreadID,
       intFromRawAllowZero(messageThreadID, 0),
     );
-    const archiveReplyToMessageID = intFromRawAllowZero(delivery.effectiveReplyToMessageID, replyToMessageID);
+    const expectedMessageThreadID = intFromRawAllowZero(messageThreadID, 0);
+    const expectedReplyToMessageID = intFromRawAllowZero(replyToMessageID, 0);
+    const observedReplyToMessageID = intFromRawAllowZero(delivery.effectiveReplyToMessageID, 0);
+    if (
+      (expectedReplyToMessageID > 0 || observedReplyToMessageID > 0)
+      && observedReplyToMessageID !== expectedReplyToMessageID
+    ) {
+      return {
+        ok: false,
+        error: buildReplyAnchorMismatchError(expectedReplyToMessageID, observedReplyToMessageID),
+        reply_anchor_mismatch: true,
+        expected_reply_to_message_id: expectedReplyToMessageID,
+        observed_reply_to_message_id: observedReplyToMessageID,
+        thread_id: thread.threadID,
+        work_item_id: thread.workItemID,
+      };
+    }
+    if (
+      (expectedMessageThreadID > 0 || observedMessageThreadID > 0)
+      && observedMessageThreadID !== expectedMessageThreadID
+    ) {
+      return {
+        ok: false,
+        error: buildMessageThreadMismatchError(expectedMessageThreadID, observedMessageThreadID),
+        message_thread_mismatch: true,
+        expected_message_thread_id: expectedMessageThreadID,
+        observed_message_thread_id: observedMessageThreadID,
+        thread_id: thread.threadID,
+        work_item_id: thread.workItemID,
+      };
+    }
     if (archiveDedupeOutbound && deliveredMessageID > 0) {
       const existingComments = await listThreadCommentsTail({
         siteBaseURL,
@@ -119,8 +157,8 @@ export async function finalizeLocalBotDeliveryArchive({
       destination,
       replyText: text,
       messageID: deliveredMessageID,
-      messageThreadID: deliveredMessageThreadID,
-      replyToMessageID: archiveReplyToMessageID,
+      messageThreadID: expectedMessageThreadID,
+      replyToMessageID: expectedReplyToMessageID,
       conversation: archiveConversation,
     });
     const createdComment = await createThreadComment({

package/lib/runner-helpers.mjs

@@ -314,6 +314,27 @@ export function buildTelegramMessageEnvelopeFromParsedArchive(parsedArchiveRaw,
   });
 }
 
+export function resolveTelegramReplyAnchorMessageID({
+  replyToMessageID = 0,
+  sourceEnvelope: sourceEnvelopeRaw = {},
+  fallbackReplyToMessageID = 0,
+} = {}) {
+  const explicitReplyToMessageID = intFromRawAllowZero(replyToMessageID, 0);
+  if (explicitReplyToMessageID > 0) {
+    return explicitReplyToMessageID;
+  }
+  const sourceEnvelope = normalizeTelegramMessageEnvelope(sourceEnvelopeRaw);
+  const sourceMessageID = intFromRawAllowZero(sourceEnvelope.message_id, 0);
+  if (sourceMessageID > 0) {
+    return sourceMessageID;
+  }
+  const sourceReplyToMessageID = intFromRawAllowZero(sourceEnvelope.reply_to_message_id, 0);
+  if (sourceReplyToMessageID > 0) {
+    return sourceReplyToMessageID;
+  }
+  return intFromRawAllowZero(fallbackReplyToMessageID, 0);
+}
+
 export function buildTelegramBotReplyEnvelope({
   sourceEnvelope: sourceEnvelopeRaw = {},
   chatID = "",

package/lib/runner-orchestration-selected-record-preparation.mjs

@@ -1,3 +1,7 @@
+import {
+  resolveTelegramReplyAnchorMessageID,
+} from "./runner-helpers.mjs";
+
 function safeObject(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
     return {};
@@ -154,9 +158,20 @@ export function prepareRunnerSelectedRecordIngress({
           currentBotSelector,
         });
   const replyMessageThreadID = intFromRawAllowZero(sourceMessageEnvelope.message_thread_id, 0);
-  const replyToMessageID = intFromRawAllowZero(sourceMessageEnvelope.message_id, 0);
+  const sourceMessageID = intFromRawAllowZero(sourceMessageEnvelope.message_id, 0);
+  const sourceReplyToMessageID = intFromRawAllowZero(sourceMessageEnvelope.reply_to_message_id, 0);
+  const replyToMessageID = resolveTelegramReplyAnchorMessageID({
+    replyToMessageID: sourceMessageID,
+    sourceEnvelope: sourceMessageEnvelope,
+  });
   const replyAnchorSource = String(sourceMessageEnvelope.source_origin || "").trim()
-    || (replyToMessageID > 0 ? "source_message_envelope" : "");
+    || (replyToMessageID > 0
+      ? sourceMessageID > 0
+        ? "source_message_envelope"
+        : sourceReplyToMessageID > 0
+          ? "source_message_envelope_reply_to"
+          : ""
+      : "");
 
   return {
     handledResult: null,

package/lib/runner-orchestration-selected-record-reply-outcome.mjs

@@ -29,6 +29,10 @@ function buildConversationSummaryDetail({
   ].filter(Boolean).join(" | ");
 }
 
+function buildMessageThreadMismatchError(expectedMessageThreadID, observedMessageThreadID) {
+  return `message thread mismatch: expected ${String(expectedMessageThreadID || 0)}, observed ${String(observedMessageThreadID || 0)}`;
+}
+
 function buildSelectedRecordReplyOutcomeBase({
   routeKey,
   normalizedRoute,
@@ -354,11 +358,19 @@ export async function finalizeRunnerSelectedRecordReplyOutcome({
     deliveryBody.result?.message_id ?? deliveryBody.message_id,
     0,
   );
-  const effectiveReplyMessageThreadID = intFromRawAllowZero(
+  const expectedReplyMessageThreadID = intFromRawAllowZero(replyMessageThreadID, 0);
+  const observedReplyMessageThreadID = intFromRawAllowZero(
     deliveryResult?.delivery?.effectiveMessageThreadID,
-    replyMessageThreadID,
+    0,
+  );
+  const messageThreadMismatch = (
+    (expectedReplyMessageThreadID > 0 || observedReplyMessageThreadID > 0)
+    && observedReplyMessageThreadID !== expectedReplyMessageThreadID
   );
-  const effectiveReplyToMessageID = intFromRawAllowZero(deliveryResult?.delivery?.effectiveReplyToMessageID, replyToMessageID);
+  const messageThreadError = messageThreadMismatch
+    ? buildMessageThreadMismatchError(expectedReplyMessageThreadID, observedReplyMessageThreadID)
+    : "";
+  const effectiveReplyToMessageID = intFromRawAllowZero(replyToMessageID, 0);
   const conversationDetail = buildConversationSummaryDetail({
     effectiveConversationContext,
     executionContract,
@@ -371,7 +383,7 @@ export async function finalizeRunnerSelectedRecordReplyOutcome({
       ...buildRunnerRouteStateFromComment(selectedRecord, {
         last_action: "replied",
         last_reply_message_id: replyMessageID,
-        last_reply_message_thread_id: effectiveReplyMessageThreadID,
+        last_reply_message_thread_id: expectedReplyMessageThreadID,
         last_reply_anchor_source: replyAnchorSource,
         last_contract_validation_status: String(responseContractValidation?.status || "").trim(),
         last_contract_validation_reason: String(responseContractValidation?.reason || "").trim(),
@@ -445,17 +457,21 @@ export async function finalizeRunnerSelectedRecordReplyOutcome({
       evidence_ids: ensureArray(aiResult?.evidenceItems).map((item) => String(safeObject(item).id || "").trim()).filter(Boolean),
       evidence_paths: ensureArray(aiResult?.evidenceItems).map((item) => String(safeObject(item).path || "").trim()).filter(Boolean),
       last_reply_message_id: replyMessageID,
-      last_reply_message_thread_id: effectiveReplyMessageThreadID,
+      last_reply_message_thread_id: expectedReplyMessageThreadID,
       reply_to_message_id: effectiveReplyToMessageID,
       last_reply_message_envelope: buildTelegramBotReplyEnvelope({
         sourceEnvelope: sourceMessageEnvelope,
         messageID: replyMessageID,
-        messageThreadID: effectiveReplyMessageThreadID,
+        messageThreadID: expectedReplyMessageThreadID,
         replyToMessageID: effectiveReplyToMessageID,
         sender: bot?.username ? `@${String(bot.username || "").trim().replace(/^@+/, "")}` : String(bot?.name || "bot").trim(),
         senderUsername: normalizeMentionSelector(bot?.username || bot?.name),
         body: sanitizedReplyText,
       }),
+      message_thread_mismatch: messageThreadMismatch,
+      expected_message_thread_id: expectedReplyMessageThreadID || undefined,
+      observed_message_thread_id: observedReplyMessageThreadID || undefined,
+      message_thread_error: messageThreadError,
       reply_anchor_source: replyAnchorSource,
       reply_fallback_used: deliveryResult?.delivery?.replyFallbackUsed === true,
       delivery_status: deliveryResult?.delivery?.dryRun ? "dry_run" : "delivered",

package/lib/runner-recorder-failure-delivery-handoff.mjs

@@ -36,14 +36,8 @@ export function prepareRunnerFailureReplyDeliveryHandoff({
   const sourceMessageEnvelope = Object.keys(safeObject(authoritativeSourceMessageEnvelope)).length > 0
     ? safeObject(authoritativeSourceMessageEnvelope)
     : safeObject(result.source_message_envelope);
-  const replyToMessageID = intFromRawAllowZero(
-    result.reply_to_message_id,
-    intFromRawAllowZero(sourceMessageEnvelope.message_id, 0),
-  );
-  const messageThreadID = intFromRawAllowZero(
-    result.reply_message_thread_id,
-    intFromRawAllowZero(sourceMessageEnvelope.message_thread_id, 0),
-  );
+  const replyToMessageID = intFromRawAllowZero(result.reply_to_message_id, 0);
+  const messageThreadID = intFromRawAllowZero(result.reply_message_thread_id, 0);
   return {
     siteBaseURL: normalizedRuntime.baseURL,
     token: normalizedRuntime.token,

package/lib/runner-recorder-failure-delivery-outcome-handoff.mjs

@@ -11,6 +11,14 @@ function intFromRawAllowZero(value, fallback = 0) {
   return Number.isFinite(parsed) ? parsed : fallback;
 }
 
+function buildReplyAnchorMismatchError(expectedReplyToMessageID, observedReplyToMessageID) {
+  return `reply anchor mismatch: expected ${String(expectedReplyToMessageID || 0)}, observed ${String(observedReplyToMessageID || 0)}`;
+}
+
+function buildMessageThreadMismatchError(expectedMessageThreadID, observedMessageThreadID) {
+  return `message thread mismatch: expected ${String(expectedMessageThreadID || 0)}, observed ${String(observedMessageThreadID || 0)}`;
+}
+
 export function finalizeRunnerFailureReplyDeliveryOutcome({
   processed = {},
   routeKey = "",
@@ -50,6 +58,24 @@ export function finalizeRunnerFailureReplyDeliveryOutcome({
   const delivery = safeObject(normalizedDeliveryResult.delivery);
   const archive = safeObject(normalizedDeliveryResult.archive);
   const handoff = safeObject(deliveryHandoff);
+  const expectedReplyToMessageID = intFromRawAllowZero(handoff.replyToMessageID, 0);
+  const observedReplyToMessageID = intFromRawAllowZero(delivery.effectiveReplyToMessageID, 0);
+  const expectedMessageThreadID = intFromRawAllowZero(handoff.messageThreadID, 0);
+  const observedMessageThreadID = intFromRawAllowZero(delivery.effectiveMessageThreadID, 0);
+  const replyAnchorMismatch = (
+    (expectedReplyToMessageID > 0 || observedReplyToMessageID > 0)
+    && observedReplyToMessageID !== expectedReplyToMessageID
+  );
+  const replyAnchorError = replyAnchorMismatch
+    ? buildReplyAnchorMismatchError(expectedReplyToMessageID, observedReplyToMessageID)
+    : "";
+  const messageThreadMismatch = (
+    (expectedMessageThreadID > 0 || observedMessageThreadID > 0)
+    && observedMessageThreadID !== expectedMessageThreadID
+  );
+  const messageThreadError = messageThreadMismatch
+    ? buildMessageThreadMismatchError(expectedMessageThreadID, observedMessageThreadID)
+    : "";
   const mergedResult = {
     ...result,
     failure_reply_sent: true,
@@ -69,14 +95,16 @@ export function finalizeRunnerFailureReplyDeliveryOutcome({
       safeObject(delivery.body).result?.message_id ?? safeObject(delivery.body).message_id,
       intFromRawAllowZero(result.last_reply_message_id, 0),
     ),
-    last_reply_message_thread_id: intFromRawAllowZero(
-      delivery.effectiveMessageThreadID,
-      intFromRawAllowZero(handoff.messageThreadID, 0),
-    ),
-    reply_to_message_id: intFromRawAllowZero(
-      delivery.effectiveReplyToMessageID,
-      intFromRawAllowZero(handoff.replyToMessageID, 0),
-    ),
+    last_reply_message_thread_id: expectedMessageThreadID,
+    reply_to_message_id: expectedReplyToMessageID,
+    reply_anchor_mismatch: replyAnchorMismatch,
+    expected_reply_to_message_id: expectedReplyToMessageID || undefined,
+    observed_reply_to_message_id: observedReplyToMessageID || undefined,
+    reply_anchor_error: replyAnchorError,
+    message_thread_mismatch: messageThreadMismatch,
+    expected_message_thread_id: expectedMessageThreadID || undefined,
+    observed_message_thread_id: observedMessageThreadID || undefined,
+    message_thread_error: messageThreadError,
   };
   if (normalizedRouteKey && typeof saveRunnerRouteState === "function") {
     const currentRouteState = typeof loadRouteState === "function"

package/lib/selftest-runner-scenarios.mjs

@@ -18930,7 +18930,7 @@ export async function runSelftestRunnerScenarios(push, deps) {
         next_expected_responders: ["beta_bot"],
       },
       authoritativeSourceMessageEnvelope: {
-        message_id: 4401,
+        message_id: 5501,
         source_origin: "local_receipt",
       },
       buildRunnerDeliveryDeps: () => ({
@@ -18940,12 +18940,13 @@ export async function runSelftestRunnerScenarios(push, deps) {
     push(
       "runner_recorder_failure_delivery_handoff_stays_within_5_to_6_boundary",
       String(handoff.text || "") === "I could not finish this request."
+        && String(handoff.replyToMessageID || "") === "4401"
         && String(handoff.archiveConversationContext?.id || "") === "conversation-failure-handoff-1"
         && String(handoff.archiveExecutionContract?.type || "") === "delegation"
         && !Object.prototype.hasOwnProperty.call(handoff, "archiveConversation")
         && !Object.prototype.hasOwnProperty.call(handoff, "requestKey")
         && !Object.prototype.hasOwnProperty.call(handoff, "status"),
-      `text=${String(handoff.text || "(none)")} conversation=${String(handoff.archiveConversationContext?.id || "(none)")} contract=${String(handoff.archiveExecutionContract?.type || "(none)")} archiveConversation=${String(handoff.archiveConversation || "(none)")}`,
+      `text=${String(handoff.text || "(none)")} replyTo=${String(handoff.replyToMessageID || "(none)")} conversation=${String(handoff.archiveConversationContext?.id || "(none)")} contract=${String(handoff.archiveExecutionContract?.type || "(none)")} archiveConversation=${String(handoff.archiveConversation || "(none)")}`,
     );
   } catch (err) {
     push("runner_recorder_failure_delivery_handoff_stays_within_5_to_6_boundary", false, String(err?.message || err));
@@ -19003,6 +19004,96 @@ export async function runSelftestRunnerScenarios(push, deps) {
     push("runner_recorder_failure_delivery_outcome_handoff_stays_within_module_5_boundary", false, String(err?.message || err));
   }
 
+  try {
+    const finalizedFailureDelivery = finalizeRunnerFailureReplyDeliveryOutcome({
+      processed: {
+        kind: "error",
+        result: {
+          failure_reply_text: "I could not finish this request.",
+          last_reply_message_id: 11,
+        },
+      },
+      routeKey: "route-failure-delivery-outcome-mismatch-1",
+      deliveryResult: {
+        delivery: {
+          dryRun: false,
+          effectiveMessageThreadID: 22,
+          effectiveReplyToMessageID: 99,
+          body: {
+            result: {
+              message_id: 44,
+            },
+          },
+        },
+        archive: {
+          ok: true,
+        },
+      },
+      deliveryHandoff: {
+        messageThreadID: 22,
+        replyToMessageID: 33,
+      },
+      loadRouteState: () => ({}),
+      saveRunnerRouteState: () => {},
+    });
+    push(
+      "runner_failure_delivery_outcome_preserves_module_4_reply_anchor_on_mismatch",
+      intFromRawAllowZero(safeSelftestObject(finalizedFailureDelivery.result).reply_to_message_id, 0) === 33
+        && safeSelftestObject(finalizedFailureDelivery.result).reply_anchor_mismatch === true
+        && intFromRawAllowZero(safeSelftestObject(finalizedFailureDelivery.result).expected_reply_to_message_id, 0) === 33
+        && intFromRawAllowZero(safeSelftestObject(finalizedFailureDelivery.result).observed_reply_to_message_id, 0) === 99
+        && /expected 33, observed 99/i.test(String(safeSelftestObject(finalizedFailureDelivery.result).reply_anchor_error || "")),
+      `reply_to=${String(safeSelftestObject(finalizedFailureDelivery.result).reply_to_message_id || "(none)")} mismatch=${String(safeSelftestObject(finalizedFailureDelivery.result).reply_anchor_mismatch || false)} expected=${String(safeSelftestObject(finalizedFailureDelivery.result).expected_reply_to_message_id || "(none)")} observed=${String(safeSelftestObject(finalizedFailureDelivery.result).observed_reply_to_message_id || "(none)")}`,
+    );
+  } catch (err) {
+    push("runner_failure_delivery_outcome_preserves_module_4_reply_anchor_on_mismatch", false, String(err?.message || err));
+  }
+
+  try {
+    const finalizedFailureDelivery = finalizeRunnerFailureReplyDeliveryOutcome({
+      processed: {
+        kind: "error",
+        result: {
+          failure_reply_text: "I could not finish this request.",
+          last_reply_message_id: 11,
+        },
+      },
+      routeKey: "route-failure-delivery-thread-mismatch-1",
+      deliveryResult: {
+        delivery: {
+          dryRun: false,
+          effectiveMessageThreadID: 99,
+          effectiveReplyToMessageID: 33,
+          body: {
+            result: {
+              message_id: 44,
+            },
+          },
+        },
+        archive: {
+          ok: true,
+        },
+      },
+      deliveryHandoff: {
+        messageThreadID: 22,
+        replyToMessageID: 33,
+      },
+      loadRouteState: () => ({}),
+      saveRunnerRouteState: () => {},
+    });
+    push(
+      "runner_failure_delivery_outcome_preserves_module_4_message_thread_on_mismatch",
+      intFromRawAllowZero(safeSelftestObject(finalizedFailureDelivery.result).last_reply_message_thread_id, 0) === 22
+        && safeSelftestObject(finalizedFailureDelivery.result).message_thread_mismatch === true
+        && intFromRawAllowZero(safeSelftestObject(finalizedFailureDelivery.result).expected_message_thread_id, 0) === 22
+        && intFromRawAllowZero(safeSelftestObject(finalizedFailureDelivery.result).observed_message_thread_id, 0) === 99
+        && /expected 22, observed 99/i.test(String(safeSelftestObject(finalizedFailureDelivery.result).message_thread_error || "")),
+      `thread=${String(safeSelftestObject(finalizedFailureDelivery.result).last_reply_message_thread_id || "(none)")} mismatch=${String(safeSelftestObject(finalizedFailureDelivery.result).message_thread_mismatch || false)} expected=${String(safeSelftestObject(finalizedFailureDelivery.result).expected_message_thread_id || "(none)")} observed=${String(safeSelftestObject(finalizedFailureDelivery.result).observed_message_thread_id || "(none)")}`,
+    );
+  } catch (err) {
+    push("runner_failure_delivery_outcome_preserves_module_4_message_thread_on_mismatch", false, String(err?.message || err));
+  }
+
   try {
     const activePatch = buildRunnerRootWorkItemRoutePatch({
       syncedRequest: {
@@ -20260,6 +20351,137 @@ export async function runSelftestRunnerScenarios(push, deps) {
     push("runner_selected_record_delivery_context_stays_within_module_4_boundary", false, String(err?.message || err));
   }
 
+  try {
+    const savedStates = [];
+    const ingress = prepareRunnerSelectedRecordIngress({
+      routeKey: "route-ingress-reply-fallback-1",
+      routeState: {},
+      selectedRecord: {
+        id: "comment-ingress-reply-fallback-1",
+        parsedArchive: {
+          kind: "telegram_message",
+          senderIsBot: false,
+          messageID: 4703,
+        },
+      },
+      persistedHumanIntentRequest: null,
+      precomputedHumanInboundVisibility: {
+        applies: true,
+        executable: true,
+        visibilityMode: "reply_chain",
+        visibilityStatus: "visible",
+        visibilityReason: "",
+        visibilitySource: "local_receipt",
+        candidateBotUsernames: ["alpha_bot"],
+        sourceMessageEnvelope: {
+          reply_to_message_id: 4702,
+          message_thread_id: 82,
+          source_origin: "local_receipt",
+        },
+      },
+      currentBotSelector: "alpha_bot",
+      triggerDecision: {
+        shouldRespond: true,
+        trigger: "reply_to_bot",
+        candidateBotUsernames: ["alpha_bot"],
+      },
+      saveRunnerRouteState: (_routeKey, patch) => {
+        savedStates.push(patch);
+      },
+      deps: {
+        hasPrecomputedRunnerTriggerDecision: (decision) => typeof decision?.shouldRespond === "boolean",
+        buildRunnerTriggerStatePatch: () => ({ last_trigger_candidate_bot_usernames: ["alpha_bot"] }),
+        buildRunnerRouteStateFromComment: (_comment, patch) => patch,
+        intFromRawAllowZero: (raw, fallback = 0) => {
+          const numeric = Number.parseInt(String(raw ?? ""), 10);
+          return Number.isFinite(numeric) ? numeric : fallback;
+        },
+        shouldRunnerTriggerProceed: (decision) => decision?.shouldRespond === true,
+        resolveRunnerHumanInboundVisibility: () => {
+          throw new Error("ingress helper should use provided visibility before recomputing");
+        },
+        resolveRunnerDeliverySourceMessageEnvelope: () => {
+          throw new Error("ingress helper should not build fallback source when visibility already supplies one");
+        },
+      },
+    });
+    push(
+      "runner_selected_record_ingress_resolves_reply_anchor_once_from_source_reply_to",
+      !ingress.handledResult
+        && ingress.replyToMessageID === 4702
+        && ingress.replyMessageThreadID === 82
+        && ingress.replyAnchorSource === "local_receipt"
+        && savedStates.length === 0,
+      `replyTo=${String(ingress.replyToMessageID || 0)} thread=${String(ingress.replyMessageThreadID || 0)} anchor=${String(ingress.replyAnchorSource || "(none)")} savedStates=${savedStates.length}`,
+    );
+  } catch (err) {
+    push("runner_selected_record_ingress_resolves_reply_anchor_once_from_source_reply_to", false, String(err?.message || err));
+  }
+
+  try {
+    const prepared = await prepareRunnerSelectedRecordDeliveryContext({
+      aiResult: {
+        reply: "reply without explicit anchor",
+      },
+      bot: {
+        name: "RyoAI_bot",
+        username: "RyoAI_bot",
+      },
+      selectedRecord: {
+        id: "comment-delivery-context-anchor-fallback",
+      },
+      currentBotSelector: "ryoai_bot",
+      executionContract: {
+        type: "direct_result",
+        assignments: [],
+        nextResponders: [],
+      },
+      effectiveTriggerDecision: {
+        trigger: "mention",
+      },
+      effectiveConversationContext: {
+        mode: "single_bot",
+        stage: "human_opening",
+        intentMode: "single_bot",
+        leadBotUsername: "ryoai_bot",
+      },
+      effectiveResolvedIntentMode: "single_bot",
+      directHumanPeerMap: new Map(),
+      responseContractValidation: {
+        ok: true,
+        status: "valid",
+        reason: "",
+        targets: [],
+      },
+      sourceMessageEnvelope: {
+        chat_id: "-1001",
+        message_id: 7001,
+        source_origin: "local_telegram_inbound",
+      },
+      replyToMessageID: 6123,
+      replyMessageThreadID: 0,
+      deps: {
+        normalizeMentionSelector: normalizeSelftestMentionSelector,
+        sanitizeForcedDirectReplyText: ({ replyText }) => String(replyText || "").trim(),
+        buildTelegramBotReplyEnvelope: ({ sourceEnvelope, replyToMessageID, body }) => ({
+          chat_id: sourceEnvelope?.chat_id || "",
+          message_id: sourceEnvelope?.message_id || 0,
+          reply_to_message_id: replyToMessageID,
+          body,
+        }),
+        collectExecutionContractNextResponders: () => [],
+        extractManagedPeerMentionSelectors: () => [],
+      },
+    });
+    push(
+      "runner_selected_record_delivery_context_uses_module_4_resolved_reply_anchor",
+      String(prepared.attemptedDeliveryEnvelope?.reply_to_message_id || "") === "6123",
+      `replyTo=${String(prepared.attemptedDeliveryEnvelope?.reply_to_message_id || "(none)")}`,
+    );
+  } catch (err) {
+    push("runner_selected_record_delivery_context_uses_module_4_resolved_reply_anchor", false, String(err?.message || err));
+  }
+
   try {
     const prepared = await prepareRunnerSelectedRecordDeliveryContext({
       aiResult: {
@@ -20395,6 +20617,65 @@ export async function runSelftestRunnerScenarios(push, deps) {
     push("runner_selected_record_delivery_handoff_stays_within_4_to_6_boundary", false, String(err?.message || err));
   }
 
+  try {
+    const handoff = prepareRunnerSelectedRecordDeliveryHandoff({
+      runtime: {
+        baseURL: "https://example.test",
+        token: "selftest-token",
+        timeoutSeconds: 5,
+        actor: { user_id: "user-delivery-handoff-anchor-fallback" },
+      },
+      bot: {
+        id: "bot-delivery-handoff-anchor-fallback",
+        name: "RyoAI_bot",
+        username: "RyoAI_bot",
+        role: "monitor",
+        provider: "telegram",
+      },
+      normalizedRoute: {
+        projectID: "project-delivery-handoff-anchor-fallback",
+        provider: "telegram",
+        dryRunDelivery: true,
+        archivePolicy: {
+          mirrorReplies: true,
+          dedupeOutbound: true,
+        },
+      },
+      destination: {
+        id: "dest-delivery-handoff-anchor-fallback",
+        label: "Main Room",
+      },
+      sanitizedReplyText: "Anchor from source envelope.",
+      replyMessageThreadID: 0,
+      replyToMessageID: 7788,
+      sourceMessageEnvelope: {
+        chat_id: "-2002",
+        message_id: 7002,
+        source_origin: "local_telegram_inbound",
+      },
+      archiveThread: {
+        threadID: "thread-delivery-handoff-anchor-fallback",
+        workItemID: "workitem-delivery-handoff-anchor-fallback",
+      },
+      effectiveConversationContext: {
+        id: "conversation-delivery-handoff-anchor-fallback",
+        mode: "single_bot",
+        stage: "human_opening",
+      },
+      executionContract: {
+        type: "direct_result",
+      },
+      buildRunnerDeliveryDeps: () => ({ test: true }),
+    });
+    push(
+      "runner_selected_record_delivery_handoff_uses_module_4_resolved_reply_anchor",
+      String(handoff.replyToMessageID || "") === "7788",
+      `replyTo=${String(handoff.replyToMessageID || "(none)")}`,
+    );
+  } catch (err) {
+    push("runner_selected_record_delivery_handoff_uses_module_4_resolved_reply_anchor", false, String(err?.message || err));
+  }
+
   try {
     const savedStates = [];
     const finalized = await finalizeRunnerSelectedRecordReplyOutcome({
@@ -20545,6 +20826,152 @@ export async function runSelftestRunnerScenarios(push, deps) {
     push("runner_selected_record_reply_outcome_stays_within_module_4_boundary", false, String(err?.message || err));
   }
 
+  try {
+    const savedStates = [];
+    const finalized = await finalizeRunnerSelectedRecordReplyOutcome({
+      routeKey: "route-reply-outcome-thread-mismatch-1",
+      normalizedRoute: {
+        name: "Reply Outcome Thread Mismatch Route",
+      },
+      archiveThread: {
+        threadID: "thread-reply-outcome-thread-mismatch-1",
+      },
+      selectedRecord: {
+        id: "comment-reply-outcome-thread-mismatch-1",
+        parsedArchive: {
+          senderIsBot: false,
+        },
+      },
+      effectiveTriggerDecision: {
+        trigger: "precomputed_human_intent_contract",
+      },
+      effectiveConversationContext: {
+        id: "conversation-reply-outcome-thread-mismatch-1",
+        stage: "lead_kickoff",
+        intentMode: "multi_bot_collab",
+        leadBotUsername: "leadbot",
+        summaryBotUsername: "",
+        participantSelectors: ["leadbot", "peerbot"],
+        initialResponderSelectors: ["leadbot"],
+        allowedResponderSelectors: ["leadbot", "peerbot"],
+        allowBotToBot: true,
+        replyExpectation: "public_reply",
+      },
+      executionContract: {
+        type: "delegation",
+        actionable: true,
+      },
+      normalizedExecutionContractType: "delegation",
+      normalizedExecutionTargets: ["peerbot"],
+      normalizedExecutionNextResponders: ["peerbot"],
+      artifactValidation: {
+        status: "none",
+      },
+      aiResult: {},
+      authoritativeDecisionBundle: {
+        schema_version: "conversation_decision.v1",
+        decision_type: "reply_outcome",
+      },
+      projectContextSuggestion: {},
+      bot: {
+        name: "Lead Bot",
+        username: "leadbot",
+      },
+      sourceMessageEnvelope: {
+        source_origin: "local_telegram_inbound",
+        message_id: 4900,
+        message_thread_id: 93,
+      },
+      attemptedDeliveryEnvelope: {
+        message_id: 4900,
+      },
+      humanInboundVisibility: {
+        visibilityStatus: "local",
+        visibilityReason: "",
+        visibilitySource: "local_receipt",
+      },
+      replyToMessageID: 4900,
+      replyMessageThreadID: 93,
+      replyAnchorSource: "local_receipt",
+      responseContractValidation: {
+        status: "valid",
+        reason: "",
+        targets: [],
+      },
+      assignmentExecutionValidation: {
+        status: "direct_execution",
+        reason: "",
+        assignmentModes: [],
+      },
+      responderStatePatch: {},
+      intentStatePatch: {},
+      visibilityStatePatch: {},
+      effectiveExecutionPlan: {
+        mode: "lookup_only",
+        roleProfileName: "monitor",
+        workspaceDir: "C:\\selftest",
+        usedCommandFallback: false,
+      },
+      executedRolePlan: {},
+      sanitizedReplyText: "bot replied",
+      aiReplyGeneratedAt: "2026-03-30T00:00:00.000Z",
+      aiReplyPreview: "bot replied",
+      deliveryResult: {
+        delivery: {
+          dryRun: false,
+          effectiveMessageThreadID: 199,
+          effectiveReplyToMessageID: 4900,
+          body: {
+            result: {
+              message_id: 4901,
+            },
+          },
+        },
+        archive: {
+          ok: true,
+        },
+      },
+      saveRunnerRouteState: (_routeKey, patch) => {
+        savedStates.push(patch);
+      },
+      emitRunnerStage: () => {},
+      deps: {
+        buildRunnerRouteStateFromComment: (_comment, patch) => patch,
+        summarizeValidatedArtifactPaths: () => [],
+        intFromRawAllowZero: (raw, fallback = 0) => {
+          const numeric = Number.parseInt(String(raw ?? ""), 10);
+          return Number.isFinite(numeric) ? numeric : fallback;
+        },
+        normalizeMentionSelector: normalizeSelftestMentionSelector,
+        formatConversationContractSummary: () => "contract=delegation",
+        maybeCreateSuggestedProjectContext: async () => ({ created: false, reason: "message_is_interrogative" }),
+        buildConversationSessionsPatch: (_routeState, _conversationContext, patch) => patch,
+        normalizeConversationReplyFingerprint: (text) => String(text || "").trim(),
+        buildTelegramBotReplyEnvelope: ({ messageID, messageThreadID, replyToMessageID, body }) => ({
+          message_id: messageID,
+          message_thread_id: messageThreadID,
+          reply_to_message_id: replyToMessageID,
+          body,
+        }),
+        publicMultiBotDefaultMaxTurns: 6,
+        publicMultiBotDefaultTtlMs: 300000,
+      },
+    });
+    push(
+      "runner_selected_record_reply_outcome_preserves_module_4_message_thread_on_mismatch",
+      finalized.kind === "replied"
+        && savedStates.length === 1
+        && intFromRawAllowZero(finalized.result?.last_reply_message_thread_id, 0) === 93
+        && finalized.result?.message_thread_mismatch === true
+        && intFromRawAllowZero(finalized.result?.expected_message_thread_id, 0) === 93
+        && intFromRawAllowZero(finalized.result?.observed_message_thread_id, 0) === 199
+        && /expected 93, observed 199/i.test(String(finalized.result?.message_thread_error || "")),
+      `thread=${String(finalized.result?.last_reply_message_thread_id || "(none)")} mismatch=${String(finalized.result?.message_thread_mismatch || false)} expected=${String(finalized.result?.expected_message_thread_id || "(none)")} observed=${String(finalized.result?.observed_message_thread_id || "(none)")}`,
+    );
+  } catch (err) {
+    push("runner_selected_record_reply_outcome_preserves_module_4_message_thread_on_mismatch", false, String(err?.message || err));
+  }
+
   try {
     const finalized = finalizeExecutionPlanSteps(
       {
@@ -21113,6 +21540,154 @@ export async function runSelftestRunnerScenarios(push, deps) {
     push("runner_delivery_archive_handoff_stays_within_module_6_boundary", false, String(err?.message || err));
   }
 
+  try {
+    let createCommentCalls = 0;
+    const archivedReply = await finalizeLocalBotDeliveryArchive({
+      siteBaseURL: "https://example.test",
+      token: "token-delivery-archive-mismatch-1",
+      timeoutSeconds: 10,
+      actorUserID: "actor-delivery-archive-mismatch-1",
+      projectID: "project-delivery-archive-mismatch-1",
+      provider: "telegram",
+      destination: {
+        id: "dest-delivery-archive-mismatch-1",
+        provider: "telegram",
+        label: "Delivery Archive Mismatch",
+        chatID: "-100558",
+      },
+      bot: {
+        id: "bot-delivery-archive-mismatch-1",
+        name: "DeliveryArchiveMismatchBot",
+        username: "deliveryarchivemismatchbot",
+        role: "monitor",
+      },
+      text: "archive mismatch delivery",
+      messageThreadID: 77,
+      replyToMessageID: 55,
+      archiveReplies: true,
+      archiveDedupeOutbound: true,
+      archiveThreadID: "thread-delivery-archive-mismatch-1",
+      archiveWorkItemID: "workitem-delivery-archive-mismatch-1",
+      archiveConversation: {
+        id: "delivery-archive-mismatch-conversation",
+      },
+      dryRun: false,
+      delivery: {
+        body: {
+          result: {
+            message_id: 502,
+            message_thread_id: 77,
+          },
+        },
+        effectiveReplyToMessageID: 66,
+        effectiveMessageThreadID: 77,
+      },
+      formatBotReplyArchiveComment,
+      findArchivedBotReplyRecord,
+      deps: {
+        discoverArchiveThreadForDestination: async () => ({
+          threadID: "thread-delivery-archive-mismatch-1",
+          workItemID: "workitem-delivery-archive-mismatch-1",
+        }),
+        listThreadComments: async () => [],
+        listThreadCommentsTail: async () => [],
+        createThreadComment: async () => {
+          createCommentCalls += 1;
+          return {
+            id: "comment-delivery-archive-mismatch-1",
+          };
+        },
+        parseArchivedChatComment,
+      },
+    });
+    push(
+      "runner_delivery_archive_reveals_reply_anchor_mismatch_instead_of_masking",
+      archivedReply.ok === false
+        && archivedReply.reply_anchor_mismatch === true
+        && intFromRawAllowZero(archivedReply.expected_reply_to_message_id, 0) === 55
+        && intFromRawAllowZero(archivedReply.observed_reply_to_message_id, 0) === 66
+        && createCommentCalls === 0
+        && /expected 55, observed 66/i.test(String(archivedReply.error || "")),
+      `ok=${String(archivedReply.ok)} mismatch=${String(archivedReply.reply_anchor_mismatch || false)} expected=${String(archivedReply.expected_reply_to_message_id || "(none)")} observed=${String(archivedReply.observed_reply_to_message_id || "(none)")} created=${createCommentCalls}`,
+    );
+  } catch (err) {
+    push("runner_delivery_archive_reveals_reply_anchor_mismatch_instead_of_masking", false, String(err?.message || err));
+  }
+
+  try {
+    let createCommentCalls = 0;
+    const archivedReply = await finalizeLocalBotDeliveryArchive({
+      siteBaseURL: "https://example.test",
+      token: "token-delivery-thread-mismatch-1",
+      timeoutSeconds: 10,
+      actorUserID: "actor-delivery-thread-mismatch-1",
+      projectID: "project-delivery-thread-mismatch-1",
+      provider: "telegram",
+      destination: {
+        id: "dest-delivery-thread-mismatch-1",
+        provider: "telegram",
+        label: "Delivery Thread Mismatch",
+        chatID: "-100559",
+      },
+      bot: {
+        id: "bot-delivery-thread-mismatch-1",
+        name: "DeliveryThreadMismatchBot",
+        username: "deliverythreadmismatchbot",
+        role: "monitor",
+      },
+      text: "archive thread mismatch delivery",
+      messageThreadID: 77,
+      replyToMessageID: 55,
+      archiveReplies: true,
+      archiveDedupeOutbound: true,
+      archiveThreadID: "thread-delivery-thread-mismatch-1",
+      archiveWorkItemID: "workitem-delivery-thread-mismatch-1",
+      archiveConversation: {
+        id: "delivery-thread-mismatch-conversation",
+      },
+      dryRun: false,
+      delivery: {
+        body: {
+          result: {
+            message_id: 503,
+            message_thread_id: 88,
+          },
+        },
+        effectiveReplyToMessageID: 55,
+        effectiveMessageThreadID: 88,
+      },
+      formatBotReplyArchiveComment,
+      findArchivedBotReplyRecord,
+      deps: {
+        discoverArchiveThreadForDestination: async () => ({
+          threadID: "thread-delivery-thread-mismatch-1",
+          workItemID: "workitem-delivery-thread-mismatch-1",
+        }),
+        listThreadComments: async () => [],
+        listThreadCommentsTail: async () => [],
+        createThreadComment: async () => {
+          createCommentCalls += 1;
+          return {
+            id: "comment-delivery-thread-mismatch-1",
+          };
+        },
+        parseArchivedChatComment,
+      },
+    });
+    push(
+      "runner_delivery_archive_reveals_message_thread_mismatch_instead_of_masking",
+      archivedReply.ok === false
+        && archivedReply.message_thread_mismatch === true
+        && intFromRawAllowZero(archivedReply.expected_message_thread_id, 0) === 77
+        && intFromRawAllowZero(archivedReply.observed_message_thread_id, 0) === 88
+        && createCommentCalls === 0
+        && /expected 77, observed 88/i.test(String(archivedReply.error || "")),
+      `ok=${String(archivedReply.ok)} mismatch=${String(archivedReply.message_thread_mismatch || false)} expected=${String(archivedReply.expected_message_thread_id || "(none)")} observed=${String(archivedReply.observed_message_thread_id || "(none)")} created=${createCommentCalls}`,
+    );
+  } catch (err) {
+    push("runner_delivery_archive_reveals_message_thread_mismatch_instead_of_masking", false, String(err?.message || err));
+  }
+
   try {
     const finalizedDeliveryResult = finalizeLocalBotDeliveryResult({
       provider: "telegram",

package/package.json

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