metheus-governance-mcp-cli 0.2.241 → 0.2.247

package/cli.mjs

@@ -133,16 +133,19 @@ import {
   tryRegister,
   withWorkspaceDirArg,
 } from "./lib/client-registration.mjs";
-import {
-  applyPendingAgeSelection,
-  buildRunnerRouteStateFromComment,
-  buildProcessableArchiveLogicalKey,
-  findEarlierProcessableArchiveDuplicate,
-  isInboundArchiveKind,
-  normalizeArchiveCommentRecord,
-  selectPendingArchiveComments,
-  printRunnerResult,
-} from "./lib/runner-helpers.mjs";
+import {
+  applyPendingAgeSelection,
+  buildTelegramBotReplyEnvelope,
+  buildTelegramMessageEnvelopeFromParsedArchive as buildRunnerTelegramMessageEnvelopeFromParsedArchive,
+  buildRunnerRouteStateFromComment,
+  buildProcessableArchiveLogicalKey,
+  findEarlierProcessableArchiveDuplicate,
+  isInboundArchiveKind,
+  normalizeTelegramMessageEnvelope as normalizeRunnerTelegramMessageEnvelope,
+  normalizeArchiveCommentRecord,
+  selectPendingArchiveComments,
+  printRunnerResult,
+} from "./lib/runner-helpers.mjs";
 import {
   createProjectContextItem as createProjectContextItemImpl,
   createProjectEvidence as createProjectEvidenceImpl,
@@ -1915,15 +1918,24 @@ function mergeRunnerStateRecords(preferred, fallback) {
     }
     return allowUndefined ? undefined : 0;
   };
