metheus-governance-mcp-cli 0.2.247 → 0.2.249

package/cli.mjs

@@ -2075,9 +2075,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 +2128,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 +2231,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 +2278,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 = {};
@@ -2728,30 +2818,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 +3908,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([
@@ -5217,15 +5279,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 +5656,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 +6001,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 +6031,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

package/lib/runner-orchestration.mjs

@@ -4724,14 +4724,6 @@ export async function processRunnerSelectedRecord({
   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
@@ -5500,6 +5492,14 @@ export async function processRunnerSelectedRecord({
     triggerDecision: effectiveTriggerDecision,
     conversationContext: effectiveConversationContext,
   });
+  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 normalizedExecutionTargets = ensureArray(executionContract?.assignments)
     .map((item) => normalizeMentionSelector(item?.targetBot))
     .filter(Boolean);

package/package.json

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