metheus-governance-mcp-cli 0.2.248 → 0.2.250

package/cli.mjs

@@ -140,6 +140,7 @@ import {
   buildRunnerRouteStateFromComment,
   buildProcessableArchiveLogicalKey,
   findEarlierProcessableArchiveDuplicate,
+  findRecentTelegramMessageEnvelope,
   isInboundArchiveKind,
   normalizeTelegramMessageEnvelope as normalizeRunnerTelegramMessageEnvelope,
   normalizeArchiveCommentRecord,
@@ -1989,6 +1990,7 @@ function mergeRunnerStateRecords(preferred, fallback) {
     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"),
+    recent_local_inbound_envelopes: pickObjectField("recent_local_inbound_envelopes"),
     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),
@@ -2075,9 +2077,10 @@ function migrateBotRunnerStateRoutes(routes, runnerConfig) {
   };
 }
 
-function loadBotRunnerState() {
-  const filePath = botRunnerStateFilePath();
-  try {
+function loadBotRunnerState() {
+  const filePath = botRunnerStateFilePath();
+  waitForBotRunnerStateLockRelease(filePath);
+  try {
     if (!fs.existsSync(filePath)) {
       return {
         filePath,
@@ -2127,8 +2130,97 @@ function loadBotRunnerState() {
       remainingAnonymousKeys: [],
     };
   }
-}
-
+}
+
+function sleepSyncMs(delayMs) {
+  const ms = Number(delayMs) || 0;
+  if (!(ms > 0)) {
+    return;
+  }
+  const sleepBuffer = new SharedArrayBuffer(4);
+  const sleepArray = new Int32Array(sleepBuffer);
+  Atomics.wait(sleepArray, 0, 0, ms);
+}
+
+function botRunnerStateLockFilePath(filePath) {
+  const normalizedPath = String(filePath || "").trim();
+  return normalizedPath ? `${normalizedPath}.lock` : "";
+}
+
+function tryReleaseStaleBotRunnerStateLock(lockPath, staleMs = 60000) {
+  const normalizedPath = String(lockPath || "").trim();
+  if (!normalizedPath) {
+    return false;
+  }
+  try {
+    const stats = fs.statSync(normalizedPath);
+    const ageMs = Date.now() - Number(stats.mtimeMs || 0);
+    if (Number.isFinite(ageMs) && ageMs >= staleMs) {
+      fs.rmSync(normalizedPath, { force: true });
+      return true;
+    }
+  } catch {}
+  return false;
+}
+
+function waitForBotRunnerStateLockRelease(filePath, timeoutMs = 5000, staleMs = 60000) {
+  const lockPath = botRunnerStateLockFilePath(filePath);
+  if (!lockPath) {
+    return;
+  }
+  const deadlineMs = Date.now() + Math.max(0, Number(timeoutMs) || 0);
+  while (fs.existsSync(lockPath)) {
+    tryReleaseStaleBotRunnerStateLock(lockPath, staleMs);
+    if (!fs.existsSync(lockPath)) {
+      return;
+    }
+    if (Date.now() >= deadlineMs) {
+      return;
+    }
+    sleepSyncMs(25);
+  }
+}
+
+function withBotRunnerStateFileLock(filePath, callback, timeoutMs = 5000, staleMs = 60000) {
+  const lockPath = botRunnerStateLockFilePath(filePath);
+  if (!lockPath) {
+    return callback();
+  }
+  const deadlineMs = Date.now() + Math.max(0, Number(timeoutMs) || 0);
+  let lockFD = null;
+  while (lockFD === null) {
+    try {
+      lockFD = fs.openSync(lockPath, "wx");
+      fs.writeFileSync(lockFD, `${process.pid} ${new Date().toISOString()}\n`, "utf8");
+      break;
+    } catch (error) {
+      const errorCode = String(error?.code || "").trim().toUpperCase();
+      if (!["EEXIST", "EPERM", "EBUSY"].includes(errorCode)) {
+        throw error;
+      }
+      tryReleaseStaleBotRunnerStateLock(lockPath, staleMs);
+      if (Date.now() >= deadlineMs) {
+        throw error;
+      }
+      sleepSyncMs(25);
+    }
+  }
+  try {
+    return callback();
+  } finally {
+    try {
+      if (lockFD !== null) {
+        fs.closeSync(lockFD);
+      }
+    } catch {}
+    try {
+      if (fs.existsSync(lockPath)) {
+        fs.rmSync(lockPath, { force: true });
+      }
+    } catch {}
+  }
+}
+
 function writeTextFileAtomic(filePath, text) {
   const normalizedPath = String(filePath || "").trim();
   if (!normalizedPath) {
@@ -2141,14 +2233,12 @@ function writeTextFileAtomic(filePath, text) {
     `.${path.basename(normalizedPath)}.${process.pid}.${Date.now()}.tmp`,
   );
   fs.writeFileSync(tempPath, text, "utf8");
-  const renameRetryDelaysMs = [0, 20, 50, 100, 200];
-  const sleepBuffer = new SharedArrayBuffer(4);
-  const sleepArray = new Int32Array(sleepBuffer);
-  let lastRenameError = null;
+  const renameRetryDelaysMs = [0, 20, 50, 100, 200];
+  let lastRenameError = null;
   try {
     for (const delayMs of renameRetryDelaysMs) {
       if (delayMs > 0) {
-        Atomics.wait(sleepArray, 0, 0, delayMs);
+        sleepSyncMs(delayMs);
       }
       try {
         fs.renameSync(tempPath, normalizedPath);
@@ -2190,186 +2280,188 @@ function writeTextFileAtomic(filePath, text) {
   }
 }
 
-function saveBotRunnerState(nextState) {
-  const filePath = botRunnerStateFilePath();
-  let current = {};
-  try {
-    current = safeObject(tryJsonParse(fs.readFileSync(filePath, "utf8")));
-  } catch {}
-  const stateEntryTimestampMs = (...values) => {
-    for (const value of values) {
-      const ms = Date.parse(String(value || "").trim());
-      if (Number.isFinite(ms)) {
-        return ms;
-      }
-    }
-    return 0;
-  };
-  const mergeRunnerStateRoutes = (currentRoutesRaw, nextRoutesRaw) => {
-    const currentRoutes = safeObject(currentRoutesRaw);
-    const nextRoutes = safeObject(nextRoutesRaw);
-    const merged = {
-      ...currentRoutes,
-    };
-    const mergeConversationSessions = (currentSessionsRaw, nextSessionsRaw) => {
-      const currentSessions = safeObject(currentSessionsRaw);
-      const nextSessions = safeObject(nextSessionsRaw);
-      const mergedSessions = {
-        ...currentSessions,
-      };
-      for (const [conversationID, nextSessionRaw] of Object.entries(nextSessions)) {
-        const currentSession = safeObject(currentSessions[conversationID]);
-        const nextSession = safeObject(nextSessionRaw);
-        if (!Object.keys(currentSession).length) {
-          mergedSessions[conversationID] = nextSession;
-          continue;
-        }
-        const currentMs = stateEntryTimestampMs(
-          currentSession.updated_at,
-          currentSession.last_activity_at,
-          currentSession.closed_at,
-          currentSession.started_at,
-          currentSession.expires_at,
-        );
-        const nextMs = stateEntryTimestampMs(
-          nextSession.updated_at,
-          nextSession.last_activity_at,
-          nextSession.closed_at,
-          nextSession.started_at,
-          nextSession.expires_at,
-        );
-        mergedSessions[conversationID] = nextMs >= currentMs
-          ? {
-              ...currentSession,
-              ...nextSession,
-            }
-          : {
-              ...nextSession,
-              ...currentSession,
-            };
-      }
-      return mergedSessions;
-    };
-    for (const [routeKey, nextRouteRaw] of Object.entries(nextRoutes)) {
-      const currentRoute = safeObject(currentRoutes[routeKey]);
-      const nextRoute = safeObject(nextRouteRaw);
-      if (!Object.keys(currentRoute).length) {
-        merged[routeKey] = nextRoute;
-        continue;
-      }
-      const preferredRoute = prefersRunnerStateRecord(nextRoute, currentRoute) ? nextRoute : currentRoute;
-      const fallbackRoute = preferredRoute === nextRoute ? currentRoute : nextRoute;
-      merged[routeKey] = cleanupRunnerStateRecord({
-        ...mergeRunnerStateRecords(preferredRoute, fallbackRoute),
-        conversation_sessions: mergeConversationSessions(
-          currentRoute.conversation_sessions,
-          nextRoute.conversation_sessions,
-        ),
-      });
-    }
-    return merged;
-  };
-  const mergeRunnerStateRequests = (currentRequestsRaw, nextRequestsRaw) => {
-    const currentRequests = normalizeBotRunnerRequests(currentRequestsRaw);
-    const nextRequests = normalizeBotRunnerRequests(nextRequestsRaw);
-    const merged = {
-      ...currentRequests,
-    };
-    for (const [requestKey, nextRequestRaw] of Object.entries(nextRequests)) {
-      const currentRequest = safeObject(currentRequests[requestKey]);
-      const nextRequest = safeObject(nextRequestRaw);
-      const currentMs = stateEntryTimestampMs(
-        currentRequest.updated_at,
-        currentRequest.completed_at,
-        currentRequest.closed_at,
-        currentRequest.claimed_at,
-      );
-      const nextMs = stateEntryTimestampMs(
-        nextRequest.updated_at,
-        nextRequest.completed_at,
-        nextRequest.closed_at,
-        nextRequest.claimed_at,
-      );
-      if (!Object.keys(currentRequest).length) {
-        merged[requestKey] = nextRequest;
-        continue;
-      }
-      merged[requestKey] = nextMs >= currentMs
-        ? {
-            ...currentRequest,
-            ...nextRequest,
-          }
-        : currentRequest;
-    }
-    return normalizeBotRunnerRequests(merged);
-  };
-  const mergeRunnerStateExcludedComments = (currentExcludedRaw, nextExcludedRaw) => {
-    const currentExcluded = normalizeBotRunnerExcludedComments(currentExcludedRaw);
-    const nextExcluded = normalizeBotRunnerExcludedComments(nextExcludedRaw);
-    const merged = {
-      ...currentExcluded,
-    };
-    for (const [commentID, nextEntryRaw] of Object.entries(nextExcluded)) {
-      const currentEntry = safeObject(currentExcluded[commentID]);
-      const nextEntry = safeObject(nextEntryRaw);
-      const currentMs = stateEntryTimestampMs(currentEntry.excluded_at);
-      const nextMs = stateEntryTimestampMs(nextEntry.excluded_at);
-      if (!Object.keys(currentEntry).length || nextMs >= currentMs) {
-        merged[commentID] = {
-          ...currentEntry,
-          ...nextEntry,
-        };
-      }
-    }
-    return normalizeBotRunnerExcludedComments(merged);
-  };
-  const mergeRunnerStateConsumedComments = (currentConsumedRaw, nextConsumedRaw) => {
-    const currentConsumed = normalizeBotRunnerConsumedComments(currentConsumedRaw);
-    const nextConsumed = normalizeBotRunnerConsumedComments(nextConsumedRaw);
-    const merged = {
-      ...currentConsumed,
-    };
-    for (const [commentID, nextEntryRaw] of Object.entries(nextConsumed)) {
-      const currentEntry = safeObject(currentConsumed[commentID]);
-      const nextEntry = safeObject(nextEntryRaw);
-      const currentMs = stateEntryTimestampMs(currentEntry.consumed_at);
-      const nextMs = stateEntryTimestampMs(nextEntry.consumed_at);
-      if (!Object.keys(currentEntry).length || nextMs >= currentMs) {
-        merged[commentID] = {
-          ...currentEntry,
-          ...nextEntry,
-        };
-      }
-    }
-    return normalizeBotRunnerConsumedComments(merged);
-  };
-  const payload = {
-    version: 1,
-    updated_at: new Date().toISOString(),
-    routes: mergeRunnerStateRoutes(
-      current.routes,
-      nextState?.routes ?? current.routes,
-    ),
-    shared_inboxes: {
-      ...safeObject(current.shared_inboxes ?? current.sharedInboxes),
-      ...safeObject(nextState?.sharedInboxes ?? nextState?.shared_inboxes),
-    },
-    excluded_comments: mergeRunnerStateExcludedComments(
-      current.excluded_comments ?? current.excludedComments,
-      nextState?.excludedComments ?? nextState?.excluded_comments ?? current.excluded_comments ?? current.excludedComments,
-    ),
-    requests: mergeRunnerStateRequests(
-      current.requests,
-      nextState?.requests ?? current.requests,
-    ),
-    consumed_comments: mergeRunnerStateConsumedComments(
-      current.consumed_comments ?? current.consumedComments,
-      nextState?.consumedComments ?? nextState?.consumed_comments ?? current.consumed_comments ?? current.consumedComments,
-    ),
-  };
-  writeTextFileAtomic(filePath, `${JSON.stringify(payload, null, 2)}\n`);
-  return filePath;
-}
+function saveBotRunnerState(nextState) {
+  const filePath = botRunnerStateFilePath();
+  return withBotRunnerStateFileLock(filePath, () => {
+    let current = {};
+    try {
+      current = safeObject(tryJsonParse(fs.readFileSync(filePath, "utf8")));
+    } catch {}
+    const stateEntryTimestampMs = (...values) => {
+      for (const value of values) {
+        const ms = Date.parse(String(value || "").trim());
+        if (Number.isFinite(ms)) {
+          return ms;
+        }
+      }
+      return 0;
+    };
+    const mergeRunnerStateRoutes = (currentRoutesRaw, nextRoutesRaw) => {
+      const currentRoutes = safeObject(currentRoutesRaw);
+      const nextRoutes = safeObject(nextRoutesRaw);
+      const merged = {
+        ...currentRoutes,
+      };
+      const mergeConversationSessions = (currentSessionsRaw, nextSessionsRaw) => {
+        const currentSessions = safeObject(currentSessionsRaw);
+        const nextSessions = safeObject(nextSessionsRaw);
+        const mergedSessions = {
+          ...currentSessions,
+        };
+        for (const [conversationID, nextSessionRaw] of Object.entries(nextSessions)) {
+          const currentSession = safeObject(currentSessions[conversationID]);
+          const nextSession = safeObject(nextSessionRaw);
+          if (!Object.keys(currentSession).length) {
+            mergedSessions[conversationID] = nextSession;
+            continue;
+          }
+          const currentMs = stateEntryTimestampMs(
+            currentSession.updated_at,
+            currentSession.last_activity_at,
+            currentSession.closed_at,
+            currentSession.started_at,
+            currentSession.expires_at,
+          );
+          const nextMs = stateEntryTimestampMs(
+            nextSession.updated_at,
+            nextSession.last_activity_at,
+            nextSession.closed_at,
+            nextSession.started_at,
+            nextSession.expires_at,
+          );
+          mergedSessions[conversationID] = nextMs >= currentMs
+            ? {
+                ...currentSession,
+                ...nextSession,
+              }
+            : {
+                ...nextSession,
+                ...currentSession,
+              };
+        }
+        return mergedSessions;
+      };
+      for (const [routeKey, nextRouteRaw] of Object.entries(nextRoutes)) {
+        const currentRoute = safeObject(currentRoutes[routeKey]);
+        const nextRoute = safeObject(nextRouteRaw);
+        if (!Object.keys(currentRoute).length) {
+          merged[routeKey] = nextRoute;
+          continue;
+        }
+        const preferredRoute = prefersRunnerStateRecord(nextRoute, currentRoute) ? nextRoute : currentRoute;
+        const fallbackRoute = preferredRoute === nextRoute ? currentRoute : nextRoute;
+        merged[routeKey] = cleanupRunnerStateRecord({
+          ...mergeRunnerStateRecords(preferredRoute, fallbackRoute),
+          conversation_sessions: mergeConversationSessions(
+            currentRoute.conversation_sessions,
+            nextRoute.conversation_sessions,
+          ),
+        });
+      }
+      return merged;
+    };
+    const mergeRunnerStateRequests = (currentRequestsRaw, nextRequestsRaw) => {
+      const currentRequests = normalizeBotRunnerRequests(currentRequestsRaw);
+      const nextRequests = normalizeBotRunnerRequests(nextRequestsRaw);
+      const merged = {
+        ...currentRequests,
+      };
+      for (const [requestKey, nextRequestRaw] of Object.entries(nextRequests)) {
+        const currentRequest = safeObject(currentRequests[requestKey]);
+        const nextRequest = safeObject(nextRequestRaw);
+        const currentMs = stateEntryTimestampMs(
+          currentRequest.updated_at,
+          currentRequest.completed_at,
+          currentRequest.closed_at,
+          currentRequest.claimed_at,
+        );
+        const nextMs = stateEntryTimestampMs(
+          nextRequest.updated_at,
+          nextRequest.completed_at,
+          nextRequest.closed_at,
+          nextRequest.claimed_at,
+        );
+        if (!Object.keys(currentRequest).length) {
+          merged[requestKey] = nextRequest;
+          continue;
+        }
+        merged[requestKey] = nextMs >= currentMs
+          ? {
+              ...currentRequest,
+              ...nextRequest,
+            }
+          : currentRequest;
+      }
+      return normalizeBotRunnerRequests(merged);
+    };
+    const mergeRunnerStateExcludedComments = (currentExcludedRaw, nextExcludedRaw) => {
+      const currentExcluded = normalizeBotRunnerExcludedComments(currentExcludedRaw);
+      const nextExcluded = normalizeBotRunnerExcludedComments(nextExcludedRaw);
+      const merged = {
+        ...currentExcluded,
+      };
+      for (const [commentID, nextEntryRaw] of Object.entries(nextExcluded)) {
+        const currentEntry = safeObject(currentExcluded[commentID]);
+        const nextEntry = safeObject(nextEntryRaw);
+        const currentMs = stateEntryTimestampMs(currentEntry.excluded_at);
+        const nextMs = stateEntryTimestampMs(nextEntry.excluded_at);
+        if (!Object.keys(currentEntry).length || nextMs >= currentMs) {
+          merged[commentID] = {
+            ...currentEntry,
+            ...nextEntry,
+          };
+        }
+      }
+      return normalizeBotRunnerExcludedComments(merged);
+    };
+    const mergeRunnerStateConsumedComments = (currentConsumedRaw, nextConsumedRaw) => {
+      const currentConsumed = normalizeBotRunnerConsumedComments(currentConsumedRaw);
+      const nextConsumed = normalizeBotRunnerConsumedComments(nextConsumedRaw);
+      const merged = {
+        ...currentConsumed,
+      };
+      for (const [commentID, nextEntryRaw] of Object.entries(nextConsumed)) {
+        const currentEntry = safeObject(currentConsumed[commentID]);
+        const nextEntry = safeObject(nextEntryRaw);
+        const currentMs = stateEntryTimestampMs(currentEntry.consumed_at);
+        const nextMs = stateEntryTimestampMs(nextEntry.consumed_at);
+        if (!Object.keys(currentEntry).length || nextMs >= currentMs) {
+          merged[commentID] = {
+            ...currentEntry,
+            ...nextEntry,
+          };
+        }
+      }
+      return normalizeBotRunnerConsumedComments(merged);
+    };
+    const payload = {
+      version: 1,
+      updated_at: new Date().toISOString(),
+      routes: mergeRunnerStateRoutes(
+        current.routes,
+        nextState?.routes ?? current.routes,
+      ),
+      shared_inboxes: {
+        ...safeObject(current.shared_inboxes ?? current.sharedInboxes),
+        ...safeObject(nextState?.sharedInboxes ?? nextState?.shared_inboxes),
+      },
+      excluded_comments: mergeRunnerStateExcludedComments(
+        current.excluded_comments ?? current.excludedComments,
+        nextState?.excludedComments ?? nextState?.excluded_comments ?? current.excluded_comments ?? current.excludedComments,
+      ),
+      requests: mergeRunnerStateRequests(
+        current.requests,
+        nextState?.requests ?? current.requests,
+      ),
+      consumed_comments: mergeRunnerStateConsumedComments(
+        current.consumed_comments ?? current.consumedComments,
+        nextState?.consumedComments ?? nextState?.consumed_comments ?? current.consumed_comments ?? current.consumedComments,
+      ),
+    };
+    writeTextFileAtomic(filePath, `${JSON.stringify(payload, null, 2)}\n`);
+    return filePath;
+  });
+}
 
 function normalizeBotRunnerExcludedComments(rawExcluded, nowMs = Date.now()) {
   const normalized = {};
@@ -2552,6 +2644,42 @@ function normalizeRunnerReplyChainContext(rawContext) {
   return normalized;
 }
 
+function findRunnerRouteLocalInboundEnvelope(routeStateRaw, parsedArchiveRaw) {
+  const routeState = safeObject(routeStateRaw);
+  const parsedArchive = safeObject(parsedArchiveRaw);
+  const chatID = String(parsedArchive.chatID || parsedArchive.chatId || "").trim();
+  const messageID = intFromRawAllowZero(parsedArchive.messageID, 0);
+  if (!chatID || !(messageID > 0)) {
+    return {};
+  }
+  return findRecentTelegramMessageEnvelope(routeState.recent_local_inbound_envelopes, {
+    chatID,
+    messageID,
+  });
+}
+
+function buildRunnerSourceMessageEnvelope({
+  routeState = {},
+  routeKey = "",
+  normalizedRoute = null,
+  parsedArchive = null,
+}) {
+  const localEnvelope = findRunnerRouteLocalInboundEnvelope(routeState, parsedArchive);
+  if (String(localEnvelope.source_origin || "").trim().toLowerCase() === "local_telegram_inbound") {
+    return localEnvelope;
+  }
+  const fallbackBotSelector = normalizeTelegramMentionUsername(
+    normalizedRoute?.botName
+      || normalizedRoute?.serverBotName
+      || "",
+  );
+  return buildRunnerTelegramMessageEnvelopeFromParsedArchive(parsedArchive, {
+    source_origin: "archive_reconstructed",
+    source_route_key: String(routeKey || "").trim(),
+    source_bot_username: fallbackBotSelector,
+  });
+}
+
 function normalizeBotRunnerRequests(rawRequests, nowMs = Date.now()) {
   const normalized = {};
   for (const [requestKeyRaw, entryRaw] of Object.entries(safeObject(rawRequests))) {
@@ -2586,6 +2714,7 @@ function normalizeBotRunnerRequests(rawRequests, nowMs = Date.now()) {
               body: entry.source_message_body || entry.sourceMessageBody,
               sender: "human",
               sender_is_bot: false,
+              source_origin: "archive_reconstructed",
             }
           : {}),
       ),
@@ -2728,30 +2857,12 @@ function normalizeBotRunnerRequests(rawRequests, nowMs = Date.now()) {
       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(),
     };
@@ -3836,20 +3947,10 @@ function buildRunnerReplyChainSnapshotFromRequestReply(requestRaw) {
   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,
+      : null,
     {
       speaker_type: "bot",
       speaker_label: firstNonEmptyString([
@@ -4346,9 +4447,10 @@ async function claimRunnerRequestForHumanComment({
       reason: "non_human_comment_cannot_create_request",
     };
   }
-  const currentState = loadBotRunnerState();
-  const replyChainResolution = await resolveRunnerReplyChainConversationContextWithServerFallback({
-    state: currentState,
+  const currentState = loadBotRunnerState();
+  const currentRouteState = safeObject(safeObject(currentState.routes)[String(routeKey || "").trim()]);
+  const replyChainResolution = await resolveRunnerReplyChainConversationContextWithServerFallback({
+    state: currentState,
     normalizedRoute,
     selectedRecord,
     runtime,
@@ -4468,14 +4570,19 @@ async function claimRunnerRequestForHumanComment({
     };
   }
   const nowISO = new Date().toISOString();
-  const { requests: nextRequests, request } = upsertRunnerRequest(stateForClaim, requestKey, {
+  const { requests: nextRequests, request } = upsertRunnerRequest(stateForClaim, requestKey, {
     project_id: String(normalizedRoute?.projectID || "").trim(),
     provider: String(normalizedRoute?.provider || "").trim(),
     chat_id: String(parsed.chatID || parsed.chatId || "").trim(),
     source_message_id: intFromRawAllowZero(parsed.messageID, 0) || undefined,
     source_message_thread_id: intFromRawAllowZero(parsed.messageThreadID, 0) || undefined,
     source_message_body: String(parsed.body || "").trim(),
-    source_message_envelope: buildRunnerTelegramMessageEnvelopeFromParsedArchive(parsed),
+    source_message_envelope: buildRunnerSourceMessageEnvelope({
+      routeState: currentRouteState,
+      routeKey,
+      normalizedRoute,
+      parsedArchive: parsed,
+    }),
     root_comment_id: String(selectedRecord?.id || "").trim(),
     root_comment_kind: commentKind,
     conversation_id: resolvedConversationID,
@@ -5217,15 +5324,17 @@ function buildRunnerRequestRecoveryPatchFromRouteState(currentStateRaw, requestR
     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 routeFollowupDeliveryStatus = String(routeState.last_followup_delivery_status || "").trim().toLowerCase();
+    const routeFollowupDelivered = ["delivered", "dry_run"].includes(routeFollowupDeliveryStatus);
     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) {
+    if (!Object.keys(safeObject(request.last_reply_message_envelope)).length && routeFollowupDelivered) {
       const recoveredReplyEnvelope = normalizeRunnerTelegramMessageEnvelope(routeState.last_followup_last_reply_message_envelope);
-      if (Object.keys(recoveredReplyEnvelope).length) {
+      if (intFromRawAllowZero(recoveredReplyEnvelope.message_id, 0) > 0) {
         patch.last_reply_message_envelope = recoveredReplyEnvelope;
       }
     }
@@ -5592,6 +5701,9 @@ function markRunnerRequestLifecycle({
     senderUsername: normalizedCurrentBotSelector,
     body: aiReplyPreview,
   });
+  const normalizedDeliveryStatus = String(deliveryStatus || "").trim().toLowerCase();
+  const persistSuccessfulReplyEnvelope = ["delivered", "dry_run"].includes(normalizedDeliveryStatus)
+    && intFromRawAllowZero(lastReplyMessageEnvelope.message_id, 0) > 0;
   const attemptedDeliveryEnvelope = buildTelegramBotReplyEnvelope({
     sourceEnvelope: sourceMessageEnvelope,
     chatID: existing.chat_id,
@@ -5934,11 +6046,11 @@ function markRunnerRequestLifecycle({
         ? transportError || existing.followup_transport_error || ""
         : existing.followup_transport_error || "",
     ).trim(),
-    followup_archive_error: String(
-      isFollowupComment
-        ? archiveError || existing.followup_archive_error || ""
-        : existing.followup_archive_error || "",
-    ).trim(),
+    followup_archive_error: String(
+      isFollowupComment
+        ? archiveError || existing.followup_archive_error || ""
+        : existing.followup_archive_error || "",
+    ).trim(),
     normalized_intent: nextNormalizedIntent,
     status: nextStatus,
     started_at: firstNonEmptyString([existing.started_at, nowISO]),
@@ -5964,7 +6076,7 @@ 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
+    last_reply_message_envelope: persistSuccessfulReplyEnvelope
       ? lastReplyMessageEnvelope
       : safeObject(existing.last_reply_message_envelope),
     attempted_delivery_envelope: shouldRefreshAttemptedDeliveryEnvelope
@@ -7485,11 +7597,11 @@ function parseArchivedChatComment(rawBody) {
           .filter(Boolean),
       }
     : null;
-  return {
-    kind,
-    header,
-    metadata,
-    body,
+  return {
+    kind,
+    header,
+    metadata,
+    body,
     chatID: String(metadata.chat_id || "").trim(),
     chatType: String(metadata.chat_type || "").trim().toLowerCase(),
     messageID: intFromRawAllowZero(metadata.message_id, 0),
@@ -7502,8 +7614,11 @@ function parseArchivedChatComment(rawBody) {
       .split(",")
       .map((value) => normalizeTelegramMentionUsername(value))
       .filter(Boolean),
-    occurredAt: String(metadata.occurred_at || "").trim(),
-    replyToMessageID: intFromRawAllowZero(metadata.reply_to_message_id, 0),
+    occurredAt: String(metadata.occurred_at || "").trim(),
+    sourceOrigin: String(metadata.source_origin || "").trim().toLowerCase(),
+    sourceRouteKey: String(metadata.source_route_key || "").trim(),
+    sourceBotUsername: normalizeTelegramMentionUsername(metadata.source_bot_username || ""),
+    replyToMessageID: intFromRawAllowZero(metadata.reply_to_message_id, 0),
     replyToSender: String(metadata.reply_to_sender || "").trim(),
     replyToUsername: String(metadata.reply_to_telegram_username || "").trim(),
     replyToSenderIsBot: boolFromRaw(metadata.reply_to_sender_is_bot, false),
@@ -7819,18 +7934,27 @@ function buildArchivedInboundMessageKey(chatID, messageID) {
   return `${String(chatID || "").trim()}:${intFromRawAllowZero(messageID, 0)}`;
 }
 
-function formatTelegramInboundArchiveComment(normalized) {
-  const headerLines = [
+function formatTelegramInboundArchiveComment(normalized) {
+  const headerLines = [
     `[Telegram ${normalized.eventName === "telegram.message.updated" ? "edited" : "message"}]`,
     `chat_id: ${normalized.chatID || "<missing>"}`,
     `chat_type: ${normalized.chatType || "unknown"}`,
     `message_id: ${normalized.messageID || "<missing>"}`,
     `occurred_at: ${normalized.occurredAt || new Date().toISOString()}`,
     `sender_id: ${normalized.fromID || "<missing>"}`,
-    `sender: ${normalized.fromName || normalized.fromUsername || normalized.fromID || "unknown"}`,
-    `sender_is_bot: ${normalized.fromIsBot ? "true" : "false"}`,
-  ];
-  if (normalized.fromUsername) {
+    `sender: ${normalized.fromName || normalized.fromUsername || normalized.fromID || "unknown"}`,
+    `sender_is_bot: ${normalized.fromIsBot ? "true" : "false"}`,
+  ];
+  if (String(normalized.sourceOrigin || "").trim()) {
+    headerLines.push(`source_origin: ${String(normalized.sourceOrigin || "").trim()}`);
+  }
+  if (String(normalized.sourceRouteKey || "").trim()) {
+    headerLines.push(`source_route_key: ${String(normalized.sourceRouteKey || "").trim()}`);
+  }
+  if (String(normalized.sourceBotUsername || "").trim()) {
+    headerLines.push(`source_bot_username: @${String(normalized.sourceBotUsername || "").trim().replace(/^@+/, "")}`);
+  }
+  if (normalized.fromUsername) {
     headerLines.push(`telegram_username: @${normalized.fromUsername.replace(/^@+/, "")}`);
   }
   if (normalized.mentionUsernames.length > 0) {