-  const pickArrayField = (key, normalizer = (value) => String(value || "").trim()) => {
-    if (hasOwn(primary, key)) {
-      const value = uniqueOrderedStrings(ensureArray(primary[key]), normalizer).filter(Boolean);
-      if (value.length) {
-        return value;
-      }
-    }
-    return uniqueOrderedStrings(ensureArray(secondary[key]), normalizer).filter(Boolean);
-  };
+  const pickArrayField = (key, normalizer = (value) => String(value || "").trim()) => {
+    if (hasOwn(primary, key)) {
+      const value = uniqueOrderedStrings(ensureArray(primary[key]), normalizer).filter(Boolean);
+      if (value.length) {
+        return value;
+      }
+    }
+    return uniqueOrderedStrings(ensureArray(secondary[key]), normalizer).filter(Boolean);
+  };
+  const pickObjectField = (key) => {
+    if (hasOwn(primary, key)) {
+      const value = safeObject(primary[key]);
+      if (Object.keys(value).length) {
+        return value;
+      }
+    }
+    return safeObject(secondary[key]);
+  };
   return {
     last_processed_comment_id: pickStringField("last_processed_comment_id"),
     last_processed_created_at: pickStringField("last_processed_created_at"),
@@ -1970,11 +1982,14 @@ function mergeRunnerStateRecords(preferred, fallback) {
     last_followup_response_contract_validation_reason: pickStringField("last_followup_response_contract_validation_reason"),
     last_followup_assignment_validation_status: pickStringField("last_followup_assignment_validation_status"),
     last_followup_assignment_validation_reason: pickStringField("last_followup_assignment_validation_reason"),
-    last_followup_delivery_status: pickStringField("last_followup_delivery_status"),
-    last_followup_archive_status: pickStringField("last_followup_archive_status"),
-    last_followup_transport_error: pickStringField("last_followup_transport_error"),
-    last_followup_archive_error: pickStringField("last_followup_archive_error"),
-    last_contract_validation_targets: pickArrayField("last_contract_validation_targets", normalizeTelegramMentionUsername),
+    last_followup_delivery_status: pickStringField("last_followup_delivery_status"),
+    last_followup_archive_status: pickStringField("last_followup_archive_status"),
+    last_followup_transport_error: pickStringField("last_followup_transport_error"),
+    last_followup_archive_error: pickStringField("last_followup_archive_error"),
+    last_followup_source_message_envelope: pickObjectField("last_followup_source_message_envelope"),
+    last_followup_last_reply_message_envelope: pickObjectField("last_followup_last_reply_message_envelope"),
+    last_followup_attempted_delivery_envelope: pickObjectField("last_followup_attempted_delivery_envelope"),
+    last_contract_validation_targets: pickArrayField("last_contract_validation_targets", normalizeTelegramMentionUsername),
     last_normalized_execution_contract_targets: pickArrayField("last_normalized_execution_contract_targets", normalizeTelegramMentionUsername),
     last_normalized_execution_next_responders: pickArrayField("last_normalized_execution_next_responders", normalizeTelegramMentionUsername),
     last_followup_execution_contract_targets: pickArrayField("last_followup_execution_contract_targets", normalizeTelegramMentionUsername),
@@ -2114,11 +2129,11 @@ function loadBotRunnerState() {
   }
 }
 
-function writeTextFileAtomic(filePath, text) {
-  const normalizedPath = String(filePath || "").trim();
-  if (!normalizedPath) {
-    throw new Error("filePath is required");
-  }
+function writeTextFileAtomic(filePath, text) {
+  const normalizedPath = String(filePath || "").trim();
+  if (!normalizedPath) {
+    throw new Error("filePath is required");
+  }
   const directoryPath = path.dirname(normalizedPath);
   fs.mkdirSync(directoryPath, { recursive: true });
   const tempPath = path.join(
@@ -2130,31 +2145,39 @@ function writeTextFileAtomic(filePath, text) {
   const sleepBuffer = new SharedArrayBuffer(4);
   const sleepArray = new Int32Array(sleepBuffer);
   let lastRenameError = null;
-  try {
-    for (const delayMs of renameRetryDelaysMs) {
-      if (delayMs > 0) {
-        Atomics.wait(sleepArray, 0, 0, delayMs);
-      }
-      try {
-        fs.renameSync(tempPath, normalizedPath);
-        lastRenameError = null;
-        break;
-      } catch (error) {
-        lastRenameError = error;
-        try {
-          fs.rmSync(normalizedPath, { force: true });
-          fs.renameSync(tempPath, normalizedPath);
-          lastRenameError = null;
-          break;
-        } catch (retryError) {
-          lastRenameError = retryError;
-          const errorCode = String(retryError?.code || error?.code || "").trim().toUpperCase();
-          if (!["EPERM", "EBUSY", "ENOTEMPTY"].includes(errorCode)) {
-            throw retryError;
-          }
-        }
-      }
-    }
+  try {
+    for (const delayMs of renameRetryDelaysMs) {
+      if (delayMs > 0) {
+        Atomics.wait(sleepArray, 0, 0, delayMs);
+      }
+      try {
+        fs.renameSync(tempPath, normalizedPath);
+        lastRenameError = null;
+        break;
+      } catch (error) {
+        lastRenameError = error;
+        try {
+          fs.copyFileSync(tempPath, normalizedPath);
+          lastRenameError = null;
+          break;
+        } catch (copyError) {
+          lastRenameError = copyError;
+          try {
+            fs.writeFileSync(normalizedPath, text, "utf8");
+            lastRenameError = null;
+            break;
+          } catch (writeError) {
+            lastRenameError = writeError;
+          }
+          const errorCode = String(
+            lastRenameError?.code || copyError?.code || error?.code || "",
+          ).trim().toUpperCase();
+          if (!["EPERM", "EBUSY", "ENOTEMPTY"].includes(errorCode)) {
+            throw lastRenameError;
+          }
+        }
+      }
+    }
     if (lastRenameError) {
       throw lastRenameError;
     }
@@ -2468,6 +2491,28 @@ function normalizeRunnerReplyChainSnapshot(rawSnapshot) {
   };
 }
 
+function buildRunnerReplyChainSnapshotFromMessageEnvelope(envelopeRaw, overrides = {}) {
+  const envelope = normalizeRunnerTelegramMessageEnvelope(envelopeRaw);
+  if (!Object.keys(envelope).length) {
+    return null;
+  }
+  return normalizeRunnerReplyChainSnapshot({
+    message_id: envelope.message_id,
+    message_thread_id: envelope.message_thread_id,
+    reply_to_message_id: envelope.reply_to_message_id,
+    speaker_type: firstNonEmptyString([
+      overrides.speaker_type,
+      envelope.sender_is_bot === true ? "bot" : "human",
+    ]),
+    speaker_label: firstNonEmptyString([
+      overrides.speaker_label,
+      envelope.sender_username ? `@${String(envelope.sender_username || "").trim().replace(/^@+/, "")}` : "",
+      envelope.sender,
+    ]),
+    body: firstNonEmptyString([overrides.body, envelope.body]),
+  });
+}
+
 function normalizeRunnerReplyChainContext(rawContext) {
   const context = safeObject(rawContext);
   const normalized = {
@@ -2530,6 +2575,20 @@ function normalizeBotRunnerRequests(rawRequests, nowMs = Date.now()) {
         0,
       ) || undefined,
       source_message_body: String(entry.source_message_body || entry.sourceMessageBody || "").trim(),
+      source_message_envelope: normalizeRunnerTelegramMessageEnvelope(
+        entry.source_message_envelope
+        || entry.sourceMessageEnvelope
+        || (intFromRawAllowZero(entry.source_message_id || entry.sourceMessageID, 0) > 0
+          ? {
+              chat_id: entry.chat_id || entry.chatID,
+              message_id: entry.source_message_id || entry.sourceMessageID,
+              message_thread_id: entry.source_message_thread_id || entry.sourceMessageThreadID,
+              body: entry.source_message_body || entry.sourceMessageBody,
+              sender: "human",
+              sender_is_bot: false,
+            }
+          : {}),
+      ),
       root_comment_id: String(entry.root_comment_id || entry.rootCommentID || "").trim(),
       root_comment_kind: String(entry.root_comment_kind || entry.rootCommentKind || "").trim().toLowerCase(),
       conversation_id: String(entry.conversation_id || entry.conversationId || "").trim(),
@@ -2662,11 +2721,43 @@ function normalizeBotRunnerRequests(rawRequests, nowMs = Date.now()) {
         entry.last_reply_message_thread_id || entry.lastReplyMessageThreadID,
         0,
       ) || undefined,
+      last_reply_to_message_id: intFromRawAllowZero(
+        entry.last_reply_to_message_id || entry.lastReplyToMessageID,
+        0,
+      ) || undefined,
+      last_reply_message_envelope: normalizeRunnerTelegramMessageEnvelope(
+        entry.last_reply_message_envelope
+        || entry.lastReplyMessageEnvelope
+        || (intFromRawAllowZero(entry.last_reply_message_id || entry.lastReplyMessageID, 0) > 0
+          ? buildTelegramBotReplyEnvelope({
+              chatID: entry.chat_id || entry.chatID,
+              messageID: entry.last_reply_message_id || entry.lastReplyMessageID,
+              messageThreadID: entry.last_reply_message_thread_id || entry.lastReplyMessageThreadID,
+              replyToMessageID: entry.last_reply_to_message_id || entry.lastReplyToMessageID,
+              senderUsername: entry.conversation_summary_bot || ensureArray(entry.selected_bot_usernames || entry.selectedBotUsernames)[0] || "",
+              body: entry.followup_ai_reply_preview || entry.followupAiReplyPreview || entry.ai_reply_preview || entry.aiReplyPreview,
+            })
+          : {}),
+      ),
+      attempted_delivery_envelope: normalizeRunnerTelegramMessageEnvelope(
+        entry.attempted_delivery_envelope
+        || entry.attemptedDeliveryEnvelope
+        || ((intFromRawAllowZero(entry.last_reply_to_message_id || entry.lastReplyToMessageID, 0) > 0
+            || intFromRawAllowZero(entry.last_reply_message_thread_id || entry.lastReplyMessageThreadID, 0) > 0)
+          ? buildTelegramBotReplyEnvelope({
+              chatID: entry.chat_id || entry.chatID,
+              messageThreadID: entry.last_reply_message_thread_id || entry.lastReplyMessageThreadID,
+              replyToMessageID: entry.last_reply_to_message_id || entry.lastReplyToMessageID,
+              senderUsername: entry.conversation_summary_bot || ensureArray(entry.selected_bot_usernames || entry.selectedBotUsernames)[0] || "",
+              body: entry.followup_ai_reply_preview || entry.followupAiReplyPreview || entry.ai_reply_preview || entry.aiReplyPreview,
+            })
+          : {}),
+      ),
       updated_at: updatedAt || new Date(nowMs).toISOString(),
-    };
-  }
-  return normalized;
-}
+    };
+  }
+  return normalized;
+}
 
 function normalizeBotRunnerConsumedComments(rawConsumed, nowMs = Date.now()) {
   const normalized = {};
@@ -3366,23 +3457,26 @@ function runnerRequestPreferredArchiveError(entryRaw) {
   ).trim();
 }
 
-function buildRunnerValidationAndDeliverySummary({
-  aiReplyPreview = "",
-  executionContractType = "",
-  executionContractTargets = [],
-  nextExpectedResponders = [],
+function buildRunnerValidationAndDeliverySummary({
+  aiReplyPreview = "",
+  executionContractType = "",
+  executionContractTargets = [],
+  nextExpectedResponders = [],
   responseContractValidationStatus = "",
   responseContractValidationReason = "",
   responseContractValidationTargets = [],
   assignmentValidationStatus = "",
   assignmentValidationReason = "",
   assignmentValidationModes = [],
-  deliveryStatus = "",
-  archiveStatus = "",
-  transportError = "",
-  archiveError = "",
-} = {}) {
-  return {
+  deliveryStatus = "",
+  archiveStatus = "",
+  transportError = "",
+  archiveError = "",
+  sourceMessageEnvelope = {},
+  lastReplyMessageEnvelope = {},
+  attemptedDeliveryEnvelope = {},
+} = {}) {
+  return {
     ai_reply_preview: String(aiReplyPreview || "").trim(),
     execution_contract_type: String(executionContractType || "").trim().toLowerCase(),
     execution_contract_targets: uniqueOrderedStrings(
@@ -3405,12 +3499,15 @@ function buildRunnerValidationAndDeliverySummary({
       ensureArray(assignmentValidationModes),
       (value) => String(value || "").trim().toLowerCase(),
     ),
-    delivery_status: String(deliveryStatus || "").trim().toLowerCase(),
-    archive_status: String(archiveStatus || "").trim().toLowerCase(),
-    transport_error: String(transportError || "").trim(),
-    archive_error: String(archiveError || "").trim(),
-  };
-}
+    delivery_status: String(deliveryStatus || "").trim().toLowerCase(),
+    archive_status: String(archiveStatus || "").trim().toLowerCase(),
+    transport_error: String(transportError || "").trim(),
+    archive_error: String(archiveError || "").trim(),
+    source_message_envelope: safeObject(sourceMessageEnvelope),
+    last_reply_message_envelope: safeObject(lastReplyMessageEnvelope),
+    attempted_delivery_envelope: safeObject(attemptedDeliveryEnvelope),
+  };
+}
 
 function buildRunnerRequestRootWorkItemSummary(entryRaw) {
   const entry = safeObject(entryRaw);
@@ -3489,12 +3586,15 @@ function buildRunnerRouteLastResultSummary(routeStateRaw) {
       responseContractValidationTargets,
       assignmentValidationStatus,
       assignmentValidationReason,
-      assignmentValidationModes,
-      deliveryStatus: routeState.last_followup_delivery_status,
-      archiveStatus: routeState.last_followup_archive_status,
-      transportError: routeState.last_followup_transport_error,
-      archiveError: routeState.last_followup_archive_error,
-    }),
+      assignmentValidationModes,
+      deliveryStatus: routeState.last_followup_delivery_status,
+      archiveStatus: routeState.last_followup_archive_status,
+      transportError: routeState.last_followup_transport_error,
+      archiveError: routeState.last_followup_archive_error,
+      sourceMessageEnvelope: routeState.last_followup_source_message_envelope,
+      lastReplyMessageEnvelope: routeState.last_followup_last_reply_message_envelope,
+      attemptedDeliveryEnvelope: routeState.last_followup_attempted_delivery_envelope,
+    }),
     workspace_dir: String(routeState.last_workspace_dir || "").trim(),
     artifact_validation: String(routeState.last_artifact_validation || "").trim(),
     artifact_paths: ensureArray(routeState.last_artifact_paths).map((item) => String(item || "").trim()).filter(Boolean),
@@ -3677,35 +3777,22 @@ async function findRunnerArchiveThreadMessageByID({
 
 function buildRunnerReplyChainSnapshotFromParsedArchive(parsedArchiveRaw, overrides = {}) {
   const parsedArchive = safeObject(parsedArchiveRaw);
-  const messageID = intFromRawAllowZero(overrides.message_id ?? parsedArchive.messageID, 0);
-  const messageThreadID = intFromRawAllowZero(
-    overrides.message_thread_id ?? parsedArchive.messageThreadID,
-    0,
+  return buildRunnerReplyChainSnapshotFromMessageEnvelope(
+    buildRunnerTelegramMessageEnvelopeFromParsedArchive(parsedArchive, overrides),
+    {
+      speaker_type: firstNonEmptyString([
+        overrides.speaker_type,
+        buildRunnerReplyChainSpeakerType(parsedArchive),
+      ]),
+      speaker_label: firstNonEmptyString([
+        overrides.speaker_label,
+        buildRunnerReplyChainSpeakerLabel(parsedArchive),
+      ]),
+      body: truncateRunnerReplyChainText(
+        firstNonEmptyString([overrides.body, parsedArchive.body]),
+      ),
+    },
   );
-  const replyToMessageID = intFromRawAllowZero(
-    overrides.reply_to_message_id ?? parsedArchive.replyToMessageID,
-    0,
-  );
-  const body = truncateRunnerReplyChainText(
-    firstNonEmptyString([overrides.body, parsedArchive.body]),
-  );
-  if (!(messageID > 0) && !body) {
-    return null;
-  }
-  return normalizeRunnerReplyChainSnapshot({
-    message_id: messageID,
-    message_thread_id: messageThreadID,
-    reply_to_message_id: replyToMessageID,
-    speaker_type: firstNonEmptyString([
-      overrides.speaker_type,
-      buildRunnerReplyChainSpeakerType(parsedArchive),
-    ]),
-    speaker_label: firstNonEmptyString([
-      overrides.speaker_label,
-      buildRunnerReplyChainSpeakerLabel(parsedArchive),
-    ]),
-    body,
-  });
 }
 
 function buildRunnerReplyChainSnapshotFromArchiveRecord(recordRaw) {
@@ -3716,16 +3803,28 @@ function buildRunnerReplyChainSnapshotFromArchiveRecord(recordRaw) {
 
 function buildRunnerReplyChainSnapshotFromRequestSource(requestRaw) {
   const request = safeObject(requestRaw);
-  return buildRunnerReplyChainSnapshotFromParsedArchive({
-    messageID: request.source_message_id,
-    messageThreadID: request.source_message_thread_id,
-    body: request.source_message_body,
-    senderIsBot: false,
-    sender: "human",
-  }, {
-    speaker_type: "human",
-    speaker_label: "human",
-  });
+  const explicitEnvelope = normalizeRunnerTelegramMessageEnvelope(
+    request.source_message_envelope || request.sourceMessageEnvelope,
+  );
+  const fallbackEnvelope = intFromRawAllowZero(request.source_message_id, 0) > 0
+    ? {
+        chat_id: request.chat_id,
+        message_id: request.source_message_id,
+        message_thread_id: request.source_message_thread_id,
+        body: request.source_message_body,
+        sender: "human",
+        sender_is_bot: false,
+      }
+    : null;
+  return buildRunnerReplyChainSnapshotFromMessageEnvelope(
+    explicitEnvelope && Object.keys(explicitEnvelope).length
+      ? explicitEnvelope
+      : fallbackEnvelope,
+    {
+      speaker_type: "human",
+      speaker_label: "human",
+    },
+  );
 }
 
 function buildRunnerReplyChainSnapshotFromRequestReply(requestRaw) {
@@ -3734,20 +3833,35 @@ function buildRunnerReplyChainSnapshotFromRequestReply(requestRaw) {
   if (!preview) {
     return null;
   }
-  return normalizeRunnerReplyChainSnapshot({
-    message_id: intFromRawAllowZero(request.last_reply_message_id, 0) || undefined,
-    message_thread_id: intFromRawAllowZero(request.last_reply_message_thread_id, 0) || undefined,
-    reply_to_message_id: intFromRawAllowZero(request.last_source_message_id || request.source_message_id, 0) || undefined,
-    speaker_type: "bot",
-    speaker_label: firstNonEmptyString([
-      request.conversation_summary_bot ? `@${String(request.conversation_summary_bot || "").trim().replace(/^@+/, "")}` : "",
-      ensureArray(request.selected_bot_usernames)[0]
-        ? `@${String(ensureArray(request.selected_bot_usernames)[0] || "").trim().replace(/^@+/, "")}`
-        : "",
-      "bot",
-    ]),
-    body: preview,
-  });
+  const explicitEnvelope = normalizeRunnerTelegramMessageEnvelope(
+    request.last_reply_message_envelope || request.lastReplyMessageEnvelope,
+  );
+  const fallbackEnvelope = intFromRawAllowZero(request.last_reply_message_id, 0) > 0
+    ? buildTelegramBotReplyEnvelope({
+        chatID: request.chat_id,
+        messageID: request.last_reply_message_id,
+        messageThreadID: request.last_reply_message_thread_id,
+        replyToMessageID: request.last_reply_to_message_id || request.last_source_message_id || request.source_message_id,
+        senderUsername: request.conversation_summary_bot || ensureArray(request.selected_bot_usernames)[0] || "",
+        body: preview,
+      })
+    : null;
+  return buildRunnerReplyChainSnapshotFromMessageEnvelope(
+    explicitEnvelope && intFromRawAllowZero(explicitEnvelope.message_id, 0) > 0
+      ? explicitEnvelope
+      : fallbackEnvelope,
+    {
+      speaker_type: "bot",
+      speaker_label: firstNonEmptyString([
+        request.conversation_summary_bot ? `@${String(request.conversation_summary_bot || "").trim().replace(/^@+/, "")}` : "",
+        ensureArray(request.selected_bot_usernames)[0]
+          ? `@${String(ensureArray(request.selected_bot_usernames)[0] || "").trim().replace(/^@+/, "")}`
+          : "",
+        "bot",
+      ]),
+      body: preview,
+    },
+  );
 }
 
 function uniqueRunnerReplyChainSnapshots(snapshots, limit = 4) {
@@ -4361,6 +4475,7 @@ async function claimRunnerRequestForHumanComment({
     source_message_id: intFromRawAllowZero(parsed.messageID, 0) || undefined,
     source_message_thread_id: intFromRawAllowZero(parsed.messageThreadID, 0) || undefined,
     source_message_body: String(parsed.body || "").trim(),
+    source_message_envelope: buildRunnerTelegramMessageEnvelopeFromParsedArchive(parsed),
     root_comment_id: String(selectedRecord?.id || "").trim(),
     root_comment_kind: commentKind,
     conversation_id: resolvedConversationID,
@@ -4971,7 +5086,7 @@ function buildRunnerRootWorkItemTransitionPath(currentStatusRaw, targetStatusRaw
   return [];
 }
 
-function buildRunnerRouteFollowupSnapshotPatch(selectedRecordRaw, resultRaw = {}) {
+function buildRunnerRouteFollowupSnapshotPatch(selectedRecordRaw, resultRaw = {}) {
   const parsed = safeObject(safeObject(selectedRecordRaw).parsedArchive);
   const commentKind = String(parsed.kind || "").trim().toLowerCase();
   if (["telegram_message", "telegram_edited_message"].includes(commentKind)) {
@@ -5010,12 +5125,15 @@ function buildRunnerRouteFollowupSnapshotPatch(selectedRecordRaw, resultRaw = {}
       ensureArray(result.assignment_validation_modes),
       (value) => String(value || "").trim().toLowerCase(),
     ),
-    last_followup_delivery_status: String(result.delivery_status || "").trim().toLowerCase(),
-    last_followup_archive_status: String(result.archive_status || "").trim().toLowerCase(),
-    last_followup_transport_error: String(result.transport_error || "").trim(),
-    last_followup_archive_error: String(result.archive_error || "").trim(),
-  });
-}
+    last_followup_delivery_status: String(result.delivery_status || "").trim().toLowerCase(),
+    last_followup_archive_status: String(result.archive_status || "").trim().toLowerCase(),
+    last_followup_transport_error: String(result.transport_error || "").trim(),
+    last_followup_archive_error: String(result.archive_error || "").trim(),
+    last_followup_source_message_envelope: normalizeRunnerTelegramMessageEnvelope(result.source_message_envelope),
+    last_followup_last_reply_message_envelope: normalizeRunnerTelegramMessageEnvelope(result.last_reply_message_envelope),
+    last_followup_attempted_delivery_envelope: normalizeRunnerTelegramMessageEnvelope(result.attempted_delivery_envelope),
+  });
+}
 
 function buildRunnerRequestRecoveryPatchFromRouteState(currentStateRaw, requestRaw, routeKeyHint = "") {
   const currentState = safeObject(currentStateRaw);
@@ -5095,11 +5213,29 @@ function buildRunnerRequestRecoveryPatchFromRouteState(currentStateRaw, requestR
     setFollowupStringPatch("followup_assignment_validation_status", ["last_followup_assignment_validation_status", "last_assignment_validation_status"]);
     setFollowupStringPatch("followup_assignment_validation_reason", ["last_followup_assignment_validation_reason", "last_assignment_validation_reason"]);
     setFollowupArrayPatch("followup_assignment_validation_modes", ["last_followup_assignment_validation_modes"], (value) => String(value || "").trim().toLowerCase());
-    setFollowupStringPatch("followup_delivery_status", ["last_followup_delivery_status"]);
-    setFollowupStringPatch("followup_archive_status", ["last_followup_archive_status"]);
-    setFollowupStringPatch("followup_transport_error", ["last_followup_transport_error"]);
-    setFollowupStringPatch("followup_archive_error", ["last_followup_archive_error"]);
-    const requestStatus = normalizeRunnerRequestStatus(request.status);
+    setFollowupStringPatch("followup_delivery_status", ["last_followup_delivery_status"]);
+    setFollowupStringPatch("followup_archive_status", ["last_followup_archive_status"]);
+    setFollowupStringPatch("followup_transport_error", ["last_followup_transport_error"]);
+    setFollowupStringPatch("followup_archive_error", ["last_followup_archive_error"]);
+    if (!Object.keys(safeObject(request.source_message_envelope)).length) {
+      const recoveredSourceEnvelope = normalizeRunnerTelegramMessageEnvelope(routeState.last_followup_source_message_envelope);
+      if (Object.keys(recoveredSourceEnvelope).length) {
+        patch.source_message_envelope = recoveredSourceEnvelope;
+      }
+    }
+    if (!Object.keys(safeObject(request.last_reply_message_envelope)).length) {
+      const recoveredReplyEnvelope = normalizeRunnerTelegramMessageEnvelope(routeState.last_followup_last_reply_message_envelope);
+      if (Object.keys(recoveredReplyEnvelope).length) {
+        patch.last_reply_message_envelope = recoveredReplyEnvelope;
+      }
+    }
+    if (!Object.keys(safeObject(request.attempted_delivery_envelope)).length) {
+      const recoveredAttemptEnvelope = normalizeRunnerTelegramMessageEnvelope(routeState.last_followup_attempted_delivery_envelope);
+      if (Object.keys(recoveredAttemptEnvelope).length) {
+        patch.attempted_delivery_envelope = recoveredAttemptEnvelope;
+      }
+    }
+    const requestStatus = normalizeRunnerRequestStatus(request.status);
     if (!isFinalRunnerRequestStatus(requestStatus)) {
       const routeAction = String(routeState.last_action || "").trim().toLowerCase();
       if (routeAction === "replied") {
@@ -5432,19 +5568,50 @@ function markRunnerRequestLifecycle({
   const key = String(requestKey || "").trim();
   if (!key) return null;
   const currentState = loadBotRunnerState();
-  const existing = safeObject(normalizeBotRunnerRequests(currentState.requests)[key]);
-  if (!Object.keys(existing).length) return null;
-  const parsed = safeObject(selectedRecord?.parsedArchive);
-  const conversationID = String(conversationIDRaw || existing.conversation_id || parsed.conversationID || "").trim();
-  const normalizedCurrentBotSelector = normalizeTelegramMentionUsername(
+  const existing = safeObject(normalizeBotRunnerRequests(currentState.requests)[key]);
+  if (!Object.keys(existing).length) return null;
+  const parsed = safeObject(selectedRecord?.parsedArchive);
+  const parsedKind = String(parsed.kind || "").trim().toLowerCase();
+  const conversationID = String(conversationIDRaw || existing.conversation_id || parsed.conversationID || "").trim();
+  const normalizedCurrentBotSelector = normalizeTelegramMentionUsername(
     currentBotSelector
       || safeObject(currentState.routes)[String(routeKey || "").trim()]?.last_speaker_bot_username
-      || "",
-  );
-  const rootEffectiveExecutionContractTargets = uniqueOrderedStrings(
-    [
-      ...ensureArray(executionContractTargets),
-      ...ensureArray(normalizedExecutionContractTargets),
+      || "",
+  );
+  const sourceMessageEnvelope = buildRunnerTelegramMessageEnvelopeFromParsedArchive(parsed);
+  const effectiveReplyToMessageID = intFromRawAllowZero(
+    replyToMessageID,
+    intFromRawAllowZero(existing.last_reply_to_message_id, 0),
+  );
+  const lastReplyMessageEnvelope = buildTelegramBotReplyEnvelope({
+    sourceEnvelope: sourceMessageEnvelope,
+    chatID: existing.chat_id,
+    messageID: lastReplyMessageID,
+    messageThreadID: lastReplyMessageThreadID,
+    replyToMessageID: effectiveReplyToMessageID,
+    senderUsername: normalizedCurrentBotSelector,
+    body: aiReplyPreview,
+  });
+  const attemptedDeliveryEnvelope = buildTelegramBotReplyEnvelope({
+    sourceEnvelope: sourceMessageEnvelope,
+    chatID: existing.chat_id,
+    messageThreadID: lastReplyMessageThreadID,
+    replyToMessageID: effectiveReplyToMessageID,
+    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 rootEffectiveExecutionContractTargets = uniqueOrderedStrings(
+    [
+      ...ensureArray(executionContractTargets),
+      ...ensureArray(normalizedExecutionContractTargets),
       ...ensureArray(responseContractValidationTargets),
     ],
     normalizeTelegramMentionUsername,
@@ -5779,9 +5946,17 @@ function markRunnerRequestLifecycle({
     closed_at: (nextStatus === "closed" || nextStatus === "expired" || nextStatus === "loop_closed")
       ? nowISO
       : String(existing.closed_at || "").trim(),
-    closed_reason: (nextStatus === "closed" || nextStatus === "expired" || nextStatus === "loop_closed")
-      ? String(closedReason || existing.closed_reason || normalizedOutcome).trim()
-      : String(existing.closed_reason || "").trim(),
+    closed_reason: (nextStatus === "closed" || nextStatus === "expired" || nextStatus === "loop_closed")
+      ? String(closedReason || existing.closed_reason || normalizedOutcome).trim()
+      : String(existing.closed_reason || "").trim(),
+    source_message_body: parsedKind === "bot_reply"
+      ? String(existing.source_message_body || "").trim()
+      : String(parsed.body || existing.source_message_body || "").trim(),
+    source_message_envelope: parsedKind === "bot_reply"
+      ? safeObject(existing.source_message_envelope)
+      : Object.keys(sourceMessageEnvelope).length
+        ? sourceMessageEnvelope
+      : safeObject(existing.source_message_envelope),
     last_comment_id: String(selectedRecord?.id || existing.last_comment_id || "").trim(),
     last_comment_kind: String(parsed.kind || existing.last_comment_kind || "").trim().toLowerCase(),
     last_source_message_id: intFromRawAllowZero(parsed.messageID, 0) || existing.last_source_message_id,
@@ -5789,6 +5964,12 @@ function markRunnerRequestLifecycle({
     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_message_envelope: intFromRawAllowZero(lastReplyMessageEnvelope.message_id, 0) > 0
+      ? lastReplyMessageEnvelope
+      : safeObject(existing.last_reply_message_envelope),
+    attempted_delivery_envelope: shouldRefreshAttemptedDeliveryEnvelope
+      ? attemptedDeliveryEnvelope
+      : safeObject(existing.attempted_delivery_envelope),
     last_reply_fallback_used: replyFallbackUsed === true
       ? true
       : existing.last_reply_fallback_used === true,
@@ -5997,6 +6178,9 @@ function mergeRunnerRequestForServerHydration(localEntryRaw, serverEntryRaw) {
     }
   };
   preserveLocalStringWhenServerBlank("source_message_body");
+  preserveLocalObjectWhenServerBlank("source_message_envelope");
+  preserveLocalObjectWhenServerBlank("last_reply_message_envelope");
+  preserveLocalObjectWhenServerBlank("attempted_delivery_envelope");
   preserveLocalStringWhenServerBlank("conversation_id");
   preserveLocalStringWhenServerBlank("conversation_intent_mode");
   preserveLocalStringWhenServerBlank("conversation_lead_bot");
@@ -8444,22 +8628,25 @@ function summarizeRunnerRequestForStatusLookup(entryRaw) {
     updated_at: String(entry.updated_at || "").trim(),
     source_message_id: intFromRawAllowZero(entry.source_message_id, 0) || undefined,
     last_source_message_id: intFromRawAllowZero(entry.last_source_message_id, 0) || undefined,
-    ...buildRunnerValidationAndDeliverySummary({
-      aiReplyPreview: runnerRequestPreferredAIReplyPreview(entry),
-      executionContractType: runnerRequestPreferredExecutionContractType(entry),
-      executionContractTargets: runnerRequestPreferredExecutionContractTargets(entry),
-      nextExpectedResponders: runnerRequestPreferredNextExpectedResponders(entry),
+    ...buildRunnerValidationAndDeliverySummary({
+      aiReplyPreview: runnerRequestPreferredAIReplyPreview(entry),
+      executionContractType: runnerRequestPreferredExecutionContractType(entry),
+      executionContractTargets: runnerRequestPreferredExecutionContractTargets(entry),
+      nextExpectedResponders: runnerRequestPreferredNextExpectedResponders(entry),
       responseContractValidationStatus: runnerRequestPreferredResponseContractValidationStatus(entry),
       responseContractValidationReason: runnerRequestPreferredResponseContractValidationReason(entry),
       responseContractValidationTargets: runnerRequestPreferredResponseContractValidationTargets(entry),
       assignmentValidationStatus: runnerRequestPreferredAssignmentValidationStatus(entry),
       assignmentValidationReason: runnerRequestPreferredAssignmentValidationReason(entry),
       assignmentValidationModes: runnerRequestPreferredAssignmentValidationModes(entry),
-      deliveryStatus: runnerRequestPreferredDeliveryStatus(entry),
-      archiveStatus: runnerRequestPreferredArchiveStatus(entry),
-      transportError: runnerRequestPreferredTransportError(entry),
-      archiveError: runnerRequestPreferredArchiveError(entry),
-    }),
+      deliveryStatus: runnerRequestPreferredDeliveryStatus(entry),
+      archiveStatus: runnerRequestPreferredArchiveStatus(entry),
+      transportError: runnerRequestPreferredTransportError(entry),
+      archiveError: runnerRequestPreferredArchiveError(entry),
+      sourceMessageEnvelope: entry.source_message_envelope,
+      lastReplyMessageEnvelope: entry.last_reply_message_envelope,
+      attemptedDeliveryEnvelope: entry.attempted_delivery_envelope,
+    }),
     selected_bot_usernames: ensureArray(entry.selected_bot_usernames)
       .map((value) => normalizeTelegramMentionUsername(value))
       .filter(Boolean),
@@ -8569,10 +8756,10 @@ function resolveRunnerStatusLookupRequests({
 
 function buildRunnerShowLastRunPayload(lastRunSummaryRaw) {
   const lastRunSummary = safeObject(lastRunSummaryRaw);
-  return {
-    action: lastRunSummary.action || "-",
-    reason: lastRunSummary.reason || "-",
-    intent_type: lastRunSummary.intent_type || "-",
+  return {
+    action: lastRunSummary.action || "-",
+    reason: lastRunSummary.reason || "-",
+    intent_type: lastRunSummary.intent_type || "-",
     ai_reply_preview: lastRunSummary.ai_reply_preview || "-",
     execution_contract_type: lastRunSummary.execution_contract_type || "-",
     execution_contract_targets: ensureArray(lastRunSummary.execution_contract_targets),
@@ -8585,10 +8772,13 @@ function buildRunnerShowLastRunPayload(lastRunSummaryRaw) {
     assignment_validation_modes: ensureArray(lastRunSummary.assignment_validation_modes),
     delivery_status: lastRunSummary.delivery_status || "-",
     archive_status: lastRunSummary.archive_status || "-",
-    transport_error: lastRunSummary.transport_error || "-",
-    archive_error: lastRunSummary.archive_error || "-",
-    workspace_dir: lastRunSummary.workspace_dir || "-",
-    artifact_validation: lastRunSummary.artifact_validation || "-",
+    transport_error: lastRunSummary.transport_error || "-",
+    archive_error: lastRunSummary.archive_error || "-",
+    source_message_envelope: safeObject(lastRunSummary.source_message_envelope),
+    last_reply_message_envelope: safeObject(lastRunSummary.last_reply_message_envelope),
+    attempted_delivery_envelope: safeObject(lastRunSummary.attempted_delivery_envelope),
+    workspace_dir: lastRunSummary.workspace_dir || "-",
+    artifact_validation: lastRunSummary.artifact_validation || "-",
     artifact_paths: ensureArray(lastRunSummary.artifact_paths),
     artifact_errors: ensureArray(lastRunSummary.artifact_errors),
     boundary_violations: ensureArray(lastRunSummary.boundary_violations),

package/lib/provider-local-transport.mjs

@@ -23,6 +23,14 @@ function parseJSONText(rawText) {
   }
 }
 
+function intFromRawAllowZero(value, fallback = 0) {
+  if (value === null || value === undefined || value === "") {
+    return fallback;
+  }
+  const parsed = Number.parseInt(String(value).trim(), 10);
+  return Number.isFinite(parsed) ? parsed : fallback;
+}
+
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }

package/lib/runner-helpers.mjs

@@ -31,6 +31,130 @@ function intFromRaw(raw, fallback) {
   return parsed > 0 ? parsed : fallback;
 }
 
+export function normalizeTelegramMessageEnvelope(rawEnvelope) {
+  const envelope = safeObject(rawEnvelope);
+  const chatID = String(
+    envelope.chat_id
+    || envelope.chatID
+    || envelope.chatId
+    || "",
+  ).trim();
+  const messageID = intFromRawAllowZero(envelope.message_id || envelope.messageID, 0);
+  const messageThreadID = intFromRawAllowZero(
+    envelope.message_thread_id || envelope.messageThreadID,
+    0,
+  );
+  const replyToMessageID = intFromRawAllowZero(
+    envelope.reply_to_message_id || envelope.replyToMessageID,
+    0,
+  );
+  const kind = String(envelope.kind || "").trim().toLowerCase();
+  const senderUsername = normalizeMentionSelector(
+    envelope.sender_username
+    || envelope.senderUsername
+    || envelope.username
+    || envelope.bot_username
+    || envelope.botUsername
+    || "",
+  );
+  const sender = firstNonEmptyString([
+    envelope.sender,
+    senderUsername ? `@${senderUsername}` : "",
+  ]);
+  const rawSenderIsBot = envelope.sender_is_bot ?? envelope.senderIsBot;
+  const senderIsBot = rawSenderIsBot === true
+    || rawSenderIsBot === "true"
+    || rawSenderIsBot === 1
+    || rawSenderIsBot === "1"
+    || kind === "bot_reply";
+  const body = String(envelope.body || envelope.text || "").trim();
+  if (
+    !chatID
+    && !(messageID > 0)
+    && !(messageThreadID > 0)
+    && !(replyToMessageID > 0)
+    && !kind
+    && !sender
+    && !senderUsername
+    && !body
+  ) {
+    return {};
+  }
+  return {
+    ...(chatID ? { chat_id: chatID } : {}),
+    ...(messageID > 0 ? { message_id: messageID } : {}),
+    ...(messageThreadID > 0 ? { message_thread_id: messageThreadID } : {}),
+    ...(replyToMessageID > 0 ? { reply_to_message_id: replyToMessageID } : {}),
+    ...(kind ? { kind } : {}),
+    ...(sender ? { sender } : {}),
+    ...(senderUsername ? { sender_username: senderUsername } : {}),
+    sender_is_bot: senderIsBot === true,
+    ...(body ? { body } : {}),
+  };
+}
+
+export function buildTelegramMessageEnvelopeFromParsedArchive(parsedArchiveRaw, overrides = {}) {
+  const parsedArchive = safeObject(parsedArchiveRaw);
+  return normalizeTelegramMessageEnvelope({
+    chat_id: firstNonEmptyString([
+      overrides.chat_id,
+      parsedArchive.chatID,
+      parsedArchive.chatId,
+    ]),
+    message_id: overrides.message_id ?? parsedArchive.messageID,
+    message_thread_id: overrides.message_thread_id ?? parsedArchive.messageThreadID,
+    reply_to_message_id: overrides.reply_to_message_id ?? parsedArchive.replyToMessageID,
+    kind: firstNonEmptyString([overrides.kind, parsedArchive.kind]),
+    sender: firstNonEmptyString([
+      overrides.sender,
+      parsedArchive.sender,
+      parsedArchive.botName,
+      parsedArchive.replyToSender,
+    ]),
+    sender_username: firstNonEmptyString([
+      overrides.sender_username,
+      parsedArchive.botUsername,
+      parsedArchive.username,
+      parsedArchive.replyToUsername,
+    ]),
+    sender_is_bot: overrides.sender_is_bot ?? parsedArchive.senderIsBot,
+    body: firstNonEmptyString([overrides.body, parsedArchive.body]),
+  });
+}
+
+export function buildTelegramBotReplyEnvelope({
+  sourceEnvelope: sourceEnvelopeRaw = {},
+  chatID = "",
+  messageID = 0,
+  messageThreadID = 0,
+  replyToMessageID = 0,
+  sender = "",
+  senderUsername = "",
+  body = "",
+} = {}) {
+  const sourceEnvelope = normalizeTelegramMessageEnvelope(sourceEnvelopeRaw);
+  const normalizedSenderUsername = normalizeMentionSelector(senderUsername);
+  const senderLabel = firstNonEmptyString([
+    sender,
+    normalizedSenderUsername ? `@${normalizedSenderUsername}` : "",
+    "bot",
+  ]);
+  return normalizeTelegramMessageEnvelope({
+    chat_id: firstNonEmptyString([
+      chatID,
+      sourceEnvelope.chat_id,
+    ]),
+    message_id: intFromRawAllowZero(messageID, 0) || undefined,
+    message_thread_id: intFromRawAllowZero(messageThreadID, 0) || undefined,
+    reply_to_message_id: intFromRawAllowZero(replyToMessageID, 0) || undefined,
+    kind: "bot_reply",
+    sender: senderLabel,
+    sender_username: normalizedSenderUsername,
+    sender_is_bot: true,
+    body: String(body || "").trim(),
+  });
+}
+
 function normalizePendingSelectionOptions(rawOptions) {
   const options = safeObject(rawOptions);
   const maxPendingAgeMs = intFromRawAllowZero(options.maxPendingAgeMs, 0);

package/lib/runner-orchestration.mjs

@@ -1,11 +1,14 @@
 import fs from "node:fs";
 import path from "node:path";
 import {
+  buildTelegramBotReplyEnvelope,
+  buildTelegramMessageEnvelopeFromParsedArchive,
   buildRunnerContextWindow,
   buildRunnerRouteStateFromComment,
   compareArchiveCommentRecords,
   dedupeProcessableArchiveComments,
   isInboundArchiveKind,
+  normalizeTelegramMessageEnvelope,
   selectPendingArchiveComments,
 } from "./runner-helpers.mjs";
 import {
@@ -4717,16 +4720,18 @@ export async function processRunnerSelectedRecord({
     safeObject(persistedHumanIntentRequest).reply_chain_context
     || safeObject(persistedHumanIntentRequest).replyChainContext,
   );
-  const replyMessageThreadID = intFromRawAllowZero(
-    safeObject(selectedRecord?.parsedArchive).messageThreadID
-      || authorityReplyChainContext.current_message_thread_id
-      || safeObject(authorityReplyChainContext.parent_message).message_thread_id
-      || safeObject(authorityReplyChainContext.latest_prior_bot_reply).message_thread_id
-      || safeObject(persistedHumanIntentRequest).last_source_message_thread_id
-      || safeObject(persistedHumanIntentRequest).source_message_thread_id
-      || safeObject(persistedHumanIntentRequest).last_reply_message_thread_id,
-    0,
-  );
+  const sourceMessageEnvelope = buildTelegramMessageEnvelopeFromParsedArchive(selectedRecord?.parsedArchive);
+  const replyMessageThreadID = intFromRawAllowZero(sourceMessageEnvelope.message_thread_id, 0);
+  const replyToMessageID = intFromRawAllowZero(sourceMessageEnvelope.message_id, 0);
+  const replyAnchorSource = replyToMessageID > 0 ? "source_message_envelope" : "";
+  const attemptedDeliveryEnvelope = buildTelegramBotReplyEnvelope({
+    sourceEnvelope: sourceMessageEnvelope,
+    messageThreadID: replyMessageThreadID,
+    replyToMessageID,
+    sender: bot?.username ? `@${String(bot.username || "").trim().replace(/^@+/, "")}` : String(bot?.name || "bot").trim(),
+    senderUsername: normalizeMentionSelector(bot?.username || bot?.name),
+    body: sanitizedReplyText,
+  });
   const normalizedPrecomputedHumanIntentContext = safeObject(precomputedHumanIntentContext);
   const validateWorkspaceArtifacts = typeof executionDeps.validateWorkspaceArtifacts === "function"
     ? executionDeps.validateWorkspaceArtifacts
@@ -5136,7 +5141,7 @@ export async function processRunnerSelectedRecord({
         text: replyText,
         disableWebPagePreview: true,
         messageThreadID: replyMessageThreadID,
-        replyToMessageID: intFromRawAllowZero(selectedRecord.parsedArchive?.messageID, 0),
+        replyToMessageID,
         archiveReplies: normalizedRoute.archivePolicy.mirrorReplies,
         archiveDedupeOutbound: normalizedRoute.archivePolicy.dedupeOutbound,
         archiveThreadID: archiveThread.threadID,
@@ -5488,9 +5493,6 @@ export async function processRunnerSelectedRecord({
       },
     };
   }
-  const replyToMessageID = aiResult.replyToMessageID > 0
-    ? aiResult.replyToMessageID
-    : intFromRawAllowZero(selectedRecord.parsedArchive?.messageID, 0);
   const sanitizedReplyText = sanitizeForcedDirectReplyText({
     replyText: aiResult.reply,
     bot,
@@ -5667,6 +5669,10 @@ export async function processRunnerSelectedRecord({
         ai_reply_generated: true,
         ai_reply_generated_at: aiReplyGeneratedAt,
         ai_reply_preview: aiReplyPreview,
+        source_message_envelope: sourceMessageEnvelope,
+        attempted_delivery_envelope: attemptedDeliveryEnvelope,
+        reply_to_message_id: replyToMessageID,
+        reply_message_thread_id: replyMessageThreadID,
         delivery_status: "failed_transport",
         archive_status: "not_attempted",
         transport_error: transportError,
@@ -5765,6 +5771,7 @@ export async function processRunnerSelectedRecord({
           0,
         ),
         last_reply_message_thread_id: intFromRawAllowZero(deliveryResult.delivery.effectiveMessageThreadID, replyMessageThreadID),
+        last_reply_anchor_source: replyAnchorSource,
           last_contract_validation_status: String(responseContractValidation.status || "").trim(),
           last_contract_validation_reason: String(responseContractValidation.reason || "").trim(),
           last_contract_validation_targets: ensureArray(responseContractValidation.targets),
@@ -5873,12 +5880,27 @@ export async function processRunnerSelectedRecord({
       ai_reply_generated: true,
       ai_reply_generated_at: aiReplyGeneratedAt,
       ai_reply_preview: aiReplyPreview,
+      source_message_envelope: sourceMessageEnvelope,
+      attempted_delivery_envelope: attemptedDeliveryEnvelope,
       last_reply_message_id: intFromRawAllowZero(
         safeObject(deliveryResult.delivery.body).result?.message_id ?? safeObject(deliveryResult.delivery.body).message_id,
         0,
       ),
       last_reply_message_thread_id: intFromRawAllowZero(deliveryResult.delivery.effectiveMessageThreadID, replyMessageThreadID),
       reply_to_message_id: intFromRawAllowZero(deliveryResult.delivery.effectiveReplyToMessageID, replyToMessageID),
+      last_reply_message_envelope: buildTelegramBotReplyEnvelope({
+        sourceEnvelope: sourceMessageEnvelope,
+        messageID: intFromRawAllowZero(
+          safeObject(deliveryResult.delivery.body).result?.message_id ?? safeObject(deliveryResult.delivery.body).message_id,
+          0,
+        ),
+        messageThreadID: intFromRawAllowZero(deliveryResult.delivery.effectiveMessageThreadID, replyMessageThreadID),
+        replyToMessageID: intFromRawAllowZero(deliveryResult.delivery.effectiveReplyToMessageID, replyToMessageID),
+        sender: bot?.username ? `@${String(bot.username || "").trim().replace(/^@+/, "")}` : String(bot?.name || "bot").trim(),
+        senderUsername: normalizeMentionSelector(bot?.username || bot?.name),
+        body: sanitizedReplyText,
+      }),
+      reply_anchor_source: replyAnchorSource,
       reply_fallback_used: deliveryResult.delivery.replyFallbackUsed === true,
       response_contract_validation_status: String(responseContractValidation.status || "").trim(),
       response_contract_validation_reason: String(responseContractValidation.reason || "").trim(),

package/package.json

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