metheus-governance-mcp-cli 0.2.256 → 0.2.258

package/cli.mjs

@@ -133,21 +133,21 @@ import {
   tryRegister,
   withWorkspaceDirArg,
 } from "./lib/client-registration.mjs";
-import {
-  applyPendingAgeSelection,
-  buildTelegramBotReplyEnvelope,
-  buildTelegramMessageEnvelopeFromParsedArchive as buildRunnerTelegramMessageEnvelopeFromParsedArchive,
-  buildRunnerRouteStateFromComment,
-  buildProcessableArchiveLogicalKey,
-  findEarlierProcessableArchiveDuplicate,
-  findRecentTelegramMessageEnvelope,
-  isTelegramLocalInboundEnvelopeForRoute,
-  isInboundArchiveKind,
-  normalizeTelegramMessageEnvelope as normalizeRunnerTelegramMessageEnvelope,
-  normalizeArchiveCommentRecord,
-  selectPendingArchiveComments,
-  printRunnerResult,
-} from "./lib/runner-helpers.mjs";
+import {
+  applyPendingAgeSelection,
+  buildTelegramBotReplyEnvelope,
+  buildTelegramMessageEnvelopeFromParsedArchive as buildRunnerTelegramMessageEnvelopeFromParsedArchive,
+  buildRunnerRouteStateFromComment,
+  buildProcessableArchiveLogicalKey,
+  findEarlierProcessableArchiveDuplicate,
+  findRecentTelegramMessageEnvelope,
+  isTelegramLocalInboundEnvelopeForRoute,
+  isInboundArchiveKind,
+  normalizeTelegramMessageEnvelope as normalizeRunnerTelegramMessageEnvelope,
+  normalizeArchiveCommentRecord,
+  selectPendingArchiveComments,
+  printRunnerResult,
+} from "./lib/runner-helpers.mjs";
 import {
   createProjectContextItem as createProjectContextItemImpl,
   createProjectEvidence as createProjectEvidenceImpl,
@@ -186,30 +186,30 @@ import {
   resolveRunnerWorkspaceSelection,
   runRunnerAIExecution,
 } from "./lib/runner-execution.mjs";
-import {
-  buildRunnerResponderAdjudicationFromConversationContext,
-  buildRunnerResponderAdjudicationFromHumanIntent,
-  processRunnerSelectedRecord,
-  resolveHumanIntentContext,
-  resolvePublicConversationContext,
-  resolveRunnerHumanInboundVisibility,
-  resolveRunnerResponderAdjudication,
-  resolveRunnerStartupLoopAdjudication,
-  selectRunnerPendingWork,
-} from "./lib/runner-orchestration.mjs";
+import {
+  buildRunnerResponderAdjudicationFromConversationContext,
+  buildRunnerResponderAdjudicationFromHumanIntent,
+  processRunnerSelectedRecord,
+  resolveHumanIntentContext,
+  resolvePublicConversationContext,
+  resolveRunnerHumanInboundVisibility,
+  resolveRunnerResponderAdjudication,
+  resolveRunnerStartupLoopAdjudication,
+  selectRunnerPendingWork,
+} from "./lib/runner-orchestration.mjs";
 import {
   archiveLocalTelegramMessagesForRoute,
   maybeSendRunnerChatAction,
   startRunnerTypingHeartbeat,
 } from "./lib/runner-runtime.mjs";
-import {
-  deleteTelegramWebhook,
-  getTelegramBotMe,
-  getTelegramUpdates,
-  listTelegramChatAdministrators,
-  getTelegramWebhookInfo,
-  sendLocalProviderChatAction,
-  verifyLocalProviderToken,
+import {
+  deleteTelegramWebhook,
+  getTelegramBotMe,
+  getTelegramUpdates,
+  listTelegramChatAdministrators,
+  getTelegramWebhookInfo,
+  sendLocalProviderChatAction,
+  verifyLocalProviderToken,
 } from "./lib/provider-local-transport.mjs";
 
 const DEFAULT_SITE_URL = "https://metheus.gesiaplatform.com";
@@ -1922,24 +1922,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 pickObjectField = (key) => {
-    if (hasOwn(primary, key)) {
-      const value = safeObject(primary[key]);
-      if (Object.keys(value).length) {
-        return value;
-      }
-    }
-    return safeObject(secondary[key]);
-  };
+  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"),
@@ -1947,16 +1947,16 @@ function mergeRunnerStateRecords(preferred, fallback) {
     last_source_kind: pickStringField("last_source_kind"),
     last_error: pickStringField("last_error", { allowBlank: true }),
     updated_at: firstNonEmptyString([primary.updated_at, secondary.updated_at, new Date().toISOString()]),
-    last_action: pickStringField("last_action"),
-    last_reason: pickStringField("last_reason"),
-    last_trigger: pickStringField("last_trigger"),
-    last_visibility_status: pickStringField("last_visibility_status"),
-    last_visibility_reason: pickStringField("last_visibility_reason", { allowBlank: true }),
-    last_visibility_source: pickStringField("last_visibility_source", { allowBlank: true }),
-    last_reply_message_id: pickNumberField("last_reply_message_id", { allowUndefined: true }),
-    last_conversation_id: pickStringField("last_conversation_id"),
-    last_conversation_stage: pickStringField("last_conversation_stage"),
-    last_speaker_bot_username: pickStringField("last_speaker_bot_username"),
+    last_action: pickStringField("last_action"),
+    last_reason: pickStringField("last_reason"),
+    last_trigger: pickStringField("last_trigger"),
+    last_visibility_status: pickStringField("last_visibility_status"),
+    last_visibility_reason: pickStringField("last_visibility_reason", { allowBlank: true }),
+    last_visibility_source: pickStringField("last_visibility_source", { allowBlank: true }),
+    last_reply_message_id: pickNumberField("last_reply_message_id", { allowUndefined: true }),
+    last_conversation_id: pickStringField("last_conversation_id"),
+    last_conversation_stage: pickStringField("last_conversation_stage"),
+    last_speaker_bot_username: pickStringField("last_speaker_bot_username"),
     local_receive_mode: pickStringField("local_receive_mode"),
     local_telegram_polling_ready: Boolean(primary.local_telegram_polling_ready || secondary.local_telegram_polling_ready),
     local_telegram_webhook_cleared_url: pickStringField("local_telegram_webhook_cleared_url", { allowBlank: true }),
@@ -1989,16 +1989,16 @@ 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_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_candidate_bot_usernames: pickArrayField("last_candidate_bot_usernames", normalizeTelegramMentionUsername),
-    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"),
+    recent_local_inbound_envelopes: pickObjectField("recent_local_inbound_envelopes"),
+    last_candidate_bot_usernames: pickArrayField("last_candidate_bot_usernames", normalizeTelegramMentionUsername),
+    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),
@@ -2084,10 +2084,10 @@ function migrateBotRunnerStateRoutes(routes, runnerConfig) {
   };
 }
 
-function loadBotRunnerState() {
-  const filePath = botRunnerStateFilePath();
-  waitForBotRunnerStateLockRelease(filePath);
-  try {
+function loadBotRunnerState() {
+  const filePath = botRunnerStateFilePath();
+  waitForBotRunnerStateLockRelease(filePath);
+  try {
     if (!fs.existsSync(filePath)) {
       return {
         filePath,
@@ -2137,102 +2137,102 @@ 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) {
-    throw new Error("filePath is required");
-  }
+}
+
+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) {
+    throw new Error("filePath is required");
+  }
   const directoryPath = path.dirname(normalizedPath);
   fs.mkdirSync(directoryPath, { recursive: true });
   const tempPath = path.join(
@@ -2240,41 +2240,41 @@ function writeTextFileAtomic(filePath, text) {
     `.${path.basename(normalizedPath)}.${process.pid}.${Date.now()}.tmp`,
   );
   fs.writeFileSync(tempPath, text, "utf8");
-  const renameRetryDelaysMs = [0, 20, 50, 100, 200];
-  let lastRenameError = null;
-  try {
-    for (const delayMs of renameRetryDelaysMs) {
-      if (delayMs > 0) {
-        sleepSyncMs(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;
-          }
-        }
-      }
-    }
+  const renameRetryDelaysMs = [0, 20, 50, 100, 200];
+  let lastRenameError = null;
+  try {
+    for (const delayMs of renameRetryDelaysMs) {
+      if (delayMs > 0) {
+        sleepSyncMs(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;
     }
@@ -2287,188 +2287,188 @@ function writeTextFileAtomic(filePath, text) {
   }
 }
 
-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 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 = {};
@@ -2525,388 +2525,382 @@ function isActiveRunnerRequestStatus(rawStatus) {
   return status === "planned" || status === "claimed" || status === "running";
 }
 
-function normalizeRunnerWorkItemStatus(rawStatus) {
-  const status = String(rawStatus || "").trim().toLowerCase();
-  return ["backlog", "doing", "review", "done", "canceled"].includes(status)
-    ? status
-    : "";
-}
-
-function truncateRunnerReplyChainText(rawValue, maxLength = 280) {
-  const text = String(rawValue || "").trim().replace(/\s+/g, " ");
-  if (!text) return "";
-  if (!(maxLength > 0) || text.length <= maxLength) {
-    return text;
-  }
-  return `${text.slice(0, Math.max(0, maxLength - 3)).trimEnd()}...`;
-}
-
-function buildRunnerReplyChainSpeakerType(parsedArchiveRaw) {
-  const parsedArchive = safeObject(parsedArchiveRaw);
-  const kind = String(parsedArchive.kind || "").trim().toLowerCase();
-  if (kind === "bot_reply" || parsedArchive.senderIsBot === true) {
-    return "bot";
-  }
-  return "human";
-}
-
-function buildRunnerReplyChainSpeakerLabel(parsedArchiveRaw) {
-  const parsedArchive = safeObject(parsedArchiveRaw);
-  const username = normalizeTelegramMentionUsername(
-    parsedArchive.botUsername
-    || parsedArchive.username
-    || parsedArchive.replyToUsername
-    || parsedArchive.conversationTargetBotUsername,
-  );
-  if (username) {
-    return `@${username}`;
-  }
-  return firstNonEmptyString([
-    parsedArchive.sender,
-    parsedArchive.botName,
-    parsedArchive.replyToSender,
-    parsedArchive.chatTitle,
-    buildRunnerReplyChainSpeakerType(parsedArchive) === "bot" ? "bot" : "human",
-  ]);
-}
-
-function normalizeRunnerReplyChainSnapshot(rawSnapshot) {
-  const snapshot = safeObject(rawSnapshot);
-  const messageID = intFromRawAllowZero(snapshot.message_id || snapshot.messageID, 0);
-  const messageThreadID = intFromRawAllowZero(snapshot.message_thread_id || snapshot.messageThreadID, 0);
-  const replyToMessageID = intFromRawAllowZero(snapshot.reply_to_message_id || snapshot.replyToMessageID, 0);
-  const speakerType = String(snapshot.speaker_type || snapshot.speakerType || "").trim().toLowerCase();
-  const body = truncateRunnerReplyChainText(snapshot.body || "");
-  if (!(messageID > 0) && !body) {
-    return null;
-  }
-  return {
-    message_id: messageID || undefined,
-    message_thread_id: messageThreadID || undefined,
-    reply_to_message_id: replyToMessageID || undefined,
-    speaker_type: speakerType === "bot" ? "bot" : "human",
-    speaker_label: String(snapshot.speaker_label || snapshot.speakerLabel || "").trim(),
-    body,
-  };
-}
-
-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 = {
-    conversation_id: String(context.conversation_id || context.conversationID || "").trim(),
-    current_message_id: intFromRawAllowZero(context.current_message_id || context.currentMessageID, 0) || undefined,
-    current_message_thread_id: intFromRawAllowZero(
-      context.current_message_thread_id || context.currentMessageThreadID,
-      0,
-    ) || undefined,
-    parent_message_id: intFromRawAllowZero(context.parent_message_id || context.parentMessageID, 0) || undefined,
-    root_message_id: intFromRawAllowZero(context.root_message_id || context.rootMessageID, 0) || undefined,
-    current_turn_relation: String(context.current_turn_relation || context.currentTurnRelation || "").trim(),
-    root_message: normalizeRunnerReplyChainSnapshot(context.root_message || context.rootMessage),
-    parent_message: normalizeRunnerReplyChainSnapshot(context.parent_message || context.parentMessage),
-    latest_prior_bot_reply: normalizeRunnerReplyChainSnapshot(
-      context.latest_prior_bot_reply || context.latestPriorBotReply,
-    ),
-    recent_chain_messages: ensureArray(context.recent_chain_messages || context.recentChainMessages)
-      .map((item) => normalizeRunnerReplyChainSnapshot(item))
-      .filter(Boolean)
-      .slice(-4),
-  };
-  if (
-    !normalized.conversation_id
-    && !(normalized.current_message_id > 0)
-    && !(normalized.current_message_thread_id > 0)
-    && !(normalized.parent_message_id > 0)
-    && !(normalized.root_message_id > 0)
-    && !normalized.current_turn_relation
-    && !normalized.root_message
-    && !normalized.parent_message
-    && !normalized.latest_prior_bot_reply
-    && !normalized.recent_chain_messages.length
-  ) {
-    return {};
-  }
-  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);
-  return findRunnerRouteLocalInboundEnvelopeByMessage(routeState, {
-    chatID,
-    messageID,
-  });
-}
-
-function findRunnerRouteLocalInboundEnvelopeByMessage(routeStateRaw, {
-  chatID = "",
-  messageID = 0,
-} = {}) {
-  const routeState = safeObject(routeStateRaw);
-  const normalizedChatID = String(chatID || "").trim();
-  const normalizedMessageID = intFromRawAllowZero(messageID, 0);
-  if (!normalizedChatID || !(normalizedMessageID > 0)) {
-    return {};
-  }
-  return findRecentTelegramMessageEnvelope(routeState.recent_local_inbound_envelopes, {
-    chatID: normalizedChatID,
-    messageID: normalizedMessageID,
-  });
-}
-
-function mergeRunnerSourceMessageEnvelopes(primaryRaw, fallbackRaw) {
-  const primary = normalizeRunnerTelegramMessageEnvelope(primaryRaw);
-  const fallback = normalizeRunnerTelegramMessageEnvelope(fallbackRaw);
-  return normalizeRunnerTelegramMessageEnvelope({
-    ...fallback,
-    ...primary,
-    chat_id: firstNonEmptyString([primary.chat_id, fallback.chat_id]),
-    message_id: intFromRawAllowZero(primary.message_id || fallback.message_id, 0) || undefined,
-    message_thread_id: intFromRawAllowZero(
-      primary.message_thread_id || fallback.message_thread_id,
-      0,
-    ) || undefined,
-    reply_to_message_id: intFromRawAllowZero(
-      primary.reply_to_message_id || fallback.reply_to_message_id,
-      0,
-    ) || undefined,
-    body: firstNonEmptyString([primary.body, fallback.body]),
-    source_origin: firstNonEmptyString([primary.source_origin, fallback.source_origin]),
-    source_route_key: firstNonEmptyString([primary.source_route_key, fallback.source_route_key]),
-    source_bot_username: firstNonEmptyString([primary.source_bot_username, fallback.source_bot_username]),
-  });
-}
-
-function scoreRunnerSourceMessageEnvelopeAuthority(rawEnvelope) {
-  const envelope = normalizeRunnerTelegramMessageEnvelope(rawEnvelope);
-  if (!String(envelope.chat_id || "").trim() || !(intFromRawAllowZero(envelope.message_id, 0) > 0)) {
-    return 0;
-  }
-  const origin = String(envelope.source_origin || "").trim().toLowerCase();
-  let score = 0;
-  switch (origin) {
-    case "local_telegram_inbound":
-      score = 500;
-      break;
-    case "trigger_addressed_human_inbound":
-      score = 450;
-      break;
-    case "group_read_visible_human_inbound":
-      score = 400;
-      break;
-    case "archive_reconstructed":
-      score = 100;
-      break;
-    default:
-      score = 250;
-      break;
-  }
-  if (String(envelope.source_route_key || "").trim()) score += 10;
-  if (String(envelope.source_bot_username || "").trim()) score += 10;
-  if (intFromRawAllowZero(envelope.reply_to_message_id, 0) > 0) score += 1;
-  return score;
-}
-
-function selectAuthoritativeRunnerSourceMessageEnvelope(primaryRaw, fallbackRaw) {
-  const primary = normalizeRunnerTelegramMessageEnvelope(primaryRaw);
-  const fallback = normalizeRunnerTelegramMessageEnvelope(fallbackRaw);
-  const primaryScore = scoreRunnerSourceMessageEnvelopeAuthority(primary);
-  const fallbackScore = scoreRunnerSourceMessageEnvelopeAuthority(fallback);
-  if (!(primaryScore > 0)) {
-    return fallback;
-  }
-  if (!(fallbackScore > 0)) {
-    return primary;
-  }
-  if (primaryScore === fallbackScore) {
-    return mergeRunnerSourceMessageEnvelopes(primary, fallback);
-  }
-  return primaryScore > fallbackScore ? primary : fallback;
-}
-
-function buildRunnerSourceMessageEnvelope({
-  routeState = {},
-  routeKey = "",
-  normalizedRoute = null,
-  parsedArchive = null,
-}) {
-  const localEnvelope = findRunnerRouteLocalInboundEnvelope(routeState, parsedArchive);
-  const fallbackBotSelector = normalizeTelegramMentionUsername(
-    normalizedRoute?.botName
-      || normalizedRoute?.serverBotName
-      || "",
-  );
-  const archivedSourceEnvelope = buildRunnerTelegramMessageEnvelopeFromParsedArchive(parsedArchive);
-  if (isTelegramLocalInboundEnvelopeForRoute(localEnvelope, {
-    routeKey,
-    botUsername: fallbackBotSelector,
-  })) {
-    return localEnvelope;
-  }
-  if (isTelegramLocalInboundEnvelopeForRoute(archivedSourceEnvelope, {
-    routeKey,
-    botUsername: fallbackBotSelector,
-  })) {
-    return archivedSourceEnvelope;
-  }
-  return buildRunnerTelegramMessageEnvelopeFromParsedArchive(parsedArchive, {
-    source_origin: "archive_reconstructed",
-  });
-}
-
-function normalizeBotRunnerRequests(rawRequests, nowMs = Date.now()) {
-  const normalized = {};
-  for (const [requestKeyRaw, entryRaw] of Object.entries(safeObject(rawRequests))) {
+function normalizeRunnerWorkItemStatus(rawStatus) {
+  const status = String(rawStatus || "").trim().toLowerCase();
+  return ["backlog", "doing", "review", "done", "canceled"].includes(status)
+    ? status
+    : "";
+}
+
+function truncateRunnerReplyChainText(rawValue, maxLength = 280) {
+  const text = String(rawValue || "").trim().replace(/\s+/g, " ");
+  if (!text) return "";
+  if (!(maxLength > 0) || text.length <= maxLength) {
+    return text;
+  }
+  return `${text.slice(0, Math.max(0, maxLength - 3)).trimEnd()}...`;
+}
+
+function buildRunnerReplyChainSpeakerType(parsedArchiveRaw) {
+  const parsedArchive = safeObject(parsedArchiveRaw);
+  const kind = String(parsedArchive.kind || "").trim().toLowerCase();
+  if (kind === "bot_reply" || parsedArchive.senderIsBot === true) {
+    return "bot";
+  }
+  return "human";
+}
+
+function buildRunnerReplyChainSpeakerLabel(parsedArchiveRaw) {
+  const parsedArchive = safeObject(parsedArchiveRaw);
+  const username = normalizeTelegramMentionUsername(
+    parsedArchive.botUsername
+    || parsedArchive.username
+    || parsedArchive.replyToUsername
+    || parsedArchive.conversationTargetBotUsername,
+  );
+  if (username) {
+    return `@${username}`;
+  }
+  return firstNonEmptyString([
+    parsedArchive.sender,
+    parsedArchive.botName,
+    parsedArchive.replyToSender,
+    parsedArchive.chatTitle,
+    buildRunnerReplyChainSpeakerType(parsedArchive) === "bot" ? "bot" : "human",
+  ]);
+}
+
+function normalizeRunnerReplyChainSnapshot(rawSnapshot) {
+  const snapshot = safeObject(rawSnapshot);
+  const messageID = intFromRawAllowZero(snapshot.message_id || snapshot.messageID, 0);
+  const messageThreadID = intFromRawAllowZero(snapshot.message_thread_id || snapshot.messageThreadID, 0);
+  const replyToMessageID = intFromRawAllowZero(snapshot.reply_to_message_id || snapshot.replyToMessageID, 0);
+  const speakerType = String(snapshot.speaker_type || snapshot.speakerType || "").trim().toLowerCase();
+  const body = truncateRunnerReplyChainText(snapshot.body || "");
+  if (!(messageID > 0) && !body) {
+    return null;
+  }
+  return {
+    message_id: messageID || undefined,
+    message_thread_id: messageThreadID || undefined,
+    reply_to_message_id: replyToMessageID || undefined,
+    speaker_type: speakerType === "bot" ? "bot" : "human",
+    speaker_label: String(snapshot.speaker_label || snapshot.speakerLabel || "").trim(),
+    body,
+  };
+}
+
+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 = {
+    conversation_id: String(context.conversation_id || context.conversationID || "").trim(),
+    current_message_id: intFromRawAllowZero(context.current_message_id || context.currentMessageID, 0) || undefined,
+    current_message_thread_id: intFromRawAllowZero(
+      context.current_message_thread_id || context.currentMessageThreadID,
+      0,
+    ) || undefined,
+    parent_message_id: intFromRawAllowZero(context.parent_message_id || context.parentMessageID, 0) || undefined,
+    root_message_id: intFromRawAllowZero(context.root_message_id || context.rootMessageID, 0) || undefined,
+    current_turn_relation: String(context.current_turn_relation || context.currentTurnRelation || "").trim(),
+    root_message: normalizeRunnerReplyChainSnapshot(context.root_message || context.rootMessage),
+    parent_message: normalizeRunnerReplyChainSnapshot(context.parent_message || context.parentMessage),
+    latest_prior_bot_reply: normalizeRunnerReplyChainSnapshot(
+      context.latest_prior_bot_reply || context.latestPriorBotReply,
+    ),
+    recent_chain_messages: ensureArray(context.recent_chain_messages || context.recentChainMessages)
+      .map((item) => normalizeRunnerReplyChainSnapshot(item))
+      .filter(Boolean)
+      .slice(-4),
+  };
+  if (
+    !normalized.conversation_id
+    && !(normalized.current_message_id > 0)
+    && !(normalized.current_message_thread_id > 0)
+    && !(normalized.parent_message_id > 0)
+    && !(normalized.root_message_id > 0)
+    && !normalized.current_turn_relation
+    && !normalized.root_message
+    && !normalized.parent_message
+    && !normalized.latest_prior_bot_reply
+    && !normalized.recent_chain_messages.length
+  ) {
+    return {};
+  }
+  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);
+  return findRunnerRouteLocalInboundEnvelopeByMessage(routeState, {
+    chatID,
+    messageID,
+  });
+}
+
+function findRunnerRouteLocalInboundEnvelopeByMessage(routeStateRaw, {
+  chatID = "",
+  messageID = 0,
+} = {}) {
+  const routeState = safeObject(routeStateRaw);
+  const normalizedChatID = String(chatID || "").trim();
+  const normalizedMessageID = intFromRawAllowZero(messageID, 0);
+  if (!normalizedChatID || !(normalizedMessageID > 0)) {
+    return {};
+  }
+  return findRecentTelegramMessageEnvelope(routeState.recent_local_inbound_envelopes, {
+    chatID: normalizedChatID,
+    messageID: normalizedMessageID,
+  });
+}
+
+function mergeRunnerSourceMessageEnvelopes(primaryRaw, fallbackRaw) {
+  const primary = normalizeRunnerTelegramMessageEnvelope(primaryRaw);
+  const fallback = normalizeRunnerTelegramMessageEnvelope(fallbackRaw);
+  return normalizeRunnerTelegramMessageEnvelope({
+    ...fallback,
+    ...primary,
+    chat_id: firstNonEmptyString([primary.chat_id, fallback.chat_id]),
+    message_id: intFromRawAllowZero(primary.message_id || fallback.message_id, 0) || undefined,
+    message_thread_id: intFromRawAllowZero(
+      primary.message_thread_id || fallback.message_thread_id,
+      0,
+    ) || undefined,
+    reply_to_message_id: intFromRawAllowZero(
+      primary.reply_to_message_id || fallback.reply_to_message_id,
+      0,
+    ) || undefined,
+    body: firstNonEmptyString([primary.body, fallback.body]),
+    source_origin: firstNonEmptyString([primary.source_origin, fallback.source_origin]),
+    source_route_key: firstNonEmptyString([primary.source_route_key, fallback.source_route_key]),
+    source_bot_username: firstNonEmptyString([primary.source_bot_username, fallback.source_bot_username]),
+  });
+}
+
+function scoreRunnerSourceMessageEnvelopeAuthority(rawEnvelope) {
+  const envelope = normalizeRunnerTelegramMessageEnvelope(rawEnvelope);
+  if (!String(envelope.chat_id || "").trim() || !(intFromRawAllowZero(envelope.message_id, 0) > 0)) {
+    return 0;
+  }
+  const origin = String(envelope.source_origin || "").trim().toLowerCase();
+  let score = 0;
+  switch (origin) {
+    case "local_telegram_inbound":
+      score = 500;
+      break;
+    case "archive_reconstructed":
+      score = 100;
+      break;
+    default:
+      score = 50;
+      break;
+  }
+  if (String(envelope.source_route_key || "").trim()) score += 10;
+  if (String(envelope.source_bot_username || "").trim()) score += 10;
+  if (intFromRawAllowZero(envelope.reply_to_message_id, 0) > 0) score += 1;
+  return score;
+}
+
+function selectAuthoritativeRunnerSourceMessageEnvelope(primaryRaw, fallbackRaw) {
+  const primary = normalizeRunnerTelegramMessageEnvelope(primaryRaw);
+  const fallback = normalizeRunnerTelegramMessageEnvelope(fallbackRaw);
+  const primaryScore = scoreRunnerSourceMessageEnvelopeAuthority(primary);
+  const fallbackScore = scoreRunnerSourceMessageEnvelopeAuthority(fallback);
+  if (!(primaryScore > 0)) {
+    return fallback;
+  }
+  if (!(fallbackScore > 0)) {
+    return primary;
+  }
+  if (primaryScore === fallbackScore) {
+    return mergeRunnerSourceMessageEnvelopes(primary, fallback);
+  }
+  return primaryScore > fallbackScore ? primary : fallback;
+}
+
+function buildRunnerSourceMessageEnvelope({
+  routeState = {},
+  routeKey = "",
+  normalizedRoute = null,
+  parsedArchive = null,
+}) {
+  const localEnvelope = findRunnerRouteLocalInboundEnvelope(routeState, parsedArchive);
+  const fallbackBotSelector = normalizeTelegramMentionUsername(
+    normalizedRoute?.botName
+      || normalizedRoute?.serverBotName
+      || "",
+  );
+  const archivedSourceEnvelope = buildRunnerTelegramMessageEnvelopeFromParsedArchive(parsedArchive);
+  if (isTelegramLocalInboundEnvelopeForRoute(localEnvelope, {
+    routeKey,
+    botUsername: fallbackBotSelector,
+  })) {
+    return localEnvelope;
+  }
+  if (isTelegramLocalInboundEnvelopeForRoute(archivedSourceEnvelope, {
+    routeKey,
+    botUsername: fallbackBotSelector,
+  })) {
+    return archivedSourceEnvelope;
+  }
+  return buildRunnerTelegramMessageEnvelopeFromParsedArchive(parsedArchive, {
+    source_origin: "archive_reconstructed",
+  });
+}
+
+function normalizeBotRunnerRequests(rawRequests, nowMs = Date.now()) {
+  const normalized = {};
+  for (const [requestKeyRaw, entryRaw] of Object.entries(safeObject(rawRequests))) {
     const requestKey = String(requestKeyRaw || safeObject(entryRaw).request_key || "").trim();
     if (!requestKey) continue;
     const entry = safeObject(entryRaw);
     const status = normalizeRunnerRequestStatus(entry.status);
     const updatedAt = firstNonEmptyString([entry.updated_at, entry.updatedAt, entry.completed_at, entry.completedAt, entry.closed_at, entry.closedAt, entry.claimed_at, entry.claimedAt]);
     const updatedAtMs = Date.parse(updatedAt);
-    if (isFinalRunnerRequestStatus(status) && Number.isFinite(updatedAtMs) && nowMs - updatedAtMs > BOT_RUNNER_REQUEST_KEEP_MS) {
-      continue;
-    }
-    const fallbackSourceMessageEnvelope = 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,
-          source_origin: entry.source_message_origin || entry.sourceMessageOrigin,
-          source_route_key: entry.source_message_route_key || entry.sourceMessageRouteKey,
-          source_bot_username: entry.source_message_bot_username || entry.sourceMessageBotUsername,
-        }
-      : {};
-    const normalizedSourceMessageEnvelope = normalizeRunnerTelegramMessageEnvelope({
-      ...safeObject(
-        normalizeRunnerTelegramMessageEnvelope(
-          entry.source_message_envelope
-          || entry.sourceMessageEnvelope
-          || fallbackSourceMessageEnvelope,
-        ),
-      ),
-      chat_id: firstNonEmptyString([
-        safeObject(entry.source_message_envelope || entry.sourceMessageEnvelope).chat_id,
-        safeObject(entry.source_message_envelope || entry.sourceMessageEnvelope).chatID,
-        entry.chat_id,
-        entry.chatID,
-      ]),
-      message_id: intFromRawAllowZero(
-        safeObject(entry.source_message_envelope || entry.sourceMessageEnvelope).message_id
-        || safeObject(entry.source_message_envelope || entry.sourceMessageEnvelope).messageID
-        || entry.source_message_id
-        || entry.sourceMessageID,
-        0,
-      ) || undefined,
-      message_thread_id: intFromRawAllowZero(
-        safeObject(entry.source_message_envelope || entry.sourceMessageEnvelope).message_thread_id
-        || safeObject(entry.source_message_envelope || entry.sourceMessageEnvelope).messageThreadID
-        || entry.source_message_thread_id
-        || entry.sourceMessageThreadID,
-        0,
-      ) || undefined,
-      body: firstNonEmptyString([
-        safeObject(entry.source_message_envelope || entry.sourceMessageEnvelope).body,
-        safeObject(entry.source_message_envelope || entry.sourceMessageEnvelope).text,
-        entry.source_message_body,
-        entry.sourceMessageBody,
-      ]),
-      source_origin: firstNonEmptyString([
-        safeObject(entry.source_message_envelope || entry.sourceMessageEnvelope).source_origin,
-        safeObject(entry.source_message_envelope || entry.sourceMessageEnvelope).sourceOrigin,
-        entry.source_message_origin,
-        entry.sourceMessageOrigin,
-      ]),
-      source_route_key: firstNonEmptyString([
-        safeObject(entry.source_message_envelope || entry.sourceMessageEnvelope).source_route_key,
-        safeObject(entry.source_message_envelope || entry.sourceMessageEnvelope).sourceRouteKey,
-        entry.source_message_route_key,
-        entry.sourceMessageRouteKey,
-      ]),
-      source_bot_username: firstNonEmptyString([
-        safeObject(entry.source_message_envelope || entry.sourceMessageEnvelope).source_bot_username,
-        safeObject(entry.source_message_envelope || entry.sourceMessageEnvelope).sourceBotUsername,
-        entry.source_message_bot_username,
-        entry.sourceMessageBotUsername,
-      ]),
-    });
-    normalized[requestKey] = {
-      request_key: requestKey,
-      project_id: String(entry.project_id || entry.projectID || "").trim(),
-      provider: String(entry.provider || "").trim(),
-      chat_id: firstNonEmptyString([
-        entry.chat_id,
-        entry.chatID,
-        normalizedSourceMessageEnvelope.chat_id,
-      ]),
-      source_message_id: intFromRawAllowZero(
-        entry.source_message_id
-        || entry.sourceMessageID
-        || normalizedSourceMessageEnvelope.message_id,
-        0,
-      ) || undefined,
-      source_message_thread_id: intFromRawAllowZero(
-        entry.source_message_thread_id
-        || entry.sourceMessageThreadID
-        || normalizedSourceMessageEnvelope.message_thread_id,
-        0,
-      ) || undefined,
-      source_message_body: firstNonEmptyString([
-        entry.source_message_body,
-        entry.sourceMessageBody,
-        normalizedSourceMessageEnvelope.body,
-      ]),
-      source_message_origin: String(
-        entry.source_message_origin
-        || entry.sourceMessageOrigin
-        || normalizedSourceMessageEnvelope.source_origin
-        || "",
-      ).trim().toLowerCase(),
-      source_message_route_key: String(
-        entry.source_message_route_key
-        || entry.sourceMessageRouteKey
-        || normalizedSourceMessageEnvelope.source_route_key
-        || "",
-      ).trim(),
-      source_message_bot_username: normalizeTelegramMentionUsername(
-        entry.source_message_bot_username
-        || entry.sourceMessageBotUsername
-        || normalizedSourceMessageEnvelope.source_bot_username,
-      ),
-      source_message_envelope: normalizedSourceMessageEnvelope,
-      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(),
-      reply_chain_context: normalizeRunnerReplyChainContext(entry.reply_chain_context || entry.replyChainContext),
-      selected_bot_usernames: ensureArray(entry.selected_bot_usernames || entry.selectedBotUsernames)
-        .map((value) => normalizeTelegramMentionUsername(value))
-        .filter(Boolean),
+    if (isFinalRunnerRequestStatus(status) && Number.isFinite(updatedAtMs) && nowMs - updatedAtMs > BOT_RUNNER_REQUEST_KEEP_MS) {
+      continue;
+    }
+    const fallbackSourceMessageEnvelope = 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,
+          source_origin: entry.source_message_origin || entry.sourceMessageOrigin,
+          source_route_key: entry.source_message_route_key || entry.sourceMessageRouteKey,
+          source_bot_username: entry.source_message_bot_username || entry.sourceMessageBotUsername,
+        }
+      : {};
+    const normalizedSourceMessageEnvelope = normalizeRunnerTelegramMessageEnvelope({
+      ...safeObject(
+        normalizeRunnerTelegramMessageEnvelope(
+          entry.source_message_envelope
+          || entry.sourceMessageEnvelope
+          || fallbackSourceMessageEnvelope,
+        ),
+      ),
+      chat_id: firstNonEmptyString([
+        safeObject(entry.source_message_envelope || entry.sourceMessageEnvelope).chat_id,
+        safeObject(entry.source_message_envelope || entry.sourceMessageEnvelope).chatID,
+        entry.chat_id,
+        entry.chatID,
+      ]),
+      message_id: intFromRawAllowZero(
+        safeObject(entry.source_message_envelope || entry.sourceMessageEnvelope).message_id
+        || safeObject(entry.source_message_envelope || entry.sourceMessageEnvelope).messageID
+        || entry.source_message_id
+        || entry.sourceMessageID,
+        0,
+      ) || undefined,
+      message_thread_id: intFromRawAllowZero(
+        safeObject(entry.source_message_envelope || entry.sourceMessageEnvelope).message_thread_id
+        || safeObject(entry.source_message_envelope || entry.sourceMessageEnvelope).messageThreadID
+        || entry.source_message_thread_id
+        || entry.sourceMessageThreadID,
+        0,
+      ) || undefined,
+      body: firstNonEmptyString([
+        safeObject(entry.source_message_envelope || entry.sourceMessageEnvelope).body,
+        safeObject(entry.source_message_envelope || entry.sourceMessageEnvelope).text,
+        entry.source_message_body,
+        entry.sourceMessageBody,
+      ]),
+      source_origin: firstNonEmptyString([
+        safeObject(entry.source_message_envelope || entry.sourceMessageEnvelope).source_origin,
+        safeObject(entry.source_message_envelope || entry.sourceMessageEnvelope).sourceOrigin,
+        entry.source_message_origin,
+        entry.sourceMessageOrigin,
+      ]),
+      source_route_key: firstNonEmptyString([
+        safeObject(entry.source_message_envelope || entry.sourceMessageEnvelope).source_route_key,
+        safeObject(entry.source_message_envelope || entry.sourceMessageEnvelope).sourceRouteKey,
+        entry.source_message_route_key,
+        entry.sourceMessageRouteKey,
+      ]),
+      source_bot_username: firstNonEmptyString([
+        safeObject(entry.source_message_envelope || entry.sourceMessageEnvelope).source_bot_username,
+        safeObject(entry.source_message_envelope || entry.sourceMessageEnvelope).sourceBotUsername,
+        entry.source_message_bot_username,
+        entry.sourceMessageBotUsername,
+      ]),
+    });
+    normalized[requestKey] = {
+      request_key: requestKey,
+      project_id: String(entry.project_id || entry.projectID || "").trim(),
+      provider: String(entry.provider || "").trim(),
+      chat_id: firstNonEmptyString([
+        entry.chat_id,
+        entry.chatID,
+        normalizedSourceMessageEnvelope.chat_id,
+      ]),
+      source_message_id: intFromRawAllowZero(
+        entry.source_message_id
+        || entry.sourceMessageID
+        || normalizedSourceMessageEnvelope.message_id,
+        0,
+      ) || undefined,
+      source_message_thread_id: intFromRawAllowZero(
+        entry.source_message_thread_id
+        || entry.sourceMessageThreadID
+        || normalizedSourceMessageEnvelope.message_thread_id,
+        0,
+      ) || undefined,
+      source_message_body: firstNonEmptyString([
+        entry.source_message_body,
+        entry.sourceMessageBody,
+        normalizedSourceMessageEnvelope.body,
+      ]),
+      source_message_origin: String(
+        entry.source_message_origin
+        || entry.sourceMessageOrigin
+        || normalizedSourceMessageEnvelope.source_origin
+        || "",
+      ).trim().toLowerCase(),
+      source_message_route_key: String(
+        entry.source_message_route_key
+        || entry.sourceMessageRouteKey
+        || normalizedSourceMessageEnvelope.source_route_key
+        || "",
+      ).trim(),
+      source_message_bot_username: normalizeTelegramMentionUsername(
+        entry.source_message_bot_username
+        || entry.sourceMessageBotUsername
+        || normalizedSourceMessageEnvelope.source_bot_username,
+      ),
+      source_message_envelope: normalizedSourceMessageEnvelope,
+      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(),
+      reply_chain_context: normalizeRunnerReplyChainContext(entry.reply_chain_context || entry.replyChainContext),
+      selected_bot_usernames: ensureArray(entry.selected_bot_usernames || entry.selectedBotUsernames)
+        .map((value) => normalizeTelegramMentionUsername(value))
+        .filter(Boolean),
       conversation_allowed_responders: ensureArray(entry.conversation_allowed_responders || entry.conversationAllowedResponders)
         .map((value) => normalizeTelegramMentionUsername(value))
         .filter(Boolean),
@@ -3020,37 +3014,37 @@ function normalizeBotRunnerRequests(rawRequests, nowMs = Date.now()) {
       root_thread_id: String(entry.root_thread_id || entry.rootThreadID || "").trim(),
       root_work_item_created_at: firstNonEmptyString([entry.root_work_item_created_at, entry.rootWorkItemCreatedAt]),
       root_work_item_last_error: String(entry.root_work_item_last_error || entry.rootWorkItemLastError || "").trim(),
-      last_comment_id: String(entry.last_comment_id || entry.lastCommentID || "").trim(),
-      last_comment_kind: String(entry.last_comment_kind || entry.lastCommentKind || "").trim().toLowerCase(),
-      last_source_message_id: intFromRawAllowZero(entry.last_source_message_id || entry.lastSourceMessageID, 0) || undefined,
-      last_source_message_thread_id: intFromRawAllowZero(
-        entry.last_source_message_thread_id || entry.lastSourceMessageThreadID,
-        0,
-      ) || undefined,
-      last_reply_message_id: intFromRawAllowZero(entry.last_reply_message_id || entry.lastReplyMessageID, 0) || undefined,
-      last_reply_message_thread_id: intFromRawAllowZero(
-        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
-        || {},
-      ),
-      attempted_delivery_envelope: normalizeRunnerTelegramMessageEnvelope(
-        entry.attempted_delivery_envelope
-        || entry.attemptedDeliveryEnvelope
-        || {},
-      ),
-      updated_at: updatedAt || new Date(nowMs).toISOString(),
-    };
-  }
-  return normalized;
-}
+      last_comment_id: String(entry.last_comment_id || entry.lastCommentID || "").trim(),
+      last_comment_kind: String(entry.last_comment_kind || entry.lastCommentKind || "").trim().toLowerCase(),
+      last_source_message_id: intFromRawAllowZero(entry.last_source_message_id || entry.lastSourceMessageID, 0) || undefined,
+      last_source_message_thread_id: intFromRawAllowZero(
+        entry.last_source_message_thread_id || entry.lastSourceMessageThreadID,
+        0,
+      ) || undefined,
+      last_reply_message_id: intFromRawAllowZero(entry.last_reply_message_id || entry.lastReplyMessageID, 0) || undefined,
+      last_reply_message_thread_id: intFromRawAllowZero(
+        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
+        || {},
+      ),
+      attempted_delivery_envelope: normalizeRunnerTelegramMessageEnvelope(
+        entry.attempted_delivery_envelope
+        || entry.attemptedDeliveryEnvelope
+        || {},
+      ),
+      updated_at: updatedAt || new Date(nowMs).toISOString(),
+    };
+  }
+  return normalized;
+}
 
 function normalizeBotRunnerConsumedComments(rawConsumed, nowMs = Date.now()) {
   const normalized = {};
@@ -3257,40 +3251,40 @@ function uniqueOrderedStrings(values, normalizer = (value) => String(value || ""
   return output;
 }
 
-function buildRunnerRequestKey({
-  normalizedRoute,
-  selectedRecord,
-  selectedBotUsernames = [],
-  normalizedIntent = "",
-  conversationID = "",
-}) {
-  const parsed = safeObject(selectedRecord?.parsedArchive);
-  const chatID = String(parsed.chatID || parsed.chatId || "").trim() || "-";
-  const messageID = intFromRawAllowZero(parsed.messageID, 0);
-  const kind = String(parsed.kind || "").trim().toLowerCase() || "-";
-  const responders = uniqueOrderedStrings(selectedBotUsernames, normalizeTelegramMentionUsername).join(",") || "-";
-  const intent = String(normalizedIntent || "").trim().toLowerCase() || "-";
-  const resolvedConversationID = String(conversationID || parsed.conversationID || "").trim() || "-";
-  return [
-    String(normalizedRoute?.projectID || "").trim() || "-",
-    String(normalizedRoute?.provider || "").trim() || "-",
-    chatID,
-    String(messageID || "-"),
-    kind,
-    responders,
-    intent,
-    resolvedConversationID,
-  ].join("::");
-}
-
-function resolveRunnerRequestClaimIntent({
-  normalizedIntent = "",
-  selectedRecord,
-}) {
-  void selectedRecord;
-  const explicitIntent = String(normalizedIntent || "").trim().toLowerCase();
-  return explicitIntent;
-}
+function buildRunnerRequestKey({
+  normalizedRoute,
+  selectedRecord,
+  selectedBotUsernames = [],
+  normalizedIntent = "",
+  conversationID = "",
+}) {
+  const parsed = safeObject(selectedRecord?.parsedArchive);
+  const chatID = String(parsed.chatID || parsed.chatId || "").trim() || "-";
+  const messageID = intFromRawAllowZero(parsed.messageID, 0);
+  const kind = String(parsed.kind || "").trim().toLowerCase() || "-";
+  const responders = uniqueOrderedStrings(selectedBotUsernames, normalizeTelegramMentionUsername).join(",") || "-";
+  const intent = String(normalizedIntent || "").trim().toLowerCase() || "-";
+  const resolvedConversationID = String(conversationID || parsed.conversationID || "").trim() || "-";
+  return [
+    String(normalizedRoute?.projectID || "").trim() || "-",
+    String(normalizedRoute?.provider || "").trim() || "-",
+    chatID,
+    String(messageID || "-"),
+    kind,
+    responders,
+    intent,
+    resolvedConversationID,
+  ].join("::");
+}
+
+function resolveRunnerRequestClaimIntent({
+  normalizedIntent = "",
+  selectedRecord,
+}) {
+  void selectedRecord;
+  const explicitIntent = String(normalizedIntent || "").trim().toLowerCase();
+  return explicitIntent;
+}
 
 function buildSyntheticReplyChainConversationID(normalizedRoute, chatID, anchorMessageID) {
   const provider = String(normalizedRoute?.provider || "").trim() || "unknown";
@@ -3595,9 +3589,9 @@ function runnerRequestPreferredExecutionContractTargets(entryRaw) {
   );
 }
 
-function runnerRequestPreferredNextExpectedResponders(entryRaw) {
-  const entry = safeObject(entryRaw);
-  return uniqueOrderedStrings(
+function runnerRequestPreferredNextExpectedResponders(entryRaw) {
+  const entry = safeObject(entryRaw);
+  return uniqueOrderedStrings(
     ensureArray(entry.next_expected_responders).length
       ? entry.next_expected_responders
       : ensureArray(entry.followup_next_expected_responders).length
@@ -3605,40 +3599,40 @@ function runnerRequestPreferredNextExpectedResponders(entryRaw) {
         : ensureArray(entry.root_next_expected_responders).length
           ? entry.root_next_expected_responders
           : [],
-    normalizeTelegramMentionUsername,
-  );
-}
-
-function runnerRequestPreferredAuthoritySelectedBotUsernames(entryRaw) {
-  const entry = safeObject(entryRaw);
-  const normalizedSummaryBot = normalizeTelegramMentionUsername(entry.conversation_summary_bot);
-  return uniqueOrderedStrings(
-    runnerRequestPreferredNextExpectedResponders(entry).length
-      ? runnerRequestPreferredNextExpectedResponders(entry)
-      : runnerRequestPreferredExecutionContractTargets(entry).length
-        ? runnerRequestPreferredExecutionContractTargets(entry)
-        : ensureArray(entry.selected_bot_usernames).length
-          ? entry.selected_bot_usernames
-          : ensureArray(entry.conversation_initial_responders).length
-            ? entry.conversation_initial_responders
-            : normalizedSummaryBot
-              ? [normalizedSummaryBot]
-              : [],
-    normalizeTelegramMentionUsername,
-  );
-}
-
-function extractRunnerExplicitSelectedBotUsernamesFromParsed(parsedArchiveRaw) {
-  const parsedArchive = safeObject(parsedArchiveRaw);
-  return uniqueOrderedStrings(
-    ensureArray(parsedArchive.mentionUsernames).length
-      ? parsedArchive.mentionUsernames
-      : String(parsedArchive.replyToUsername || "").trim()
-        ? [parsedArchive.replyToUsername]
-        : [],
-    normalizeTelegramMentionUsername,
-  );
-}
+    normalizeTelegramMentionUsername,
+  );
+}
+
+function runnerRequestPreferredAuthoritySelectedBotUsernames(entryRaw) {
+  const entry = safeObject(entryRaw);
+  const normalizedSummaryBot = normalizeTelegramMentionUsername(entry.conversation_summary_bot);
+  return uniqueOrderedStrings(
+    runnerRequestPreferredNextExpectedResponders(entry).length
+      ? runnerRequestPreferredNextExpectedResponders(entry)
+      : runnerRequestPreferredExecutionContractTargets(entry).length
+        ? runnerRequestPreferredExecutionContractTargets(entry)
+        : ensureArray(entry.selected_bot_usernames).length
+          ? entry.selected_bot_usernames
+          : ensureArray(entry.conversation_initial_responders).length
+            ? entry.conversation_initial_responders
+            : normalizedSummaryBot
+              ? [normalizedSummaryBot]
+              : [],
+    normalizeTelegramMentionUsername,
+  );
+}
+
+function extractRunnerExplicitSelectedBotUsernamesFromParsed(parsedArchiveRaw) {
+  const parsedArchive = safeObject(parsedArchiveRaw);
+  return uniqueOrderedStrings(
+    ensureArray(parsedArchive.mentionUsernames).length
+      ? parsedArchive.mentionUsernames
+      : String(parsedArchive.replyToUsername || "").trim()
+        ? [parsedArchive.replyToUsername]
+        : [],
+    normalizeTelegramMentionUsername,
+  );
+}
 
 function runnerRequestPreferredAIReplyPreview(entryRaw) {
   const entry = safeObject(entryRaw);
@@ -3750,26 +3744,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 = "",
-  sourceMessageEnvelope = {},
-  lastReplyMessageEnvelope = {},
-  attemptedDeliveryEnvelope = {},
-} = {}) {
-  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(
@@ -3792,15 +3786,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(),
-    source_message_envelope: safeObject(sourceMessageEnvelope),
-    last_reply_message_envelope: safeObject(lastReplyMessageEnvelope),
-    attempted_delivery_envelope: safeObject(attemptedDeliveryEnvelope),
-  };
-}
+    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);
@@ -3816,8 +3810,8 @@ function buildRunnerRequestRootWorkItemSummary(entryRaw) {
   };
 }
 
-function buildRunnerRouteLastResultSummary(routeStateRaw) {
-  const routeState = safeObject(routeStateRaw);
+function buildRunnerRouteLastResultSummary(routeStateRaw) {
+  const routeState = safeObject(routeStateRaw);
   const executionContractType = String(
     routeState.last_followup_execution_contract_type
       || routeState.last_normalized_execution_contract_type
@@ -3865,18 +3859,18 @@ function buildRunnerRouteLastResultSummary(routeStateRaw) {
     ensureArray(routeState.last_followup_assignment_validation_modes),
     (value) => String(value || "").trim().toLowerCase(),
   );
-  return {
-    action: String(routeState.last_action || "").trim(),
-    reason: String(routeState.last_reason || "").trim(),
-    visibility_status: String(routeState.last_visibility_status || "").trim(),
-    visibility_reason: String(routeState.last_visibility_reason || "").trim(),
-    visibility_source: String(routeState.last_visibility_source || "").trim(),
-    candidate_bot_usernames: uniqueOrderedStrings(
-      ensureArray(routeState.last_candidate_bot_usernames),
-      normalizeTelegramMentionUsername,
-    ),
-    intent_type: String(routeState.last_intent_type || "").trim(),
-    ...buildRunnerValidationAndDeliverySummary({
+  return {
+    action: String(routeState.last_action || "").trim(),
+    reason: String(routeState.last_reason || "").trim(),
+    visibility_status: String(routeState.last_visibility_status || "").trim(),
+    visibility_reason: String(routeState.last_visibility_reason || "").trim(),
+    visibility_source: String(routeState.last_visibility_source || "").trim(),
+    candidate_bot_usernames: uniqueOrderedStrings(
+      ensureArray(routeState.last_candidate_bot_usernames),
+      normalizeTelegramMentionUsername,
+    ),
+    intent_type: String(routeState.last_intent_type || "").trim(),
+    ...buildRunnerValidationAndDeliverySummary({
       aiReplyPreview: routeState.last_followup_ai_reply_preview,
       executionContractType,
       executionContractTargets,
@@ -3886,15 +3880,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,
-      sourceMessageEnvelope: routeState.last_followup_source_message_envelope,
-      lastReplyMessageEnvelope: routeState.last_followup_last_reply_message_envelope,
-      attemptedDeliveryEnvelope: routeState.last_followup_attempted_delivery_envelope,
-    }),
+      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),
@@ -4058,10 +4052,10 @@ async function loadRunnerArchiveThreadMessageIndex({
   }
 }
 
-async function findRunnerArchiveThreadMessageByID({
-  runtime,
-  threadID,
-  messageID,
+async function findRunnerArchiveThreadMessageByID({
+  runtime,
+  threadID,
+  messageID,
   cache = null,
 }) {
   const nextCache = await loadRunnerArchiveThreadMessageIndex({
@@ -4069,244 +4063,244 @@ async function findRunnerArchiveThreadMessageByID({
     threadID,
     cache,
   });
-  return {
-    cache: nextCache,
-    record: safeObject(nextCache.messageIndex.get(intFromRawAllowZero(messageID, 0))),
-  };
-}
-
-function buildRunnerReplyChainSnapshotFromParsedArchive(parsedArchiveRaw, overrides = {}) {
-  const parsedArchive = safeObject(parsedArchiveRaw);
-  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]),
-      ),
-    },
-  );
-}
-
-function buildRunnerReplyChainSnapshotFromArchiveRecord(recordRaw) {
-  const record = safeObject(recordRaw);
-  const parsedArchive = safeObject(record.parsedArchive || parseArchivedChatComment(record.body));
-  return buildRunnerReplyChainSnapshotFromParsedArchive(parsedArchive);
-}
-
-function buildRunnerReplyChainSnapshotFromRequestSource(requestRaw) {
-  const request = safeObject(requestRaw);
-  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) {
-  const request = safeObject(requestRaw);
-  const preview = runnerRequestPreferredAIReplyPreview(request);
-  if (!preview) {
-    return null;
-  }
-  const explicitEnvelope = normalizeRunnerTelegramMessageEnvelope(
-    request.last_reply_message_envelope || request.lastReplyMessageEnvelope,
-  );
-  return buildRunnerReplyChainSnapshotFromMessageEnvelope(
-    explicitEnvelope && intFromRawAllowZero(explicitEnvelope.message_id, 0) > 0
-      ? explicitEnvelope
-      : null,
-    {
-      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) {
-  const normalized = [];
-  const seen = new Set();
-  for (const snapshotRaw of ensureArray(snapshots)) {
-    const snapshot = normalizeRunnerReplyChainSnapshot(snapshotRaw);
-    if (!snapshot) continue;
-    const key = snapshot.message_id
-      ? `message:${snapshot.message_id}`
-      : `body:${snapshot.speaker_type}:${String(snapshot.body || "").trim()}`;
-    if (seen.has(key)) continue;
-    seen.add(key);
-    normalized.push(snapshot);
-  }
-  return normalized.slice(-(Math.max(1, intFromRawAllowZero(limit, 4) || 4)));
-}
-
-async function buildRunnerAuthorityReplyChainContext({
-  selectedRecord,
-  replyChainContext = null,
-  authoritySource = null,
-  runtime,
-  archiveThreadID = "",
-}) {
-  const parsed = safeObject(selectedRecord?.parsedArchive);
-  const normalizedReplyChainContext = safeObject(replyChainContext);
-  const referencedRequest = safeObject(
-    authoritySource?.request_key
-      ? authoritySource
-      : normalizedReplyChainContext.referencedRequest,
-  );
-  const normalizedArchiveThreadID = firstNonEmptyString([
-    archiveThreadID,
-    selectedRecord?.thread_id,
-    selectedRecord?.threadID,
-    selectedRecord?.threadId,
-  ]);
-  const conversationID = firstNonEmptyString([
-    normalizedReplyChainContext.conversationID,
-    parsed.conversationID,
-    referencedRequest.conversation_id,
-  ]);
-  const currentMessageID = intFromRawAllowZero(parsed.messageID, 0);
-  const parentMessageID = intFromRawAllowZero(
-    parsed.replyToMessageID || normalizedReplyChainContext.replyToMessageID,
-    0,
-  );
-  let archiveThreadCache = null;
-  const loadArchiveSnapshot = async (messageID) => {
-    if (!(messageID > 0) || !normalizedArchiveThreadID || !runtime?.baseURL || !runtime?.token) {
-      return null;
-    }
-    const lookup = await findRunnerArchiveThreadMessageByID({
-      runtime,
-      threadID: normalizedArchiveThreadID,
-      messageID,
-      cache: archiveThreadCache,
-    });
-    archiveThreadCache = lookup.cache;
-    return buildRunnerReplyChainSnapshotFromArchiveRecord(lookup.record);
-  };
-
-  const ancestorSnapshots = [];
-  let nextReplyToMessageID = parentMessageID;
-  const visitedMessageIDs = new Set();
-  for (let hop = 0; hop < 8 && nextReplyToMessageID > 0; hop += 1) {
-    if (visitedMessageIDs.has(nextReplyToMessageID)) {
-      break;
-    }
-    visitedMessageIDs.add(nextReplyToMessageID);
-    const archivedLookup = await findRunnerArchiveThreadMessageByID({
-      runtime,
-      threadID: normalizedArchiveThreadID,
-      messageID: nextReplyToMessageID,
-      cache: archiveThreadCache,
-    });
-    archiveThreadCache = archivedLookup.cache;
-    const archivedRecord = safeObject(archivedLookup.record);
-    if (!Object.keys(archivedRecord).length) {
-      break;
-    }
-    const snapshot = buildRunnerReplyChainSnapshotFromArchiveRecord(archivedRecord);
-    if (snapshot) {
-      ancestorSnapshots.unshift(snapshot);
-    }
-    const archivedParsed = safeObject(archivedRecord.parsedArchive || parseArchivedChatComment(archivedRecord.body));
-    nextReplyToMessageID = intFromRawAllowZero(archivedParsed.replyToMessageID, 0);
-  }
-
-  let parentMessage = ancestorSnapshots.length
-    ? safeObject(ancestorSnapshots[ancestorSnapshots.length - 1])
-    : {};
-  let rootMessage = safeObject(
-    ancestorSnapshots.find((item) => String(item?.speaker_type || "").trim().toLowerCase() === "human"),
-  );
-  let latestPriorBotReply = safeObject(
-    [...ancestorSnapshots].reverse().find((item) => String(item?.speaker_type || "").trim().toLowerCase() === "bot"),
-  );
-
-  const requestRootMessage = buildRunnerReplyChainSnapshotFromRequestSource(referencedRequest);
-  const requestLatestBotReply = buildRunnerReplyChainSnapshotFromRequestReply(referencedRequest);
-
-  if (!Object.keys(parentMessage).length && parentMessageID > 0) {
-    parentMessage = safeObject(await loadArchiveSnapshot(parentMessageID));
-  }
-  if (!Object.keys(rootMessage).length) {
-    rootMessage = safeObject(requestRootMessage);
-  }
-  if (
-    Object.keys(requestLatestBotReply || {}).length
-    && (
-      !Object.keys(latestPriorBotReply).length
-      || intFromRawAllowZero(requestLatestBotReply.message_id, 0) > intFromRawAllowZero(latestPriorBotReply.message_id, 0)
-    )
-  ) {
-    latestPriorBotReply = safeObject(requestLatestBotReply);
-  }
-  if (!Object.keys(latestPriorBotReply).length) {
-    latestPriorBotReply = safeObject(requestLatestBotReply);
-  }
-  if (!Object.keys(rootMessage).length && !parentMessageID && currentMessageID > 0) {
-    rootMessage = safeObject(buildRunnerReplyChainSnapshotFromParsedArchive(parsed));
-  }
-
-  const recentChainMessages = uniqueRunnerReplyChainSnapshots(
-    [
-      ...ancestorSnapshots,
-      requestLatestBotReply,
-      parentMessage,
-      latestPriorBotReply,
-    ].filter(Boolean),
-    4,
-  );
-  const currentTurnRelation = Object.keys(parentMessage).length
-    ? "reply_to_parent_message"
-    : conversationID
-      ? "same_conversation_followup"
-      : "standalone_message";
-  return normalizeRunnerReplyChainContext({
-    conversation_id: conversationID,
-    current_message_id: currentMessageID,
-    current_message_thread_id: intFromRawAllowZero(parsed.messageThreadID, 0) || undefined,
-    parent_message_id: parentMessageID,
-    root_message_id: intFromRawAllowZero(rootMessage.message_id, 0) || undefined,
-    current_turn_relation: currentTurnRelation,
-    root_message: rootMessage,
-    parent_message: parentMessage,
-    latest_prior_bot_reply: latestPriorBotReply,
-    recent_chain_messages: recentChainMessages,
-  });
-}
-
-function resolveRunnerReplyChainConversationContext(state, normalizedRoute, selectedRecord) {
-  const parsed = safeObject(selectedRecord?.parsedArchive);
+  return {
+    cache: nextCache,
+    record: safeObject(nextCache.messageIndex.get(intFromRawAllowZero(messageID, 0))),
+  };
+}
+
+function buildRunnerReplyChainSnapshotFromParsedArchive(parsedArchiveRaw, overrides = {}) {
+  const parsedArchive = safeObject(parsedArchiveRaw);
+  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]),
+      ),
+    },
+  );
+}
+
+function buildRunnerReplyChainSnapshotFromArchiveRecord(recordRaw) {
+  const record = safeObject(recordRaw);
+  const parsedArchive = safeObject(record.parsedArchive || parseArchivedChatComment(record.body));
+  return buildRunnerReplyChainSnapshotFromParsedArchive(parsedArchive);
+}
+
+function buildRunnerReplyChainSnapshotFromRequestSource(requestRaw) {
+  const request = safeObject(requestRaw);
+  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) {
+  const request = safeObject(requestRaw);
+  const preview = runnerRequestPreferredAIReplyPreview(request);
+  if (!preview) {
+    return null;
+  }
+  const explicitEnvelope = normalizeRunnerTelegramMessageEnvelope(
+    request.last_reply_message_envelope || request.lastReplyMessageEnvelope,
+  );
+  return buildRunnerReplyChainSnapshotFromMessageEnvelope(
+    explicitEnvelope && intFromRawAllowZero(explicitEnvelope.message_id, 0) > 0
+      ? explicitEnvelope
+      : null,
+    {
+      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) {
+  const normalized = [];
+  const seen = new Set();
+  for (const snapshotRaw of ensureArray(snapshots)) {
+    const snapshot = normalizeRunnerReplyChainSnapshot(snapshotRaw);
+    if (!snapshot) continue;
+    const key = snapshot.message_id
+      ? `message:${snapshot.message_id}`
+      : `body:${snapshot.speaker_type}:${String(snapshot.body || "").trim()}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    normalized.push(snapshot);
+  }
+  return normalized.slice(-(Math.max(1, intFromRawAllowZero(limit, 4) || 4)));
+}
+
+async function buildRunnerAuthorityReplyChainContext({
+  selectedRecord,
+  replyChainContext = null,
+  authoritySource = null,
+  runtime,
+  archiveThreadID = "",
+}) {
+  const parsed = safeObject(selectedRecord?.parsedArchive);
+  const normalizedReplyChainContext = safeObject(replyChainContext);
+  const referencedRequest = safeObject(
+    authoritySource?.request_key
+      ? authoritySource
+      : normalizedReplyChainContext.referencedRequest,
+  );
+  const normalizedArchiveThreadID = firstNonEmptyString([
+    archiveThreadID,
+    selectedRecord?.thread_id,
+    selectedRecord?.threadID,
+    selectedRecord?.threadId,
+  ]);
+  const conversationID = firstNonEmptyString([
+    normalizedReplyChainContext.conversationID,
+    parsed.conversationID,
+    referencedRequest.conversation_id,
+  ]);
+  const currentMessageID = intFromRawAllowZero(parsed.messageID, 0);
+  const parentMessageID = intFromRawAllowZero(
+    parsed.replyToMessageID || normalizedReplyChainContext.replyToMessageID,
+    0,
+  );
+  let archiveThreadCache = null;
+  const loadArchiveSnapshot = async (messageID) => {
+    if (!(messageID > 0) || !normalizedArchiveThreadID || !runtime?.baseURL || !runtime?.token) {
+      return null;
+    }
+    const lookup = await findRunnerArchiveThreadMessageByID({
+      runtime,
+      threadID: normalizedArchiveThreadID,
+      messageID,
+      cache: archiveThreadCache,
+    });
+    archiveThreadCache = lookup.cache;
+    return buildRunnerReplyChainSnapshotFromArchiveRecord(lookup.record);
+  };
+
+  const ancestorSnapshots = [];
+  let nextReplyToMessageID = parentMessageID;
+  const visitedMessageIDs = new Set();
+  for (let hop = 0; hop < 8 && nextReplyToMessageID > 0; hop += 1) {
+    if (visitedMessageIDs.has(nextReplyToMessageID)) {
+      break;
+    }
+    visitedMessageIDs.add(nextReplyToMessageID);
+    const archivedLookup = await findRunnerArchiveThreadMessageByID({
+      runtime,
+      threadID: normalizedArchiveThreadID,
+      messageID: nextReplyToMessageID,
+      cache: archiveThreadCache,
+    });
+    archiveThreadCache = archivedLookup.cache;
+    const archivedRecord = safeObject(archivedLookup.record);
+    if (!Object.keys(archivedRecord).length) {
+      break;
+    }
+    const snapshot = buildRunnerReplyChainSnapshotFromArchiveRecord(archivedRecord);
+    if (snapshot) {
+      ancestorSnapshots.unshift(snapshot);
+    }
+    const archivedParsed = safeObject(archivedRecord.parsedArchive || parseArchivedChatComment(archivedRecord.body));
+    nextReplyToMessageID = intFromRawAllowZero(archivedParsed.replyToMessageID, 0);
+  }
+
+  let parentMessage = ancestorSnapshots.length
+    ? safeObject(ancestorSnapshots[ancestorSnapshots.length - 1])
+    : {};
+  let rootMessage = safeObject(
+    ancestorSnapshots.find((item) => String(item?.speaker_type || "").trim().toLowerCase() === "human"),
+  );
+  let latestPriorBotReply = safeObject(
+    [...ancestorSnapshots].reverse().find((item) => String(item?.speaker_type || "").trim().toLowerCase() === "bot"),
+  );
+
+  const requestRootMessage = buildRunnerReplyChainSnapshotFromRequestSource(referencedRequest);
+  const requestLatestBotReply = buildRunnerReplyChainSnapshotFromRequestReply(referencedRequest);
+
+  if (!Object.keys(parentMessage).length && parentMessageID > 0) {
+    parentMessage = safeObject(await loadArchiveSnapshot(parentMessageID));
+  }
+  if (!Object.keys(rootMessage).length) {
+    rootMessage = safeObject(requestRootMessage);
+  }
+  if (
+    Object.keys(requestLatestBotReply || {}).length
+    && (
+      !Object.keys(latestPriorBotReply).length
+      || intFromRawAllowZero(requestLatestBotReply.message_id, 0) > intFromRawAllowZero(latestPriorBotReply.message_id, 0)
+    )
+  ) {
+    latestPriorBotReply = safeObject(requestLatestBotReply);
+  }
+  if (!Object.keys(latestPriorBotReply).length) {
+    latestPriorBotReply = safeObject(requestLatestBotReply);
+  }
+  if (!Object.keys(rootMessage).length && !parentMessageID && currentMessageID > 0) {
+    rootMessage = safeObject(buildRunnerReplyChainSnapshotFromParsedArchive(parsed));
+  }
+
+  const recentChainMessages = uniqueRunnerReplyChainSnapshots(
+    [
+      ...ancestorSnapshots,
+      requestLatestBotReply,
+      parentMessage,
+      latestPriorBotReply,
+    ].filter(Boolean),
+    4,
+  );
+  const currentTurnRelation = Object.keys(parentMessage).length
+    ? "reply_to_parent_message"
+    : conversationID
+      ? "same_conversation_followup"
+      : "standalone_message";
+  return normalizeRunnerReplyChainContext({
+    conversation_id: conversationID,
+    current_message_id: currentMessageID,
+    current_message_thread_id: intFromRawAllowZero(parsed.messageThreadID, 0) || undefined,
+    parent_message_id: parentMessageID,
+    root_message_id: intFromRawAllowZero(rootMessage.message_id, 0) || undefined,
+    current_turn_relation: currentTurnRelation,
+    root_message: rootMessage,
+    parent_message: parentMessage,
+    latest_prior_bot_reply: latestPriorBotReply,
+    recent_chain_messages: recentChainMessages,
+  });
+}
+
+function resolveRunnerReplyChainConversationContext(state, normalizedRoute, selectedRecord) {
+  const parsed = safeObject(selectedRecord?.parsedArchive);
   const explicitConversationID = String(parsed.conversationID || "").trim();
   if (explicitConversationID) {
     return {
@@ -4534,9 +4528,9 @@ function upsertRunnerRequest(state, requestKey, patch = {}) {
   };
 }
 
-function upsertRunnerConsumedComment(state, commentIDRaw, patch = {}) {
-  const commentID = String(commentIDRaw || "").trim();
-  const currentState = safeObject(state);
+function upsertRunnerConsumedComment(state, commentIDRaw, patch = {}) {
+  const commentID = String(commentIDRaw || "").trim();
+  const currentState = safeObject(state);
   const consumedComments = normalizeBotRunnerConsumedComments(currentState.consumedComments || currentState.consumed_comments);
   const ledgerKey = buildRunnerConsumedCommentLedgerKey(commentID, patch.route_key, patch.comment_kind);
   const existing = safeObject(consumedComments[ledgerKey]);
@@ -4550,85 +4544,85 @@ function upsertRunnerConsumedComment(state, commentIDRaw, patch = {}) {
     request_status: normalizeRunnerRequestStatus(patch.request_status || existing.request_status),
   };
   consumedComments[ledgerKey] = nextEntry;
-  return {
-    consumedComments,
-    consumedComment: nextEntry,
-  };
-}
-
-function resolveRunnerHumanCommentAuthorityContext({
-  normalizedRoute,
-  selectedRecord,
-  replyChainContext = null,
-  referencedRequest = null,
-  sharedConversationSource = null,
-  selectedBotUsernames = [],
-  normalizedSharedHumanIntent = null,
-  resolvedNormalizedIntent = "",
-}) {
-  const parsed = safeObject(selectedRecord?.parsedArchive);
-  const explicitCurrentSelectedBotUsernames = extractRunnerExplicitSelectedBotUsernamesFromParsed(parsed);
-  const replyChain = safeObject(replyChainContext);
-  const referenced = safeObject(referencedRequest);
-  const sharedSource = safeObject(sharedConversationSource);
-  const sharedIntent = safeObject(normalizedSharedHumanIntent);
-  const authoritySource = Object.keys(referenced).length
-    ? referenced
-    : Object.keys(sharedSource).length
-      ? sharedSource
-      : {};
-  const currentMessageID = intFromRawAllowZero(parsed.messageID, 0);
-  const resolvedConversationID = firstNonEmptyString([
-    parsed.conversationID,
-    replyChain.conversationID,
-    authoritySource.conversation_id,
-    Object.keys(sharedIntent).length > 0
-      ? buildSyntheticHumanOpeningConversationID(
-        normalizedRoute,
-        String(parsed.chatID || parsed.chatId || "").trim(),
-        currentMessageID,
-      )
-      : "",
-  ]);
-  const explicitSelectedBotUsernames = uniqueOrderedStrings(
-    selectedBotUsernames,
-    normalizeTelegramMentionUsername,
-  );
-  const authoritySelectedBotUsernames = uniqueOrderedStrings(
-    explicitCurrentSelectedBotUsernames.length > 0
-      ? explicitCurrentSelectedBotUsernames
-      : explicitSelectedBotUsernames.length > 0
-        ? explicitSelectedBotUsernames
-      : resolvedConversationID && runnerRequestPreferredAuthoritySelectedBotUsernames(authoritySource).length
-        ? runnerRequestPreferredAuthoritySelectedBotUsernames(authoritySource)
-        : [],
-    normalizeTelegramMentionUsername,
-  );
-  const preferredNormalizedIntent = String(
-    sharedIntent.intentType
-      || resolvedNormalizedIntent
-      || authoritySource.normalized_intent
-      || "",
-  ).trim().toLowerCase();
-  return {
-    authoritySource,
-    conversationID: String(resolvedConversationID || "").trim(),
-    selectedBotUsernames: authoritySelectedBotUsernames,
-    normalizedIntent: preferredNormalizedIntent,
-  };
-}
-
-async function claimRunnerRequestForHumanComment({
-  normalizedRoute,
-  routeKey,
-  selectedRecord,
-  selectedBotUsernames = [],
-  normalizedIntent = "",
-  sharedHumanIntent = null,
-  runtime = null,
-  archiveThreadID = "",
-  authoritativeSourceMessageEnvelope = {},
-}) {
+  return {
+    consumedComments,
+    consumedComment: nextEntry,
+  };
+}
+
+function resolveRunnerHumanCommentAuthorityContext({
+  normalizedRoute,
+  selectedRecord,
+  replyChainContext = null,
+  referencedRequest = null,
+  sharedConversationSource = null,
+  selectedBotUsernames = [],
+  normalizedSharedHumanIntent = null,
+  resolvedNormalizedIntent = "",
+}) {
+  const parsed = safeObject(selectedRecord?.parsedArchive);
+  const explicitCurrentSelectedBotUsernames = extractRunnerExplicitSelectedBotUsernamesFromParsed(parsed);
+  const replyChain = safeObject(replyChainContext);
+  const referenced = safeObject(referencedRequest);
+  const sharedSource = safeObject(sharedConversationSource);
+  const sharedIntent = safeObject(normalizedSharedHumanIntent);
+  const authoritySource = Object.keys(referenced).length
+    ? referenced
+    : Object.keys(sharedSource).length
+      ? sharedSource
+      : {};
+  const currentMessageID = intFromRawAllowZero(parsed.messageID, 0);
+  const resolvedConversationID = firstNonEmptyString([
+    parsed.conversationID,
+    replyChain.conversationID,
+    authoritySource.conversation_id,
+    Object.keys(sharedIntent).length > 0
+      ? buildSyntheticHumanOpeningConversationID(
+        normalizedRoute,
+        String(parsed.chatID || parsed.chatId || "").trim(),
+        currentMessageID,
+      )
+      : "",
+  ]);
+  const explicitSelectedBotUsernames = uniqueOrderedStrings(
+    selectedBotUsernames,
+    normalizeTelegramMentionUsername,
+  );
+  const authoritySelectedBotUsernames = uniqueOrderedStrings(
+    explicitCurrentSelectedBotUsernames.length > 0
+      ? explicitCurrentSelectedBotUsernames
+      : explicitSelectedBotUsernames.length > 0
+        ? explicitSelectedBotUsernames
+      : resolvedConversationID && runnerRequestPreferredAuthoritySelectedBotUsernames(authoritySource).length
+        ? runnerRequestPreferredAuthoritySelectedBotUsernames(authoritySource)
+        : [],
+    normalizeTelegramMentionUsername,
+  );
+  const preferredNormalizedIntent = String(
+    sharedIntent.intentType
+      || resolvedNormalizedIntent
+      || authoritySource.normalized_intent
+      || "",
+  ).trim().toLowerCase();
+  return {
+    authoritySource,
+    conversationID: String(resolvedConversationID || "").trim(),
+    selectedBotUsernames: authoritySelectedBotUsernames,
+    normalizedIntent: preferredNormalizedIntent,
+  };
+}
+
+async function claimRunnerRequestForHumanComment({
+  normalizedRoute,
+  routeKey,
+  selectedRecord,
+  selectedBotUsernames = [],
+  normalizedIntent = "",
+  sharedHumanIntent = null,
+  runtime = null,
+  archiveThreadID = "",
+  authoritativeSourceMessageEnvelope = {},
+}) {
   const parsed = safeObject(selectedRecord?.parsedArchive);
   const commentKind = String(parsed.kind || "").trim().toLowerCase();
   if (!isInboundArchiveKind(commentKind)) {
@@ -4637,45 +4631,45 @@ async function claimRunnerRequestForHumanComment({
       reason: "non_human_comment_cannot_create_request",
     };
   }
-  const currentState = loadBotRunnerState();
-  const currentRouteState = safeObject(safeObject(currentState.routes)[String(routeKey || "").trim()]);
-  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,
     archiveThreadID,
   });
   const replyChainContext = safeObject(replyChainResolution.replyChainContext);
-  const referencedRequest = safeObject(replyChainContext.referencedRequest);
-  const resolvedNormalizedIntent = resolveRunnerRequestClaimIntent({
-    normalizedIntent,
-    selectedRecord,
-  });
-  let stateForClaim = safeObject(replyChainResolution.state);
-  const normalizedSharedHumanIntent = safeObject(sharedHumanIntent);
-  const provisionalConversationID = String(
-    parsed.conversationID
-    || replyChainContext.conversationID
-    || "",
-  ).trim();
-  const provisionalNormalizedIntent = String(
-    normalizedSharedHumanIntent.intentType
-      || resolvedNormalizedIntent
-      || referencedRequest.normalized_intent
-      || "",
-  ).trim().toLowerCase();
-  const provisionalRequestKey = buildRunnerRequestKey({
-    normalizedRoute,
-    selectedRecord,
-    selectedBotUsernames,
-    normalizedIntent: provisionalNormalizedIntent,
-    conversationID: provisionalConversationID,
-  });
-  const baseConversationID = provisionalConversationID;
-  if (
-    Object.keys(referencedRequest).length > 0
-    && baseConversationID
+  const referencedRequest = safeObject(replyChainContext.referencedRequest);
+  const resolvedNormalizedIntent = resolveRunnerRequestClaimIntent({
+    normalizedIntent,
+    selectedRecord,
+  });
+  let stateForClaim = safeObject(replyChainResolution.state);
+  const normalizedSharedHumanIntent = safeObject(sharedHumanIntent);
+  const provisionalConversationID = String(
+    parsed.conversationID
+    || replyChainContext.conversationID
+    || "",
+  ).trim();
+  const provisionalNormalizedIntent = String(
+    normalizedSharedHumanIntent.intentType
+      || resolvedNormalizedIntent
+      || referencedRequest.normalized_intent
+      || "",
+  ).trim().toLowerCase();
+  const provisionalRequestKey = buildRunnerRequestKey({
+    normalizedRoute,
+    selectedRecord,
+    selectedBotUsernames,
+    normalizedIntent: provisionalNormalizedIntent,
+    conversationID: provisionalConversationID,
+  });
+  const baseConversationID = provisionalConversationID;
+  if (
+    Object.keys(referencedRequest).length > 0
+    && baseConversationID
     && !String(referencedRequest.conversation_id || "").trim()
     && String(referencedRequest.request_key || "").trim()
   ) {
@@ -4703,44 +4697,44 @@ async function claimRunnerRequestForHumanComment({
     && runtime?.baseURL
     && runtime?.token
   ) {
-    sharedConversationSource = safeObject(await findServerRunnerConversationSourceRequestForMessageID({
-      normalizedRoute,
-      runtime,
-      chatID: String(parsed.chatID || parsed.chatId || "").trim(),
-      messageID: currentMessageID,
-      excludeRequestKey: provisionalRequestKey,
-    }));
-  }
-  const authorityContext = resolveRunnerHumanCommentAuthorityContext({
-    normalizedRoute,
-    selectedRecord,
-    replyChainContext,
-    referencedRequest,
-    sharedConversationSource,
-    selectedBotUsernames,
-    normalizedSharedHumanIntent,
-    resolvedNormalizedIntent,
-  });
-  const authoritySource = safeObject(authorityContext.authoritySource);
-  const authorityReplyChainContext = await buildRunnerAuthorityReplyChainContext({
-    selectedRecord,
-    replyChainContext,
-    authoritySource,
-    runtime,
-    archiveThreadID,
-  });
-  const resolvedConversationID = String(authorityContext.conversationID || "").trim();
-  const preferredNormalizedIntent = String(authorityContext.normalizedIntent || "").trim().toLowerCase();
-  const requestSelectedBotUsernames = ensureArray(authorityContext.selectedBotUsernames);
-  const requestKey = buildRunnerRequestKey({
-    normalizedRoute,
-    selectedRecord,
-    selectedBotUsernames: requestSelectedBotUsernames,
-    normalizedIntent: preferredNormalizedIntent,
-    conversationID: resolvedConversationID,
-  });
-  const requests = normalizeBotRunnerRequests(stateForClaim.requests);
-  const existing = safeObject(requests[requestKey]);
+    sharedConversationSource = safeObject(await findServerRunnerConversationSourceRequestForMessageID({
+      normalizedRoute,
+      runtime,
+      chatID: String(parsed.chatID || parsed.chatId || "").trim(),
+      messageID: currentMessageID,
+      excludeRequestKey: provisionalRequestKey,
+    }));
+  }
+  const authorityContext = resolveRunnerHumanCommentAuthorityContext({
+    normalizedRoute,
+    selectedRecord,
+    replyChainContext,
+    referencedRequest,
+    sharedConversationSource,
+    selectedBotUsernames,
+    normalizedSharedHumanIntent,
+    resolvedNormalizedIntent,
+  });
+  const authoritySource = safeObject(authorityContext.authoritySource);
+  const authorityReplyChainContext = await buildRunnerAuthorityReplyChainContext({
+    selectedRecord,
+    replyChainContext,
+    authoritySource,
+    runtime,
+    archiveThreadID,
+  });
+  const resolvedConversationID = String(authorityContext.conversationID || "").trim();
+  const preferredNormalizedIntent = String(authorityContext.normalizedIntent || "").trim().toLowerCase();
+  const requestSelectedBotUsernames = ensureArray(authorityContext.selectedBotUsernames);
+  const requestKey = buildRunnerRequestKey({
+    normalizedRoute,
+    selectedRecord,
+    selectedBotUsernames: requestSelectedBotUsernames,
+    normalizedIntent: preferredNormalizedIntent,
+    conversationID: resolvedConversationID,
+  });
+  const requests = normalizeBotRunnerRequests(stateForClaim.requests);
+  const existing = safeObject(requests[requestKey]);
   if (isFinalRunnerRequestStatus(existing.status)) {
     return {
       ok: false,
@@ -4758,126 +4752,126 @@ async function claimRunnerRequestForHumanComment({
       reason: "request_already_claimed",
       requestKey,
     };
-  }
-  const nowISO = new Date().toISOString();
-  const sourceMessageEnvelope = selectAuthoritativeRunnerSourceMessageEnvelope(
-    authoritativeSourceMessageEnvelope,
-    buildRunnerSourceMessageEnvelope({
-      routeState: currentRouteState,
-      routeKey,
-      normalizedRoute,
-      parsedArchive: parsed,
-    }),
-  );
-  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_origin: String(sourceMessageEnvelope.source_origin || "").trim().toLowerCase(),
-    source_message_route_key: String(sourceMessageEnvelope.source_route_key || "").trim(),
-    source_message_bot_username: normalizeTelegramMentionUsername(sourceMessageEnvelope.source_bot_username),
-    source_message_envelope: sourceMessageEnvelope,
-    root_comment_id: String(selectedRecord?.id || "").trim(),
-    root_comment_kind: commentKind,
-    conversation_id: resolvedConversationID,
-    reply_chain_context: authorityReplyChainContext,
-    selected_bot_usernames: uniqueOrderedStrings(requestSelectedBotUsernames, normalizeTelegramMentionUsername),
-    conversation_intent_mode: String(
-      normalizedSharedHumanIntent.intentMode
-        || existing.conversation_intent_mode
-        || authoritySource.conversation_intent_mode
-        || "",
-    ).trim().toLowerCase(),
-    conversation_lead_bot: normalizeTelegramMentionUsername(
-      normalizedSharedHumanIntent.leadBotSelector
-        || existing.conversation_lead_bot
-        || authoritySource.conversation_lead_bot,
-    ),
-    conversation_summary_bot: normalizeTelegramMentionUsername(
-      normalizedSharedHumanIntent.summaryBotSelector
-        || existing.conversation_summary_bot
-        || authoritySource.conversation_summary_bot,
-    ),
-    conversation_participants: uniqueOrderedStrings(
-      ensureArray(normalizedSharedHumanIntent.participantSelectors).length
-        ? normalizedSharedHumanIntent.participantSelectors
-        : ensureArray(existing.conversation_participants).length
-          ? existing.conversation_participants
-          : ensureArray(authoritySource.conversation_participants).length
-            ? authoritySource.conversation_participants
-            : [],
-      normalizeTelegramMentionUsername,
-    ),
-    conversation_initial_responders: uniqueOrderedStrings(
-      ensureArray(normalizedSharedHumanIntent.initialResponderSelectors).length
-        ? normalizedSharedHumanIntent.initialResponderSelectors
-        : ensureArray(existing.conversation_initial_responders).length
-          ? existing.conversation_initial_responders
-          : ensureArray(authoritySource.conversation_initial_responders).length
-            ? authoritySource.conversation_initial_responders
-            : [],
-      normalizeTelegramMentionUsername,
-    ),
-    conversation_allowed_responders: uniqueOrderedStrings(
-      ensureArray(normalizedSharedHumanIntent.allowedResponderSelectors).length
-        ? normalizedSharedHumanIntent.allowedResponderSelectors
-        : ensureArray(existing.conversation_allowed_responders).length
-          ? existing.conversation_allowed_responders
-          : ensureArray(authoritySource.conversation_allowed_responders).length
-            ? authoritySource.conversation_allowed_responders
-            : [],
-      normalizeTelegramMentionUsername,
-    ),
-    conversation_allow_bot_to_bot: normalizedSharedHumanIntent.allowBotToBot === true
-      || existing.conversation_allow_bot_to_bot === true
-      || authoritySource.conversation_allow_bot_to_bot === true,
-    conversation_reply_expectation: String(
-      normalizedSharedHumanIntent.replyExpectation
-        || existing.conversation_reply_expectation
-        || authoritySource.conversation_reply_expectation
-        || "",
-    ).trim().toLowerCase(),
-    execution_contract_type: runnerRequestPreferredExecutionContractType(existing)
-      || runnerRequestPreferredExecutionContractType(authoritySource),
-    execution_contract_actionable: runnerRequestPreferredExecutionContractActionable(existing)
-      || runnerRequestPreferredExecutionContractActionable(authoritySource),
-    execution_contract_targets: uniqueOrderedStrings(
-      runnerRequestPreferredExecutionContractTargets(existing).length
-        ? runnerRequestPreferredExecutionContractTargets(existing)
-        : runnerRequestPreferredExecutionContractTargets(authoritySource),
-      normalizeTelegramMentionUsername,
-    ),
-    next_expected_responders: uniqueOrderedStrings(
-      runnerRequestPreferredNextExpectedResponders(existing).length
-        ? runnerRequestPreferredNextExpectedResponders(existing)
-        : runnerRequestPreferredNextExpectedResponders(authoritySource),
-      normalizeTelegramMentionUsername,
-    ),
-    normalized_intent: String(preferredNormalizedIntent || existing.normalized_intent || "").trim().toLowerCase(),
-    status: "claimed",
-    claimed_by_route: String(routeKey || "").trim(),
-    claimed_at: firstNonEmptyString([existing.claimed_at, nowISO]) || nowISO,
-    root_work_item_id: String(existing.root_work_item_id || authoritySource.root_work_item_id || "").trim(),
-    root_work_item_title: String(existing.root_work_item_title || authoritySource.root_work_item_title || "").trim(),
-    root_work_item_status: normalizeRunnerWorkItemStatus(
-      existing.root_work_item_status || authoritySource.root_work_item_status,
-    ),
-    root_thread_id: String(existing.root_thread_id || authoritySource.root_thread_id || "").trim(),
-    root_work_item_created_at: firstNonEmptyString([
-      existing.root_work_item_created_at,
-      authoritySource.root_work_item_created_at,
-    ]),
-    root_work_item_last_error: String(
-      existing.root_work_item_last_error || authoritySource.root_work_item_last_error || "",
-    ).trim(),
-    last_comment_id: String(selectedRecord?.id || "").trim(),
-    last_comment_kind: commentKind,
-    last_source_message_id: intFromRawAllowZero(parsed.messageID, 0) || undefined,
-    last_source_message_thread_id: intFromRawAllowZero(parsed.messageThreadID, 0) || undefined,
-  });
+  }
+  const nowISO = new Date().toISOString();
+  const sourceMessageEnvelope = selectAuthoritativeRunnerSourceMessageEnvelope(
+    authoritativeSourceMessageEnvelope,
+    buildRunnerSourceMessageEnvelope({
+      routeState: currentRouteState,
+      routeKey,
+      normalizedRoute,
+      parsedArchive: parsed,
+    }),
+  );
+  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_origin: String(sourceMessageEnvelope.source_origin || "").trim().toLowerCase(),
+    source_message_route_key: String(sourceMessageEnvelope.source_route_key || "").trim(),
+    source_message_bot_username: normalizeTelegramMentionUsername(sourceMessageEnvelope.source_bot_username),
+    source_message_envelope: sourceMessageEnvelope,
+    root_comment_id: String(selectedRecord?.id || "").trim(),
+    root_comment_kind: commentKind,
+    conversation_id: resolvedConversationID,
+    reply_chain_context: authorityReplyChainContext,
+    selected_bot_usernames: uniqueOrderedStrings(requestSelectedBotUsernames, normalizeTelegramMentionUsername),
+    conversation_intent_mode: String(
+      normalizedSharedHumanIntent.intentMode
+        || existing.conversation_intent_mode
+        || authoritySource.conversation_intent_mode
+        || "",
+    ).trim().toLowerCase(),
+    conversation_lead_bot: normalizeTelegramMentionUsername(
+      normalizedSharedHumanIntent.leadBotSelector
+        || existing.conversation_lead_bot
+        || authoritySource.conversation_lead_bot,
+    ),
+    conversation_summary_bot: normalizeTelegramMentionUsername(
+      normalizedSharedHumanIntent.summaryBotSelector
+        || existing.conversation_summary_bot
+        || authoritySource.conversation_summary_bot,
+    ),
+    conversation_participants: uniqueOrderedStrings(
+      ensureArray(normalizedSharedHumanIntent.participantSelectors).length
+        ? normalizedSharedHumanIntent.participantSelectors
+        : ensureArray(existing.conversation_participants).length
+          ? existing.conversation_participants
+          : ensureArray(authoritySource.conversation_participants).length
+            ? authoritySource.conversation_participants
+            : [],
+      normalizeTelegramMentionUsername,
+    ),
+    conversation_initial_responders: uniqueOrderedStrings(
+      ensureArray(normalizedSharedHumanIntent.initialResponderSelectors).length
+        ? normalizedSharedHumanIntent.initialResponderSelectors
+        : ensureArray(existing.conversation_initial_responders).length
+          ? existing.conversation_initial_responders
+          : ensureArray(authoritySource.conversation_initial_responders).length
+            ? authoritySource.conversation_initial_responders
+            : [],
+      normalizeTelegramMentionUsername,
+    ),
+    conversation_allowed_responders: uniqueOrderedStrings(
+      ensureArray(normalizedSharedHumanIntent.allowedResponderSelectors).length
+        ? normalizedSharedHumanIntent.allowedResponderSelectors
+        : ensureArray(existing.conversation_allowed_responders).length
+          ? existing.conversation_allowed_responders
+          : ensureArray(authoritySource.conversation_allowed_responders).length
+            ? authoritySource.conversation_allowed_responders
+            : [],
+      normalizeTelegramMentionUsername,
+    ),
+    conversation_allow_bot_to_bot: normalizedSharedHumanIntent.allowBotToBot === true
+      || existing.conversation_allow_bot_to_bot === true
+      || authoritySource.conversation_allow_bot_to_bot === true,
+    conversation_reply_expectation: String(
+      normalizedSharedHumanIntent.replyExpectation
+        || existing.conversation_reply_expectation
+        || authoritySource.conversation_reply_expectation
+        || "",
+    ).trim().toLowerCase(),
+    execution_contract_type: runnerRequestPreferredExecutionContractType(existing)
+      || runnerRequestPreferredExecutionContractType(authoritySource),
+    execution_contract_actionable: runnerRequestPreferredExecutionContractActionable(existing)
+      || runnerRequestPreferredExecutionContractActionable(authoritySource),
+    execution_contract_targets: uniqueOrderedStrings(
+      runnerRequestPreferredExecutionContractTargets(existing).length
+        ? runnerRequestPreferredExecutionContractTargets(existing)
+        : runnerRequestPreferredExecutionContractTargets(authoritySource),
+      normalizeTelegramMentionUsername,
+    ),
+    next_expected_responders: uniqueOrderedStrings(
+      runnerRequestPreferredNextExpectedResponders(existing).length
+        ? runnerRequestPreferredNextExpectedResponders(existing)
+        : runnerRequestPreferredNextExpectedResponders(authoritySource),
+      normalizeTelegramMentionUsername,
+    ),
+    normalized_intent: String(preferredNormalizedIntent || existing.normalized_intent || "").trim().toLowerCase(),
+    status: "claimed",
+    claimed_by_route: String(routeKey || "").trim(),
+    claimed_at: firstNonEmptyString([existing.claimed_at, nowISO]) || nowISO,
+    root_work_item_id: String(existing.root_work_item_id || authoritySource.root_work_item_id || "").trim(),
+    root_work_item_title: String(existing.root_work_item_title || authoritySource.root_work_item_title || "").trim(),
+    root_work_item_status: normalizeRunnerWorkItemStatus(
+      existing.root_work_item_status || authoritySource.root_work_item_status,
+    ),
+    root_thread_id: String(existing.root_thread_id || authoritySource.root_thread_id || "").trim(),
+    root_work_item_created_at: firstNonEmptyString([
+      existing.root_work_item_created_at,
+      authoritySource.root_work_item_created_at,
+    ]),
+    root_work_item_last_error: String(
+      existing.root_work_item_last_error || authoritySource.root_work_item_last_error || "",
+    ).trim(),
+    last_comment_id: String(selectedRecord?.id || "").trim(),
+    last_comment_kind: commentKind,
+    last_source_message_id: intFromRawAllowZero(parsed.messageID, 0) || undefined,
+    last_source_message_thread_id: intFromRawAllowZero(parsed.messageThreadID, 0) || undefined,
+  });
   const { consumedComments: nextConsumedComments } = upsertRunnerConsumedComment(stateForClaim, selectedRecord?.id, {
     project_id: String(normalizedRoute?.projectID || "").trim(),
     provider: String(normalizedRoute?.provider || "").trim(),
@@ -5390,7 +5384,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)) {
@@ -5429,26 +5423,26 @@ 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_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);
-  const request = safeObject(requestRaw);
-  const requestKey = String(request.request_key || "").trim();
-  if (!requestKey) {
-    return {};
-  }
-  const requestSourceMessageID = intFromRawAllowZero(request.last_source_message_id, 0)
-    || intFromRawAllowZero(request.source_message_id, 0)
-    || intFromRawAllowZero(safeObject(request.source_message_envelope).message_id, 0);
+    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);
+  const request = safeObject(requestRaw);
+  const requestKey = String(request.request_key || "").trim();
+  if (!requestKey) {
+    return {};
+  }
+  const requestSourceMessageID = intFromRawAllowZero(request.last_source_message_id, 0)
+    || intFromRawAllowZero(request.source_message_id, 0)
+    || intFromRawAllowZero(safeObject(request.source_message_envelope).message_id, 0);
   const routeKeys = uniqueOrderedStrings(
     [
       routeKeyHint,
@@ -5456,14 +5450,14 @@ function buildRunnerRequestRecoveryPatchFromRouteState(currentStateRaw, requestR
     ],
     (value) => String(value || "").trim(),
   ).filter(Boolean);
-  for (const routeKey of routeKeys) {
-    const routeState = safeObject(safeObject(currentState.routes)[routeKey]);
+  for (const routeKey of routeKeys) {
+    const routeState = safeObject(safeObject(currentState.routes)[routeKey]);
     if (!Object.keys(routeState).length) {
       continue;
     }
-    const routeSourceMessageID = intFromRawAllowZero(routeState.last_source_message_id, 0)
-      || intFromRawAllowZero(routeState.source_message_id, 0)
-      || intFromRawAllowZero(safeObject(routeState.last_followup_source_message_envelope).message_id, 0);
+    const routeSourceMessageID = intFromRawAllowZero(routeState.last_source_message_id, 0)
+      || intFromRawAllowZero(routeState.source_message_id, 0)
+      || intFromRawAllowZero(safeObject(routeState.last_followup_source_message_envelope).message_id, 0);
     if (requestSourceMessageID && routeSourceMessageID && requestSourceMessageID !== routeSourceMessageID) {
       continue;
     }
@@ -5519,69 +5513,69 @@ 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 routeFollowupDeliveryStatus = String(routeState.last_followup_delivery_status || "").trim().toLowerCase();
-    const routeFollowupDelivered = ["delivered", "dry_run"].includes(routeFollowupDeliveryStatus);
-    const routeLocalRecoveredSourceEnvelope = normalizeRunnerTelegramMessageEnvelope(
-      findRunnerRouteLocalInboundEnvelopeByMessage(routeState, {
-        chatID: String(request.chat_id || request.chatID || "").trim(),
-        messageID: requestSourceMessageID || routeSourceMessageID,
-      }),
-    );
-    const recoveredSourceEnvelope = mergeRunnerSourceMessageEnvelopes(
-      routeState.last_followup_source_message_envelope,
-      routeLocalRecoveredSourceEnvelope,
-    );
-    if (Object.keys(recoveredSourceEnvelope).length) {
-      if (!Object.keys(safeObject(request.source_message_envelope)).length) {
-        patch.source_message_envelope = recoveredSourceEnvelope;
-      }
-      if (!(intFromRawAllowZero(request.source_message_id, 0) > 0)) {
-        const recoveredMessageID = intFromRawAllowZero(recoveredSourceEnvelope.message_id, 0);
-        if (recoveredMessageID > 0) {
-          patch.source_message_id = recoveredMessageID;
-        }
-      }
-      if (!(intFromRawAllowZero(request.source_message_thread_id, 0) > 0)) {
-        const recoveredThreadID = intFromRawAllowZero(recoveredSourceEnvelope.message_thread_id, 0);
-        if (recoveredThreadID > 0) {
-          patch.source_message_thread_id = recoveredThreadID;
-        }
-      }
-      if (!String(request.source_message_body || "").trim() && String(recoveredSourceEnvelope.body || "").trim()) {
-        patch.source_message_body = String(recoveredSourceEnvelope.body || "").trim();
-      }
-      if (!String(request.source_message_origin || "").trim() && String(recoveredSourceEnvelope.source_origin || "").trim()) {
-        patch.source_message_origin = String(recoveredSourceEnvelope.source_origin || "").trim().toLowerCase();
-      }
-      if (!String(request.source_message_route_key || "").trim() && String(recoveredSourceEnvelope.source_route_key || "").trim()) {
-        patch.source_message_route_key = String(recoveredSourceEnvelope.source_route_key || "").trim();
-      }
-      if (
-        !normalizeTelegramMentionUsername(request.source_message_bot_username)
-        && normalizeTelegramMentionUsername(recoveredSourceEnvelope.source_bot_username)
-      ) {
-        patch.source_message_bot_username = normalizeTelegramMentionUsername(
-          recoveredSourceEnvelope.source_bot_username,
-        );
-      }
-    }
-    if (!Object.keys(safeObject(request.last_reply_message_envelope)).length && routeFollowupDelivered) {
-      const recoveredReplyEnvelope = normalizeRunnerTelegramMessageEnvelope(routeState.last_followup_last_reply_message_envelope);
-      if (intFromRawAllowZero(recoveredReplyEnvelope.message_id, 0) > 0) {
-        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);
+    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 routeFollowupDeliveryStatus = String(routeState.last_followup_delivery_status || "").trim().toLowerCase();
+    const routeFollowupDelivered = ["delivered", "dry_run"].includes(routeFollowupDeliveryStatus);
+    const routeLocalRecoveredSourceEnvelope = normalizeRunnerTelegramMessageEnvelope(
+      findRunnerRouteLocalInboundEnvelopeByMessage(routeState, {
+        chatID: String(request.chat_id || request.chatID || "").trim(),
+        messageID: requestSourceMessageID || routeSourceMessageID,
+      }),
+    );
+    const recoveredSourceEnvelope = mergeRunnerSourceMessageEnvelopes(
+      routeState.last_followup_source_message_envelope,
+      routeLocalRecoveredSourceEnvelope,
+    );
+    if (Object.keys(recoveredSourceEnvelope).length) {
+      if (!Object.keys(safeObject(request.source_message_envelope)).length) {
+        patch.source_message_envelope = recoveredSourceEnvelope;
+      }
+      if (!(intFromRawAllowZero(request.source_message_id, 0) > 0)) {
+        const recoveredMessageID = intFromRawAllowZero(recoveredSourceEnvelope.message_id, 0);
+        if (recoveredMessageID > 0) {
+          patch.source_message_id = recoveredMessageID;
+        }
+      }
+      if (!(intFromRawAllowZero(request.source_message_thread_id, 0) > 0)) {
+        const recoveredThreadID = intFromRawAllowZero(recoveredSourceEnvelope.message_thread_id, 0);
+        if (recoveredThreadID > 0) {
+          patch.source_message_thread_id = recoveredThreadID;
+        }
+      }
+      if (!String(request.source_message_body || "").trim() && String(recoveredSourceEnvelope.body || "").trim()) {
+        patch.source_message_body = String(recoveredSourceEnvelope.body || "").trim();
+      }
+      if (!String(request.source_message_origin || "").trim() && String(recoveredSourceEnvelope.source_origin || "").trim()) {
+        patch.source_message_origin = String(recoveredSourceEnvelope.source_origin || "").trim().toLowerCase();
+      }
+      if (!String(request.source_message_route_key || "").trim() && String(recoveredSourceEnvelope.source_route_key || "").trim()) {
+        patch.source_message_route_key = String(recoveredSourceEnvelope.source_route_key || "").trim();
+      }
+      if (
+        !normalizeTelegramMentionUsername(request.source_message_bot_username)
+        && normalizeTelegramMentionUsername(recoveredSourceEnvelope.source_bot_username)
+      ) {
+        patch.source_message_bot_username = normalizeTelegramMentionUsername(
+          recoveredSourceEnvelope.source_bot_username,
+        );
+      }
+    }
+    if (!Object.keys(safeObject(request.last_reply_message_envelope)).length && routeFollowupDelivered) {
+      const recoveredReplyEnvelope = normalizeRunnerTelegramMessageEnvelope(routeState.last_followup_last_reply_message_envelope);
+      if (intFromRawAllowZero(recoveredReplyEnvelope.message_id, 0) > 0) {
+        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") {
@@ -5741,49 +5735,49 @@ function peekRunnerContinuationRequestForBotReply({
       || safeObject(sessionMatch.routeState).last_request_key
       || "",
     ).trim();
-    if (
-      fallbackRequestKey
-      && String(session.status || "").trim().toLowerCase() === "open"
-    ) {
-      const fallbackRequest = safeObject(normalizeBotRunnerRequests(currentState.requests)[fallbackRequestKey]);
-      const fallbackSourceMessageID = intFromRawAllowZero(
-        fallbackRequest.source_message_id
-        || safeObject(sessionMatch.routeState).last_source_message_id
-        || safeObject(sessionMatch.routeState).source_message_id
-        || safeObject(safeObject(sessionMatch.routeState).last_followup_source_message_envelope).message_id,
-        0,
-      );
-      const fallbackLocalSourceEnvelope = normalizeRunnerTelegramMessageEnvelope(
-        findRunnerRouteLocalInboundEnvelopeByMessage(sessionMatch.routeState, {
-          chatID: String(parsed.chatID || parsed.chatId || "").trim(),
-          messageID: fallbackSourceMessageID,
-        }),
-      );
-      const fallbackSourceEnvelope = mergeRunnerSourceMessageEnvelopes(
-        safeObject(sessionMatch.routeState).last_followup_source_message_envelope,
-        fallbackLocalSourceEnvelope,
-      );
-      const nowISO = new Date().toISOString();
-      const seedRequest = Object.keys(fallbackRequest).length
-        ? fallbackRequest
-        : {
-          request_key: fallbackRequestKey,
-          project_id: String(normalizedRoute?.projectID || "").trim(),
-          provider: String(normalizedRoute?.provider || "").trim(),
-          chat_id: String(parsed.chatID || parsed.chatId || "").trim(),
-          source_message_id: intFromRawAllowZero(fallbackSourceEnvelope.message_id, 0) || undefined,
-          source_message_thread_id: intFromRawAllowZero(fallbackSourceEnvelope.message_thread_id, 0) || undefined,
-          source_message_body: String(fallbackSourceEnvelope.body || "").trim(),
-          source_message_origin: String(fallbackSourceEnvelope.source_origin || "").trim().toLowerCase(),
-          source_message_route_key: String(fallbackSourceEnvelope.source_route_key || "").trim(),
-          source_message_bot_username: normalizeTelegramMentionUsername(
-            fallbackSourceEnvelope.source_bot_username,
-          ),
-          source_message_envelope: fallbackSourceEnvelope,
-          conversation_id: conversationID,
-          selected_bot_usernames: ensureArray(session.participants),
-          conversation_allowed_responders: ensureArray(session.allowed_responders),
-          conversation_intent_mode: String(session.intent_mode || "").trim().toLowerCase(),
+    if (
+      fallbackRequestKey
+      && String(session.status || "").trim().toLowerCase() === "open"
+    ) {
+      const fallbackRequest = safeObject(normalizeBotRunnerRequests(currentState.requests)[fallbackRequestKey]);
+      const fallbackSourceMessageID = intFromRawAllowZero(
+        fallbackRequest.source_message_id
+        || safeObject(sessionMatch.routeState).last_source_message_id
+        || safeObject(sessionMatch.routeState).source_message_id
+        || safeObject(safeObject(sessionMatch.routeState).last_followup_source_message_envelope).message_id,
+        0,
+      );
+      const fallbackLocalSourceEnvelope = normalizeRunnerTelegramMessageEnvelope(
+        findRunnerRouteLocalInboundEnvelopeByMessage(sessionMatch.routeState, {
+          chatID: String(parsed.chatID || parsed.chatId || "").trim(),
+          messageID: fallbackSourceMessageID,
+        }),
+      );
+      const fallbackSourceEnvelope = mergeRunnerSourceMessageEnvelopes(
+        safeObject(sessionMatch.routeState).last_followup_source_message_envelope,
+        fallbackLocalSourceEnvelope,
+      );
+      const nowISO = new Date().toISOString();
+      const seedRequest = Object.keys(fallbackRequest).length
+        ? fallbackRequest
+        : {
+          request_key: fallbackRequestKey,
+          project_id: String(normalizedRoute?.projectID || "").trim(),
+          provider: String(normalizedRoute?.provider || "").trim(),
+          chat_id: String(parsed.chatID || parsed.chatId || "").trim(),
+          source_message_id: intFromRawAllowZero(fallbackSourceEnvelope.message_id, 0) || undefined,
+          source_message_thread_id: intFromRawAllowZero(fallbackSourceEnvelope.message_thread_id, 0) || undefined,
+          source_message_body: String(fallbackSourceEnvelope.body || "").trim(),
+          source_message_origin: String(fallbackSourceEnvelope.source_origin || "").trim().toLowerCase(),
+          source_message_route_key: String(fallbackSourceEnvelope.source_route_key || "").trim(),
+          source_message_bot_username: normalizeTelegramMentionUsername(
+            fallbackSourceEnvelope.source_bot_username,
+          ),
+          source_message_envelope: fallbackSourceEnvelope,
+          conversation_id: conversationID,
+          selected_bot_usernames: ensureArray(session.participants),
+          conversation_allowed_responders: ensureArray(session.allowed_responders),
+          conversation_intent_mode: String(session.intent_mode || "").trim().toLowerCase(),
           conversation_lead_bot: normalizeTelegramMentionUsername(session.lead_bot_username),
           conversation_summary_bot: normalizeTelegramMentionUsername(session.summary_bot_username),
           conversation_participants: ensureArray(session.participants),
@@ -5845,16 +5839,16 @@ function peekRunnerContinuationRequestForBotReply({
   };
 }
 
-function resolveRunnerContinuationRequestForBotReply({
-  normalizedRoute,
-  routeKey,
-  selectedRecord,
-}) {
-  const parsed = safeObject(selectedRecord?.parsedArchive);
-  const continuation = peekRunnerContinuationRequestForBotReply({
-    normalizedRoute,
-    selectedRecord,
-  });
+function resolveRunnerContinuationRequestForBotReply({
+  normalizedRoute,
+  routeKey,
+  selectedRecord,
+}) {
+  const parsed = safeObject(selectedRecord?.parsedArchive);
+  const continuation = peekRunnerContinuationRequestForBotReply({
+    normalizedRoute,
+    selectedRecord,
+  });
   if (!continuation.ok) {
     return continuation;
   }
@@ -5874,12 +5868,12 @@ function resolveRunnerContinuationRequestForBotReply({
     comment_kind: commentKind,
     request_status: request.status,
   });
-  const { requests: nextRequests, request: nextRequest } = upsertRunnerRequest(currentState, request.request_key, {
-    last_comment_id: String(selectedRecord?.id || "").trim(),
-    last_comment_kind: commentKind,
-    last_source_message_id: intFromRawAllowZero(parsed.messageID, 0) || undefined,
-    last_source_message_thread_id: intFromRawAllowZero(parsed.messageThreadID, 0) || undefined,
-  });
+  const { requests: nextRequests, request: nextRequest } = upsertRunnerRequest(currentState, request.request_key, {
+    last_comment_id: String(selectedRecord?.id || "").trim(),
+    last_comment_kind: commentKind,
+    last_source_message_id: intFromRawAllowZero(parsed.messageID, 0) || undefined,
+    last_source_message_thread_id: intFromRawAllowZero(parsed.messageThreadID, 0) || undefined,
+  });
   saveBotRunnerState({
     routes: currentState.routes,
     sharedInboxes: currentState.sharedInboxes || currentState.shared_inboxes,
@@ -5894,11 +5888,11 @@ function resolveRunnerContinuationRequestForBotReply({
   };
 }
 
-function markRunnerRequestLifecycle({
-  normalizedRoute,
-  requestKey,
-  selectedRecord,
-  routeKey,
+function markRunnerRequestLifecycle({
+  normalizedRoute,
+  requestKey,
+  selectedRecord,
+  routeKey,
   outcome,
   conversationIDRaw = "",
   allowedResponders = [],
@@ -5928,77 +5922,77 @@ function markRunnerRequestLifecycle({
   assignmentValidationStatus = "",
   assignmentValidationReason = "",
   assignmentValidationModes = [],
-  deliveryStatus = "",
-  archiveStatus = "",
-  transportError = "",
-  archiveError = "",
-  lastReplyMessageID = 0,
-  lastReplyMessageThreadID = 0,
-  replyToMessageID = 0,
-  replyFallbackUsed = false,
-  authoritativeSourceMessageEnvelope = {},
-}) {
+  deliveryStatus = "",
+  archiveStatus = "",
+  transportError = "",
+  archiveError = "",
+  lastReplyMessageID = 0,
+  lastReplyMessageThreadID = 0,
+  replyToMessageID = 0,
+  replyFallbackUsed = false,
+  authoritativeSourceMessageEnvelope = {},
+}) {
   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 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 sourceMessageEnvelope = selectAuthoritativeRunnerSourceMessageEnvelope(
-    selectAuthoritativeRunnerSourceMessageEnvelope(
-      authoritativeSourceMessageEnvelope,
-      safeObject(existing.source_message_envelope),
-    ),
-    buildRunnerSourceMessageEnvelope({
-      routeState: safeObject(safeObject(currentState.routes)[String(routeKey || "").trim()]),
-      routeKey,
-      normalizedRoute,
-      parsedArchive: 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 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,
-    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),
+  const currentState = loadBotRunnerState();
+  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 sourceMessageEnvelope = selectAuthoritativeRunnerSourceMessageEnvelope(
+    selectAuthoritativeRunnerSourceMessageEnvelope(
+      authoritativeSourceMessageEnvelope,
+      safeObject(existing.source_message_envelope),
+    ),
+    buildRunnerSourceMessageEnvelope({
+      routeState: safeObject(safeObject(currentState.routes)[String(routeKey || "").trim()]),
+      routeKey,
+      normalizedRoute,
+      parsedArchive: 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 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,
+    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,
@@ -6321,11 +6315,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]),
@@ -6333,45 +6327,45 @@ 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(),
-    source_message_body: parsedKind === "bot_reply"
-      ? String(existing.source_message_body || "").trim()
-      : String(parsed.body || existing.source_message_body || "").trim(),
-    source_message_origin: parsedKind === "bot_reply"
-      ? String(existing.source_message_origin || "").trim().toLowerCase()
-      : String(sourceMessageEnvelope.source_origin || existing.source_message_origin || "").trim().toLowerCase(),
-    source_message_route_key: parsedKind === "bot_reply"
-      ? String(existing.source_message_route_key || "").trim()
-      : String(sourceMessageEnvelope.source_route_key || existing.source_message_route_key || "").trim(),
-    source_message_bot_username: parsedKind === "bot_reply"
-      ? normalizeTelegramMentionUsername(existing.source_message_bot_username)
-      : normalizeTelegramMentionUsername(
-          sourceMessageEnvelope.source_bot_username || existing.source_message_bot_username,
-        ),
-    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,
-    last_source_message_thread_id: intFromRawAllowZero(parsed.messageThreadID, 0) || existing.last_source_message_thread_id,
-    last_reply_message_id: intFromRawAllowZero(lastReplyMessageID, 0) || existing.last_reply_message_id,
-    last_reply_message_thread_id: intFromRawAllowZero(lastReplyMessageThreadID, 0) || existing.last_reply_message_thread_id,
-    last_reply_to_message_id: intFromRawAllowZero(replyToMessageID, 0) || existing.last_reply_to_message_id,
-    last_reply_message_envelope: persistSuccessfulReplyEnvelope
-      ? 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,
-  };
+    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_origin: parsedKind === "bot_reply"
+      ? String(existing.source_message_origin || "").trim().toLowerCase()
+      : String(sourceMessageEnvelope.source_origin || existing.source_message_origin || "").trim().toLowerCase(),
+    source_message_route_key: parsedKind === "bot_reply"
+      ? String(existing.source_message_route_key || "").trim()
+      : String(sourceMessageEnvelope.source_route_key || existing.source_message_route_key || "").trim(),
+    source_message_bot_username: parsedKind === "bot_reply"
+      ? normalizeTelegramMentionUsername(existing.source_message_bot_username)
+      : normalizeTelegramMentionUsername(
+          sourceMessageEnvelope.source_bot_username || existing.source_message_bot_username,
+        ),
+    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,
+    last_source_message_thread_id: intFromRawAllowZero(parsed.messageThreadID, 0) || existing.last_source_message_thread_id,
+    last_reply_message_id: intFromRawAllowZero(lastReplyMessageID, 0) || existing.last_reply_message_id,
+    last_reply_message_thread_id: intFromRawAllowZero(lastReplyMessageThreadID, 0) || existing.last_reply_message_thread_id,
+    last_reply_to_message_id: intFromRawAllowZero(replyToMessageID, 0) || existing.last_reply_to_message_id,
+    last_reply_message_envelope: persistSuccessfulReplyEnvelope
+      ? 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,
+  };
   const { requests: nextRequests, request } = upsertRunnerRequest(currentState, key, patch);
   const commentID = String(selectedRecord?.id || "").trim();
   let nextConsumedComments = currentState.consumedComments || currentState.consumed_comments;
@@ -6547,55 +6541,55 @@ function runnerLedgerEntryMatchesProject(entryRaw, normalizedRoute, requestIndex
   );
 }
 
-function mergeRunnerRequestForServerHydration(localEntryRaw, serverEntryRaw) {
-  const localEntry = safeObject(localEntryRaw);
-  const serverEntry = safeObject(serverEntryRaw);
-  const merged = {
-    ...localEntry,
-    ...serverEntry,
-  };
-  const preserveLocalNumberWhenServerMissing = (fieldName) => {
-    const serverValue = intFromRawAllowZero(serverEntry[fieldName], 0);
-    const localValue = intFromRawAllowZero(localEntry[fieldName], 0);
-    if (!(serverValue > 0) && localValue > 0) {
-      merged[fieldName] = localValue;
-    }
-  };
-  const preserveLocalStringWhenServerBlank = (fieldName) => {
-    const serverValue = String(serverEntry[fieldName] || "").trim();
-    const localValue = String(localEntry[fieldName] || "").trim();
-    if (!serverValue && localValue) {
-      merged[fieldName] = localValue;
+function mergeRunnerRequestForServerHydration(localEntryRaw, serverEntryRaw) {
+  const localEntry = safeObject(localEntryRaw);
+  const serverEntry = safeObject(serverEntryRaw);
+  const merged = {
+    ...localEntry,
+    ...serverEntry,
+  };
+  const preserveLocalNumberWhenServerMissing = (fieldName) => {
+    const serverValue = intFromRawAllowZero(serverEntry[fieldName], 0);
+    const localValue = intFromRawAllowZero(localEntry[fieldName], 0);
+    if (!(serverValue > 0) && localValue > 0) {
+      merged[fieldName] = localValue;
+    }
+  };
+  const preserveLocalStringWhenServerBlank = (fieldName) => {
+    const serverValue = String(serverEntry[fieldName] || "").trim();
+    const localValue = String(localEntry[fieldName] || "").trim();
+    if (!serverValue && localValue) {
+      merged[fieldName] = localValue;
     }
   };
   const preserveLocalArrayWhenServerEmpty = (fieldName) => {
     const serverValues = ensureArray(serverEntry[fieldName]).filter(Boolean);
     const localValues = ensureArray(localEntry[fieldName]).filter(Boolean);
-    if (serverValues.length === 0 && localValues.length > 0) {
-      merged[fieldName] = localValues;
-    }
-  };
-  const preserveLocalObjectWhenServerBlank = (fieldName) => {
-    const serverValue = safeObject(serverEntry[fieldName]);
-    const localValue = safeObject(localEntry[fieldName]);
-    if (!Object.keys(serverValue).length && Object.keys(localValue).length) {
-      merged[fieldName] = localValue;
-    }
-  };
-  preserveLocalNumberWhenServerMissing("source_message_id");
-  preserveLocalNumberWhenServerMissing("source_message_thread_id");
-  preserveLocalStringWhenServerBlank("source_message_body");
-  preserveLocalStringWhenServerBlank("source_message_origin");
-  preserveLocalStringWhenServerBlank("source_message_route_key");
-  preserveLocalStringWhenServerBlank("source_message_bot_username");
-  preserveLocalObjectWhenServerBlank("source_message_envelope");
-  preserveLocalObjectWhenServerBlank("last_reply_message_envelope");
-  preserveLocalObjectWhenServerBlank("attempted_delivery_envelope");
-  preserveLocalStringWhenServerBlank("conversation_id");
-  preserveLocalStringWhenServerBlank("conversation_intent_mode");
-  preserveLocalStringWhenServerBlank("conversation_lead_bot");
-  preserveLocalStringWhenServerBlank("conversation_summary_bot");
-  preserveLocalStringWhenServerBlank("conversation_reply_expectation");
+    if (serverValues.length === 0 && localValues.length > 0) {
+      merged[fieldName] = localValues;
+    }
+  };
+  const preserveLocalObjectWhenServerBlank = (fieldName) => {
+    const serverValue = safeObject(serverEntry[fieldName]);
+    const localValue = safeObject(localEntry[fieldName]);
+    if (!Object.keys(serverValue).length && Object.keys(localValue).length) {
+      merged[fieldName] = localValue;
+    }
+  };
+  preserveLocalNumberWhenServerMissing("source_message_id");
+  preserveLocalNumberWhenServerMissing("source_message_thread_id");
+  preserveLocalStringWhenServerBlank("source_message_body");
+  preserveLocalStringWhenServerBlank("source_message_origin");
+  preserveLocalStringWhenServerBlank("source_message_route_key");
+  preserveLocalStringWhenServerBlank("source_message_bot_username");
+  preserveLocalObjectWhenServerBlank("source_message_envelope");
+  preserveLocalObjectWhenServerBlank("last_reply_message_envelope");
+  preserveLocalObjectWhenServerBlank("attempted_delivery_envelope");
+  preserveLocalStringWhenServerBlank("conversation_id");
+  preserveLocalStringWhenServerBlank("conversation_intent_mode");
+  preserveLocalStringWhenServerBlank("conversation_lead_bot");
+  preserveLocalStringWhenServerBlank("conversation_summary_bot");
+  preserveLocalStringWhenServerBlank("conversation_reply_expectation");
   preserveLocalStringWhenServerBlank("execution_contract_type");
   preserveLocalStringWhenServerBlank("normalized_execution_contract_type");
   preserveLocalStringWhenServerBlank("ai_reply_generated_at");
@@ -6631,16 +6625,16 @@ function mergeRunnerRequestForServerHydration(localEntryRaw, serverEntryRaw) {
   preserveLocalArrayWhenServerEmpty("root_execution_contract_targets");
   preserveLocalArrayWhenServerEmpty("root_next_expected_responders");
   preserveLocalArrayWhenServerEmpty("root_response_contract_validation_targets");
-  preserveLocalArrayWhenServerEmpty("followup_execution_contract_targets");
-  preserveLocalArrayWhenServerEmpty("followup_next_expected_responders");
-  preserveLocalArrayWhenServerEmpty("followup_normalized_execution_contract_targets");
-  preserveLocalArrayWhenServerEmpty("followup_normalized_execution_next_responders");
-  preserveLocalArrayWhenServerEmpty("followup_response_contract_validation_targets");
-  preserveLocalArrayWhenServerEmpty("followup_assignment_validation_modes");
-  preserveLocalObjectWhenServerBlank("reply_chain_context");
-  if (serverEntry.conversation_allow_bot_to_bot !== true && localEntry.conversation_allow_bot_to_bot === true) {
-    merged.conversation_allow_bot_to_bot = true;
-  }
+  preserveLocalArrayWhenServerEmpty("followup_execution_contract_targets");
+  preserveLocalArrayWhenServerEmpty("followup_next_expected_responders");
+  preserveLocalArrayWhenServerEmpty("followup_normalized_execution_contract_targets");
+  preserveLocalArrayWhenServerEmpty("followup_normalized_execution_next_responders");
+  preserveLocalArrayWhenServerEmpty("followup_response_contract_validation_targets");
+  preserveLocalArrayWhenServerEmpty("followup_assignment_validation_modes");
+  preserveLocalObjectWhenServerBlank("reply_chain_context");
+  if (serverEntry.conversation_allow_bot_to_bot !== true && localEntry.conversation_allow_bot_to_bot === true) {
+    merged.conversation_allow_bot_to_bot = true;
+  }
   if (serverEntry.execution_contract_actionable !== true && localEntry.execution_contract_actionable === true) {
     merged.execution_contract_actionable = true;
   }
@@ -7895,16 +7889,16 @@ function parseArchivedChatComment(rawBody) {
           .filter(Boolean),
       }
     : null;
-  return {
-    kind,
-    header,
-    metadata,
-    body,
-    chatID: String(metadata.chat_id || "").trim(),
-    chatType: String(metadata.chat_type || "").trim().toLowerCase(),
-    messageID: intFromRawAllowZero(metadata.message_id, 0),
-    messageThreadID: intFromRawAllowZero(metadata.message_thread_id, 0),
-    senderID: String(metadata.sender_id || "").trim(),
+  return {
+    kind,
+    header,
+    metadata,
+    body,
+    chatID: String(metadata.chat_id || "").trim(),
+    chatType: String(metadata.chat_type || "").trim().toLowerCase(),
+    messageID: intFromRawAllowZero(metadata.message_id, 0),
+    messageThreadID: intFromRawAllowZero(metadata.message_thread_id, 0),
+    senderID: String(metadata.sender_id || "").trim(),
     sender: String(metadata.sender || metadata.bot_username || metadata.bot_name || "").trim(),
     senderIsBot: kind === "bot_reply" ? true : boolFromRaw(metadata.sender_is_bot, false),
     username: String(metadata.telegram_username || metadata.bot_username || metadata.bot_name || "").trim(),
@@ -7912,11 +7906,11 @@ function parseArchivedChatComment(rawBody) {
       .split(",")
       .map((value) => normalizeTelegramMentionUsername(value))
       .filter(Boolean),
-    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),
+    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),
@@ -8163,23 +8157,23 @@ function extractTelegramEntityText(text, entity) {
   return body.slice(offset, offset + length);
 }
 
-function extractTelegramMentionUsernames(text, entities) {
-  const set = new Set();
-  for (const entityRaw of ensureArray(entities)) {
-    const entity = safeObject(entityRaw);
+function extractTelegramMentionUsernames(text, entities) {
+  const set = new Set();
+  for (const entityRaw of ensureArray(entities)) {
+    const entity = safeObject(entityRaw);
     const type = String(entity.type || "").trim().toLowerCase();
     if (type === "mention") {
       const username = normalizeTelegramMentionUsername(extractTelegramEntityText(text, entity));
       if (username) set.add(username);
       continue;
     }
-    if (type === "text_mention") {
-      const username = normalizeTelegramMentionUsername(entity.user?.username);
-      if (username) set.add(username);
-    }
-  }
-  return Array.from(set);
-}
+    if (type === "text_mention") {
+      const username = normalizeTelegramMentionUsername(entity.user?.username);
+      if (username) set.add(username);
+    }
+  }
+  return Array.from(set);
+}
 
 function normalizeLocalTelegramUpdate(rawUpdate) {
   const update = safeObject(rawUpdate);
@@ -8225,47 +8219,47 @@ 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 (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) {
+    `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) {
     headerLines.push(`mention_usernames: ${normalized.mentionUsernames.map((item) => `@${item}`).join(", ")}`);
   }
-  if (normalized.replyToMessageID > 0) {
-    headerLines.push(`reply_to_message_id: ${normalized.replyToMessageID}`);
-    headerLines.push(`reply_to_sender_is_bot: ${normalized.replyToFromIsBot ? "true" : "false"}`);
+  if (normalized.replyToMessageID > 0) {
+    headerLines.push(`reply_to_message_id: ${normalized.replyToMessageID}`);
+    headerLines.push(`reply_to_sender_is_bot: ${normalized.replyToFromIsBot ? "true" : "false"}`);
     if (normalized.replyToFromName) {
       headerLines.push(`reply_to_sender: ${normalized.replyToFromName}`);
     }
     if (normalized.replyToFromUsername) {
-      headerLines.push(`reply_to_telegram_username: @${normalized.replyToFromUsername.replace(/^@+/, "")}`);
-    }
-  }
-  if (intFromRawAllowZero(normalized.messageThreadID, 0) > 0) {
-    headerLines.push(`message_thread_id: ${intFromRawAllowZero(normalized.messageThreadID, 0)}`);
-  }
-  return `${headerLines.join("\n")}\n\n${String(normalized.text || "").trim()}`;
-}
+      headerLines.push(`reply_to_telegram_username: @${normalized.replyToFromUsername.replace(/^@+/, "")}`);
+    }
+  }
+  if (intFromRawAllowZero(normalized.messageThreadID, 0) > 0) {
+    headerLines.push(`message_thread_id: ${intFromRawAllowZero(normalized.messageThreadID, 0)}`);
+  }
+  return `${headerLines.join("\n")}\n\n${String(normalized.text || "").trim()}`;
+}
 
 async function postJSONWithAuthHeaders(urlText, timeoutSeconds, token, payload, extraHeaders = {}) {
   return new Promise((resolve, reject) => {
@@ -9043,25 +9037,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),
-      sourceMessageEnvelope: entry.source_message_envelope,
-      lastReplyMessageEnvelope: entry.last_reply_message_envelope,
-      attemptedDeliveryEnvelope: entry.attempted_delivery_envelope,
-    }),
+      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),
@@ -9169,16 +9163,16 @@ function resolveRunnerStatusLookupRequests({
   };
 }
 
-function buildRunnerShowLastRunPayload(lastRunSummaryRaw) {
-  const lastRunSummary = safeObject(lastRunSummaryRaw);
-  return {
-    action: lastRunSummary.action || "-",
-    reason: lastRunSummary.reason || "-",
-    visibility_status: lastRunSummary.visibility_status || "-",
-    visibility_reason: lastRunSummary.visibility_reason || "-",
-    visibility_source: lastRunSummary.visibility_source || "-",
-    candidate_bot_usernames: ensureArray(lastRunSummary.candidate_bot_usernames),
-    intent_type: lastRunSummary.intent_type || "-",
+function buildRunnerShowLastRunPayload(lastRunSummaryRaw) {
+  const lastRunSummary = safeObject(lastRunSummaryRaw);
+  return {
+    action: lastRunSummary.action || "-",
+    reason: lastRunSummary.reason || "-",
+    visibility_status: lastRunSummary.visibility_status || "-",
+    visibility_reason: lastRunSummary.visibility_reason || "-",
+    visibility_source: lastRunSummary.visibility_source || "-",
+    candidate_bot_usernames: ensureArray(lastRunSummary.candidate_bot_usernames),
+    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),
@@ -9191,13 +9185,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 || "-",
-    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 || "-",
+    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),
@@ -9513,16 +9507,16 @@ function buildRunnerExecutionDeps() {
   };
 }
 
-function buildRunnerRuntimeDeps() {
-  return {
-    loadProviderEnvConfig,
-    loadBotRunnerState,
-    saveBotRunnerState,
-    getTelegramBotMe,
-    getTelegramWebhookInfo,
-    deleteTelegramWebhook,
-    saveRunnerRouteState,
-    getTelegramUpdates,
+function buildRunnerRuntimeDeps() {
+  return {
+    loadProviderEnvConfig,
+    loadBotRunnerState,
+    saveBotRunnerState,
+    getTelegramBotMe,
+    getTelegramWebhookInfo,
+    deleteTelegramWebhook,
+    saveRunnerRouteState,
+    getTelegramUpdates,
     normalizeLocalTelegramUpdate,
     listThreadComments,
     listThreadCommentsTail,
@@ -10153,12 +10147,12 @@ async function processRunnerRouteOnce(route, runtime, mode, options = {}) {
         role_profile: executionPlan.roleProfileName,
       };
     };
-    const prepareRunnerRequestClaim = async (
-      selectedRecord,
-      selectedResponderSelectors = [],
-      sharedHumanIntent = null,
-      authoritativeSourceMessageEnvelope = {},
-    ) => {
+    const prepareRunnerRequestClaim = async (
+      selectedRecord,
+      selectedResponderSelectors = [],
+      sharedHumanIntent = null,
+      authoritativeSourceMessageEnvelope = {},
+    ) => {
       const parsed = safeObject(selectedRecord?.parsedArchive);
       const kind = String(parsed.kind || "").trim().toLowerCase();
       if (kind === "bot_reply") {
@@ -10183,18 +10177,18 @@ async function processRunnerRouteOnce(route, runtime, mode, options = {}) {
         }
         return continuation;
       }
-      return claimRunnerRequestForHumanComment({
-        normalizedRoute,
-        routeKey,
-        selectedRecord,
-        selectedBotUsernames: selectedResponderSelectors,
-        normalizedIntent: String(safeObject(sharedHumanIntent).intentType || "").trim().toLowerCase(),
-        sharedHumanIntent,
-        runtime,
-        archiveThreadID: archiveThread.threadID,
-        authoritativeSourceMessageEnvelope,
-      });
-    };
+      return claimRunnerRequestForHumanComment({
+        normalizedRoute,
+        routeKey,
+        selectedRecord,
+        selectedBotUsernames: selectedResponderSelectors,
+        normalizedIntent: String(safeObject(sharedHumanIntent).intentType || "").trim().toLowerCase(),
+        sharedHumanIntent,
+        runtime,
+        archiveThreadID: archiveThread.threadID,
+        authoritativeSourceMessageEnvelope,
+      });
+    };
     const buildContinuationResponderAdjudication = (selectedRecord, requestRaw) => {
       const request = safeObject(requestRaw);
       const referencedBotUsernames = ensureArray(safeObject(selectedRecord?.parsedArchive).mentionUsernames)
@@ -10228,11 +10222,11 @@ async function processRunnerRouteOnce(route, runtime, mode, options = {}) {
         clarification: "",
       };
     };
-    const finalizePreparedRunnerRequest = async (
-      selectedRecord,
-      requestClaim,
-      authoritativeSourceMessageEnvelope = {},
-    ) => {
+    const finalizePreparedRunnerRequest = async (
+      selectedRecord,
+      requestClaim,
+      authoritativeSourceMessageEnvelope = {},
+    ) => {
       const inheritedRootReference = await inheritRunnerReferenceRootWorkItemForRequest({
         normalizedRoute,
         selectedRecord,
@@ -10259,20 +10253,20 @@ async function processRunnerRouteOnce(route, runtime, mode, options = {}) {
           || rootWorkItemClaim.reason
           || (missingRequiredRootWorkItem ? "root_work_item_missing" : "root_work_item_create_failed"),
         ).trim() || "root_work_item_create_failed";
-        if (String(requestClaim.requestKey || "").trim()) {
-          markRunnerRequestLifecycle({
-            normalizedRoute,
-            requestKey: requestClaim.requestKey,
-            selectedRecord,
-            routeKey,
-            outcome: "closed",
-            closedReason: rootWorkItemFailure,
-            authoritativeSourceMessageEnvelope,
-          });
-          await syncRunnerRequestLedgerForProjectToServer({
-            normalizedRoute,
-            runtime,
-          });
+        if (String(requestClaim.requestKey || "").trim()) {
+          markRunnerRequestLifecycle({
+            normalizedRoute,
+            requestKey: requestClaim.requestKey,
+            selectedRecord,
+            routeKey,
+            outcome: "closed",
+            closedReason: rootWorkItemFailure,
+            authoritativeSourceMessageEnvelope,
+          });
+          await syncRunnerRequestLedgerForProjectToServer({
+            normalizedRoute,
+            runtime,
+          });
         }
         return {
           ok: false,
@@ -10292,109 +10286,109 @@ async function processRunnerRouteOnce(route, runtime, mode, options = {}) {
           },
         };
       }
-      return {
-        ok: true,
-        claimedRequest,
-      };
-    };
-    const prepareRunnerBotReplyAuthorityContext = async (selectedRecord, routingExecutionDeps, triggerDecision) => {
-      const requestClaim = await prepareRunnerRequestClaim(selectedRecord);
-      if (!requestClaim.ok) {
-        const requestFailureReason = String(requestClaim.reason || "").trim();
-        if (requestFailureReason === "bot_reply_without_active_request") {
-          const conversationContext = await resolvePublicConversationContext({
-            selectedRecord,
-            pendingOrdered: pending.ordered,
-            normalizedRoute,
-            bot,
-            routeState: safeObject(refreshedState.routes?.[routeKey]),
-            executionPlan,
-            deps: routingExecutionDeps,
-          });
-          const conversationAdjudication = buildRunnerResponderAdjudicationFromConversationContext({
-            selectedRecord,
-            conversationContext,
-            currentBotSelector,
-          });
-          const currentBotSelectedFromConversation = ensureArray(conversationAdjudication?.selected_bot_usernames)
-            .map((value) => String(value || "").trim().replace(/^@+/, "").toLowerCase())
-            .includes(currentBotSelector);
-          if (currentBotSelectedFromConversation) {
-            return {
-              ok: true,
-              triggerDecision,
-              routingExecutionDeps,
-              sharedHumanIntentContext: null,
-              adjudication: conversationAdjudication,
-              requestClaim: {
-                ok: true,
-                requestKey: "",
-                request: {},
-              },
-              claimedRequest: {},
-            };
-          }
-        }
-        await syncRunnerRequestLedgerForProjectToServer({
-          normalizedRoute,
-          runtime,
-        });
-        return {
-          ok: false,
-          skip: {
-            kind: "skip",
-            skipAction: "request_skipped",
-            skipReason: requestFailureReason || "request_unavailable",
-            skipTrigger: "request_ledger",
-            skipRecordPatch: {
-              diagnosticType: "skip",
-              contextExcluded: requestFailureReason === "bot_reply_without_active_request",
-              action: "skip_invalid_request_state",
-              closedReason: requestFailureReason,
-            },
-          },
-        };
-      }
-      const continuationAdjudication = buildContinuationResponderAdjudication(
-        selectedRecord,
-        requestClaim.request,
-      );
-      const currentBotSelected = ensureArray(continuationAdjudication.selected_bot_usernames)
-        .map((value) => String(value || "").trim().replace(/^@+/, "").toLowerCase())
-        .includes(currentBotSelector);
-      if (!currentBotSelected) {
-        return {
-          ok: false,
-          skip: {
-            kind: "skip",
-            skipAction: "adjudication_skipped",
-            skipReason: String(continuationAdjudication.reason_code || "").trim() || "not_selected_by_request_contract",
-            skipTrigger: "request_contract",
-          },
-        };
-      }
-      const finalizedRequest = await finalizePreparedRunnerRequest(
-        selectedRecord,
-        requestClaim,
-      );
-      if (!finalizedRequest.ok) {
-        return {
-          ok: false,
-          skip: finalizedRequest.skip,
-        };
-      }
-      return {
-        ok: true,
-        triggerDecision,
-        routingExecutionDeps,
-        sharedHumanIntentContext: null,
-        adjudication: continuationAdjudication,
-        requestClaim,
-        claimedRequest: finalizedRequest.claimedRequest,
-      };
-    };
-    const prepareRunnerSelectedRecordForExecution = async (selectedRecord) => {
-      const selectedRecordKind = String(safeObject(selectedRecord?.parsedArchive).kind || "").trim().toLowerCase();
+      return {
+        ok: true,
+        claimedRequest,
+      };
+    };
+    const prepareRunnerBotReplyAuthorityContext = async (selectedRecord, routingExecutionDeps, triggerDecision) => {
+      const requestClaim = await prepareRunnerRequestClaim(selectedRecord);
+      if (!requestClaim.ok) {
+        const requestFailureReason = String(requestClaim.reason || "").trim();
+        if (requestFailureReason === "bot_reply_without_active_request") {
+          const conversationContext = await resolvePublicConversationContext({
+            selectedRecord,
+            pendingOrdered: pending.ordered,
+            normalizedRoute,
+            bot,
+            routeState: safeObject(refreshedState.routes?.[routeKey]),
+            executionPlan,
+            deps: routingExecutionDeps,
+          });
+          const conversationAdjudication = buildRunnerResponderAdjudicationFromConversationContext({
+            selectedRecord,
+            conversationContext,
+            currentBotSelector,
+          });
+          const currentBotSelectedFromConversation = ensureArray(conversationAdjudication?.selected_bot_usernames)
+            .map((value) => String(value || "").trim().replace(/^@+/, "").toLowerCase())
+            .includes(currentBotSelector);
+          if (currentBotSelectedFromConversation) {
+            return {
+              ok: true,
+              triggerDecision,
+              routingExecutionDeps,
+              sharedHumanIntentContext: null,
+              adjudication: conversationAdjudication,
+              requestClaim: {
+                ok: true,
+                requestKey: "",
+                request: {},
+              },
+              claimedRequest: {},
+            };
+          }
+        }
+        await syncRunnerRequestLedgerForProjectToServer({
+          normalizedRoute,
+          runtime,
+        });
+        return {
+          ok: false,
+          skip: {
+            kind: "skip",
+            skipAction: "request_skipped",
+            skipReason: requestFailureReason || "request_unavailable",
+            skipTrigger: "request_ledger",
+            skipRecordPatch: {
+              diagnosticType: "skip",
+              contextExcluded: requestFailureReason === "bot_reply_without_active_request",
+              action: "skip_invalid_request_state",
+              closedReason: requestFailureReason,
+            },
+          },
+        };
+      }
+      const continuationAdjudication = buildContinuationResponderAdjudication(
+        selectedRecord,
+        requestClaim.request,
+      );
+      const currentBotSelected = ensureArray(continuationAdjudication.selected_bot_usernames)
+        .map((value) => String(value || "").trim().replace(/^@+/, "").toLowerCase())
+        .includes(currentBotSelector);
+      if (!currentBotSelected) {
+        return {
+          ok: false,
+          skip: {
+            kind: "skip",
+            skipAction: "adjudication_skipped",
+            skipReason: String(continuationAdjudication.reason_code || "").trim() || "not_selected_by_request_contract",
+            skipTrigger: "request_contract",
+          },
+        };
+      }
+      const finalizedRequest = await finalizePreparedRunnerRequest(
+        selectedRecord,
+        requestClaim,
+      );
+      if (!finalizedRequest.ok) {
+        return {
+          ok: false,
+          skip: finalizedRequest.skip,
+        };
+      }
+      return {
+        ok: true,
+        triggerDecision,
+        routingExecutionDeps,
+        sharedHumanIntentContext: null,
+        adjudication: continuationAdjudication,
+        requestClaim,
+        claimedRequest: finalizedRequest.claimedRequest,
+      };
+    };
+    const prepareRunnerSelectedRecordForExecution = async (selectedRecord) => {
+      const selectedRecordKind = String(safeObject(selectedRecord?.parsedArchive).kind || "").trim().toLowerCase();
       const duplicateArchivedSkip = maybeBuildDuplicateArchivedSkip(selectedRecord, refreshedState);
       if (duplicateArchivedSkip) {
         return {
@@ -10447,68 +10441,68 @@ async function processRunnerRouteOnce(route, runtime, mode, options = {}) {
           ? currentBotSelector !== representativeBotSelector
           : false,
       });
-      if (startupLoopSkipped) {
-        return {
-          kind: "startup_loop_skipped",
-          skippedRecord: startupLoopSkipped.skippedRecord,
-        };
-      }
-      const visibilityRouteState = safeObject(loadBotRunnerState().routes[routeKey]);
-      const humanInboundVisibility = resolveRunnerHumanInboundVisibility({
-        routeState: Object.keys(visibilityRouteState).length > 0
-          ? visibilityRouteState
-          : refreshedState,
-        persistedRequest: null,
-        selectedRecord,
-        routeKey,
-        currentBotSelector,
-        triggerDecision,
-      });
-      const visibilityStatePatch = humanInboundVisibility.applies
-        ? {
-            last_visibility_status: String(humanInboundVisibility.visibilityStatus || "").trim(),
-            last_visibility_reason: String(humanInboundVisibility.visibilityReason || "").trim(),
-            last_visibility_source: String(humanInboundVisibility.visibilitySource || "").trim(),
-            last_candidate_bot_usernames: ensureArray(humanInboundVisibility.candidateBotUsernames),
-          }
-        : {};
-      if (humanInboundVisibility.applies && humanInboundVisibility.executable !== true) {
-        return {
-          kind: "skip",
-          skipAction: "visibility_skipped",
-          skipReason: String(
-            humanInboundVisibility.visibilityReason || "telegram human inbound is not local to this route",
-          ).trim() || "telegram human inbound is not local to this route",
-          skipTrigger: "local_inbound_visibility",
-          skipStatePatch: visibilityStatePatch,
-        };
-      }
-      const routingExecutionDeps = {
-        ...buildRunnerExecutionDeps(),
-        managedConversationBots,
-        resolveConversationPeerBots: resolveRunnerConversationPeers,
-      };
-      if (selectedRecordKind === "bot_reply") {
-        const botReplyAuthorityContext = await prepareRunnerBotReplyAuthorityContext(
-          selectedRecord,
-          routingExecutionDeps,
-          triggerDecision,
-        );
-        if (!botReplyAuthorityContext.ok) {
-          return botReplyAuthorityContext.skip;
-        }
-        return {
-          kind: "ready",
-          triggerDecision: botReplyAuthorityContext.triggerDecision,
-          routingExecutionDeps: botReplyAuthorityContext.routingExecutionDeps,
-          sharedHumanIntentContext: botReplyAuthorityContext.sharedHumanIntentContext,
-          adjudication: botReplyAuthorityContext.adjudication,
-          requestClaim: botReplyAuthorityContext.requestClaim,
-          claimedRequest: botReplyAuthorityContext.claimedRequest,
-          humanInboundVisibility,
-          visibilityStatePatch,
-        };
-      }
+      if (startupLoopSkipped) {
+        return {
+          kind: "startup_loop_skipped",
+          skippedRecord: startupLoopSkipped.skippedRecord,
+        };
+      }
+      const visibilityRouteState = safeObject(loadBotRunnerState().routes[routeKey]);
+      const humanInboundVisibility = resolveRunnerHumanInboundVisibility({
+        routeState: Object.keys(visibilityRouteState).length > 0
+          ? visibilityRouteState
+          : refreshedState,
+        persistedRequest: null,
+        selectedRecord,
+        routeKey,
+        currentBotSelector,
+        triggerDecision,
+      });
+      const visibilityStatePatch = humanInboundVisibility.applies
+        ? {
+            last_visibility_status: String(humanInboundVisibility.visibilityStatus || "").trim(),
+            last_visibility_reason: String(humanInboundVisibility.visibilityReason || "").trim(),
+            last_visibility_source: String(humanInboundVisibility.visibilitySource || "").trim(),
+            last_candidate_bot_usernames: ensureArray(humanInboundVisibility.candidateBotUsernames),
+          }
+        : {};
+      if (humanInboundVisibility.applies && humanInboundVisibility.executable !== true) {
+        return {
+          kind: "skip",
+          skipAction: "visibility_skipped",
+          skipReason: String(
+            humanInboundVisibility.visibilityReason || "telegram human inbound is not local to this route",
+          ).trim() || "telegram human inbound is not local to this route",
+          skipTrigger: "local_inbound_visibility",
+          skipStatePatch: visibilityStatePatch,
+        };
+      }
+      const routingExecutionDeps = {
+        ...buildRunnerExecutionDeps(),
+        managedConversationBots,
+        resolveConversationPeerBots: resolveRunnerConversationPeers,
+      };
+      if (selectedRecordKind === "bot_reply") {
+        const botReplyAuthorityContext = await prepareRunnerBotReplyAuthorityContext(
+          selectedRecord,
+          routingExecutionDeps,
+          triggerDecision,
+        );
+        if (!botReplyAuthorityContext.ok) {
+          return botReplyAuthorityContext.skip;
+        }
+        return {
+          kind: "ready",
+          triggerDecision: botReplyAuthorityContext.triggerDecision,
+          routingExecutionDeps: botReplyAuthorityContext.routingExecutionDeps,
+          sharedHumanIntentContext: botReplyAuthorityContext.sharedHumanIntentContext,
+          adjudication: botReplyAuthorityContext.adjudication,
+          requestClaim: botReplyAuthorityContext.requestClaim,
+          claimedRequest: botReplyAuthorityContext.claimedRequest,
+          humanInboundVisibility,
+          visibilityStatePatch,
+        };
+      }
       const sharedHumanIntentContext = await resolveHumanIntentContext({
         selectedRecord,
         normalizedRoute,
@@ -10561,12 +10555,12 @@ async function processRunnerRouteOnce(route, runtime, mode, options = {}) {
           skipTrigger: "responder_adjudication",
         };
       }
-      const requestClaim = await prepareRunnerRequestClaim(
-        selectedRecord,
-        adjudication.selected_bot_usernames,
-        safeObject(sharedHumanIntentContext).humanIntent || null,
-        humanInboundVisibility.sourceMessageEnvelope,
-      );
+      const requestClaim = await prepareRunnerRequestClaim(
+        selectedRecord,
+        adjudication.selected_bot_usernames,
+        safeObject(sharedHumanIntentContext).humanIntent || null,
+        humanInboundVisibility.sourceMessageEnvelope,
+      );
       if (!requestClaim.ok) {
         await syncRunnerRequestLedgerForProjectToServer({
           normalizedRoute,
@@ -10585,26 +10579,26 @@ async function processRunnerRouteOnce(route, runtime, mode, options = {}) {
           },
         };
       }
-      const finalizedRequest = await finalizePreparedRunnerRequest(
-        selectedRecord,
-        requestClaim,
-        humanInboundVisibility.sourceMessageEnvelope,
-      );
+      const finalizedRequest = await finalizePreparedRunnerRequest(
+        selectedRecord,
+        requestClaim,
+        humanInboundVisibility.sourceMessageEnvelope,
+      );
       if (!finalizedRequest.ok) {
         return finalizedRequest.skip;
       }
-      return {
-        kind: "ready",
-        triggerDecision,
-        routingExecutionDeps,
-        sharedHumanIntentContext,
-        adjudication,
-        requestClaim,
-        claimedRequest: finalizedRequest.claimedRequest,
-        humanInboundVisibility,
-        visibilityStatePatch,
-      };
-    };
+      return {
+        kind: "ready",
+        triggerDecision,
+        routingExecutionDeps,
+        sharedHumanIntentContext,
+        adjudication,
+        requestClaim,
+        claimedRequest: finalizedRequest.claimedRequest,
+        humanInboundVisibility,
+        visibilityStatePatch,
+      };
+    };
     if (deferExecution) {
       const skippedRecords = [];
       for (const selectedRecord of pending.pending) {
@@ -10623,27 +10617,27 @@ async function processRunnerRouteOnce(route, runtime, mode, options = {}) {
           skippedRecords.push(preparation.skippedRecord);
           continue;
         }
-        const {
-          triggerDecision,
-          sharedHumanIntentContext,
-          adjudication,
-          requestClaim,
-          claimedRequest,
-          humanInboundVisibility,
-          visibilityStatePatch,
-        } = preparation;
-        saveRunnerRouteState(routeKey, {
-          ...buildRunnerActiveExecutionPatch(selectedRecord, requestClaim.requestKey, {
-            id: String(claimedRequest.root_work_item_id || "").trim(),
-            title: String(claimedRequest.root_work_item_title || "").trim(),
+        const {
+          triggerDecision,
+          sharedHumanIntentContext,
+          adjudication,
+          requestClaim,
+          claimedRequest,
+          humanInboundVisibility,
+          visibilityStatePatch,
+        } = preparation;
+        saveRunnerRouteState(routeKey, {
+          ...buildRunnerActiveExecutionPatch(selectedRecord, requestClaim.requestKey, {
+            id: String(claimedRequest.root_work_item_id || "").trim(),
+            title: String(claimedRequest.root_work_item_title || "").trim(),
             status: String(claimedRequest.root_work_item_status || "").trim(),
           }),
-          last_request_key: String(requestClaim.requestKey || "").trim(),
-          last_root_work_item_id: String(claimedRequest.root_work_item_id || "").trim(),
-          last_root_work_item_title: String(claimedRequest.root_work_item_title || "").trim(),
-          last_root_work_item_status: String(claimedRequest.root_work_item_status || "").trim(),
-          ...safeObject(visibilityStatePatch),
-        });
+          last_request_key: String(requestClaim.requestKey || "").trim(),
+          last_root_work_item_id: String(claimedRequest.root_work_item_id || "").trim(),
+          last_root_work_item_title: String(claimedRequest.root_work_item_title || "").trim(),
+          last_root_work_item_status: String(claimedRequest.root_work_item_status || "").trim(),
+          ...safeObject(visibilityStatePatch),
+        });
         await syncRunnerRequestLedgerForProjectToServer({
           normalizedRoute,
           runtime,
@@ -10672,14 +10666,14 @@ async function processRunnerRouteOnce(route, runtime, mode, options = {}) {
             executionPlan,
             runtime,
             managedConversationBots,
-            requestKey: String(requestClaim.requestKey || "").trim(),
-            triggerDecision,
-            responderAdjudication: adjudication,
-            humanIntentContext: sharedHumanIntentContext,
-            humanInboundVisibility,
-          },
-        };
-      }
+            requestKey: String(requestClaim.requestKey || "").trim(),
+            triggerDecision,
+            responderAdjudication: adjudication,
+            humanIntentContext: sharedHumanIntentContext,
+            humanInboundVisibility,
+          },
+        };
+      }
       {
         const skippedOutcome = await finalizeSkippedPendingRecords(skippedRecords);
         if (skippedOutcome) {
@@ -10705,39 +10699,39 @@ async function processRunnerRouteOnce(route, runtime, mode, options = {}) {
         continue;
       }
       const currentRouteState = safeObject(loadBotRunnerState().routes[routeKey]);
-      const {
-        triggerDecision,
-        sharedHumanIntentContext,
-        adjudication: inlineAdjudication,
-        requestClaim,
-        claimedRequest,
-        humanInboundVisibility,
-        visibilityStatePatch,
-      } = preparation;
-      saveRunnerRouteState(routeKey, {
-        ...buildRunnerActiveExecutionPatch(selectedRecord, requestClaim.requestKey, {
-          id: String(claimedRequest.root_work_item_id || "").trim(),
-          title: String(claimedRequest.root_work_item_title || "").trim(),
+      const {
+        triggerDecision,
+        sharedHumanIntentContext,
+        adjudication: inlineAdjudication,
+        requestClaim,
+        claimedRequest,
+        humanInboundVisibility,
+        visibilityStatePatch,
+      } = preparation;
+      saveRunnerRouteState(routeKey, {
+        ...buildRunnerActiveExecutionPatch(selectedRecord, requestClaim.requestKey, {
+          id: String(claimedRequest.root_work_item_id || "").trim(),
+          title: String(claimedRequest.root_work_item_title || "").trim(),
           status: String(claimedRequest.root_work_item_status || "").trim(),
         }),
-        last_request_key: String(requestClaim.requestKey || "").trim(),
-        last_root_work_item_id: String(claimedRequest.root_work_item_id || "").trim(),
-        last_root_work_item_title: String(claimedRequest.root_work_item_title || "").trim(),
-        last_root_work_item_status: String(claimedRequest.root_work_item_status || "").trim(),
-        ...safeObject(visibilityStatePatch),
-      });
+        last_request_key: String(requestClaim.requestKey || "").trim(),
+        last_root_work_item_id: String(claimedRequest.root_work_item_id || "").trim(),
+        last_root_work_item_title: String(claimedRequest.root_work_item_title || "").trim(),
+        last_root_work_item_status: String(claimedRequest.root_work_item_status || "").trim(),
+        ...safeObject(visibilityStatePatch),
+      });
       if (String(requestClaim.requestKey || "").trim()) {
         const resolvedIntentType = String(safeObject(loadBotRunnerState().routes[routeKey]).last_intent_type || "").trim();
-        markRunnerRequestLifecycle({
-          normalizedRoute,
-          requestKey: requestClaim.requestKey,
-          selectedRecord,
-          routeKey,
-          outcome: "running",
-          authoritativeSourceMessageEnvelope: safeObject(
-            humanInboundVisibility.sourceMessageEnvelope,
-          ),
-        });
+        markRunnerRequestLifecycle({
+          normalizedRoute,
+          requestKey: requestClaim.requestKey,
+          selectedRecord,
+          routeKey,
+          outcome: "running",
+          authoritativeSourceMessageEnvelope: safeObject(
+            humanInboundVisibility.sourceMessageEnvelope,
+          ),
+        });
         const rootWorkItemSync = await syncRunnerRequestRootWorkItemForOutcome({
           normalizedRoute,
           runtime,
@@ -10777,15 +10771,15 @@ async function processRunnerRouteOnce(route, runtime, mode, options = {}) {
         archiveThread,
         executionPlan,
         runtime,
-        triggerDecision,
-        responderAdjudication: inlineAdjudication,
-        persistedHumanIntentRequest: claimedRequest,
-        precomputedHumanIntentContext: sharedHumanIntentContext,
-        precomputedHumanInboundVisibility: humanInboundVisibility,
-        deps: {
-          saveRunnerRouteState,
-          startRunnerTypingHeartbeat,
-          runRunnerAIExecution,
+        triggerDecision,
+        responderAdjudication: inlineAdjudication,
+        persistedHumanIntentRequest: claimedRequest,
+        precomputedHumanIntentContext: sharedHumanIntentContext,
+        precomputedHumanInboundVisibility: humanInboundVisibility,
+        deps: {
+          saveRunnerRouteState,
+          startRunnerTypingHeartbeat,
+          runRunnerAIExecution,
           explainExecutionFailureWithAI,
           performLocalBotDelivery,
           serializeRunnerTriggerPolicy,
@@ -10799,17 +10793,17 @@ async function processRunnerRouteOnce(route, runtime, mode, options = {}) {
       });
       if (processed.kind === "skipped") {
         if (String(requestClaim.requestKey || "").trim()) {
-          markRunnerRequestLifecycle({
-            normalizedRoute,
-            requestKey: requestClaim.requestKey,
-            selectedRecord,
-            routeKey,
-            outcome: "skipped",
-            closedReason: String(processed.skippedRecord?.reason || "skipped").trim() || "skipped",
-            authoritativeSourceMessageEnvelope: safeObject(
-              humanInboundVisibility.sourceMessageEnvelope,
-            ),
-          });
+          markRunnerRequestLifecycle({
+            normalizedRoute,
+            requestKey: requestClaim.requestKey,
+            selectedRecord,
+            routeKey,
+            outcome: "skipped",
+            closedReason: String(processed.skippedRecord?.reason || "skipped").trim() || "skipped",
+            authoritativeSourceMessageEnvelope: safeObject(
+              humanInboundVisibility.sourceMessageEnvelope,
+            ),
+          });
           const rootWorkItemSync = await syncRunnerRequestRootWorkItemForOutcome({
             normalizedRoute,
             runtime,
@@ -10833,11 +10827,11 @@ async function processRunnerRouteOnce(route, runtime, mode, options = {}) {
       }
       if (String(requestClaim.requestKey || "").trim()) {
         const resolvedIntentType = String(safeObject(loadBotRunnerState().routes[routeKey]).last_intent_type || "").trim();
-        markRunnerRequestLifecycle({
-          normalizedRoute,
-          requestKey: requestClaim.requestKey,
-          selectedRecord,
-          routeKey,
+        markRunnerRequestLifecycle({
+          normalizedRoute,
+          requestKey: requestClaim.requestKey,
+          selectedRecord,
+          routeKey,
           outcome: processed.kind === "delivery_failed"
             ? "delivery_failed_after_generation"
             : String(processed.result?.outcome || "replied").trim().toLowerCase(),
@@ -10867,19 +10861,19 @@ async function processRunnerRouteOnce(route, runtime, mode, options = {}) {
           responseContractValidationTargets: ensureArray(processed.result?.response_contract_validation_targets),
           assignmentValidationStatus: String(processed.result?.assignment_validation_status || "").trim(),
           assignmentValidationReason: String(processed.result?.assignment_validation_reason || "").trim(),
-          assignmentValidationModes: ensureArray(processed.result?.assignment_validation_modes),
-          deliveryStatus: String(processed.result?.delivery_status || "").trim(),
-          archiveStatus: String(processed.result?.archive_status || "").trim(),
-          transportError: String(processed.result?.transport_error || "").trim(),
-          archiveError: String(processed.result?.archive_error || "").trim(),
-          lastReplyMessageID: intFromRawAllowZero(processed.result?.last_reply_message_id, 0),
-          lastReplyMessageThreadID: intFromRawAllowZero(processed.result?.last_reply_message_thread_id, 0),
-          replyToMessageID: intFromRawAllowZero(processed.result?.reply_to_message_id, 0),
-          replyFallbackUsed: processed.result?.reply_fallback_used === true,
-          authoritativeSourceMessageEnvelope: safeObject(
-            humanInboundVisibility.sourceMessageEnvelope,
-          ),
-        });
+          assignmentValidationModes: ensureArray(processed.result?.assignment_validation_modes),
+          deliveryStatus: String(processed.result?.delivery_status || "").trim(),
+          archiveStatus: String(processed.result?.archive_status || "").trim(),
+          transportError: String(processed.result?.transport_error || "").trim(),
+          archiveError: String(processed.result?.archive_error || "").trim(),
+          lastReplyMessageID: intFromRawAllowZero(processed.result?.last_reply_message_id, 0),
+          lastReplyMessageThreadID: intFromRawAllowZero(processed.result?.last_reply_message_thread_id, 0),
+          replyToMessageID: intFromRawAllowZero(processed.result?.reply_to_message_id, 0),
+          replyFallbackUsed: processed.result?.reply_fallback_used === true,
+          authoritativeSourceMessageEnvelope: safeObject(
+            humanInboundVisibility.sourceMessageEnvelope,
+          ),
+        });
         if (processed.kind !== "delivery_failed") {
           await ensureRunnerRootWorkItemForRequest({
             normalizedRoute,
@@ -11831,11 +11825,24 @@ function resolveRunnerProjectUpRoutes({
     server_bot_name: botName,
     server_bot_id: botID,
   });
-  return ensureArray(config.routes)
+  const matched = ensureArray(config.routes)
     .map((rawRoute) => normalizeRunnerRoute(rawRoute))
     .filter((route) => route.enabled)
     .filter((route) => configuredRunnerRouteMatchesInlineSelection(route, selectionRoute, selectionFlags, { telegramEntries }))
     .filter((route) => !normalizedRoles.length || normalizedRoles.includes(normalizeBotRole(route.role)));
+  if (normalizedRoles.length) {
+    return matched;
+  }
+  const seenBotDestinations = new Map();
+  return matched.filter((route) => {
+    const botIdentity = String(route.serverBotID || route.botID || route.botName || route.serverBotName || "").trim().toLowerCase();
+    const destIdentity = String(route.destinationID || route.destinationLabel || "").trim().toLowerCase();
+    const dedupeKey = `${botIdentity}::${destIdentity}`;
+    if (!dedupeKey || dedupeKey === "::") return true;
+    if (seenBotDestinations.has(dedupeKey)) return false;
+    seenBotDestinations.set(dedupeKey, true);
+    return true;
+  });
 }
 
 async function runRunnerProjectUp(flags) {
@@ -13158,16 +13165,16 @@ async function syncRunnerDeferredExecutionRunningState(deferredExecution) {
   if (!String(deferredExecution?.requestKey || "").trim()) {
     return;
   }
-  markRunnerRequestLifecycle({
-    normalizedRoute: deferredExecution.normalizedRoute,
-    requestKey: deferredExecution.requestKey,
-    selectedRecord: deferredExecution.selectedRecord,
-    routeKey: deferredExecution.routeKey,
-    outcome: "running",
-    authoritativeSourceMessageEnvelope: safeObject(
-      safeObject(deferredExecution.humanInboundVisibility).sourceMessageEnvelope,
-    ),
-  });
+  markRunnerRequestLifecycle({
+    normalizedRoute: deferredExecution.normalizedRoute,
+    requestKey: deferredExecution.requestKey,
+    selectedRecord: deferredExecution.selectedRecord,
+    routeKey: deferredExecution.routeKey,
+    outcome: "running",
+    authoritativeSourceMessageEnvelope: safeObject(
+      safeObject(deferredExecution.humanInboundVisibility).sourceMessageEnvelope,
+    ),
+  });
   const rootWorkItemSync = await syncRunnerRequestRootWorkItemForOutcome({
     normalizedRoute: deferredExecution.normalizedRoute,
     runtime: deferredExecution.runtime,
@@ -13192,17 +13199,17 @@ async function syncRunnerDeferredExecutionRunningState(deferredExecution) {
 
 async function finalizeRunnerDeferredExecutionSkipped(deferredExecution, processed) {
   if (String(deferredExecution?.requestKey || "").trim()) {
-    markRunnerRequestLifecycle({
-      normalizedRoute: deferredExecution.normalizedRoute,
-      requestKey: deferredExecution.requestKey,
-      selectedRecord: deferredExecution.selectedRecord,
-      routeKey: deferredExecution.routeKey,
-      outcome: "skipped",
-      closedReason: String(processed?.skippedRecord?.reason || "skipped").trim() || "skipped",
-      authoritativeSourceMessageEnvelope: safeObject(
-        safeObject(deferredExecution.humanInboundVisibility).sourceMessageEnvelope,
-      ),
-    });
+    markRunnerRequestLifecycle({
+      normalizedRoute: deferredExecution.normalizedRoute,
+      requestKey: deferredExecution.requestKey,
+      selectedRecord: deferredExecution.selectedRecord,
+      routeKey: deferredExecution.routeKey,
+      outcome: "skipped",
+      closedReason: String(processed?.skippedRecord?.reason || "skipped").trim() || "skipped",
+      authoritativeSourceMessageEnvelope: safeObject(
+        safeObject(deferredExecution.humanInboundVisibility).sourceMessageEnvelope,
+      ),
+    });
     const rootWorkItemSync = await syncRunnerRequestRootWorkItemForOutcome({
       normalizedRoute: deferredExecution.normalizedRoute,
       runtime: deferredExecution.runtime,
@@ -13241,11 +13248,11 @@ async function finalizeRunnerDeferredExecutionProcessed(deferredExecution, proce
     const resolvedIntentType = String(
       safeObject(loadBotRunnerState().routes[deferredExecution.routeKey]).last_intent_type || "",
     ).trim();
-    markRunnerRequestLifecycle({
-      normalizedRoute: deferredExecution.normalizedRoute,
-      requestKey: deferredExecution.requestKey,
-      selectedRecord: deferredExecution.selectedRecord,
-      routeKey: deferredExecution.routeKey,
+    markRunnerRequestLifecycle({
+      normalizedRoute: deferredExecution.normalizedRoute,
+      requestKey: deferredExecution.requestKey,
+      selectedRecord: deferredExecution.selectedRecord,
+      routeKey: deferredExecution.routeKey,
       outcome: processed.kind === "delivery_failed"
         ? "delivery_failed_after_generation"
         : String(processed.result?.outcome || "replied").trim().toLowerCase(),
@@ -13277,19 +13284,19 @@ async function finalizeRunnerDeferredExecutionProcessed(deferredExecution, proce
       responseContractValidationTargets: ensureArray(processed.result?.response_contract_validation_targets),
       assignmentValidationStatus: String(processed.result?.assignment_validation_status || "").trim(),
       assignmentValidationReason: String(processed.result?.assignment_validation_reason || "").trim(),
-      assignmentValidationModes: ensureArray(processed.result?.assignment_validation_modes),
-      deliveryStatus: String(processed.result?.delivery_status || "").trim(),
-      archiveStatus: String(processed.result?.archive_status || "").trim(),
-      transportError: String(processed.result?.transport_error || "").trim(),
-      archiveError: String(processed.result?.archive_error || "").trim(),
-      lastReplyMessageID: intFromRawAllowZero(processed.result?.last_reply_message_id, 0),
-      lastReplyMessageThreadID: intFromRawAllowZero(processed.result?.last_reply_message_thread_id, 0),
-      replyToMessageID: intFromRawAllowZero(processed.result?.reply_to_message_id, 0),
-      replyFallbackUsed: processed.result?.reply_fallback_used === true,
-      authoritativeSourceMessageEnvelope: safeObject(
-        safeObject(deferredExecution.humanInboundVisibility).sourceMessageEnvelope,
-      ),
-    });
+      assignmentValidationModes: ensureArray(processed.result?.assignment_validation_modes),
+      deliveryStatus: String(processed.result?.delivery_status || "").trim(),
+      archiveStatus: String(processed.result?.archive_status || "").trim(),
+      transportError: String(processed.result?.transport_error || "").trim(),
+      archiveError: String(processed.result?.archive_error || "").trim(),
+      lastReplyMessageID: intFromRawAllowZero(processed.result?.last_reply_message_id, 0),
+      lastReplyMessageThreadID: intFromRawAllowZero(processed.result?.last_reply_message_thread_id, 0),
+      replyToMessageID: intFromRawAllowZero(processed.result?.reply_to_message_id, 0),
+      replyFallbackUsed: processed.result?.reply_fallback_used === true,
+      authoritativeSourceMessageEnvelope: safeObject(
+        safeObject(deferredExecution.humanInboundVisibility).sourceMessageEnvelope,
+      ),
+    });
     if (processed.kind !== "delivery_failed") {
       await ensureRunnerRootWorkItemForRequest({
         normalizedRoute: deferredExecution.normalizedRoute,
@@ -13346,18 +13353,18 @@ async function finalizeRunnerDeferredExecutionError(deferredExecution, errorText
       || currentRequest.normalized_intent
       || "",
     ).trim();
-    markRunnerRequestLifecycle({
-      normalizedRoute: deferredExecution.normalizedRoute,
-      requestKey: deferredExecution.requestKey,
-      selectedRecord: deferredExecution.selectedRecord,
-      routeKey: deferredExecution.routeKey,
-      outcome: "error",
-      closedReason: errorText || "execution_error",
-      normalizedIntent: resolvedIntentType,
-      authoritativeSourceMessageEnvelope: safeObject(
-        safeObject(deferredExecution.humanInboundVisibility).sourceMessageEnvelope,
-      ),
-    });
+    markRunnerRequestLifecycle({
+      normalizedRoute: deferredExecution.normalizedRoute,
+      requestKey: deferredExecution.requestKey,
+      selectedRecord: deferredExecution.selectedRecord,
+      routeKey: deferredExecution.routeKey,
+      outcome: "error",
+      closedReason: errorText || "execution_error",
+      normalizedIntent: resolvedIntentType,
+      authoritativeSourceMessageEnvelope: safeObject(
+        safeObject(deferredExecution.humanInboundVisibility).sourceMessageEnvelope,
+      ),
+    });
     await ensureRunnerRootWorkItemForRequest({
       normalizedRoute: deferredExecution.normalizedRoute,
       routeKey: deferredExecution.routeKey,
@@ -13572,10 +13579,10 @@ function createRunnerDeferredExecutionPromise({
 }) {
   return (async () => {
     try {
-      const processed = await processRunnerSelectedRecord({
-        routeKey: deferredExecution.routeKey,
-        normalizedRoute: deferredExecution.normalizedRoute,
-        routeState: deferredExecution.routeState,
+      const processed = await processRunnerSelectedRecord({
+        routeKey: deferredExecution.routeKey,
+        normalizedRoute: deferredExecution.normalizedRoute,
+        routeState: deferredExecution.routeState,
         selectedRecord: deferredExecution.selectedRecord,
         pendingOrdered: deferredExecution.pendingOrdered,
         bot: deferredExecution.bot,
@@ -13583,14 +13590,14 @@ function createRunnerDeferredExecutionPromise({
         archiveThread: deferredExecution.archiveThread,
         executionPlan: deferredExecution.executionPlan,
         runtime: deferredExecution.runtime,
-        triggerDecision: deferredExecution.triggerDecision,
-        responderAdjudication: deferredExecution.responderAdjudication,
-        persistedHumanIntentRequest: loadRunnerRequestByKey(deferredExecution.requestKey),
-        precomputedHumanIntentContext: safeObject(deferredExecution.humanIntentContext),
-        precomputedHumanInboundVisibility: safeObject(deferredExecution.humanInboundVisibility),
-        deps: {
-          saveRunnerRouteState,
-          startRunnerTypingHeartbeat,
+        triggerDecision: deferredExecution.triggerDecision,
+        responderAdjudication: deferredExecution.responderAdjudication,
+        persistedHumanIntentRequest: loadRunnerRequestByKey(deferredExecution.requestKey),
+        precomputedHumanIntentContext: safeObject(deferredExecution.humanIntentContext),
+        precomputedHumanInboundVisibility: safeObject(deferredExecution.humanInboundVisibility),
+        deps: {
+          saveRunnerRouteState,
+          startRunnerTypingHeartbeat,
           runRunnerAIExecution,
           explainExecutionFailureWithAI,
           performLocalBotDelivery,
@@ -17918,25 +17925,25 @@ TELEGRAM_BOT_REVIEW_TOKEN=review-token
     mergeServerRunnerRequestLedgerIntoLocalState,
     buildRunnerStatusQueryLookup,
     tryJsonParse,
-    safeObject,
-    normalizeRunnerTriggerPolicy,
-    evaluateTelegramRunnerTrigger,
-    resolveHumanIntentContext,
-    resolveRunnerResponderAdjudication,
-    selectPendingArchiveComments,
+    safeObject,
+    normalizeRunnerTriggerPolicy,
+    evaluateTelegramRunnerTrigger,
+    resolveHumanIntentContext,
+    resolveRunnerResponderAdjudication,
+    selectPendingArchiveComments,
     selectRunnerPendingWork,
     processRunnerSelectedRecord,
-    resolveRunnerStartupLoopAdjudication,
-    shouldBypassRunnerStartupLoopForContractFollowup,
-    claimRunnerRequestForHumanComment,
-    markRunnerRequestLifecycle,
-    resolveRunnerContinuationRequestForBotReply,
-    normalizeBotRunnerRequests,
-    buildRunnerRequestRecoveryPatchFromRouteState,
-    peekRunnerContinuationRequestForBotReply,
-    cleanupBotRunnerRequestState,
-    runRunnerAIExecution,
-    buildLocalBotPrompt,
+    resolveRunnerStartupLoopAdjudication,
+    shouldBypassRunnerStartupLoopForContractFollowup,
+    claimRunnerRequestForHumanComment,
+    markRunnerRequestLifecycle,
+    resolveRunnerContinuationRequestForBotReply,
+    normalizeBotRunnerRequests,
+    buildRunnerRequestRecoveryPatchFromRouteState,
+    peekRunnerContinuationRequestForBotReply,
+    cleanupBotRunnerRequestState,
+    runRunnerAIExecution,
+    buildLocalBotPrompt,
     formatBotReplyArchiveComment,
     findArchivedBotReplyRecord,
     parseArchivedChatComment,