metheus-governance-mcp-cli 0.2.296 → 0.2.304

package/cli.mjs

@@ -137,6 +137,7 @@ import {
 import {
   applyPendingAgeSelection,
   buildCanonicalHumanInboundKey as buildRunnerCanonicalHumanInboundKey,
+  buildTelegramMediaPlaceholder,
   buildTelegramBotReplyEnvelope,
   buildTelegramMessageEnvelopeFromParsedArchive as buildRunnerTelegramMessageEnvelopeFromParsedArchive,
   buildRunnerRouteDuplicateStateFromComment,
@@ -147,11 +148,13 @@ import {
   isTelegramLocalInboundEnvelopeForRoute,
   isInboundArchiveKind,
   normalizeTelegramMessageEnvelope as normalizeRunnerTelegramMessageEnvelope,
+  normalizeTelegramMessageAttachments,
   normalizeArchiveCommentRecord,
   selectPendingArchiveComments,
   printRunnerResult,
 } from "./lib/runner-helpers.mjs";
 import {
+  normalizeRunnerRecentLocalInboundReceiptEntry,
   normalizeRunnerRecentLocalInboundReceiptMap,
 } from "./lib/runner-local-inbound-receipts.mjs";
 import {
@@ -159,30 +162,40 @@ import {
   validateRunnerConversationDecisionBundle,
 } from "./lib/runner-orchestration-decision-bundle.mjs";
 import {
+  transcribeRunnerTelegramAudioAttachments,
+} from "./lib/runner-media-transcription.mjs";
+import {
+  analyzeRunnerTelegramImageAttachments,
+} from "./lib/runner-media-vision.mjs";
+import {
+  createProjectPrivateChat as createProjectPrivateChatImpl,
   createProjectContextItem as createProjectContextItemImpl,
-  createProjectEvidence as createProjectEvidenceImpl,
-  createProjectWorkItem as createProjectWorkItemImpl,
-  createThreadComment as createThreadCommentImpl,
-  createWorkItemThread as createWorkItemThreadImpl,
-  deleteProjectContextItem as deleteProjectContextItemImpl,
-  discoverArchiveThreadForDestination as discoverArchiveThreadForDestinationImpl,
-  linkWorkItemEvidence as linkWorkItemEvidenceImpl,
-  listProjectChatDestinations as listProjectChatDestinationsImpl,
-  listProjectContextItems as listProjectContextItemsImpl,
-  listProjectCtxpackFiles as listProjectCtxpackFilesImpl,
-  listProjectRunnerRequestCommentStates as listProjectRunnerRequestCommentStatesImpl,
-  listProjectRunnerRequests as listProjectRunnerRequestsImpl,
-  listWorkItemThreads as listWorkItemThreadsImpl,
-  listThreadComments as listThreadCommentsImpl,
-  listThreadCommentsTail as listThreadCommentsTailImpl,
+  createProjectEvidence as createProjectEvidenceImpl,
+  createProjectWorkItem as createProjectWorkItemImpl,
+  createThreadComment as createThreadCommentImpl,
+  getProjectRunnerSettings as getProjectRunnerSettingsImpl,
+  createWorkItemThread as createWorkItemThreadImpl,
+  deleteProjectContextItem as deleteProjectContextItemImpl,
+  discoverArchiveThreadForDestination as discoverArchiveThreadForDestinationImpl,
+  linkWorkItemEvidence as linkWorkItemEvidenceImpl,
+  listProjectChatDestinations as listProjectChatDestinationsImpl,
+  listProjectContextItems as listProjectContextItemsImpl,
+  listProjectCtxpackFiles as listProjectCtxpackFilesImpl,
+  listProjectPrivateChats as listProjectPrivateChatsImpl,
+  listProjectRunnerRequestCommentStates as listProjectRunnerRequestCommentStatesImpl,
+  listProjectRunnerRequests as listProjectRunnerRequestsImpl,
+  listWorkItemThreads as listWorkItemThreadsImpl,
+  listThreadComments as listThreadCommentsImpl,
+  listThreadCommentsTail as listThreadCommentsTailImpl,
   listUserBotsForRunner as listUserBotsForRunnerImpl,
   selectProjectChatDestination as selectProjectChatDestinationImpl,
   selectRunnerBot as selectRunnerBotImpl,
-  transitionProjectWorkItem as transitionProjectWorkItemImpl,
-  upsertProjectRunnerRequest as upsertProjectRunnerRequestImpl,
-  upsertProjectRunnerRequestCommentState as upsertProjectRunnerRequestCommentStateImpl,
-  updateProjectContextItem as updateProjectContextItemImpl,
-} from "./lib/runner-data.mjs";
+  transitionProjectWorkItem as transitionProjectWorkItemImpl,
+  upsertProjectRunnerRequest as upsertProjectRunnerRequestImpl,
+  upsertProjectRunnerRequestCommentState as upsertProjectRunnerRequestCommentStateImpl,
+  updateProjectPrivateChat as updateProjectPrivateChatImpl,
+  updateProjectContextItem as updateProjectContextItemImpl,
+} from "./lib/runner-data.mjs";
 import {
   evaluateTelegramRunnerTrigger,
   resolveRunnerPrecomputedTriggerDecision,
@@ -239,13 +252,14 @@ import {
   formatBotReplyArchiveComment,
   performLocalBotDelivery,
 } from "./lib/runner-delivery.mjs";
-import {
-  resolveRunnerExecutionPlan,
-  resolveRunnerExecutionPlanForRole,
-  resolveRunnerRoleProfile,
-  resolveRunnerWorkspaceSelection,
-  runRunnerAIExecution,
-} from "./lib/runner-execution.mjs";
+import {
+  resolveRunnerExecutionPlan,
+  resolveRunnerExecutionPlanForRole,
+  resolveRunnerLocalAIExecutionProfile,
+  resolveRunnerRoleProfile,
+  resolveRunnerWorkspaceSelection,
+  runRunnerAIExecution,
+} from "./lib/runner-execution.mjs";
 import {
   buildRunnerResponderAdjudicationFromConversationContext,
   buildRunnerResponderAdjudicationFromHumanIntent,
@@ -1430,13 +1444,14 @@ function botRunnerConfigTemplate() {
         role_profile: "monitor",
       },
     },
-    routes: [
-      {
-        name: "telegram-monitor",
-        enabled: false,
-        project_id: "<project_uuid>",
-        provider: "telegram",
-        role: "monitor",
+    routes: [
+      {
+        name: "telegram-monitor",
+        enabled: false,
+        route_kind: "room",
+        project_id: "<project_uuid>",
+        provider: "telegram",
+        role: "monitor",
         role_profile: "monitor",
         server_bot_name: "",
         server_bot_id: "",
@@ -1479,13 +1494,14 @@ function serializeBotRunnerWorkspaceRegistry(projectMappings) {
   };
 }
 
-function serializeRunnerRoute(route) {
-  const normalized = normalizeRunnerRoute(route);
-  return {
-    name: normalized.name,
-    enabled: normalized.enabled,
-    project_id: normalized.projectID,
-    provider: normalized.provider,
+function serializeRunnerRoute(route) {
+  const normalized = normalizeRunnerRoute(route);
+  return {
+    name: normalized.name,
+    enabled: normalized.enabled,
+    route_kind: normalized.routeKind,
+    project_id: normalized.projectID,
+    provider: normalized.provider,
     role: normalized.role,
     ...(normalized.roleProfile ? { role_profile: normalized.roleProfile } : {}),
     server_bot_name: normalized.botName,
@@ -1872,19 +1888,32 @@ function rememberProjectWorkspaceMapping({ projectID, workspaceDir, source }) {
   };
 }
 
-function parseRunnerStateRouteKey(routeKey) {
-  const text = String(routeKey || "").trim();
-  if (!text) return null;
-  const parts = text.split("::");
-  if (parts.length < 6) return null;
-  return {
-    raw: text,
-    name: String(parts[0] || "").trim(),
-    projectID: String(parts[1] || "").trim(),
-    provider: normalizeBotProvider(parts[2]),
-    role: normalizeBotRole(parts[3]),
-    botSelector: String(parts[4] || "").trim(),
-    destinationSelector: parts.slice(5).join("::").trim(),
+function parseRunnerStateRouteKey(routeKey) {
+  const text = String(routeKey || "").trim();
+  if (!text) return null;
+  const parts = text.split("::");
+  if (parts.length < 6) return null;
+  if (parts.length >= 7) {
+    return {
+      raw: text,
+      name: String(parts[0] || "").trim(),
+      projectID: String(parts[1] || "").trim(),
+      provider: normalizeBotProvider(parts[2]),
+      routeKind: normalizeRunnerRouteKind(parts[3], "room"),
+      role: normalizeBotRole(parts[4]),
+      botSelector: String(parts[5] || "").trim(),
+      destinationSelector: parts.slice(6).join("::").trim(),
+    };
+  }
+  return {
+    raw: text,
+    name: String(parts[0] || "").trim(),
+    projectID: String(parts[1] || "").trim(),
+    provider: normalizeBotProvider(parts[2]),
+    routeKind: "room",
+    role: normalizeBotRole(parts[3]),
+    botSelector: String(parts[4] || "").trim(),
+    destinationSelector: parts.slice(5).join("::").trim(),
   };
 }
 
@@ -1920,19 +1949,22 @@ function findConfiguredRoutesForAnonymousStateKey(parsedKey, runnerConfig) {
   const enabledRoutes = ensureArray(runnerConfig?.routes)
     .map((route) => normalizeRunnerRoute(route))
     .filter((route) => route.enabled);
-  return enabledRoutes.filter((route) => {
-    if (route.projectID !== routeKey.projectID) return false;
-    if (route.provider !== routeKey.provider) return false;
-    if (route.role !== routeKey.role) return false;
-    if (!runnerStateSelectorMatchesRoute(routeKey.botSelector, route.botID, route.botName)) {
-      return false;
-    }
-    if (!runnerStateSelectorMatchesRoute(routeKey.destinationSelector, route.destinationID, route.destinationLabel)) {
-      return false;
-    }
-    return true;
-  });
-}
+  return enabledRoutes.filter((route) => {
+    if (route.projectID !== routeKey.projectID) return false;
+    if (route.provider !== routeKey.provider) return false;
+    if ((route.routeKind || "room") !== (routeKey.routeKind || "room")) return false;
+    if (route.role !== routeKey.role) return false;
+    if (!runnerStateSelectorMatchesRoute(routeKey.botSelector, route.botID, route.botName)) {
+      return false;
+    }
+    const routeTargetID = route.routeKind === "dm" ? "direct-messages" : route.destinationID;
+    const routeTargetLabel = route.routeKind === "dm" ? describeRunnerRouteTargetLabel(route) : route.destinationLabel;
+    if (!runnerStateSelectorMatchesRoute(routeKey.destinationSelector, routeTargetID, routeTargetLabel)) {
+      return false;
+    }
+    return true;
+  });
+}
 
 function configuredRunnerRouteKeys(runnerConfig) {
   return new Set(
@@ -2979,10 +3011,10 @@ function normalizeBotRunnerRequests(rawRequests, nowMs = Date.now()) {
           source_bot_username: entry.source_message_bot_username || entry.sourceMessageBotUsername,
         }
       : {};
-    const normalizedSourceMessageEnvelope = normalizeRunnerTelegramMessageEnvelope({
-      ...safeObject(
-        normalizeRunnerTelegramMessageEnvelope(
-          entry.source_message_envelope
+    const normalizedSourceMessageEnvelope = normalizeRunnerTelegramMessageEnvelope({
+      ...safeObject(
+        normalizeRunnerTelegramMessageEnvelope(
+          entry.source_message_envelope
           || entry.sourceMessageEnvelope
           || fallbackSourceMessageEnvelope,
         ),
@@ -3028,10 +3060,155 @@ function normalizeBotRunnerRequests(rawRequests, nowMs = Date.now()) {
       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,
-      ]),
-    });
+        entry.source_message_bot_username,
+        entry.sourceMessageBotUsername,
+      ]),
+    });
+    const normalizedRootSourceMessageEnvelope = normalizeRunnerTelegramMessageEnvelope({
+      ...safeObject(
+        normalizeRunnerTelegramMessageEnvelope(
+          entry.root_source_message_envelope
+          || entry.rootSourceMessageEnvelope
+          || normalizedSourceMessageEnvelope,
+        ),
+      ),
+      chat_id: firstNonEmptyString([
+        safeObject(entry.root_source_message_envelope || entry.rootSourceMessageEnvelope).chat_id,
+        safeObject(entry.root_source_message_envelope || entry.rootSourceMessageEnvelope).chatID,
+        normalizedSourceMessageEnvelope.chat_id,
+        entry.chat_id,
+        entry.chatID,
+      ]),
+      message_id: intFromRawAllowZero(
+        safeObject(entry.root_source_message_envelope || entry.rootSourceMessageEnvelope).message_id
+        || safeObject(entry.root_source_message_envelope || entry.rootSourceMessageEnvelope).messageID
+        || entry.root_source_message_id
+        || entry.rootSourceMessageID
+        || entry.source_message_id
+        || entry.sourceMessageID,
+        0,
+      ) || undefined,
+      message_thread_id: intFromRawAllowZero(
+        safeObject(entry.root_source_message_envelope || entry.rootSourceMessageEnvelope).message_thread_id
+        || safeObject(entry.root_source_message_envelope || entry.rootSourceMessageEnvelope).messageThreadID
+        || entry.root_source_message_thread_id
+        || entry.rootSourceMessageThreadID
+        || entry.source_message_thread_id
+        || entry.sourceMessageThreadID,
+        0,
+      ) || undefined,
+      body: firstNonEmptyString([
+        safeObject(entry.root_source_message_envelope || entry.rootSourceMessageEnvelope).body,
+        safeObject(entry.root_source_message_envelope || entry.rootSourceMessageEnvelope).text,
+        entry.root_source_message_body,
+        entry.rootSourceMessageBody,
+        entry.source_message_body,
+        entry.sourceMessageBody,
+        normalizedSourceMessageEnvelope.body,
+      ]),
+      source_origin: firstNonEmptyString([
+        safeObject(entry.root_source_message_envelope || entry.rootSourceMessageEnvelope).source_origin,
+        safeObject(entry.root_source_message_envelope || entry.rootSourceMessageEnvelope).sourceOrigin,
+        entry.root_source_message_origin,
+        entry.rootSourceMessageOrigin,
+        entry.source_message_origin,
+        entry.sourceMessageOrigin,
+        normalizedSourceMessageEnvelope.source_origin,
+      ]),
+      source_route_key: firstNonEmptyString([
+        safeObject(entry.root_source_message_envelope || entry.rootSourceMessageEnvelope).source_route_key,
+        safeObject(entry.root_source_message_envelope || entry.rootSourceMessageEnvelope).sourceRouteKey,
+        entry.root_source_message_route_key,
+        entry.rootSourceMessageRouteKey,
+        entry.source_message_route_key,
+        entry.sourceMessageRouteKey,
+        normalizedSourceMessageEnvelope.source_route_key,
+      ]),
+      source_bot_username: firstNonEmptyString([
+        safeObject(entry.root_source_message_envelope || entry.rootSourceMessageEnvelope).source_bot_username,
+        safeObject(entry.root_source_message_envelope || entry.rootSourceMessageEnvelope).sourceBotUsername,
+        entry.root_source_message_bot_username,
+        entry.rootSourceMessageBotUsername,
+        entry.source_message_bot_username,
+        entry.sourceMessageBotUsername,
+        normalizedSourceMessageEnvelope.source_bot_username,
+      ]),
+    });
+    const normalizedCurrentSourceMessageEnvelope = normalizeRunnerTelegramMessageEnvelope({
+      ...safeObject(
+        normalizeRunnerTelegramMessageEnvelope(
+          entry.current_source_message_envelope
+          || entry.currentSourceMessageEnvelope
+          || normalizedSourceMessageEnvelope,
+        ),
+      ),
+      chat_id: firstNonEmptyString([
+        safeObject(entry.current_source_message_envelope || entry.currentSourceMessageEnvelope).chat_id,
+        safeObject(entry.current_source_message_envelope || entry.currentSourceMessageEnvelope).chatID,
+        normalizedSourceMessageEnvelope.chat_id,
+        entry.chat_id,
+        entry.chatID,
+      ]),
+      message_id: intFromRawAllowZero(
+        safeObject(entry.current_source_message_envelope || entry.currentSourceMessageEnvelope).message_id
+        || safeObject(entry.current_source_message_envelope || entry.currentSourceMessageEnvelope).messageID
+        || entry.current_source_message_id
+        || entry.currentSourceMessageID
+        || entry.last_source_message_id
+        || entry.lastSourceMessageID
+        || normalizedSourceMessageEnvelope.message_id,
+        0,
+      ) || undefined,
+      message_thread_id: intFromRawAllowZero(
+        safeObject(entry.current_source_message_envelope || entry.currentSourceMessageEnvelope).message_thread_id
+        || safeObject(entry.current_source_message_envelope || entry.currentSourceMessageEnvelope).messageThreadID
+        || entry.current_source_message_thread_id
+        || entry.currentSourceMessageThreadID
+        || entry.last_source_message_thread_id
+        || entry.lastSourceMessageThreadID
+        || normalizedSourceMessageEnvelope.message_thread_id,
+        0,
+      ) || undefined,
+      body: firstNonEmptyString([
+        safeObject(entry.current_source_message_envelope || entry.currentSourceMessageEnvelope).body,
+        safeObject(entry.current_source_message_envelope || entry.currentSourceMessageEnvelope).text,
+        entry.current_source_message_body,
+        entry.currentSourceMessageBody,
+        entry.source_message_body,
+        entry.sourceMessageBody,
+        normalizedSourceMessageEnvelope.body,
+      ]),
+      source_origin: firstNonEmptyString([
+        safeObject(entry.current_source_message_envelope || entry.currentSourceMessageEnvelope).source_origin,
+        safeObject(entry.current_source_message_envelope || entry.currentSourceMessageEnvelope).sourceOrigin,
+        entry.current_source_message_origin,
+        entry.currentSourceMessageOrigin,
+        entry.source_message_origin,
+        entry.sourceMessageOrigin,
+        normalizedSourceMessageEnvelope.source_origin,
+      ]),
+      source_route_key: firstNonEmptyString([
+        safeObject(entry.current_source_message_envelope || entry.currentSourceMessageEnvelope).source_route_key,
+        safeObject(entry.current_source_message_envelope || entry.currentSourceMessageEnvelope).sourceRouteKey,
+        entry.current_source_message_route_key,
+        entry.currentSourceMessageRouteKey,
+        entry.source_message_route_key,
+        entry.sourceMessageRouteKey,
+        normalizedSourceMessageEnvelope.source_route_key,
+      ]),
+      source_bot_username: firstNonEmptyString([
+        safeObject(entry.current_source_message_envelope || entry.currentSourceMessageEnvelope).source_bot_username,
+        safeObject(entry.current_source_message_envelope || entry.currentSourceMessageEnvelope).sourceBotUsername,
+        entry.current_source_message_bot_username,
+        entry.currentSourceMessageBotUsername,
+        entry.source_message_bot_username,
+        entry.sourceMessageBotUsername,
+        normalizedSourceMessageEnvelope.source_bot_username,
+      ]),
+    });
+    const normalizedReplyChainContext = normalizeRunnerReplyChainContext(
+      entry.reply_chain_context || entry.replyChainContext,
+    );
     normalized[requestKey] = {
       request_key: requestKey,
       project_id: String(entry.project_id || entry.projectID || "").trim(),
@@ -3075,16 +3252,108 @@ function normalizeBotRunnerRequests(rawRequests, nowMs = Date.now()) {
         || 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),
+      source_message_bot_username: normalizeTelegramMentionUsername(
+        entry.source_message_bot_username
+        || entry.sourceMessageBotUsername
+        || normalizedSourceMessageEnvelope.source_bot_username,
+      ),
+      source_message_envelope: normalizedSourceMessageEnvelope,
+      root_source_message_id: intFromRawAllowZero(
+        entry.root_source_message_id
+        || entry.rootSourceMessageID
+        || entry.source_message_id
+        || entry.sourceMessageID
+        || normalizedRootSourceMessageEnvelope.message_id,
+        0,
+      ) || undefined,
+      root_source_message_thread_id: intFromRawAllowZero(
+        entry.root_source_message_thread_id
+        || entry.rootSourceMessageThreadID
+        || entry.source_message_thread_id
+        || entry.sourceMessageThreadID
+        || normalizedRootSourceMessageEnvelope.message_thread_id,
+        0,
+      ) || undefined,
+      root_source_message_body: firstNonEmptyString([
+        entry.root_source_message_body,
+        entry.rootSourceMessageBody,
+        entry.source_message_body,
+        entry.sourceMessageBody,
+        normalizedRootSourceMessageEnvelope.body,
+      ]),
+      root_source_message_origin: String(
+        entry.root_source_message_origin
+        || entry.rootSourceMessageOrigin
+        || entry.source_message_origin
+        || entry.sourceMessageOrigin
+        || normalizedRootSourceMessageEnvelope.source_origin
+        || "",
+      ).trim().toLowerCase(),
+      root_source_message_route_key: String(
+        entry.root_source_message_route_key
+        || entry.rootSourceMessageRouteKey
+        || entry.source_message_route_key
+        || entry.sourceMessageRouteKey
+        || normalizedRootSourceMessageEnvelope.source_route_key
+        || "",
+      ).trim(),
+      root_source_message_bot_username: normalizeTelegramMentionUsername(
+        entry.root_source_message_bot_username
+        || entry.rootSourceMessageBotUsername
+        || entry.source_message_bot_username
+        || entry.sourceMessageBotUsername
+        || normalizedRootSourceMessageEnvelope.source_bot_username,
+      ),
+      root_source_message_envelope: normalizedRootSourceMessageEnvelope,
+      current_source_message_id: intFromRawAllowZero(
+        entry.current_source_message_id
+        || entry.currentSourceMessageID
+        || entry.last_source_message_id
+        || entry.lastSourceMessageID
+        || normalizedCurrentSourceMessageEnvelope.message_id,
+        0,
+      ) || undefined,
+      current_source_message_thread_id: intFromRawAllowZero(
+        entry.current_source_message_thread_id
+        || entry.currentSourceMessageThreadID
+        || entry.last_source_message_thread_id
+        || entry.lastSourceMessageThreadID
+        || normalizedCurrentSourceMessageEnvelope.message_thread_id,
+        0,
+      ) || undefined,
+      current_source_message_body: firstNonEmptyString([
+        entry.current_source_message_body,
+        entry.currentSourceMessageBody,
+        normalizedCurrentSourceMessageEnvelope.body,
+      ]),
+      current_source_message_origin: String(
+        entry.current_source_message_origin
+        || entry.currentSourceMessageOrigin
+        || normalizedCurrentSourceMessageEnvelope.source_origin
+        || "",
+      ).trim().toLowerCase(),
+      current_source_message_route_key: String(
+        entry.current_source_message_route_key
+        || entry.currentSourceMessageRouteKey
+        || normalizedCurrentSourceMessageEnvelope.source_route_key
+        || "",
+      ).trim(),
+      current_source_message_bot_username: normalizeTelegramMentionUsername(
+        entry.current_source_message_bot_username
+        || entry.currentSourceMessageBotUsername
+        || normalizedCurrentSourceMessageEnvelope.source_bot_username,
+      ),
+      current_source_message_envelope: normalizedCurrentSourceMessageEnvelope,
+      current_turn_relation: String(
+        entry.current_turn_relation
+        || entry.currentTurnRelation
+        || normalizedReplyChainContext.current_turn_relation
+        || "",
+      ).trim(),
+      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: normalizedReplyChainContext,
       selected_bot_usernames: ensureArray(entry.selected_bot_usernames || entry.selectedBotUsernames)
         .map((value) => normalizeTelegramMentionUsername(value))
         .filter(Boolean),
@@ -3095,12 +3364,25 @@ function normalizeBotRunnerRequests(rawRequests, nowMs = Date.now()) {
           entry.authoritative_decision_bundle || entry.authoritativeDecisionBundle,
         )
         : {},
+      last_reply_decision_bundle: Object.keys(
+        safeObject(entry.last_reply_decision_bundle || entry.lastReplyDecisionBundle),
+      ).length
+        ? normalizeRunnerConversationDecisionBundle(
+          entry.last_reply_decision_bundle || entry.lastReplyDecisionBundle,
+        )
+        : {},
       decision_bundle_validation_status: String(
         entry.decision_bundle_validation_status || entry.decisionBundleValidationStatus || "",
       ).trim().toLowerCase(),
       decision_bundle_validation_reason: String(
         entry.decision_bundle_validation_reason || entry.decisionBundleValidationReason || "",
       ).trim(),
+      last_reply_decision_bundle_validation_status: String(
+        entry.last_reply_decision_bundle_validation_status || entry.lastReplyDecisionBundleValidationStatus || "",
+      ).trim().toLowerCase(),
+      last_reply_decision_bundle_validation_reason: String(
+        entry.last_reply_decision_bundle_validation_reason || entry.lastReplyDecisionBundleValidationReason || "",
+      ).trim(),
       conversation_allowed_responders: ensureArray(entry.conversation_allowed_responders || entry.conversationAllowedResponders)
         .map((value) => normalizeTelegramMentionUsername(value))
         .filter(Boolean),
@@ -3602,7 +3884,7 @@ function findRunnerRequestsForScope(state, normalizedRoute, selectors = {}) {
     });
 }
 
-function findScopedConversationSessionState(state, normalizedRoute, conversationIDRaw = "") {
+function findScopedConversationSessionState(state, normalizedRoute, conversationIDRaw = "") {
   const conversationID = String(conversationIDRaw || "").trim();
   if (!conversationID) {
     return {};
@@ -3661,11 +3943,315 @@ function findScopedConversationSessionState(state, normalizedRoute, conversation
       }
       return String(left.routeKey || "").localeCompare(String(right.routeKey || ""));
     });
-  return safeObject(ranked[0]);
-}
-
-function sessionAllowsConversationResponder(sessionRaw, responderSelectorRaw = "") {
-  const session = safeObject(sessionRaw);
+  return safeObject(ranked[0]);
+}
+
+const DIRECT_MESSAGE_CONTINUATION_LOOKBACK_MS = 45 * 60 * 1000;
+
+function isPrivateTelegramChatID(chatIDRaw = "") {
+  const chatID = String(chatIDRaw || "").trim();
+  if (!chatID) return false;
+  const numeric = Number.parseInt(chatID, 10);
+  return Number.isFinite(numeric) && numeric > 0;
+}
+
+function isRunnerOpenDirectMessageSession(sessionRaw, {
+  chatID = "",
+  botUsername = "",
+  nowMs = Date.now(),
+} = {}) {
+  const session = safeObject(sessionRaw);
+  if (String(session.mode || "").trim().toLowerCase() !== "direct_single_bot") {
+    return false;
+  }
+  if (String(session.status || "").trim().toLowerCase() !== "open") {
+    return false;
+  }
+  const normalizedChatID = String(chatID || "").trim();
+  if (normalizedChatID && String(session.chat_id || "").trim() !== normalizedChatID) {
+    return false;
+  }
+  const normalizedBotUsername = normalizeTelegramMentionUsername(botUsername);
+  if (
+    normalizedBotUsername
+    && normalizeTelegramMentionUsername(session.bot_username) !== normalizedBotUsername
+  ) {
+    return false;
+  }
+  const expiresAtMs = Date.parse(String(session.expires_at || "").trim());
+  if (Number.isFinite(expiresAtMs) && expiresAtMs > 0 && expiresAtMs <= nowMs) {
+    return false;
+  }
+  return true;
+}
+
+function findRunnerDirectMessageSessionCandidate({
+  state,
+  normalizedRoute,
+  routeKey = "",
+  chatID = "",
+  botUsername = "",
+  nowMs = Date.now(),
+}) {
+  const resolvedRouteKey = String(routeKey || runnerRouteKey(normalizedRoute)).trim();
+  if (!resolvedRouteKey || !isPrivateTelegramChatID(chatID)) {
+    return {};
+  }
+  const routeState = safeObject(safeObject(state?.routes)[resolvedRouteKey]);
+  const ranked = Object.entries(safeObject(routeState.conversation_sessions))
+    .map(([conversationID, sessionRaw]) => ({
+      conversationID: String(conversationID || "").trim(),
+      session: safeObject(sessionRaw),
+    }))
+    .filter((candidate) => candidate.conversationID)
+    .filter((candidate) => isRunnerOpenDirectMessageSession(candidate.session, {
+      chatID,
+      botUsername,
+      nowMs,
+    }))
+    .sort((left, right) => {
+      const leftActivity = firstNonEmptyString([
+        left.session.last_activity_at,
+        left.session.updated_at,
+        left.session.started_at,
+      ]);
+      const rightActivity = firstNonEmptyString([
+        right.session.last_activity_at,
+        right.session.updated_at,
+        right.session.started_at,
+      ]);
+      if (leftActivity && rightActivity && leftActivity !== rightActivity) {
+        return leftActivity < rightActivity ? 1 : -1;
+      }
+      return String(left.conversationID || "").localeCompare(String(right.conversationID || ""));
+    });
+  return safeObject(ranked[0]);
+}
+
+function isRunnerDirectMessageContinuationRequestCandidate(entryRaw, {
+  routeKey = "",
+  chatID = "",
+  botUsername = "",
+  nowMs = Date.now(),
+} = {}) {
+  const entry = safeObject(entryRaw);
+  const normalizedChatID = String(chatID || "").trim();
+  if (!normalizedChatID || String(entry.chat_id || "").trim() !== normalizedChatID) {
+    return false;
+  }
+  const normalizedRouteKey = String(routeKey || "").trim();
+  if (normalizedRouteKey) {
+    const entryRouteKey = firstNonEmptyString([
+      entry.claimed_by_route,
+      entry.source_message_route_key,
+      safeObject(entry.source_message_envelope).source_route_key,
+    ]);
+    if (entryRouteKey && entryRouteKey !== normalizedRouteKey) {
+      return false;
+    }
+  }
+  const normalizedBotUsername = normalizeTelegramMentionUsername(botUsername);
+  if (normalizedBotUsername) {
+    const entryBotUsername = normalizeTelegramMentionUsername(
+      entry.source_message_bot_username
+        || safeObject(entry.source_message_envelope).source_bot_username,
+    );
+    if (entryBotUsername && entryBotUsername !== normalizedBotUsername) {
+      return false;
+    }
+  }
+  const updatedAt = firstNonEmptyString([
+    entry.updated_at,
+    entry.completed_at,
+    entry.closed_at,
+    entry.claimed_at,
+  ]);
+  const updatedAtMs = Date.parse(updatedAt);
+  return !Number.isFinite(updatedAtMs) || nowMs - updatedAtMs <= DIRECT_MESSAGE_CONTINUATION_LOOKBACK_MS;
+}
+
+function sortRunnerDirectMessageContinuationCandidates(entries = []) {
+  return ensureArray(entries).slice().sort((leftRaw, rightRaw) => {
+    const left = safeObject(leftRaw);
+    const right = safeObject(rightRaw);
+    const leftStatus = normalizeRunnerRequestStatus(left.status);
+    const rightStatus = normalizeRunnerRequestStatus(right.status);
+    const leftActive = isActiveRunnerRequestStatus(leftStatus);
+    const rightActive = isActiveRunnerRequestStatus(rightStatus);
+    if (leftActive !== rightActive) {
+      return leftActive ? -1 : 1;
+    }
+    const leftTime = firstNonEmptyString([left.updated_at, left.completed_at, left.closed_at, left.claimed_at]);
+    const rightTime = firstNonEmptyString([right.updated_at, right.completed_at, right.closed_at, right.claimed_at]);
+    if (leftTime && rightTime && leftTime !== rightTime) {
+      return leftTime < rightTime ? 1 : -1;
+    }
+    return String(left.request_key || "").localeCompare(String(right.request_key || ""));
+  });
+}
+
+function findRunnerDirectMessageContinuationSourceRequest({
+  state,
+  normalizedRoute,
+  routeKey = "",
+  routeState = {},
+  chatID = "",
+  botUsername = "",
+  nowMs = Date.now(),
+}) {
+  const normalizedChatID = String(chatID || "").trim();
+  if (!isPrivateTelegramChatID(normalizedChatID)) {
+    return null;
+  }
+  const requestsByKey = normalizeBotRunnerRequests(safeObject(state).requests, nowMs);
+  const resolvedRouteKey = String(routeKey || runnerRouteKey(normalizedRoute)).trim();
+  const currentRouteState = safeObject(routeState);
+  const resolveCandidateByKey = (requestKeyRaw = "") => {
+    const requestKey = String(requestKeyRaw || "").trim();
+    if (!requestKey) return null;
+    const candidate = safeObject(requestsByKey[requestKey]);
+    return candidate.request_key && isRunnerDirectMessageContinuationRequestCandidate(candidate, {
+      routeKey: resolvedRouteKey,
+      chatID: normalizedChatID,
+      botUsername,
+      nowMs,
+    })
+      ? candidate
+      : null;
+  };
+  const activeRequestCandidate = resolveCandidateByKey(currentRouteState.active_request_key);
+  if (activeRequestCandidate?.request_key) {
+    return activeRequestCandidate;
+  }
+  const sessionCandidate = findRunnerDirectMessageSessionCandidate({
+    state,
+    normalizedRoute,
+    routeKey: resolvedRouteKey,
+    chatID: normalizedChatID,
+    botUsername,
+    nowMs,
+  });
+  const sessionRequestCandidate = resolveCandidateByKey(safeObject(sessionCandidate.session).request_key);
+  if (sessionRequestCandidate?.request_key) {
+    return sessionRequestCandidate;
+  }
+  const lastRequestCandidate = resolveCandidateByKey(currentRouteState.last_request_key);
+  if (lastRequestCandidate?.request_key) {
+    return lastRequestCandidate;
+  }
+  const scopedCandidates = sortRunnerDirectMessageContinuationCandidates(
+    findRunnerRequestsForScope(state, normalizedRoute, { chatID: normalizedChatID })
+      .filter((entry) => isRunnerDirectMessageContinuationRequestCandidate(entry, {
+        routeKey: resolvedRouteKey,
+        chatID: normalizedChatID,
+        botUsername,
+        nowMs,
+      })),
+  );
+  return safeObject(scopedCandidates[0]).request_key ? safeObject(scopedCandidates[0]) : null;
+}
+
+function isRunnerDirectMessageRestartMessage(selectedRecordRaw) {
+  const parsed = safeObject(safeObject(selectedRecordRaw).parsedArchive);
+  if (!isPrivateTelegramChatID(String(parsed.chatID || parsed.chatId || "").trim())) {
+    return false;
+  }
+  const body = String(parsed.body || "").trim();
+  if (!body) {
+    return false;
+  }
+  return /^\/start(?:@[A-Za-z0-9_]+)?(?:\s|$)/i.test(body);
+}
+
+function closeRunnerDirectMessageScopedActiveRequests({
+  state,
+  normalizedRoute,
+  routeKey = "",
+  chatID = "",
+  botUsername = "",
+  excludeRequestKey = "",
+  closedReason = "direct_message_restart",
+  nowISO = new Date().toISOString(),
+}) {
+  const normalizedChatID = String(chatID || "").trim();
+  if (!isPrivateTelegramChatID(normalizedChatID)) {
+    return {
+      requests: normalizeBotRunnerRequests(safeObject(state).requests),
+      closedRequestKeys: [],
+    };
+  }
+  const requests = normalizeBotRunnerRequests(safeObject(state).requests);
+  const projectID = String(normalizedRoute?.projectID || "").trim();
+  const provider = String(normalizedRoute?.provider || "").trim();
+  const normalizedExcludeRequestKey = String(excludeRequestKey || "").trim();
+  const normalizedRouteKey = String(routeKey || "").trim();
+  const normalizedBotUsername = normalizeTelegramMentionUsername(botUsername);
+  const scopedActiveRequests = sortRunnerDirectMessageContinuationCandidates(
+    Object.values(requests).filter((entryRaw) => {
+      const entry = safeObject(entryRaw);
+      const requestKey = String(entry.request_key || "").trim();
+      if (!requestKey || requestKey === normalizedExcludeRequestKey) {
+        return false;
+      }
+      if (!isActiveRunnerRequestStatus(entry.status)) {
+        return false;
+      }
+      if (projectID && String(entry.project_id || "").trim() !== projectID) {
+        return false;
+      }
+      if (provider && String(entry.provider || "").trim() !== provider) {
+        return false;
+      }
+      if (String(entry.chat_id || "").trim() !== normalizedChatID) {
+        return false;
+      }
+      if (normalizedRouteKey) {
+        const entryRouteKey = firstNonEmptyString([
+          entry.claimed_by_route,
+          entry.source_message_route_key,
+          safeObject(entry.source_message_envelope).source_route_key,
+        ]);
+        if (entryRouteKey && entryRouteKey !== normalizedRouteKey) {
+          return false;
+        }
+      }
+      if (normalizedBotUsername) {
+        const entryBotCandidates = uniqueOrderedStrings([
+          entry.source_message_bot_username,
+          safeObject(entry.source_message_envelope).source_bot_username,
+          ...ensureArray(entry.selected_bot_usernames),
+        ], normalizeTelegramMentionUsername);
+        if (entryBotCandidates.length > 0 && !entryBotCandidates.includes(normalizedBotUsername)) {
+          return false;
+        }
+      }
+      return true;
+    }),
+  );
+  const closedRequestKeys = [];
+  for (const requestRaw of scopedActiveRequests) {
+    const request = safeObject(requestRaw);
+    const requestKey = String(request.request_key || "").trim();
+    if (!requestKey) {
+      continue;
+    }
+    requests[requestKey] = {
+      ...request,
+      status: "closed",
+      closed_reason: closedReason,
+      closed_at: nowISO,
+      updated_at: nowISO,
+    };
+    closedRequestKeys.push(requestKey);
+  }
+  return {
+    requests,
+    closedRequestKeys,
+  };
+}
+
+function sessionAllowsConversationResponder(sessionRaw, responderSelectorRaw = "") {
+  const session = safeObject(sessionRaw);
   const responderSelector = normalizeTelegramMentionUsername(responderSelectorRaw);
   if (!responderSelector) {
     return false;
@@ -3871,21 +4457,42 @@ function runnerRequestAuthoritativeDecisionBundle(entryRaw) {
   return validation.ok ? safeObject(validation.bundle) : {};
 }
 
+function runnerDecisionBundleDecisionType(bundleRaw) {
+  return String(
+    safeObject(bundleRaw).decision_type || safeObject(bundleRaw).decisionType || "",
+  ).trim().toLowerCase();
+}
+
+function runnerDecisionBundleIsRootHumanOpening(bundleRaw) {
+  return runnerDecisionBundleDecisionType(bundleRaw) === "human_opening";
+}
+
 function runnerRequestPreferredExecutionContractType(entryRaw) {
   const entry = safeObject(entryRaw);
   const decisionBundle = runnerRequestAuthoritativeDecisionBundle(entry);
+  const authoritativeExecutionContractType = String(
+    decisionBundle.execution_contract_type || "",
+  ).trim().toLowerCase();
   return String(
-    decisionBundle.execution_contract_type
+    authoritativeExecutionContractType
       || entry.execution_contract_type
       || entry.root_execution_contract_type
       || "",
   ).trim().toLowerCase();
 }
-
+
 function runnerRequestPreferredExecutionContractActionable(entryRaw) {
   const entry = safeObject(entryRaw);
   const decisionBundle = runnerRequestAuthoritativeDecisionBundle(entry);
-  return decisionBundle.execution_contract_actionable === true || entry.execution_contract_actionable === true;
+  const hasAuthoritativeExecutionContract = Boolean(
+    String(decisionBundle.execution_contract_type || "").trim()
+    || ensureArray(decisionBundle.execution_contract_targets).length
+    || ensureArray(decisionBundle.next_expected_responders).length,
+  );
+  if (hasAuthoritativeExecutionContract) {
+    return decisionBundle.execution_contract_actionable === true;
+  }
+  return entry.execution_contract_actionable === true;
 }
 
 function runnerRequestPreferredExecutionContractTargets(entryRaw) {
@@ -3895,14 +4502,14 @@ function runnerRequestPreferredExecutionContractTargets(entryRaw) {
     ensureArray(decisionBundle.execution_contract_targets).length
       ? decisionBundle.execution_contract_targets
       : ensureArray(entry.execution_contract_targets).length
-      ? entry.execution_contract_targets
-      : ensureArray(entry.root_execution_contract_targets).length
-        ? entry.root_execution_contract_targets
-        : [],
+        ? entry.execution_contract_targets
+        : ensureArray(entry.root_execution_contract_targets).length
+          ? entry.root_execution_contract_targets
+          : [],
     normalizeTelegramMentionUsername,
   );
 }
-
+
 function runnerRequestPreferredNextExpectedResponders(entryRaw) {
   const entry = safeObject(entryRaw);
   const decisionBundle = runnerRequestAuthoritativeDecisionBundle(entry);
@@ -3910,32 +4517,38 @@ function runnerRequestPreferredNextExpectedResponders(entryRaw) {
     ensureArray(decisionBundle.next_expected_responders).length
       ? decisionBundle.next_expected_responders
       : ensureArray(entry.next_expected_responders).length
-      ? entry.next_expected_responders
-      : ensureArray(entry.root_next_expected_responders).length
-        ? entry.root_next_expected_responders
-        : [],
+        ? entry.next_expected_responders
+        : ensureArray(entry.root_next_expected_responders).length
+          ? entry.root_next_expected_responders
+          : [],
     normalizeTelegramMentionUsername,
   );
 }
-
+
 function runnerRequestPreferredAuthoritySelectedBotUsernames(entryRaw) {
   const entry = safeObject(entryRaw);
+  const decisionBundle = runnerRequestAuthoritativeDecisionBundle(entry);
+  const hasAuthoritativeDecisionBundle = Object.keys(decisionBundle).length > 0;
   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,
-  );
-}
+    runnerRequestPreferredNextExpectedResponders(entry).length
+      ? runnerRequestPreferredNextExpectedResponders(entry)
+      : runnerRequestPreferredExecutionContractTargets(entry).length
+        ? runnerRequestPreferredExecutionContractTargets(entry)
+        : hasAuthoritativeDecisionBundle && ensureArray(decisionBundle.selected_bot_usernames).length
+          ? decisionBundle.selected_bot_usernames
+          : hasAuthoritativeDecisionBundle && ensureArray(decisionBundle.initial_responders).length
+            ? decisionBundle.initial_responders
+            : 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);
@@ -3956,6 +4569,8 @@ function runnerRequestAllowsSharedHumanClaimTakeover({
   canonicalHumanMessageKey = "",
 }) {
   const entry = safeObject(entryRaw);
+  const decisionBundle = runnerRequestAuthoritativeDecisionBundle(entry);
+  const hasAuthoritativeDecisionBundle = Object.keys(decisionBundle).length > 0;
   const normalizedCurrentBotUsername = normalizeTelegramMentionUsername(currentBotUsername);
   const normalizedCanonicalHumanMessageKey = String(canonicalHumanMessageKey || "").trim();
   if (!normalizedCurrentBotUsername || !normalizedCanonicalHumanMessageKey) {
@@ -3969,11 +4584,17 @@ function runnerRequestAllowsSharedHumanClaimTakeover({
     return pendingResponders.includes(normalizedCurrentBotUsername);
   }
   const directHumanResponders = uniqueOrderedStrings(
-    [
-      ...ensureArray(entry.selected_bot_usernames),
-      ...ensureArray(entry.conversation_initial_responders),
-      ...ensureArray(entry.conversation_allowed_responders),
-    ],
+    hasAuthoritativeDecisionBundle
+      ? [
+        ...ensureArray(decisionBundle.selected_bot_usernames),
+        ...ensureArray(decisionBundle.initial_responders),
+        ...ensureArray(decisionBundle.allowed_responders),
+      ]
+      : [
+        ...ensureArray(entry.selected_bot_usernames),
+        ...ensureArray(entry.conversation_initial_responders),
+        ...ensureArray(entry.conversation_allowed_responders),
+      ],
     normalizeTelegramMentionUsername,
   );
   return directHumanResponders.includes(normalizedCurrentBotUsername);
@@ -4715,10 +5336,10 @@ function resolveRunnerReplyChainConversationContext(state, normalizedRoute, sele
   };
 }
 
-async function resolveRunnerReplyChainConversationContextWithServerFallback({
-  state,
-  normalizedRoute,
-  selectedRecord,
+async function resolveRunnerReplyChainConversationContextWithServerFallback({
+  state,
+  normalizedRoute,
+  selectedRecord,
   runtime,
   archiveThreadID = "",
   hydrationAttempted = false,
@@ -4733,14 +5354,70 @@ async function resolveRunnerReplyChainConversationContextWithServerFallback({
     };
   }
   const parsed = safeObject(selectedRecord?.parsedArchive);
-  const initialReplyToMessageID = intFromRawAllowZero(
-    parsed.replyToMessageID || safeObject(initialContext).replyToMessageID,
-    0,
-  );
-  if (initialReplyToMessageID <= 0) {
-    return {
-      state: initialState,
-      replyChainContext: initialContext,
+  const initialReplyToMessageID = intFromRawAllowZero(
+    parsed.replyToMessageID || safeObject(initialContext).replyToMessageID,
+    0,
+  );
+  const routeKey = runnerRouteKey(normalizedRoute);
+  const routeStateForLookup = safeObject(safeObject(initialState.routes)[routeKey]);
+  const currentBotUsername = normalizeTelegramMentionUsername(
+    normalizedRoute?.botName
+      || normalizedRoute?.bot_name
+      || normalizedRoute?.serverBotName
+      || normalizedRoute?.server_bot_name,
+  );
+  if (initialReplyToMessageID <= 0) {
+    const directMessageContinuationRequest = findRunnerDirectMessageContinuationSourceRequest({
+      state: initialState,
+      normalizedRoute,
+      routeKey,
+      routeState: routeStateForLookup,
+      chatID: String(parsed.chatID || parsed.chatId || "").trim(),
+      botUsername: currentBotUsername,
+    });
+    if (safeObject(directMessageContinuationRequest).request_key) {
+      const referencedRequest = safeObject(directMessageContinuationRequest);
+      const anchorMessageID = intFromRawAllowZero(referencedRequest.source_message_id, 0)
+        || intFromRawAllowZero(parsed.messageID, 0);
+      return {
+        state: initialState,
+        replyChainContext: {
+          conversationID: String(referencedRequest.conversation_id || "").trim()
+            || buildSyntheticReplyChainConversationID(
+              normalizedRoute,
+              String(parsed.chatID || parsed.chatId || "").trim(),
+              anchorMessageID,
+            ),
+          replyToMessageID: 0,
+          anchorMessageID,
+          reason: "direct_message_continuation_request",
+          referencedRequest,
+        },
+        hydrated: false,
+      };
+    }
+    if (!hydrationAttempted && runtime?.baseURL && runtime?.token) {
+      const hydratedState = await hydrateRunnerRequestLedgerFromServer({
+        normalizedRoute,
+        runtime,
+      });
+      const hydratedResolution = await resolveRunnerReplyChainConversationContextWithServerFallback({
+        state: hydratedState,
+        normalizedRoute,
+        selectedRecord,
+        runtime,
+        archiveThreadID,
+        hydrationAttempted: true,
+      });
+      return {
+        state: hydratedResolution.state,
+        replyChainContext: hydratedResolution.replyChainContext,
+        hydrated: true,
+      };
+    }
+    return {
+      state: initialState,
+      replyChainContext: initialContext,
       hydrated: false,
     };
   }
@@ -5070,7 +5747,27 @@ async function claimRunnerRequestForHumanComment({
       requests: backfilled.requests,
     };
   }
-  const currentMessageID = intFromRawAllowZero(parsed.messageID, 0);
+  const currentMessageID = intFromRawAllowZero(parsed.messageID, 0);
+  const normalizedAuthoritativeSourceMessageEnvelope = normalizeRunnerTelegramMessageEnvelope(
+    authoritativeSourceMessageEnvelope,
+  );
+  const currentClaimBotUsername = normalizeTelegramMentionUsername(
+    normalizedAuthoritativeSourceMessageEnvelope.source_bot_username
+      || normalizedAuthoritativeSourceMessageEnvelope.sender_username
+      || currentRouteState.last_source_bot_username
+      || currentRouteState.source_message_bot_username
+      || currentRouteState.last_speaker_bot_username,
+  );
+  const claimBotUsernameCandidates = uniqueOrderedStrings([
+    currentClaimBotUsername,
+    normalizedAuthoritativeSourceMessageEnvelope.source_bot_username,
+    normalizedAuthoritativeSourceMessageEnvelope.sender_username,
+    ...ensureArray(selectedBotUsernames),
+    ...ensureArray(normalizedSharedHumanIntent.participantSelectors),
+    currentRouteState.last_source_bot_username,
+    currentRouteState.source_message_bot_username,
+    currentRouteState.last_speaker_bot_username,
+  ], normalizeTelegramMentionUsername);
   let sharedConversationSource = currentMessageID > 0
     ? pickRunnerSharedConversationSourceRequest(
       findRunnerRequestsForMessageID(stateForClaim, normalizedRoute, {
@@ -5081,10 +5778,10 @@ async function claimRunnerRequestForHumanComment({
       provisionalRequestKey,
     )
     : {};
-  if (
-    !Object.keys(sharedConversationSource).length
-    && currentMessageID > 0
-    && runtime?.baseURL
+  if (
+    !Object.keys(sharedConversationSource).length
+    && currentMessageID > 0
+    && runtime?.baseURL
     && runtime?.token
   ) {
     sharedConversationSource = safeObject(await findServerRunnerConversationSourceRequestForMessageID({
@@ -5096,68 +5793,332 @@ async function claimRunnerRequestForHumanComment({
       excludeRequestKey: provisionalRequestKey,
     }));
   }
+  if (!Object.keys(sharedConversationSource).length) {
+    sharedConversationSource = safeObject(findRunnerDirectMessageContinuationSourceRequest({
+      state: stateForClaim,
+      normalizedRoute,
+      routeKey,
+      routeState: currentRouteState,
+      chatID: String(parsed.chatID || parsed.chatId || "").trim(),
+      botUsername: currentClaimBotUsername,
+    }));
+  }
   const authorityContext = resolveRunnerHumanCommentAuthorityContext({
     normalizedRoute,
     selectedRecord,
-    replyChainContext,
-    referencedRequest,
+    replyChainContext,
+    referencedRequest,
     sharedConversationSource,
     selectedBotUsernames,
-    normalizedSharedHumanIntent,
-    resolvedNormalizedIntent,
-  });
+    normalizedSharedHumanIntent,
+    resolvedNormalizedIntent,
+  });
+  const normalizedChatID = String(parsed.chatID || parsed.chatId || "").trim();
+  const isDirectMessageChat = isPrivateTelegramChatID(normalizedChatID);
+  const isDirectMessageRestart = isDirectMessageChat && isRunnerDirectMessageRestartMessage(selectedRecord);
+  const routeStateForClaim = safeObject(safeObject(stateForClaim.routes)[String(routeKey || "").trim()]);
+  const currentRouteStateForClaim = safeObject(
+    safeObject(currentState.routes)[String(routeKey || "").trim()],
+  );
+  const requestsForDirectMessageClaimLookup = normalizeBotRunnerRequests(stateForClaim.requests);
+  const currentRequestsForDirectMessageClaimLookup = normalizeBotRunnerRequests(currentState.requests);
+  const directMessageRouteActiveRequest = safeObject(
+    requestsForDirectMessageClaimLookup[String(routeStateForClaim.active_request_key || "").trim()],
+  );
+  const directMessageRouteLastRequest = safeObject(
+    requestsForDirectMessageClaimLookup[String(routeStateForClaim.last_request_key || "").trim()],
+  );
+  const currentDirectMessageRouteActiveRequest = safeObject(
+    currentRequestsForDirectMessageClaimLookup[String(currentRouteStateForClaim.active_request_key || "").trim()],
+  );
+  const currentDirectMessageRouteLastRequest = safeObject(
+    currentRequestsForDirectMessageClaimLookup[String(currentRouteStateForClaim.last_request_key || "").trim()],
+  );
+  const directMessageRestartRequestKeysToClose = new Set();
+  if (isDirectMessageRestart) {
+    const closeBotUsername = firstNonEmptyString(claimBotUsernameCandidates);
+    const closedActiveDirectMessageRequests = closeRunnerDirectMessageScopedActiveRequests({
+      state: stateForClaim,
+      normalizedRoute,
+      routeKey,
+      chatID: normalizedChatID,
+      botUsername: closeBotUsername,
+    });
+    stateForClaim = {
+      ...stateForClaim,
+      requests: closedActiveDirectMessageRequests.requests,
+    };
+    for (const requestKeyRaw of ensureArray(closedActiveDirectMessageRequests.closedRequestKeys)) {
+      const requestKey = String(requestKeyRaw || "").trim();
+      if (requestKey) {
+        directMessageRestartRequestKeysToClose.add(requestKey);
+      }
+    }
+    const restartRequests = normalizeBotRunnerRequests(stateForClaim.requests);
+    for (const directMessageRequest of [
+      directMessageRouteActiveRequest,
+      directMessageRouteLastRequest,
+      currentDirectMessageRouteActiveRequest,
+      currentDirectMessageRouteLastRequest,
+    ]) {
+      const requestKey = String(safeObject(directMessageRequest).request_key || "").trim();
+      if (!requestKey) {
+        continue;
+      }
+      directMessageRestartRequestKeysToClose.add(requestKey);
+      const existingDirectMessageRequest = safeObject(restartRequests[requestKey]);
+      if (
+        !String(existingDirectMessageRequest.request_key || "").trim()
+        || !isActiveRunnerRequestStatus(existingDirectMessageRequest.status)
+        || String(existingDirectMessageRequest.chat_id || "").trim() !== normalizedChatID
+      ) {
+        continue;
+      }
+      restartRequests[requestKey] = {
+        ...existingDirectMessageRequest,
+        status: "closed",
+        closed_reason: "direct_message_restart",
+        closed_at: new Date().toISOString(),
+        updated_at: new Date().toISOString(),
+      };
+    }
+    stateForClaim = {
+      ...stateForClaim,
+      requests: restartRequests,
+    };
+  }
   const authoritySource = safeObject(authorityContext.authoritySource);
-  const decisionBundleValidation = validateRunnerConversationDecisionBundle(decisionBundle);
-  if (
-    Object.keys(safeObject(decisionBundle)).length > 0
-    && decisionBundleValidation.ok !== true
-  ) {
+  const effectiveAuthoritySource = isDirectMessageRestart ? {} : authoritySource;
+  const authorityReplyChainContext = await buildRunnerAuthorityReplyChainContext({
+    selectedRecord,
+    replyChainContext,
+    authoritySource: effectiveAuthoritySource,
+    runtime,
+    archiveThreadID,
+  });
+  const explicitDecisionBundle = safeObject(decisionBundle);
+  const authorityRootMessageID = intFromRawAllowZero(
+    authorityReplyChainContext.root_message_id || authorityReplyChainContext.rootMessageID,
+    0,
+  );
+  const authoritativeSourceMessageID = intFromRawAllowZero(
+    normalizedAuthoritativeSourceMessageEnvelope.message_id
+      || normalizedAuthoritativeSourceMessageEnvelope.messageID
+      || currentMessageID,
+    0,
+  );
+  const explicitDecisionType = String(
+    explicitDecisionBundle.decision_type || explicitDecisionBundle.decisionType || "",
+  ).trim().toLowerCase();
+  const preferAuthoritativeSourceReplyAnchor = explicitDecisionType === "human_opening";
+  const inferredReplyAnchorMessageID = preferAuthoritativeSourceReplyAnchor
+    ? authoritativeSourceMessageID > 0
+      ? authoritativeSourceMessageID
+      : authorityRootMessageID > 0
+        ? authorityRootMessageID
+        : 0
+    : authorityRootMessageID > 0
+      ? authorityRootMessageID
+      : authoritativeSourceMessageID > 0
+        ? authoritativeSourceMessageID
+        : 0;
+  const inferredReplyAnchorSource = preferAuthoritativeSourceReplyAnchor
+    ? authoritativeSourceMessageID > 0
+      ? "authoritative_source_message_envelope"
+      : authorityRootMessageID > 0
+        ? "reply_chain_root_message"
+        : ""
+    : authorityRootMessageID > 0
+      ? "reply_chain_root_message"
+      : authoritativeSourceMessageID > 0
+        ? "authoritative_source_message_envelope"
+        : "";
+  const inferredReplyAnchorKind = inferredReplyAnchorMessageID > 0 ? "human_root" : "";
+  const shouldOverrideHumanOpeningReplyAnchor = explicitDecisionType === "human_opening"
+    && inferredReplyAnchorMessageID > 0;
+  const decisionBundleWithReplyAnchor = Object.keys(explicitDecisionBundle).length > 0
+    ? {
+        ...explicitDecisionBundle,
+        ...((shouldOverrideHumanOpeningReplyAnchor || !(
+          intFromRawAllowZero(
+            explicitDecisionBundle.reply_to_message_id || explicitDecisionBundle.replyToMessageID,
+            0,
+          ) > 0
+        )) && inferredReplyAnchorMessageID > 0
+          ? { reply_to_message_id: inferredReplyAnchorMessageID }
+          : {}),
+        ...((shouldOverrideHumanOpeningReplyAnchor || !String(
+          explicitDecisionBundle.reply_anchor_source || explicitDecisionBundle.replyAnchorSource || "",
+        ).trim()) && inferredReplyAnchorSource
+          ? { reply_anchor_source: inferredReplyAnchorSource }
+          : {}),
+        ...((shouldOverrideHumanOpeningReplyAnchor || !String(
+          explicitDecisionBundle.reply_anchor_kind || explicitDecisionBundle.replyAnchorKind || "",
+        ).trim()) && inferredReplyAnchorKind
+          ? { reply_anchor_kind: inferredReplyAnchorKind }
+          : {}),
+      }
+    : {};
+  const decisionBundleValidation = validateRunnerConversationDecisionBundle(decisionBundleWithReplyAnchor);
+  if (Object.keys(decisionBundleWithReplyAnchor).length > 0 && decisionBundleValidation.ok !== true) {
     return {
       ok: false,
       reason: "invalid_decision_bundle",
       detail: String(decisionBundleValidation.reason || "").trim() || "invalid_decision_bundle",
     };
   }
+  if (
+    Object.keys(decisionBundleWithReplyAnchor).length > 0
+    && runnerDecisionBundleDecisionType(decisionBundleValidation.bundle) !== "human_opening"
+  ) {
+    return {
+      ok: false,
+      reason: "invalid_root_request_decision_bundle",
+      detail: "root human requests require a human_opening authoritative decision bundle",
+    };
+  }
   const authoritativeDecisionBundle = decisionBundleValidation.ok === true
     ? safeObject(decisionBundleValidation.bundle)
     : {};
-  const normalizedAuthoritativeSourceMessageEnvelope = normalizeRunnerTelegramMessageEnvelope(
-    authoritativeSourceMessageEnvelope,
-  );
-  const currentClaimBotUsername = normalizeTelegramMentionUsername(
-    normalizedAuthoritativeSourceMessageEnvelope.source_bot_username
-      || normalizedAuthoritativeSourceMessageEnvelope.sender_username
-      || currentRouteState.last_source_bot_username
-      || currentRouteState.source_message_bot_username
-      || currentRouteState.last_speaker_bot_username,
+  const resolvedConversationID = isDirectMessageRestart
+    ? buildSyntheticHumanOpeningConversationID(
+      normalizedRoute,
+      normalizedChatID,
+      currentMessageID,
+      canonicalHumanMessageKey,
+    )
+    : String(authorityContext.conversationID || "").trim();
+  const preferredNormalizedIntent = String(
+    isDirectMessageRestart
+      ? normalizedSharedHumanIntent.intentType || resolvedNormalizedIntent || ""
+      : authorityContext.normalizedIntent,
+  ).trim().toLowerCase();
+  const requestSelectedBotUsernames = ensureArray(
+    isDirectMessageRestart
+      ? ensureArray(selectedBotUsernames).length
+        ? selectedBotUsernames
+        : authorityContext.selectedBotUsernames
+      : authorityContext.selectedBotUsernames,
   );
-  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 effectiveSelectedBotUsernames = uniqueOrderedStrings(
     ensureArray(authoritativeDecisionBundle.selected_bot_usernames).length
       ? authoritativeDecisionBundle.selected_bot_usernames
       : requestSelectedBotUsernames,
     normalizeTelegramMentionUsername,
   );
-  const requestKey = buildRunnerRequestKey({
-    normalizedRoute,
-    selectedRecord,
-    selectedBotUsernames: effectiveSelectedBotUsernames,
-    normalizedIntent: preferredNormalizedIntent,
-    conversationID: resolvedConversationID,
-  });
-  const requests = normalizeBotRunnerRequests(stateForClaim.requests);
-  const existing = safeObject(requests[requestKey]);
-  if (isFinalRunnerRequestStatus(existing.status)) {
-    return {
+  const requests = normalizeBotRunnerRequests(stateForClaim.requests);
+  const resolveDirectMessageContinuationRequestByKey = (requestKeyRaw = "") => {
+    const requestKey = String(requestKeyRaw || "").trim();
+    if (!requestKey) {
+      return {};
+    }
+    const candidate = safeObject(requests[requestKey]);
+    if (!String(candidate.request_key || "").trim()) {
+      return {};
+    }
+    const botCandidates = claimBotUsernameCandidates.length > 0 ? claimBotUsernameCandidates : [""];
+    for (const botUsernameCandidate of botCandidates) {
+      if (isRunnerDirectMessageContinuationRequestCandidate(candidate, {
+        routeKey: String(routeKey || "").trim(),
+        chatID: normalizedChatID,
+        botUsername: botUsernameCandidate,
+      })) {
+        return candidate;
+      }
+    }
+    if (isRunnerDirectMessageContinuationRequestCandidate(candidate, {
+      routeKey: String(routeKey || "").trim(),
+      chatID: normalizedChatID,
+      botUsername: "",
+    })) {
+      return candidate;
+    }
+    return {};
+  };
+  let directMessageContinuationRequest = {};
+  if (isDirectMessageChat && !isDirectMessageRestart) {
+    const prefersDirectMessageRouteActiveRequest = (requestRaw = {}) => {
+      const request = safeObject(requestRaw);
+      return (
+        String(request.request_key || "").trim()
+        && String(request.project_id || "").trim() === String(normalizedRoute?.projectID || "").trim()
+        && String(request.provider || "").trim() === String(normalizedRoute?.provider || "").trim()
+        && String(request.chat_id || "").trim() === normalizedChatID
+        && isActiveRunnerRequestStatus(request.status)
+      )
+        ? request
+        : {};
+    };
+    directMessageContinuationRequest = prefersDirectMessageRouteActiveRequest(directMessageRouteActiveRequest);
+    if (!String(directMessageContinuationRequest.request_key || "").trim()) {
+      directMessageContinuationRequest = prefersDirectMessageRouteActiveRequest(directMessageRouteLastRequest);
+    }
+    const directMessageContinuationRequestKeys = uniqueOrderedStrings([
+      safeObject(effectiveAuthoritySource).request_key,
+      safeObject(authoritySource).request_key,
+      safeObject(referencedRequest).request_key,
+      safeObject(sharedConversationSource).request_key,
+      routeStateForClaim.active_request_key,
+      routeStateForClaim.last_request_key,
+    ]);
+    if (!String(directMessageContinuationRequest.request_key || "").trim()) {
+      for (const requestKeyCandidate of directMessageContinuationRequestKeys) {
+        const matchedRequest = resolveDirectMessageContinuationRequestByKey(requestKeyCandidate);
+        if (String(matchedRequest.request_key || "").trim()) {
+          directMessageContinuationRequest = matchedRequest;
+          break;
+        }
+      }
+    }
+    if (!String(directMessageContinuationRequest.request_key || "").trim()) {
+      const lookupBotCandidates = claimBotUsernameCandidates.length > 0 ? claimBotUsernameCandidates : [""];
+      for (const botUsernameCandidate of lookupBotCandidates) {
+        const matchedRequest = safeObject(findRunnerDirectMessageContinuationSourceRequest({
+          state: stateForClaim,
+          normalizedRoute,
+          routeKey,
+          routeState: routeStateForClaim,
+          chatID: normalizedChatID,
+          botUsername: botUsernameCandidate,
+        }));
+        if (String(matchedRequest.request_key || "").trim()) {
+          directMessageContinuationRequest = matchedRequest;
+          break;
+        }
+      }
+    }
+  }
+  const shouldReuseDirectMessageRequest = (
+    isDirectMessageChat
+    && !isDirectMessageRestart
+    && String(directMessageContinuationRequest.request_key || "").trim()
+    && isActiveRunnerRequestStatus(directMessageContinuationRequest.status)
+  );
+  const directMessageContinuationConversationID = String(
+    directMessageContinuationRequest.conversation_id
+      || safeObject(routeStateForClaim.conversation_sessions)[String(routeStateForClaim.last_conversation_id || "").trim()]?.conversation_id
+      || "",
+  ).trim();
+  const effectiveConversationID = shouldReuseDirectMessageRequest
+    ? String(
+      resolvedConversationID
+      || directMessageContinuationConversationID
+      || safeObject(directMessageContinuationRequest.reply_chain_context).conversation_id
+      || "",
+    ).trim()
+    : resolvedConversationID;
+  const requestKey = shouldReuseDirectMessageRequest
+    ? String(directMessageContinuationRequest.request_key || "").trim()
+    : buildRunnerRequestKey({
+      normalizedRoute,
+      selectedRecord,
+      selectedBotUsernames: effectiveSelectedBotUsernames,
+      normalizedIntent: preferredNormalizedIntent,
+      conversationID: effectiveConversationID,
+    });
+  const existing = safeObject(requests[requestKey]);
+  if (isFinalRunnerRequestStatus(existing.status)) {
+    return {
       ok: false,
       reason: "request_already_finalized",
       requestKey,
@@ -5181,6 +6142,15 @@ async function claimRunnerRequestForHumanComment({
   }
   const nowISO = new Date().toISOString();
   const existingSourceMessageEnvelope = normalizeRunnerTelegramMessageEnvelope(existing.source_message_envelope);
+  const existingRootSourceMessageEnvelope = normalizeRunnerTelegramMessageEnvelope(
+    existing.root_source_message_envelope
+      || existing.rootSourceMessageEnvelope
+      || existing.source_message_envelope,
+  );
+  const existingCurrentSourceMessageEnvelope = normalizeRunnerTelegramMessageEnvelope(
+    existing.current_source_message_envelope
+      || existing.currentSourceMessageEnvelope,
+  );
   const preserveExistingCanonicalSourceEnvelope = Boolean(
     canonicalHumanMessageKey
     && String(existing.canonical_human_message_key || "").trim() === canonicalHumanMessageKey
@@ -5192,6 +6162,23 @@ async function claimRunnerRequestForHumanComment({
     : Object.keys(normalizedAuthoritativeSourceMessageEnvelope).length
       ? normalizedAuthoritativeSourceMessageEnvelope
       : existingSourceMessageEnvelope;
+  const effectiveSourceMessageEnvelope = shouldReuseDirectMessageRequest
+    ? (Object.keys(existingSourceMessageEnvelope).length
+      ? existingSourceMessageEnvelope
+      : sourceMessageEnvelope)
+    : sourceMessageEnvelope;
+  const rootSourceMessageEnvelope = shouldReuseDirectMessageRequest
+    ? (Object.keys(existingRootSourceMessageEnvelope).length
+      ? existingRootSourceMessageEnvelope
+      : effectiveSourceMessageEnvelope)
+    : sourceMessageEnvelope;
+  const currentSourceMessageEnvelope = preserveExistingCanonicalSourceEnvelope
+    ? (Object.keys(existingCurrentSourceMessageEnvelope).length
+      ? existingCurrentSourceMessageEnvelope
+      : sourceMessageEnvelope)
+    : Object.keys(normalizedAuthoritativeSourceMessageEnvelope).length
+      ? normalizedAuthoritativeSourceMessageEnvelope
+      : sourceMessageEnvelope;
   const decisionConversationParticipants = uniqueOrderedStrings(
     ensureArray(authoritativeDecisionBundle.participants),
     normalizeTelegramMentionUsername,
@@ -5205,33 +6192,114 @@ async function claimRunnerRequestForHumanComment({
     normalizeTelegramMentionUsername,
   );
   const hasAuthoritativeConversationDecision = Object.keys(authoritativeDecisionBundle).length > 0;
-  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(),
-    canonical_human_message_key: canonicalHumanMessageKey,
-    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,
+  const rootSourceMessageID = shouldReuseDirectMessageRequest
+    ? intFromRawAllowZero(existing.source_message_id, 0) || intFromRawAllowZero(parsed.messageID, 0)
+    : intFromRawAllowZero(parsed.messageID, 0);
+  const rootSourceMessageThreadID = shouldReuseDirectMessageRequest
+    ? intFromRawAllowZero(existing.source_message_thread_id, 0)
+    : intFromRawAllowZero(parsed.messageThreadID, 0);
+  const rootSourceMessageBody = shouldReuseDirectMessageRequest
+    ? String(existing.source_message_body || parsed.body || "").trim()
+    : String(parsed.body || "").trim();
+  const rootCanonicalHumanMessageKey = shouldReuseDirectMessageRequest
+    ? firstNonEmptyString([
+      existing.canonical_human_message_key,
+      canonicalHumanMessageKey,
+    ])
+    : canonicalHumanMessageKey;
+  const currentSourceMessageID = intFromRawAllowZero(
+    currentSourceMessageEnvelope.message_id || currentMessageID,
+    0,
+  );
+  const currentSourceMessageThreadID = intFromRawAllowZero(
+    currentSourceMessageEnvelope.message_thread_id || parsed.messageThreadID,
+    0,
+  );
+  const currentSourceMessageBody = firstNonEmptyString([
+    currentSourceMessageEnvelope.body,
+    parsed.body,
+  ]);
+  const currentTurnRelation = String(
+    authorityReplyChainContext.current_turn_relation
+      || authorityReplyChainContext.currentTurnRelation
+      || existing.current_turn_relation
+      || existing.currentTurnRelation
+      || "",
+  ).trim();
+  let { requests: nextRequests, request } = upsertRunnerRequest(stateForClaim, requestKey, {
+    project_id: String(normalizedRoute?.projectID || "").trim(),
+    provider: String(normalizedRoute?.provider || "").trim(),
+    chat_id: normalizedChatID,
+    source_message_id: rootSourceMessageID || undefined,
+    source_message_thread_id: rootSourceMessageThreadID || undefined,
+    source_message_body: rootSourceMessageBody,
+    canonical_human_message_key: rootCanonicalHumanMessageKey,
+    source_message_origin: shouldReuseDirectMessageRequest
+      ? String(existing.source_message_origin || effectiveSourceMessageEnvelope.source_origin || "").trim().toLowerCase()
+      : String(effectiveSourceMessageEnvelope.source_origin || "").trim().toLowerCase(),
+    source_message_route_key: shouldReuseDirectMessageRequest
+      ? String(existing.source_message_route_key || effectiveSourceMessageEnvelope.source_route_key || "").trim()
+      : String(effectiveSourceMessageEnvelope.source_route_key || "").trim(),
+    source_message_bot_username: shouldReuseDirectMessageRequest
+      ? normalizeTelegramMentionUsername(existing.source_message_bot_username || effectiveSourceMessageEnvelope.source_bot_username)
+      : normalizeTelegramMentionUsername(effectiveSourceMessageEnvelope.source_bot_username),
+    source_message_envelope: effectiveSourceMessageEnvelope,
+    root_source_message_id: rootSourceMessageID || undefined,
+    root_source_message_thread_id: rootSourceMessageThreadID || undefined,
+    root_source_message_body: rootSourceMessageBody,
+    root_source_message_origin: String(
+      (shouldReuseDirectMessageRequest
+        ? existing.root_source_message_origin || existing.source_message_origin
+        : rootSourceMessageEnvelope.source_origin)
+        || "",
+    ).trim().toLowerCase(),
+    root_source_message_route_key: String(
+      (shouldReuseDirectMessageRequest
+        ? existing.root_source_message_route_key || existing.source_message_route_key
+        : rootSourceMessageEnvelope.source_route_key)
+        || "",
+    ).trim(),
+    root_source_message_bot_username: normalizeTelegramMentionUsername(
+      (shouldReuseDirectMessageRequest
+        ? existing.root_source_message_bot_username || existing.source_message_bot_username
+        : rootSourceMessageEnvelope.source_bot_username),
+    ),
+    root_source_message_envelope: rootSourceMessageEnvelope,
+    current_source_message_id: currentSourceMessageID || undefined,
+    current_source_message_thread_id: currentSourceMessageThreadID || undefined,
+    current_source_message_body: currentSourceMessageBody,
+    current_source_message_origin: String(currentSourceMessageEnvelope.source_origin || "").trim().toLowerCase(),
+    current_source_message_route_key: String(currentSourceMessageEnvelope.source_route_key || "").trim(),
+    current_source_message_bot_username: normalizeTelegramMentionUsername(
+      currentSourceMessageEnvelope.source_bot_username,
+    ),
+    current_source_message_envelope: currentSourceMessageEnvelope,
+    current_turn_relation: currentTurnRelation,
+    root_comment_id: shouldReuseDirectMessageRequest
+      ? String(existing.root_comment_id || selectedRecord?.id || "").trim()
+      : String(selectedRecord?.id || "").trim(),
+    root_comment_kind: shouldReuseDirectMessageRequest
+      ? String(existing.root_comment_kind || commentKind).trim().toLowerCase()
+      : commentKind,
+    conversation_id: effectiveConversationID,
     reply_chain_context: authorityReplyChainContext,
     selected_bot_usernames: effectiveSelectedBotUsernames,
-    authoritative_decision_bundle: authoritativeDecisionBundle,
-    decision_bundle_validation_status: String(decisionBundleValidation.status || "").trim(),
-    decision_bundle_validation_reason: String(decisionBundleValidation.reason || "").trim(),
+    authoritative_decision_bundle: shouldReuseDirectMessageRequest
+      ? safeObject(existing.authoritative_decision_bundle)
+      : authoritativeDecisionBundle,
+    decision_bundle_validation_status: shouldReuseDirectMessageRequest
+      ? String(existing.decision_bundle_validation_status || "").trim()
+      : String(decisionBundleValidation.status || "").trim(),
+    decision_bundle_validation_reason: shouldReuseDirectMessageRequest
+      ? String(existing.decision_bundle_validation_reason || "").trim()
+      : String(decisionBundleValidation.reason || "").trim(),
     conversation_intent_mode: String(
       (hasAuthoritativeConversationDecision
         ? authoritativeDecisionBundle.conversation_intent_mode
         : "")
         || normalizedSharedHumanIntent.intentMode
         || existing.conversation_intent_mode
-        || authoritySource.conversation_intent_mode
+        || effectiveAuthoritySource.conversation_intent_mode
         || "",
     ).trim().toLowerCase(),
     conversation_lead_bot: normalizeTelegramMentionUsername(
@@ -5240,7 +6308,7 @@ async function claimRunnerRequestForHumanComment({
         : "")
         || normalizedSharedHumanIntent.leadBotSelector
         || existing.conversation_lead_bot
-        || authoritySource.conversation_lead_bot,
+        || effectiveAuthoritySource.conversation_lead_bot,
     ),
     conversation_summary_bot: normalizeTelegramMentionUsername(
       (hasAuthoritativeConversationDecision
@@ -5248,7 +6316,7 @@ async function claimRunnerRequestForHumanComment({
         : "")
         || normalizedSharedHumanIntent.summaryBotSelector
         || existing.conversation_summary_bot
-        || authoritySource.conversation_summary_bot,
+        || effectiveAuthoritySource.conversation_summary_bot,
     ),
     conversation_participants: uniqueOrderedStrings(
       hasAuthoritativeConversationDecision && decisionConversationParticipants.length
@@ -5257,10 +6325,10 @@ async function claimRunnerRequestForHumanComment({
         ? normalizedSharedHumanIntent.participantSelectors
         : ensureArray(existing.conversation_participants).length
           ? existing.conversation_participants
-          : ensureArray(authoritySource.conversation_participants).length
-            ? authoritySource.conversation_participants
-            : [],
-      normalizeTelegramMentionUsername,
+          : ensureArray(effectiveAuthoritySource.conversation_participants).length
+            ? effectiveAuthoritySource.conversation_participants
+            : [],
+      normalizeTelegramMentionUsername,
     ),
     conversation_initial_responders: uniqueOrderedStrings(
       hasAuthoritativeConversationDecision && decisionInitialResponders.length
@@ -5269,10 +6337,10 @@ async function claimRunnerRequestForHumanComment({
         ? normalizedSharedHumanIntent.initialResponderSelectors
         : ensureArray(existing.conversation_initial_responders).length
           ? existing.conversation_initial_responders
-          : ensureArray(authoritySource.conversation_initial_responders).length
-            ? authoritySource.conversation_initial_responders
-            : [],
-      normalizeTelegramMentionUsername,
+          : ensureArray(effectiveAuthoritySource.conversation_initial_responders).length
+            ? effectiveAuthoritySource.conversation_initial_responders
+            : [],
+      normalizeTelegramMentionUsername,
     ),
     conversation_allowed_responders: uniqueOrderedStrings(
       hasAuthoritativeConversationDecision && decisionAllowedResponders.length
@@ -5281,9 +6349,9 @@ async function claimRunnerRequestForHumanComment({
         ? normalizedSharedHumanIntent.allowedResponderSelectors
         : ensureArray(existing.conversation_allowed_responders).length
           ? existing.conversation_allowed_responders
-          : ensureArray(authoritySource.conversation_allowed_responders).length
-            ? authoritySource.conversation_allowed_responders
-            : [],
+          : ensureArray(effectiveAuthoritySource.conversation_allowed_responders).length
+            ? effectiveAuthoritySource.conversation_allowed_responders
+            : [],
       normalizeTelegramMentionUsername,
     ),
     conversation_allow_bot_to_bot: (hasAuthoritativeConversationDecision
@@ -5291,14 +6359,14 @@ async function claimRunnerRequestForHumanComment({
       : false)
       || normalizedSharedHumanIntent.allowBotToBot === true
       || existing.conversation_allow_bot_to_bot === true
-      || authoritySource.conversation_allow_bot_to_bot === true,
+      || effectiveAuthoritySource.conversation_allow_bot_to_bot === true,
     conversation_reply_expectation: String(
       (hasAuthoritativeConversationDecision
         ? authoritativeDecisionBundle.conversation_reply_expectation
         : "")
         || normalizedSharedHumanIntent.replyExpectation
         || existing.conversation_reply_expectation
-        || authoritySource.conversation_reply_expectation
+        || effectiveAuthoritySource.conversation_reply_expectation
         || "",
     ).trim().toLowerCase(),
     execution_contract_type: String(
@@ -5306,20 +6374,20 @@ async function claimRunnerRequestForHumanComment({
         ? authoritativeDecisionBundle.execution_contract_type
         : "")
         || runnerRequestPreferredExecutionContractType(existing)
-        || runnerRequestPreferredExecutionContractType(authoritySource)
+        || runnerRequestPreferredExecutionContractType(effectiveAuthoritySource)
         || "",
     ).trim().toLowerCase(),
     execution_contract_actionable: (hasAuthoritativeConversationDecision
       ? authoritativeDecisionBundle.execution_contract_actionable === true
       : false)
       || runnerRequestPreferredExecutionContractActionable(existing)
-      || runnerRequestPreferredExecutionContractActionable(authoritySource),
+      || runnerRequestPreferredExecutionContractActionable(effectiveAuthoritySource),
     execution_contract_targets: uniqueOrderedStrings(
       hasAuthoritativeConversationDecision && ensureArray(authoritativeDecisionBundle.execution_contract_targets).length
         ? authoritativeDecisionBundle.execution_contract_targets
         : runnerRequestPreferredExecutionContractTargets(existing).length
         ? runnerRequestPreferredExecutionContractTargets(existing)
-        : runnerRequestPreferredExecutionContractTargets(authoritySource),
+        : runnerRequestPreferredExecutionContractTargets(effectiveAuthoritySource),
       normalizeTelegramMentionUsername,
     ),
     next_expected_responders: uniqueOrderedStrings(
@@ -5327,31 +6395,77 @@ async function claimRunnerRequestForHumanComment({
         ? authoritativeDecisionBundle.next_expected_responders
         : runnerRequestPreferredNextExpectedResponders(existing).length
         ? runnerRequestPreferredNextExpectedResponders(existing)
-        : runnerRequestPreferredNextExpectedResponders(authoritySource),
+        : runnerRequestPreferredNextExpectedResponders(effectiveAuthoritySource),
       normalizeTelegramMentionUsername,
-    ),
-    normalized_intent: String(preferredNormalizedIntent || existing.normalized_intent || "").trim().toLowerCase(),
+    ),
+    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(),
+    claimed_by_route: String(routeKey || "").trim(),
+    claimed_at: firstNonEmptyString([existing.claimed_at, nowISO]) || nowISO,
+    root_work_item_id: String(existing.root_work_item_id || effectiveAuthoritySource.root_work_item_id || "").trim(),
+    root_work_item_title: String(existing.root_work_item_title || effectiveAuthoritySource.root_work_item_title || "").trim(),
+    root_work_item_status: normalizeRunnerWorkItemStatus(
+      existing.root_work_item_status || effectiveAuthoritySource.root_work_item_status,
+    ),
+    root_thread_id: String(existing.root_thread_id || effectiveAuthoritySource.root_thread_id || "").trim(),
+    root_work_item_created_at: firstNonEmptyString([
+      existing.root_work_item_created_at,
+      effectiveAuthoritySource.root_work_item_created_at,
+    ]),
+    root_work_item_last_error: String(
+      existing.root_work_item_last_error || effectiveAuthoritySource.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,
-  });
+    last_source_message_id: intFromRawAllowZero(parsed.messageID, 0) || undefined,
+    last_source_message_thread_id: intFromRawAllowZero(parsed.messageThreadID, 0) || undefined,
+  });
+  if (isDirectMessageRestart) {
+    const restartBotUsername = firstNonEmptyString(claimBotUsernameCandidates);
+    const restartClosedRequests = closeRunnerDirectMessageScopedActiveRequests({
+      state: {
+        ...stateForClaim,
+        requests: nextRequests,
+      },
+      normalizedRoute,
+      routeKey,
+      chatID: normalizedChatID,
+      botUsername: restartBotUsername,
+      excludeRequestKey: requestKey,
+    });
+    nextRequests = normalizeBotRunnerRequests(restartClosedRequests.requests);
+    request = safeObject(nextRequests[requestKey]);
+  }
+  if (isDirectMessageRestart && directMessageRestartRequestKeysToClose.size > 0) {
+    const restartFinalNowISO = new Date().toISOString();
+    const claimedRequestKey = String(requestKey || "").trim();
+    for (const restartRequestKeyRaw of directMessageRestartRequestKeysToClose) {
+      const restartRequestKey = String(restartRequestKeyRaw || "").trim();
+      if (!restartRequestKey || restartRequestKey === claimedRequestKey) {
+        continue;
+      }
+      const existingRestartRequest = safeObject(
+        nextRequests[restartRequestKey]
+          || safeObject(stateForClaim.requests)[restartRequestKey]
+          || safeObject(currentState.requests)[restartRequestKey]
+          || safeObject(requests)[restartRequestKey],
+      );
+      if (
+        !String(existingRestartRequest.request_key || "").trim()
+        || String(existingRestartRequest.chat_id || "").trim() !== normalizedChatID
+      ) {
+        continue;
+      }
+      nextRequests[restartRequestKey] = {
+        ...existingRestartRequest,
+        status: "closed",
+        closed_reason: "direct_message_restart",
+        closed_at: restartFinalNowISO,
+        updated_at: restartFinalNowISO,
+      };
+    }
+    request = safeObject(nextRequests[requestKey]);
+  }
   const { consumedComments: nextConsumedComments } = upsertRunnerConsumedComment(stateForClaim, selectedRecord?.id, {
     project_id: String(normalizedRoute?.projectID || "").trim(),
     provider: String(normalizedRoute?.provider || "").trim(),
@@ -5365,18 +6479,55 @@ async function claimRunnerRequestForHumanComment({
     comment_kind: commentKind,
     request_status: "claimed",
   });
-  saveBotRunnerState({
-    routes: stateForClaim.routes,
-    sharedInboxes: stateForClaim.sharedInboxes || stateForClaim.shared_inboxes,
-    excludedComments: stateForClaim.excludedComments || stateForClaim.excluded_comments,
-    requests: nextRequests,
-    consumedComments: nextConsumedComments,
-  });
-  return {
-    ok: true,
-    requestKey,
-    request,
-  };
+  saveBotRunnerState({
+    routes: stateForClaim.routes,
+    sharedInboxes: stateForClaim.sharedInboxes || stateForClaim.shared_inboxes,
+    excludedComments: stateForClaim.excludedComments || stateForClaim.excluded_comments,
+    requests: nextRequests,
+    consumedComments: nextConsumedComments,
+  });
+  if (isDirectMessageRestart && directMessageRestartRequestKeysToClose.size > 0) {
+    const persistedState = loadBotRunnerState();
+    const persistedRequests = normalizeBotRunnerRequests(persistedState.requests);
+    let shouldResavePersistedRequests = false;
+    const persistedRestartNowISO = new Date().toISOString();
+    const claimedRequestKey = String(requestKey || "").trim();
+    for (const restartRequestKey of directMessageRestartRequestKeysToClose) {
+      if (!restartRequestKey || restartRequestKey === claimedRequestKey) {
+        continue;
+      }
+      const existingPersistedRequest = safeObject(persistedRequests[restartRequestKey]);
+      if (
+        !String(existingPersistedRequest.request_key || "").trim()
+        || !isActiveRunnerRequestStatus(existingPersistedRequest.status)
+        || String(existingPersistedRequest.chat_id || "").trim() !== normalizedChatID
+      ) {
+        continue;
+      }
+      persistedRequests[restartRequestKey] = {
+        ...existingPersistedRequest,
+        status: "closed",
+        closed_reason: "direct_message_restart",
+        closed_at: persistedRestartNowISO,
+        updated_at: persistedRestartNowISO,
+      };
+      shouldResavePersistedRequests = true;
+    }
+    if (shouldResavePersistedRequests) {
+      saveBotRunnerState({
+        routes: persistedState.routes,
+        sharedInboxes: persistedState.sharedInboxes || persistedState.shared_inboxes,
+        excludedComments: persistedState.excludedComments || persistedState.excluded_comments,
+        requests: persistedRequests,
+        consumedComments: persistedState.consumedComments || persistedState.consumed_comments,
+      });
+    }
+  }
+  return {
+    ok: true,
+    requestKey,
+    request,
+  };
 }
 
 function runnerRequestRequiresActionableContract(requestRaw) {
@@ -6391,6 +7542,9 @@ function markRunnerRequestLifecycle({
   const sourceMessageEnvelope = Object.keys(normalizedAuthoritativeSourceMessageEnvelope).length
     ? normalizedAuthoritativeSourceMessageEnvelope
     : normalizeRunnerTelegramMessageEnvelope(existing.source_message_envelope);
+  const commentKind = String(parsed.kind || "").trim().toLowerCase();
+  const isRootHumanComment = ["telegram_message", "telegram_edited_message"].includes(commentKind);
+  const isFollowupComment = !isRootHumanComment;
   const normalizedDecisionBundle = normalizeRunnerConversationDecisionBundle(decisionBundle);
   const resolvedDecisionBundleValidation = Object.keys(safeObject(decisionBundle)).length > 0
     ? validateRunnerConversationDecisionBundle(normalizedDecisionBundle)
@@ -6400,9 +7554,60 @@ function markRunnerRequestLifecycle({
         reason: String(decisionBundleValidationReason || "").trim(),
         bundle: {},
       };
-  const authoritativeDecisionBundle = resolvedDecisionBundleValidation.ok === true
+  const existingAuthoritativeDecisionBundle = runnerRequestAuthoritativeDecisionBundle(existing);
+  const incomingDecisionBundle = resolvedDecisionBundleValidation.ok === true
     ? safeObject(resolvedDecisionBundleValidation.bundle)
-    : runnerRequestAuthoritativeDecisionBundle(existing);
+    : {};
+  const existingHasImmutableRootAuthority = runnerDecisionBundleIsRootHumanOpening(
+    existingAuthoritativeDecisionBundle,
+  );
+  const incomingDecisionType = runnerDecisionBundleDecisionType(
+    Object.keys(incomingDecisionBundle).length > 0 ? incomingDecisionBundle : normalizedDecisionBundle,
+  );
+  const shouldWriteIncomingAuthoritativeDecisionBundle = incomingDecisionType === "human_opening"
+    && Object.keys(incomingDecisionBundle).length > 0;
+  const preserveExistingAuthoritativeDecisionBundle = Object.keys(existingAuthoritativeDecisionBundle).length > 0
+    && (
+      isFollowupComment
+      || existingHasImmutableRootAuthority
+      || !shouldWriteIncomingAuthoritativeDecisionBundle
+    );
+  const authoritativeDecisionBundle = preserveExistingAuthoritativeDecisionBundle
+    ? existingAuthoritativeDecisionBundle
+    : Object.keys(incomingDecisionBundle).length > 0
+      ? incomingDecisionBundle
+      : existingAuthoritativeDecisionBundle;
+  const effectiveDecisionBundleValidationStatus = preserveExistingAuthoritativeDecisionBundle
+    ? String(existing.decision_bundle_validation_status || "").trim()
+    : String(
+      resolvedDecisionBundleValidation.status
+      || decisionBundleValidationStatus
+      || existing.decision_bundle_validation_status
+      || "",
+    ).trim();
+  const effectiveDecisionBundleValidationReason = preserveExistingAuthoritativeDecisionBundle
+    ? String(existing.decision_bundle_validation_reason || "").trim()
+    : String(
+      resolvedDecisionBundleValidation.reason
+      || decisionBundleValidationReason
+      || existing.decision_bundle_validation_reason
+      || "",
+    ).trim();
+  const lastReplyDecisionBundle = Object.keys(incomingDecisionBundle).length > 0
+    ? incomingDecisionBundle
+    : safeObject(existing.last_reply_decision_bundle);
+  const lastReplyDecisionBundleValidationStatus = String(
+    resolvedDecisionBundleValidation.status
+    || decisionBundleValidationStatus
+    || existing.last_reply_decision_bundle_validation_status
+    || "",
+  ).trim();
+  const lastReplyDecisionBundleValidationReason = String(
+    resolvedDecisionBundleValidation.reason
+    || decisionBundleValidationReason
+    || existing.last_reply_decision_bundle_validation_reason
+    || "",
+  ).trim();
   const effectiveReplyToMessageID = intFromRawAllowZero(replyToMessageID, 0);
   const lastReplyMessageEnvelope = buildTelegramBotReplyEnvelope({
     sourceEnvelope: sourceMessageEnvelope,
@@ -6416,7 +7621,7 @@ function markRunnerRequestLifecycle({
   const normalizedDeliveryStatus = String(deliveryStatus || "").trim().toLowerCase();
   const persistSuccessfulReplyEnvelope = ["delivered", "dry_run"].includes(normalizedDeliveryStatus)
     && intFromRawAllowZero(lastReplyMessageEnvelope.message_id, 0) > 0;
-  const attemptedDeliveryEnvelope = buildTelegramBotReplyEnvelope({
+  const attemptedDeliveryEnvelope = buildTelegramBotReplyEnvelope({
     sourceEnvelope: sourceMessageEnvelope,
     chatID: existing.chat_id,
     messageThreadID: lastReplyMessageThreadID,
@@ -6432,9 +7637,13 @@ function markRunnerRequestLifecycle({
     || intFromRawAllowZero(replyToMessageID, 0) > 0
     || intFromRawAllowZero(lastReplyMessageThreadID, 0) > 0
   );
+  const continuationDecisionBundle = Object.keys(incomingDecisionBundle).length > 0
+    ? incomingDecisionBundle
+    : safeObject(existing.last_reply_decision_bundle);
   const rootEffectiveExecutionContractTargets = uniqueOrderedStrings(
     [
       ...ensureArray(authoritativeDecisionBundle.execution_contract_targets),
+      ...ensureArray(continuationDecisionBundle.execution_contract_targets),
       ...ensureArray(executionContractTargets),
       ...ensureArray(normalizedExecutionContractTargets),
       ...ensureArray(responseContractValidationTargets),
@@ -6444,6 +7653,7 @@ function markRunnerRequestLifecycle({
   const rootEffectiveNextExpectedResponders = uniqueOrderedStrings(
     [
       ...ensureArray(authoritativeDecisionBundle.next_expected_responders),
+      ...ensureArray(continuationDecisionBundle.next_expected_responders),
       ...ensureArray(nextExpectedResponders),
       ...ensureArray(normalizedExecutionNextResponders),
       ...ensureArray(responseContractValidationTargets),
@@ -6454,11 +7664,15 @@ function markRunnerRequestLifecycle({
     [
       ...ensureArray(authoritativeDecisionBundle.execution_contract_targets).length
         ? ensureArray(authoritativeDecisionBundle.execution_contract_targets)
+        : ensureArray(continuationDecisionBundle.execution_contract_targets).length
+        ? ensureArray(continuationDecisionBundle.execution_contract_targets)
         : ensureArray(executionContractTargets).length
         ? ensureArray(executionContractTargets)
         : ensureArray(existing.execution_contract_targets),
       ...ensureArray(authoritativeDecisionBundle.next_expected_responders).length
         ? ensureArray(authoritativeDecisionBundle.next_expected_responders)
+        : ensureArray(continuationDecisionBundle.next_expected_responders).length
+        ? ensureArray(continuationDecisionBundle.next_expected_responders)
         : ensureArray(nextExpectedResponders).length
         ? ensureArray(nextExpectedResponders)
         : ensureArray(existing.next_expected_responders),
@@ -6467,13 +7681,20 @@ function markRunnerRequestLifecycle({
   ).filter((selector) => selector && selector !== normalizedCurrentBotSelector);
   const nextExecutionContractType = String(
     authoritativeDecisionBundle.execution_contract_type
+    || continuationDecisionBundle.execution_contract_type
     || executionContractType
     || existing.execution_contract_type
     || "",
   ).trim().toLowerCase();
+  const shouldPromoteRootContinuationState = isRootHumanComment || existingHasImmutableRootAuthority;
   const normalizedOutcome = String(outcome || "").trim().toLowerCase();
   const normalizedFailureReplyClassification = String(failureReplyClassification || "").trim().toLowerCase();
   const normalizedFailureFacts = safeObject(failureFacts);
+  const isTerminalStaleReplyAnchorSkip = normalizedOutcome === "skipped"
+    && (
+      normalizedDeliveryStatus === "skipped_stale_reply_anchor"
+      || String(closedReason || "").trim().toLowerCase() === "stale_reply_anchor"
+    );
   const shouldPersistReplyAnchor = (
     aiReplyGenerated === true
     || intFromRawAllowZero(lastReplyMessageID, 0) > 0
@@ -6488,6 +7709,7 @@ function markRunnerRequestLifecycle({
       : continuationSelectors.length > 0;
   const shouldRemainRunningAfterSkip = normalizedOutcome === "skipped"
     && parsedKind === "bot_reply"
+    && !isTerminalStaleReplyAnchorSkip
     && authoritativeDecisionBundle.should_close_after_reply !== true
     && (
       nextExecutionContractType === "delegation"
@@ -6548,25 +7770,17 @@ function markRunnerRequestLifecycle({
     return normalizeRunnerRequestStatus(existing.status);
   })();
   const nowISO = new Date().toISOString();
-  const commentKind = String(parsed.kind || "").trim().toLowerCase();
-  const isRootHumanComment = ["telegram_message", "telegram_edited_message"].includes(commentKind);
-  const isFollowupComment = !isRootHumanComment;
   const patch = {
     authoritative_decision_bundle: Object.keys(authoritativeDecisionBundle).length > 0
       ? authoritativeDecisionBundle
       : safeObject(existing.authoritative_decision_bundle),
-    decision_bundle_validation_status: String(
-      resolvedDecisionBundleValidation.status
-      || decisionBundleValidationStatus
-      || existing.decision_bundle_validation_status
-      || "",
-    ).trim(),
-    decision_bundle_validation_reason: String(
-      resolvedDecisionBundleValidation.reason
-      || decisionBundleValidationReason
-      || existing.decision_bundle_validation_reason
-      || "",
-    ).trim(),
+    decision_bundle_validation_status: effectiveDecisionBundleValidationStatus,
+    decision_bundle_validation_reason: effectiveDecisionBundleValidationReason,
+    last_reply_decision_bundle: Object.keys(lastReplyDecisionBundle).length > 0
+      ? lastReplyDecisionBundle
+      : safeObject(existing.last_reply_decision_bundle),
+    last_reply_decision_bundle_validation_status: lastReplyDecisionBundleValidationStatus,
+    last_reply_decision_bundle_validation_reason: lastReplyDecisionBundleValidationReason,
     conversation_id: conversationID,
     conversation_participants: uniqueOrderedStrings(
       ensureArray(authoritativeDecisionBundle.participants).length
@@ -6621,7 +7835,7 @@ function markRunnerRequestLifecycle({
     execution_contract_targets: uniqueOrderedStrings(
       ensureArray(authoritativeDecisionBundle.execution_contract_targets).length
         ? authoritativeDecisionBundle.execution_contract_targets
-        : isRootHumanComment && rootEffectiveExecutionContractTargets.length
+        : shouldPromoteRootContinuationState && rootEffectiveExecutionContractTargets.length
         ? rootEffectiveExecutionContractTargets
         : ensureArray(executionContractTargets).length
           ? executionContractTargets
@@ -6631,7 +7845,7 @@ function markRunnerRequestLifecycle({
     next_expected_responders: uniqueOrderedStrings(
       ensureArray(authoritativeDecisionBundle.next_expected_responders).length
         ? authoritativeDecisionBundle.next_expected_responders
-        : isRootHumanComment && rootEffectiveNextExpectedResponders.length
+        : shouldPromoteRootContinuationState && rootEffectiveNextExpectedResponders.length
         ? rootEffectiveNextExpectedResponders
         : ensureArray(nextExpectedResponders).length
           ? nextExpectedResponders
@@ -6667,24 +7881,24 @@ function markRunnerRequestLifecycle({
         ? aiReplyPreview || existing.followup_ai_reply_preview || ""
         : existing.followup_ai_reply_preview || "",
     ).trim(),
-    root_execution_contract_type: String(
-      isRootHumanComment
-        ? nextExecutionContractType
-        : existing.root_execution_contract_type || existing.execution_contract_type || "",
-    ).trim().toLowerCase(),
-    root_execution_contract_targets: uniqueOrderedStrings(
-      isRootHumanComment && rootEffectiveExecutionContractTargets.length
-        ? rootEffectiveExecutionContractTargets
-        : ensureArray(existing.root_execution_contract_targets).length
-          ? existing.root_execution_contract_targets
+    root_execution_contract_type: String(
+      shouldPromoteRootContinuationState
+        ? nextExecutionContractType
+        : existing.root_execution_contract_type || existing.execution_contract_type || "",
+    ).trim().toLowerCase(),
+    root_execution_contract_targets: uniqueOrderedStrings(
+      shouldPromoteRootContinuationState && rootEffectiveExecutionContractTargets.length
+        ? rootEffectiveExecutionContractTargets
+        : ensureArray(existing.root_execution_contract_targets).length
+          ? existing.root_execution_contract_targets
           : existing.execution_contract_targets,
       normalizeTelegramMentionUsername,
     ),
-    root_next_expected_responders: uniqueOrderedStrings(
-      isRootHumanComment && rootEffectiveNextExpectedResponders.length
-        ? rootEffectiveNextExpectedResponders
-        : ensureArray(existing.root_next_expected_responders).length
-          ? existing.root_next_expected_responders
+    root_next_expected_responders: uniqueOrderedStrings(
+      shouldPromoteRootContinuationState && rootEffectiveNextExpectedResponders.length
+        ? rootEffectiveNextExpectedResponders
+        : ensureArray(existing.root_next_expected_responders).length
+          ? existing.root_next_expected_responders
           : existing.next_expected_responders,
       normalizeTelegramMentionUsername,
     ),
@@ -6978,18 +8192,36 @@ function cleanupBotRunnerRequestState({
       }
       const expiresAtMs = Date.parse(String(session.expires_at || "").trim());
       const expired = Number.isFinite(expiresAtMs) && expiresAtMs <= nowMs;
-      const activeRequests = Object.values(nextRequests).filter((entry) => (
-        String(entry.project_id || "").trim() === String(candidateRoute.projectID || "").trim()
-        && String(entry.provider || "").trim() === String(candidateRoute.provider || "").trim()
-        && String(entry.conversation_id || "").trim() === String(conversationID || "").trim()
-        && isActiveRunnerRequestStatus(entry.status)
-      ));
-      const pendingContinuationResponders = ensureArray(session.next_expected_responders)
-        .map((value) => normalizeTelegramMentionUsername(value))
-        .filter(Boolean);
-      if (!expired && (activeRequests.length > 0 || pendingContinuationResponders.length > 0)) {
-        continue;
-      }
+      let activeRequests = Object.values(nextRequests).filter((entry) => (
+        String(entry.project_id || "").trim() === String(candidateRoute.projectID || "").trim()
+        && String(entry.provider || "").trim() === String(candidateRoute.provider || "").trim()
+        && String(entry.conversation_id || "").trim() === String(conversationID || "").trim()
+        && isActiveRunnerRequestStatus(entry.status)
+      ));
+      if (String(session.mode || "").trim() === "direct_single_bot") {
+        const directMessageRequestKey = String(session.request_key || "").trim();
+        if (directMessageRequestKey) {
+          const directMessageRequest = safeObject(nextRequests[directMessageRequestKey]);
+          if (
+            Object.keys(directMessageRequest).length > 0
+            && isActiveRunnerRequestStatus(directMessageRequest.status)
+            && String(directMessageRequest.project_id || "").trim() === String(candidateRoute.projectID || "").trim()
+            && String(directMessageRequest.provider || "").trim() === String(candidateRoute.provider || "").trim()
+            && !activeRequests.some((entry) => String(entry.request_key || "").trim() === directMessageRequestKey)
+          ) {
+            activeRequests = [...activeRequests, directMessageRequest];
+          }
+        }
+      }
+      const pendingContinuationResponders = ensureArray(session.next_expected_responders)
+        .map((value) => normalizeTelegramMentionUsername(value))
+        .filter(Boolean);
+      if (String(session.mode || "").trim() === "direct_single_bot" && !expired) {
+        continue;
+      }
+      if (!expired && (activeRequests.length > 0 || pendingContinuationResponders.length > 0)) {
+        continue;
+      }
       const closedReason = expired ? "expired_session" : "orphaned_open_session";
       conversationSessions[conversationID] = {
         ...session,
@@ -7096,18 +8328,30 @@ function mergeRunnerRequestForServerHydration(localEntryRaw, serverEntryRaw) {
       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;
+  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 clearMergedStringWhenServerBlank = (fieldName) => {
+    const serverValue = String(serverEntry[fieldName] || "").trim();
+    if (!serverValue) {
+      delete merged[fieldName];
+    }
+  };
+  const clearMergedArrayWhenServerEmpty = (fieldName) => {
+    const serverValues = ensureArray(serverEntry[fieldName]).filter(Boolean);
+    if (serverValues.length === 0) {
+      delete merged[fieldName];
+    }
+  };
+  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");
@@ -7126,6 +8370,8 @@ function mergeRunnerRequestForServerHydration(localEntryRaw, serverEntryRaw) {
   preserveLocalStringWhenServerBlank("conversation_reply_expectation");
   preserveLocalStringWhenServerBlank("decision_bundle_validation_status");
   preserveLocalStringWhenServerBlank("decision_bundle_validation_reason");
+  preserveLocalStringWhenServerBlank("last_reply_decision_bundle_validation_status");
+  preserveLocalStringWhenServerBlank("last_reply_decision_bundle_validation_reason");
   preserveLocalStringWhenServerBlank("execution_contract_type");
   preserveLocalStringWhenServerBlank("normalized_execution_contract_type");
   preserveLocalStringWhenServerBlank("ai_reply_generated_at");
@@ -7136,16 +8382,13 @@ function mergeRunnerRequestForServerHydration(localEntryRaw, serverEntryRaw) {
   preserveLocalStringWhenServerBlank("root_thread_id");
   preserveLocalStringWhenServerBlank("root_work_item_created_at");
   preserveLocalStringWhenServerBlank("root_work_item_last_error");
-  preserveLocalStringWhenServerBlank("root_execution_contract_type");
-  preserveLocalStringWhenServerBlank("root_ai_reply_preview");
-  preserveLocalStringWhenServerBlank("root_response_contract_validation_status");
-  preserveLocalStringWhenServerBlank("root_response_contract_validation_reason");
-  preserveLocalStringWhenServerBlank("followup_ai_reply_preview");
-  preserveLocalStringWhenServerBlank("followup_execution_contract_type");
-  preserveLocalStringWhenServerBlank("followup_normalized_execution_contract_type");
-  preserveLocalStringWhenServerBlank("followup_response_contract_validation_status");
-  preserveLocalStringWhenServerBlank("followup_response_contract_validation_reason");
-  preserveLocalStringWhenServerBlank("followup_assignment_validation_status");
+  preserveLocalStringWhenServerBlank("root_ai_reply_preview");
+  preserveLocalStringWhenServerBlank("root_response_contract_validation_status");
+  preserveLocalStringWhenServerBlank("root_response_contract_validation_reason");
+  preserveLocalStringWhenServerBlank("followup_ai_reply_preview");
+  preserveLocalStringWhenServerBlank("followup_response_contract_validation_status");
+  preserveLocalStringWhenServerBlank("followup_response_contract_validation_reason");
+  preserveLocalStringWhenServerBlank("followup_assignment_validation_status");
   preserveLocalStringWhenServerBlank("followup_assignment_validation_reason");
   preserveLocalStringWhenServerBlank("followup_delivery_status");
   preserveLocalStringWhenServerBlank("followup_archive_status");
@@ -7154,24 +8397,24 @@ function mergeRunnerRequestForServerHydration(localEntryRaw, serverEntryRaw) {
   preserveLocalArrayWhenServerEmpty("conversation_participants");
   preserveLocalArrayWhenServerEmpty("conversation_initial_responders");
   preserveLocalArrayWhenServerEmpty("conversation_allowed_responders");
-  preserveLocalArrayWhenServerEmpty("execution_contract_targets");
-  preserveLocalArrayWhenServerEmpty("next_expected_responders");
-  preserveLocalArrayWhenServerEmpty("normalized_execution_contract_targets");
-  preserveLocalArrayWhenServerEmpty("normalized_execution_next_responders");
-  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("root_response_contract_validation_targets");
   preserveLocalArrayWhenServerEmpty("followup_response_contract_validation_targets");
   preserveLocalArrayWhenServerEmpty("followup_assignment_validation_modes");
   preserveLocalObjectWhenServerBlank("authoritative_decision_bundle");
+  preserveLocalObjectWhenServerBlank("last_reply_decision_bundle");
   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;
-  }
+  clearMergedStringWhenServerBlank("root_execution_contract_type");
+  clearMergedArrayWhenServerEmpty("root_execution_contract_targets");
+  clearMergedArrayWhenServerEmpty("root_next_expected_responders");
+  clearMergedStringWhenServerBlank("followup_execution_contract_type");
+  clearMergedStringWhenServerBlank("followup_normalized_execution_contract_type");
+  clearMergedArrayWhenServerEmpty("followup_execution_contract_targets");
+  clearMergedArrayWhenServerEmpty("followup_next_expected_responders");
+  clearMergedArrayWhenServerEmpty("followup_normalized_execution_contract_targets");
+  clearMergedArrayWhenServerEmpty("followup_normalized_execution_next_responders");
+  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;
   }
@@ -7729,31 +8972,60 @@ function scanExternalProjectArtifacts({
   };
 }
 
-function normalizeRunnerRouteIdentityText(rawValue) {
-  return String(rawValue || "").trim().toLowerCase();
-}
-
-function runnerRouteLogicalSignature(route) {
-  const normalized = normalizeRunnerRoute(route);
-  return [
-    normalized.projectID || "-",
-    normalized.provider || "-",
-    normalized.role || "-",
-    normalized.botID || normalizeRunnerRouteIdentityText(normalized.botName) || "-",
-    normalized.destinationID || normalizeRunnerRouteIdentityText(normalized.destinationLabel) || "-",
-  ].join("::");
-}
-
-function describeRunnerRouteLogicalTarget(route) {
-  const normalized = normalizeRunnerRoute(route);
-  return [
-    `project_id=${normalized.projectID || "-"}`,
-    `provider=${normalized.provider || "-"}`,
-    `role=${normalized.role || "-"}`,
-    `server_bot=${normalized.botName || normalized.botID || "-"}`,
-    `destination=${normalized.destinationLabel || normalized.destinationID || "-"}`,
-  ].join(", ");
-}
+function normalizeRunnerRouteIdentityText(rawValue) {
+  return String(rawValue || "").trim().toLowerCase();
+}
+
+function normalizeRunnerRouteKind(rawValue, fallback = "room") {
+  const value = String(rawValue || "").trim().toLowerCase();
+  if (["dm", "direct-messages", "direct_messages", "private", "private-chat", "private_chat"].includes(value)) {
+    return "dm";
+  }
+  if (["room", "chat-room", "chat_room"].includes(value)) {
+    return "room";
+  }
+  return fallback;
+}
+
+function buildRunnerRouteTargetIdentity(route) {
+  const normalized = normalizeRunnerRoute(route);
+  if (normalized.routeKind === "dm") {
+    return "direct-messages";
+  }
+  return normalized.destinationID || normalizeRunnerRouteIdentityText(normalized.destinationLabel) || "-";
+}
+
+function describeRunnerRouteTargetLabel(route) {
+  const normalized = normalizeRunnerRoute(route);
+  if (normalized.routeKind === "dm") {
+    return "Direct Messages";
+  }
+  return normalized.destinationLabel || normalized.destinationID || "-";
+}
+
+function runnerRouteLogicalSignature(route) {
+  const normalized = normalizeRunnerRoute(route);
+  return [
+    normalized.projectID || "-",
+    normalized.provider || "-",
+    normalized.routeKind || "room",
+    normalized.role || "-",
+    normalized.botID || normalizeRunnerRouteIdentityText(normalized.botName) || "-",
+    buildRunnerRouteTargetIdentity(normalized),
+  ].join("::");
+}
+
+function describeRunnerRouteLogicalTarget(route) {
+  const normalized = normalizeRunnerRoute(route);
+  return [
+    `project_id=${normalized.projectID || "-"}`,
+    `provider=${normalized.provider || "-"}`,
+    `route_kind=${normalized.routeKind || "room"}`,
+    `role=${normalized.role || "-"}`,
+    `server_bot=${normalized.botName || normalized.botID || "-"}`,
+    `target=${describeRunnerRouteTargetLabel(normalized)}`,
+  ].join(", ");
+}
 
 function findRunnerRouteLogicalConflicts(route, config) {
   const normalizedRoute = normalizeRunnerRoute(route);
@@ -7873,14 +9145,23 @@ async function runTasksWithConcurrencyLimit(items, limit, worker) {
   return output;
 }
 
-function runnerRouteSchedulingGroupKey(route) {
-  const normalized = normalizeRunnerRoute(route);
-  return [
-    String(normalized.projectID || "").trim(),
-    String(normalized.provider || "").trim(),
-    String(normalized.destinationID || "").trim() || String(normalized.destinationLabel || "").trim() || String(normalized.name || "").trim(),
-  ].join("::");
-}
+function runnerRouteSchedulingGroupKey(route) {
+  const normalized = normalizeRunnerRoute(route);
+  if (normalized.routeKind === "dm") {
+    return [
+      String(normalized.projectID || "").trim(),
+      String(normalized.provider || "").trim(),
+      String(normalized.routeKind || "room").trim(),
+      String(normalized.botID || "").trim() || normalizeRunnerRouteIdentityText(normalized.botName) || String(normalized.name || "").trim(),
+    ].join("::");
+  }
+  return [
+    String(normalized.projectID || "").trim(),
+    String(normalized.provider || "").trim(),
+    String(normalized.routeKind || "room").trim(),
+    String(normalized.destinationID || "").trim() || String(normalized.destinationLabel || "").trim() || String(normalized.name || "").trim(),
+  ].join("::");
+}
 
 function groupRunnerRoutesBySchedulingTarget(routes) {
   const groups = [];
@@ -7914,13 +9195,14 @@ function normalizeBotRole(rawValue) {
   return "";
 }
 
-function normalizeRunnerRoute(rawRoute, overrides = {}) {
-  const route = {
-    ...safeObject(rawRoute),
-    ...safeObject(overrides),
-  };
-  const projectID = String(route.project_id || route.projectID || "").trim();
-  const provider = normalizeBotProvider(route.provider);
+function normalizeRunnerRoute(rawRoute, overrides = {}) {
+  const route = {
+    ...safeObject(rawRoute),
+    ...safeObject(overrides),
+  };
+  const routeKind = normalizeRunnerRouteKind(route.route_kind ?? route.routeKind);
+  const projectID = String(route.project_id || route.projectID || "").trim();
+  const provider = normalizeBotProvider(route.provider);
   const role = normalizeBotRole(route.role || route.bot_role || route.botRole);
   const roleProfile = normalizeRunnerRoleProfileName(route.role_profile || route.roleProfile || route.execution_profile || route.executionProfile);
   const name = String(route.name || "").trim();
@@ -7938,11 +9220,12 @@ function normalizeRunnerRoute(rawRoute, overrides = {}) {
     route.dry_run_delivery ?? route.dryRunDelivery ?? process.env.METHEUS_BOT_DELIVERY_DRY_RUN,
     false,
   );
-  return {
-    name,
-    enabled: boolFromRaw(route.enabled, true),
-    projectID,
-    provider,
+  return {
+    name,
+    enabled: boolFromRaw(route.enabled, true),
+    routeKind,
+    projectID,
+    provider,
     role,
     roleProfile,
     botName,
@@ -7962,17 +9245,18 @@ function normalizeRunnerRoute(rawRoute, overrides = {}) {
   };
 }
 
-function runnerRouteKey(route) {
-  const normalized = normalizeRunnerRoute(route);
-  return [
-    normalized.name || "-",
-    normalized.projectID || "-",
-    normalized.provider || "-",
-    normalized.role || "-",
-    normalized.botID || normalized.botName || "-",
-    normalized.destinationID || normalized.destinationLabel || "-",
-  ].join("::");
-}
+function runnerRouteKey(route) {
+  const normalized = normalizeRunnerRoute(route);
+  return [
+    normalized.name || "-",
+    normalized.projectID || "-",
+    normalized.provider || "-",
+    normalized.routeKind || "room",
+    normalized.role || "-",
+    normalized.botID || normalized.botName || "-",
+    buildRunnerRouteTargetIdentity(normalized),
+  ].join("::");
+}
 
 function validateRunnerRoute(route, { requireCommand = true, config = null } = {}) {
   const errors = [];
@@ -7984,12 +9268,15 @@ function validateRunnerRoute(route, { requireCommand = true, config = null } = {
   if (!route.provider) {
     errors.push("provider is required");
   }
-  if (!route.role) {
-    errors.push("role must be one of: monitor, review, worker, approval");
-  }
-  if (requireCommand && !route.command) {
-    errors.push("command is required");
-  }
+  if (!route.role) {
+    errors.push("role must be one of: monitor, review, worker, approval");
+  }
+  if (route.routeKind === "room" && !route.destinationID && !route.destinationLabel) {
+    errors.push("destination_id or destination_label is required for room routes");
+  }
+  if (requireCommand && !route.command) {
+    errors.push("command is required");
+  }
   const configuredRoleProfiles = safeObject(normalizedConfig.roleProfiles);
   const resolvedRoleProfileName = normalizeRunnerRoleProfileName(route.roleProfile || route.role);
   if (resolvedRoleProfileName && !configuredRoleProfiles[resolvedRoleProfileName] && !legacyCommandAvailable) {
@@ -8050,10 +9337,10 @@ function resolveConfiguredRunnerRouteServerBotName(route, telegramEntries = [])
   return String(matchedTelegramEntry?.serverBotName || "").trim();
 }
 
-function configuredRunnerRouteMatchesInlineSelection(route, inlineRoute, flags, options = {}) {
-  const candidate = normalizeRunnerRoute(route);
-  const candidateBotName = resolveConfiguredRunnerRouteServerBotName(candidate, options.telegramEntries);
-  if (hasRunnerFlag(flags, "route-name") && !matchesRunnerRouteText(candidate.name, flags["route-name"])) {
+function configuredRunnerRouteMatchesInlineSelection(route, inlineRoute, flags, options = {}) {
+  const candidate = normalizeRunnerRoute(route);
+  const candidateBotName = resolveConfiguredRunnerRouteServerBotName(candidate, options.telegramEntries);
+  if (hasRunnerFlag(flags, "route-name") && !matchesRunnerRouteText(candidate.name, flags["route-name"])) {
     return false;
   }
   if (inlineRoute.projectID && candidate.projectID !== inlineRoute.projectID) {
@@ -8062,12 +9349,15 @@ function configuredRunnerRouteMatchesInlineSelection(route, inlineRoute, flags,
   if (inlineRoute.provider && candidate.provider !== inlineRoute.provider) {
     return false;
   }
-  if (inlineRoute.role && candidate.role !== inlineRoute.role) {
-    return false;
-  }
-  if (hasRunnerFlag(flags, "role-profile") && candidate.roleProfile !== inlineRoute.roleProfile) {
-    return false;
-  }
+  if (inlineRoute.role && candidate.role !== inlineRoute.role) {
+    return false;
+  }
+  if (hasRunnerFlag(flags, "route-kind") && candidate.routeKind !== inlineRoute.routeKind) {
+    return false;
+  }
+  if (hasRunnerFlag(flags, "role-profile") && candidate.roleProfile !== inlineRoute.roleProfile) {
+    return false;
+  }
   if (inlineRoute.botID && candidate.botID !== inlineRoute.botID) {
     return false;
   }
@@ -8089,8 +9379,8 @@ function configuredRunnerRouteMatchesInlineSelection(route, inlineRoute, flags,
   return true;
 }
 
-function applyRunnerRouteFlagOverrides(route, flags) {
-  const merged = normalizeRunnerRoute(route);
+function applyRunnerRouteFlagOverrides(route, flags) {
+  const merged = normalizeRunnerRoute(route);
   if (hasRunnerFlag(flags, "route-name")) {
     merged.name = String(flags["route-name"] || "").trim();
   }
@@ -8103,12 +9393,15 @@ function applyRunnerRouteFlagOverrides(route, flags) {
   if (hasRunnerFlag(flags, "role")) {
     merged.role = normalizeBotRole(flags.role);
   }
-  if (hasRunnerFlag(flags, "role-profile")) {
-    merged.roleProfile = normalizeRunnerRoleProfileName(flags["role-profile"]);
-  }
-  if (hasRunnerFlag(flags, "bot-name")) {
-    merged.botName = String(flags["bot-name"] || "").trim();
-  }
+  if (hasRunnerFlag(flags, "role-profile")) {
+    merged.roleProfile = normalizeRunnerRoleProfileName(flags["role-profile"]);
+  }
+  if (hasRunnerFlag(flags, "route-kind")) {
+    merged.routeKind = normalizeRunnerRouteKind(flags["route-kind"], merged.routeKind || "room");
+  }
+  if (hasRunnerFlag(flags, "bot-name")) {
+    merged.botName = String(flags["bot-name"] || "").trim();
+  }
   if (hasRunnerFlag(flags, "bot-id")) {
     merged.botID = String(flags["bot-id"] || "").trim();
   }
@@ -8194,12 +9487,13 @@ function applyRunnerRouteFlagOverrides(route, flags) {
   return merged;
 }
 
-function resolveRunnerRoutes(flags, mode) {
-  const inlineRoute = normalizeRunnerRoute({
-    name: flags["route-name"],
-    enabled: true,
-    project_id: flags["project-id"],
-    provider: flags.provider,
+function resolveRunnerRoutes(flags, mode) {
+  const inlineRoute = normalizeRunnerRoute({
+    name: flags["route-name"],
+    enabled: true,
+    ...(hasRunnerFlag(flags, "route-kind") ? { route_kind: flags["route-kind"] } : {}),
+    project_id: flags["project-id"],
+    provider: flags.provider,
     role: flags.role,
     role_profile: flags["role-profile"],
     bot_name: flags["bot-name"],
@@ -8309,13 +9603,29 @@ function resolveRunnerRoutes(flags, mode) {
   );
 }
 
-async function listProjectChatDestinations(params) {
-  return listProjectChatDestinationsImpl(params, buildRunnerDataDeps());
-}
-
-async function listProjectContextItems(params) {
-  return listProjectContextItemsImpl(params, buildRunnerDataDeps());
-}
+async function listProjectChatDestinations(params) {
+  return listProjectChatDestinationsImpl(params, buildRunnerDataDeps());
+}
+
+async function getProjectRunnerSettings(params) {
+  return getProjectRunnerSettingsImpl(params, buildRunnerDataDeps());
+}
+
+async function listProjectPrivateChats(params) {
+  return listProjectPrivateChatsImpl(params, buildRunnerDataDeps());
+}
+
+async function createProjectPrivateChat(params) {
+  return createProjectPrivateChatImpl(params, buildRunnerDataDeps());
+}
+
+async function updateProjectPrivateChat(params) {
+  return updateProjectPrivateChatImpl(params, buildRunnerDataDeps());
+}
+
+async function listProjectContextItems(params) {
+  return listProjectContextItemsImpl(params, buildRunnerDataDeps());
+}
 
 async function listProjectRunnerRequests(params) {
   return listProjectRunnerRequestsImpl(params, buildRunnerDataDeps());
@@ -8394,7 +9704,7 @@ function buildTelegramArchiveStructuredPayload(normalized) {
       occurredAt: normalized?.occurredAt,
       messageThreadID: normalized?.messageThreadID,
       replyToMessageID: normalized?.replyToMessageID,
-      body: normalized?.text,
+      body: normalized?.body || normalized?.text,
     }),
     sourceOrigin: String(normalized?.archiveSourceOrigin || normalized?.sourceOrigin || "").trim().toLowerCase(),
     sourceRouteKey: String(normalized?.archiveSourceRouteKey || normalized?.sourceRouteKey || "").trim(),
@@ -8403,7 +9713,11 @@ function buildTelegramArchiveStructuredPayload(normalized) {
     replyToSender: String(normalized?.replyToFromName || "").trim(),
     replyToUsername: String(normalized?.replyToFromUsername || "").trim(),
     replyToSenderIsBot: normalized?.replyToFromIsBot === true,
-    body: String(normalized?.text || "").trim(),
+    body: String(normalized?.body || normalized?.text || "").trim(),
+    caption: String(normalized?.caption || "").trim(),
+    attachments: normalizeTelegramMessageAttachments(normalized?.attachments),
+    derivedText: String(normalized?.derivedText || normalized?.derived_text || "").trim(),
+    derivedTextSource: String(normalized?.derivedTextSource || normalized?.derived_text_source || "").trim().toLowerCase(),
   };
   return payload;
 }
@@ -8547,6 +9861,12 @@ function parseArchivedChatComment(rawBody) {
     replyToSenderIsBot: payloadHas("replyToSenderIsBot")
       ? boolFromRaw(structuredPayload.replyToSenderIsBot, false)
       : boolFromRaw(metadata.reply_to_sender_is_bot, false),
+    caption: String(safeObject(structuredPayload).caption || metadata.caption || "").trim(),
+    attachments: normalizeTelegramMessageAttachments(
+      safeObject(structuredPayload).attachments,
+    ),
+    derivedText: String(safeObject(structuredPayload).derivedText || metadata.derived_text || "").trim(),
+    derivedTextSource: String(safeObject(structuredPayload).derivedTextSource || metadata.derived_text_source || "").trim().toLowerCase(),
     botID: firstNonEmptyString([safeObject(structuredPayload).botID, metadata.bot_id]),
     botName: firstNonEmptyString([safeObject(structuredPayload).botName, metadata.bot_name]),
     botUsername: normalizeTelegramMentionUsername(
@@ -8793,9 +10113,107 @@ function toISOStringFromUnix(rawValue) {
   return new Date(numeric * 1000).toISOString();
 }
 
-function collectTelegramUpdateText(message) {
-  return firstNonEmptyString([message?.text, message?.caption]);
-}
+function collectTelegramUpdateText(message) {
+  return firstNonEmptyString([message?.text, message?.caption]);
+}
+
+function normalizeTelegramAttachmentKind(rawValue) {
+  const value = String(rawValue || "").trim().toLowerCase();
+  if (!value) return "";
+  if (["image", "picture"].includes(value)) return "photo";
+  if (["voice_note", "voice-message", "voice_message"].includes(value)) return "voice";
+  if (["file", "attachment"].includes(value)) return "document";
+  return value;
+}
+
+function normalizeTelegramAttachmentMetadata(kind, rawAttachment, extra = {}) {
+  const attachment = safeObject(rawAttachment);
+  const normalizedKind = normalizeTelegramAttachmentKind(kind);
+  const fileID = String(attachment.file_id || "").trim();
+  if (!normalizedKind || !fileID) {
+    return null;
+  }
+  const normalized = {
+    kind: normalizedKind,
+    file_id: fileID,
+  };
+  const fileUniqueID = String(attachment.file_unique_id || "").trim();
+  if (fileUniqueID) {
+    normalized.file_unique_id = fileUniqueID;
+  }
+  const mimeType = String(attachment.mime_type || "").trim().toLowerCase();
+  if (mimeType) {
+    normalized.mime_type = mimeType;
+  }
+  const caption = String(extra.caption || "").trim();
+  if (caption) {
+    normalized.caption = caption;
+  }
+  const mediaGroupID = String(extra.media_group_id || attachment.media_group_id || "").trim();
+  if (mediaGroupID) {
+    normalized.media_group_id = mediaGroupID;
+  }
+  const fileName = String(attachment.file_name || "").trim();
+  if (fileName) {
+    normalized.file_name = fileName;
+  }
+  for (const [sourceKey, targetKey] of [
+    ["duration", "duration"],
+    ["file_size", "file_size"],
+    ["width", "width"],
+    ["height", "height"],
+  ]) {
+    const parsed = intFromRawAllowZero(attachment[sourceKey], 0);
+    if (parsed > 0) {
+      normalized[targetKey] = parsed;
+    }
+  }
+  return normalized;
+}
+
+function collectTelegramUpdateAttachments(message) {
+  const safeMessage = safeObject(message);
+  const normalizedAttachments = [];
+  const caption = String(safeMessage.caption || "").trim();
+  const mediaGroupID = String(safeMessage.media_group_id || "").trim();
+  const photoCandidates = ensureArray(safeMessage.photo)
+    .map((item) => safeObject(item))
+    .filter((item) => String(item.file_id || "").trim());
+  if (photoCandidates.length > 0) {
+    const selectedPhoto = photoCandidates
+      .slice()
+      .sort((left, right) => {
+        const leftScore = intFromRawAllowZero(left.file_size, 0)
+          || (intFromRawAllowZero(left.width, 0) * intFromRawAllowZero(left.height, 0));
+        const rightScore = intFromRawAllowZero(right.file_size, 0)
+          || (intFromRawAllowZero(right.width, 0) * intFromRawAllowZero(right.height, 0));
+        return leftScore - rightScore;
+      })
+      .pop();
+    const normalizedPhoto = normalizeTelegramAttachmentMetadata("photo", selectedPhoto, {
+      caption,
+      media_group_id: mediaGroupID,
+    });
+    if (normalizedPhoto) {
+      normalizedAttachments.push(normalizedPhoto);
+    }
+  }
+  for (const [kind, rawValue] of [
+    ["voice", safeMessage.voice],
+    ["audio", safeMessage.audio],
+    ["document", safeMessage.document],
+    ["video", safeMessage.video],
+  ]) {
+    const normalized = normalizeTelegramAttachmentMetadata(kind, rawValue, {
+      caption,
+      media_group_id: mediaGroupID,
+    });
+    if (normalized) {
+      normalizedAttachments.push(normalized);
+    }
+  }
+  return normalizeTelegramMessageAttachments(normalizedAttachments);
+}
 
 function normalizeTelegramMentionUsername(rawValue) {
   return String(rawValue || "").trim().replace(/^@+/, "").toLowerCase();
@@ -8830,23 +10248,29 @@ function extractTelegramMentionUsernames(text, entities) {
   return Array.from(set);
 }
 
-function normalizeLocalTelegramUpdate(rawUpdate) {
+function normalizeLocalTelegramUpdate(rawUpdate) {
   const update = safeObject(rawUpdate);
   const message = safeObject(update.message || update.edited_message);
   if (!message || Object.keys(message).length === 0) {
     return null;
   }
-  const chat = safeObject(message.chat);
-  const from = safeObject(message.from);
-  const replyTo = safeObject(message.reply_to_message);
-  const replyToFrom = safeObject(replyTo.from);
-  const text = collectTelegramUpdateText(message);
-  if (!text) {
-    return null;
-  }
-  const mentionUsernames = extractTelegramMentionUsernames(
-    text,
-    message.entities || message.caption_entities,
+  const chat = safeObject(message.chat);
+  const from = safeObject(message.from);
+  const replyTo = safeObject(message.reply_to_message);
+  const replyToFrom = safeObject(replyTo.from);
+  const caption = String(message.caption || "").trim();
+  const attachments = collectTelegramUpdateAttachments(message);
+  const text = collectTelegramUpdateText(message);
+  const normalizedBody = firstNonEmptyString([
+    text,
+    buildTelegramMediaPlaceholder(attachments),
+  ]);
+  if (!normalizedBody) {
+    return null;
+  }
+  const mentionUsernames = extractTelegramMentionUsernames(
+    text,
+    message.entities || message.caption_entities,
   );
   return {
     eventName: update.edited_message ? "telegram.message.updated" : "telegram.message.created",
@@ -8856,12 +10280,17 @@ function normalizeLocalTelegramUpdate(rawUpdate) {
     chatType: String(chat.type || "").trim(),
     chatTitle: firstNonEmptyString([chat.title, chat.username, joinTextParts([chat.first_name, chat.last_name]), chat.id]),
     fromID: String(from.id || "").trim(),
-    fromName: firstNonEmptyString([joinTextParts([from.first_name, from.last_name]), from.username, from.id]),
-    fromUsername: String(from.username || "").trim(),
-    fromIsBot: Boolean(from.is_bot),
-    mentionUsernames,
-    text,
-    occurredAt: toISOStringFromUnix(message.edit_date || message.date),
+    fromName: firstNonEmptyString([joinTextParts([from.first_name, from.last_name]), from.username, from.id]),
+    fromUsername: String(from.username || "").trim(),
+    fromIsBot: Boolean(from.is_bot),
+    mentionUsernames,
+    text: normalizedBody,
+    body: normalizedBody,
+    caption,
+    attachments,
+    derivedText: "",
+    derivedTextSource: "",
+    occurredAt: toISOStringFromUnix(message.edit_date || message.date),
     messageThreadID: String(message.message_thread_id || "").trim(),
     replyToMessageID: intFromRawAllowZero(replyTo.message_id, 0),
     replyToFromName: firstNonEmptyString([joinTextParts([replyToFrom.first_name, replyToFrom.last_name]), replyToFrom.username, replyToFrom.id]),
@@ -8907,6 +10336,7 @@ function formatTelegramInboundArchiveComment(normalized) {
   const archiveSourceRouteKey = String(normalized.archiveSourceRouteKey || normalized.sourceRouteKey || "").trim();
   const archiveSourceBotUsername = String(normalized.archiveSourceBotUsername || normalized.sourceBotUsername || "").trim();
   const archivePayload = buildTelegramArchiveStructuredPayload(normalized);
+  const normalizedAttachments = normalizeTelegramMessageAttachments(normalized.attachments);
   const headerLines = [
     `[Telegram ${normalized.eventName === "telegram.message.updated" ? "edited" : "message"}]`,
     `chat_id: ${normalized.chatID || "<missing>"}`,
@@ -8929,10 +10359,19 @@ function formatTelegramInboundArchiveComment(normalized) {
   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) {
+  if (normalized.mentionUsernames.length > 0) {
+    headerLines.push(`mention_usernames: ${normalized.mentionUsernames.map((item) => `@${item}`).join(", ")}`);
+  }
+  if (normalizedAttachments.length > 0) {
+    headerLines.push(`attachment_kinds: ${normalizedAttachments.map((item) => item.kind).join(", ")}`);
+  }
+  if (normalized.caption) {
+    headerLines.push(`caption: ${String(normalized.caption).trim()}`);
+  }
+  if (normalized.derivedTextSource) {
+    headerLines.push(`derived_text_source: ${String(normalized.derivedTextSource).trim().toLowerCase()}`);
+  }
+  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) {
@@ -8941,12 +10380,12 @@ function formatTelegramInboundArchiveComment(normalized) {
     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)}`);
   }
   headerLines.push(`archive_payload_json: ${JSON.stringify(archivePayload)}`);
-  return `${headerLines.join("\n")}\n\n${String(normalized.text || "").trim()}`;
+  return `${headerLines.join("\n")}\n\n${String(normalized.body || normalized.text || "").trim()}`;
 }
 
 async function postJSONWithAuthHeaders(urlText, timeoutSeconds, token, payload, extraHeaders = {}) {
@@ -9905,25 +11344,33 @@ function buildRunnerShowActiveExecutionPayload(activeExecutionStateRaw) {
   };
 }
 
-function buildRunnerShowResolvedContext({
-  normalizedRoute,
-  diagnostics,
-  envConfig,
-  resolvedServerBotName,
+function buildRunnerShowResolvedContext({
+  normalizedRoute,
+  diagnostics,
+  envConfig,
+  resolvedServerBotName,
   botNameSource,
 }) {
-  return {
-    resolved_server_identity: {
-      server_bot_name: resolvedServerBotName,
-      server_bot_name_source: botNameSource,
-      server_bot_id: normalizedRoute.botID || "-",
-      telegram_entry_file: String(envConfig?.entryFilePath || "").trim() || "-",
-    },
-    resolved_destination: {
-      destination_label: String(normalizedRoute.destinationLabel || "").trim() || "-",
-      destination_id: String(normalizedRoute.destinationID || "").trim() || "-",
-      destination_source: "route_config",
-    },
+  return {
+    resolved_server_identity: {
+      server_bot_name: resolvedServerBotName,
+      server_bot_name_source: botNameSource,
+      server_bot_id: normalizedRoute.botID || "-",
+      telegram_entry_file: String(envConfig?.entryFilePath || "").trim() || "-",
+    },
+    route_target: {
+      route_kind: normalizedRoute.routeKind || "room",
+      target_label: describeRunnerRouteTargetLabel(normalizedRoute),
+    },
+    resolved_destination: {
+      destination_label: normalizedRoute.routeKind === "dm"
+        ? "Direct Messages"
+        : (String(normalizedRoute.destinationLabel || "").trim() || "-"),
+      destination_id: normalizedRoute.routeKind === "dm"
+        ? "-"
+        : (String(normalizedRoute.destinationID || "").trim() || "-"),
+      destination_source: normalizedRoute.routeKind === "dm" ? "route_kind" : "route_config",
+    },
     workspace_mapping: {
       workspace_dir: diagnostics.workspaceDir || "-",
       workspace_source: diagnostics.workspaceSource || "-",
@@ -10167,8 +11614,8 @@ async function resolveInformationalQueryReply({
   return lookupOnlyResponse || null;
 }
 
-function buildRunnerExecutionDeps() {
-  return {
+function buildRunnerExecutionDeps() {
+  return {
     adjudicateRunnerStartupLoopWithAI,
     analyzeHumanConversationIntentWithAI,
     auditRoleExecutionPlanWithAI,
@@ -10197,6 +11644,8 @@ function buildRunnerExecutionDeps() {
     createProjectContextItem,
     replaceProjectCtxpackFiles,
     resolveInformationalQueryReply,
+    transcribeRunnerTelegramAudioAttachments,
+    analyzeRunnerTelegramImageAttachments,
     prepareRunnerSelectedRecordRecoveryContext: (input) => prepareRunnerSelectedRecordRecoveryContextImpl({
       ...safeObject(input),
       deps: buildRunnerRecoveryDeps(),
@@ -10204,15 +11653,19 @@ function buildRunnerExecutionDeps() {
   };
 }
 
-function buildRunnerRuntimeDeps() {
-  return {
-    loadProviderEnvConfig,
-    loadBotRunnerState,
-    saveBotRunnerState,
-    getTelegramBotMe,
-    getTelegramWebhookInfo,
-    deleteTelegramWebhook,
-    saveRunnerRouteState,
+function buildRunnerRuntimeDeps() {
+  return {
+    loadProviderEnvConfig,
+    loadBotRunnerState,
+    saveBotRunnerState,
+    getProjectRunnerSettings,
+    listProjectPrivateChats,
+    createProjectPrivateChat,
+    updateProjectPrivateChat,
+    getTelegramBotMe,
+    getTelegramWebhookInfo,
+    deleteTelegramWebhook,
+    saveRunnerRouteState,
     getTelegramUpdates,
     normalizeLocalTelegramUpdate,
     listThreadComments,
@@ -10555,23 +12008,34 @@ async function processRunnerRouteOnce(route, runtime, mode, options = {}) {
       runnerConfig,
       buildRunnerExecutionDeps(),
     );
-    const destinations = await listProjectChatDestinations({
-      siteBaseURL: runtime.baseURL,
-      projectID: normalizedRoute.projectID,
-      token: runtime.token,
-      timeoutSeconds: runtime.timeoutSeconds,
-    });
-    const destination = selectProjectChatDestination(
-      destinations,
-      {
-        destinationID: normalizedRoute.destinationID,
-        destinationLabel: normalizedRoute.destinationLabel,
-      },
-      normalizedRoute.provider,
-    );
-    const archiveThread = await discoverArchiveThreadForDestination({
-      siteBaseURL: runtime.baseURL,
-      projectID: normalizedRoute.projectID,
+    const destination = normalizedRoute.routeKind === "dm"
+      ? {
+        id: "",
+        label: `Direct Messages - ${String(bot?.name || bot?.username || normalizedRoute.botName || normalizedRoute.name || "Bot").trim()}`,
+        chatID: `dm:${normalizeTelegramBotUsername(bot?.username || bot?.name || normalizedRoute.botName) || normalizedRoute.botID || normalizedRoute.name}`,
+        provider: normalizedRoute.provider,
+        routeKind: "dm",
+        isDirectMessage: true,
+      }
+      : await (async () => {
+        const destinations = await listProjectChatDestinations({
+          siteBaseURL: runtime.baseURL,
+          projectID: normalizedRoute.projectID,
+          token: runtime.token,
+          timeoutSeconds: runtime.timeoutSeconds,
+        });
+        return selectProjectChatDestination(
+          destinations,
+          {
+            destinationID: normalizedRoute.destinationID,
+            destinationLabel: normalizedRoute.destinationLabel,
+          },
+          normalizedRoute.provider,
+        );
+      })();
+    const archiveThread = await discoverArchiveThreadForDestination({
+      siteBaseURL: runtime.baseURL,
+      projectID: normalizedRoute.projectID,
       provider: normalizedRoute.provider,
       destination,
       token: runtime.token,
@@ -10668,9 +12132,7 @@ async function processRunnerRouteOnce(route, runtime, mode, options = {}) {
     });
     const followupRequestsForPending = Object.values(requests).filter((entryRaw) => {
       const entry = safeObject(entryRaw);
-      const nextExpectedResponders = ensureArray(entry.next_expected_responders)
-        .map((value) => normalizeTelegramMentionUsername(value))
-        .filter(Boolean);
+      const nextExpectedResponders = runnerRequestPreferredNextExpectedResponders(entry);
       if (!nextExpectedResponders.includes(currentBotSelector)) {
         return false;
       }
@@ -11260,8 +12722,8 @@ function buildRunnerRouteListRows() {
   const config = loadBotRunnerConfig({ persistIfNeeded: true });
   const telegramState = readTelegramEnvState();
   const telegramEntries = ensureArray(telegramState.entries);
-  return ensureArray(config.routes).map((rawRoute, index) => {
-    const route = normalizeRunnerRoute(rawRoute);
+  return ensureArray(config.routes).map((rawRoute, index) => {
+    const route = normalizeRunnerRoute(rawRoute);
     const matchedTelegramEntry = route.provider === "telegram"
       ? telegramEntries.find((entry) => {
         const current = safeObject(entry);
@@ -11281,24 +12743,25 @@ function buildRunnerRouteListRows() {
       matchedTelegramEntry?.serverBotName,
       "-",
     ]);
-    return {
-      index: index + 1,
-      name: route.name || runnerRouteKey(route),
-      logicalSignature: runnerRouteLogicalSignature(route),
-      enabled: route.enabled !== false,
-      provider: route.provider || "-",
-      projectID: route.projectID || "-",
-      botName: resolvedBotName,
-      botNameSource,
-      botID: route.botID || "-",
-      role: route.role || "-",
-      roleProfile: route.roleProfile || "-",
-      destinationLabel: route.destinationLabel || "-",
-      pollIntervalMs: route.pollIntervalMs || 0,
-      configFilePath: config.filePath,
-    };
-  });
-}
+    return {
+      index: index + 1,
+      name: route.name || runnerRouteKey(route),
+      logicalSignature: runnerRouteLogicalSignature(route),
+      enabled: route.enabled !== false,
+      provider: route.provider || "-",
+      routeKind: route.routeKind || "room",
+      projectID: route.projectID || "-",
+      botName: resolvedBotName,
+      botNameSource,
+      botID: route.botID || "-",
+      role: route.role || "-",
+      roleProfile: route.roleProfile || "-",
+      destinationLabel: describeRunnerRouteTargetLabel(route),
+      pollIntervalMs: route.pollIntervalMs || 0,
+      configFilePath: config.filePath,
+    };
+  });
+}
 
 function slugifyRunnerRouteSegment(rawValue) {
   return String(rawValue || "")
@@ -11308,12 +12771,13 @@ function slugifyRunnerRouteSegment(rawValue) {
     .replace(/^-+|-+$/g, "");
 }
 
-function buildRunnerRouteNameSuggestion({ provider = "", role = "", botName = "" }, existingNames = []) {
-  const segments = [
-    slugifyRunnerRouteSegment(provider),
-    slugifyRunnerRouteSegment(role),
-    slugifyRunnerRouteSegment(botName),
-  ].filter(Boolean);
+function buildRunnerRouteNameSuggestion({ provider = "", role = "", botName = "", routeKind = "room" }, existingNames = []) {
+  const segments = [
+    slugifyRunnerRouteSegment(provider),
+    slugifyRunnerRouteSegment(role),
+    slugifyRunnerRouteSegment(botName),
+    routeKind === "dm" ? "dm" : "",
+  ].filter(Boolean);
   const base = segments.join("-") || "runner-route";
   const existing = new Set(ensureArray(existingNames).map((name) => String(name || "").trim().toLowerCase()).filter(Boolean));
   if (!existing.has(base)) {
@@ -11364,15 +12828,15 @@ function removeRunnerRouteFromConfig(config, routeName) {
   };
 }
 
-function formatRunnerRouteChoiceLabel(route, telegramEntries = []) {
-  const normalizedRoute = normalizeRunnerRoute(route);
-  const resolvedName = resolveConfiguredRunnerRouteServerBotName(normalizedRoute, telegramEntries);
-  const routeName = normalizedRoute.name || runnerRouteKey(normalizedRoute);
-  const role = normalizedRoute.role || "-";
-  const botName = resolvedName || normalizedRoute.botName || normalizedRoute.botID || "-";
-  const destination = normalizedRoute.destinationLabel || normalizedRoute.destinationID || "-";
-  return `${routeName}${normalizedRoute.enabled ? "" : " [disabled]"} - ${normalizedRoute.provider || "-"} | ${role} | ${botName} | ${destination}`;
-}
+function formatRunnerRouteChoiceLabel(route, telegramEntries = []) {
+  const normalizedRoute = normalizeRunnerRoute(route);
+  const resolvedName = resolveConfiguredRunnerRouteServerBotName(normalizedRoute, telegramEntries);
+  const routeName = normalizedRoute.name || runnerRouteKey(normalizedRoute);
+  const role = normalizedRoute.role || "-";
+  const botName = resolvedName || normalizedRoute.botName || normalizedRoute.botID || "-";
+  const target = describeRunnerRouteTargetLabel(normalizedRoute);
+  return `${routeName}${normalizedRoute.enabled ? "" : " [disabled]"} - ${normalizedRoute.provider || "-"} | ${normalizedRoute.routeKind || "room"} | ${role} | ${botName} | ${target}`;
+}
 
 async function selectRunnerManagementRoute(ui, flags, { title = "Select runner route" } = {}) {
   const config = loadBotRunnerConfig({ persistIfNeeded: true });
@@ -11516,15 +12980,16 @@ async function selectRunnerServerBotProfile(ui, { provider, role, flags, current
     token,
     timeoutSeconds,
   });
-  const candidates = ensureArray(bots)
-    .filter((bot) => bot.isActive && bot.provider === provider && bot.role === role);
+  const candidates = ensureArray(bots)
+    .filter((bot) => bot.isActive && bot.provider === provider && bot.role === role);
   if (!candidates.length) {
     throw new Error(`No active ${providerEnvConfig(provider).label} server bot exists for role "${role}".`);
   }
-  const resolveChoice = (bot) => ({
-    name: String(bot.name || "").trim(),
-    id: String(bot.id || "").trim(),
-  });
+  const resolveChoice = (bot) => ({
+    name: String(bot.name || "").trim(),
+    id: String(bot.id || "").trim(),
+    username: normalizeTelegramBotUsername(bot.username),
+  });
   if (flaggedBotID) {
     const matched = candidates.find((bot) => bot.id === flaggedBotID);
     if (!matched) {
@@ -11566,18 +13031,28 @@ async function selectRunnerServerBotProfile(ui, { provider, role, flags, current
   return resolveChoice(matched);
 }
 
-async function selectRunnerDestination(ui, { projectID, provider, flags, currentDestinationID = "", currentDestinationLabel = "" }) {
-  const timeoutSeconds = intFromRaw(flags["timeout-seconds"], 15) || 15;
-  const { siteBaseURL, token } = await resolveRunnerCommandToken(flags["base-url"], timeoutSeconds);
-  const destinations = await listProjectChatDestinations({
-    siteBaseURL,
-    projectID,
-    token,
-    timeoutSeconds,
-  });
-  const candidates = ensureArray(destinations)
-    .map((item) => normalizeChatDestination(item))
-    .filter((item) => item.isActive && item.provider === provider);
+async function selectRunnerDestination(ui, {
+  projectID,
+  provider,
+  flags,
+  currentDestinationID = "",
+  currentDestinationLabel = "",
+  preloadedDestinations = null,
+}) {
+  let destinations = ensureArray(preloadedDestinations);
+  if (!destinations.length) {
+    const timeoutSeconds = intFromRaw(flags["timeout-seconds"], 15) || 15;
+    const { siteBaseURL, token } = await resolveRunnerCommandToken(flags["base-url"], timeoutSeconds);
+    destinations = await listProjectChatDestinations({
+      siteBaseURL,
+      projectID,
+      token,
+      timeoutSeconds,
+    });
+  }
+  const candidates = ensureArray(destinations)
+    .map((item) => normalizeChatDestination(item))
+    .filter((item) => item.isActive && item.provider === provider);
   const flaggedID = String(flags["destination-id"] || "").trim();
   const flaggedLabel = String(flags["destination-label"] || "").trim();
   if (flaggedID) {
@@ -11621,15 +13096,98 @@ async function selectRunnerDestination(ui, { projectID, provider, flags, current
   if (!matched) {
     throw new Error("selected destination was not found");
   }
-  return { id: matched.id, label: matched.label || matched.id };
-}
+  return { id: matched.id, label: matched.label || matched.id };
+}
+
+function isRunnerDirectMessageBotAllowed(projectSettingsRaw, botUsername) {
+  const projectSettings = safeObject(projectSettingsRaw);
+  const normalizedBotUsername = normalizeTelegramBotUsername(botUsername);
+  if (!(projectSettings.directMessagesEnabled === true) || !normalizedBotUsername) {
+    return false;
+  }
+  return ensureArray(projectSettings.directMessageBotUsernames)
+    .map((value) => normalizeTelegramBotUsername(value))
+    .filter(Boolean)
+    .includes(normalizedBotUsername);
+}
+
+async function resolveRunnerRouteTargetSelection(ui, {
+  projectID,
+  provider,
+  flags,
+  botSelection,
+}) {
+  const timeoutSeconds = intFromRaw(flags["timeout-seconds"], 15) || 15;
+  const { siteBaseURL, token } = await resolveRunnerCommandToken(flags["base-url"], timeoutSeconds);
+  const [projectSettings, destinations] = await Promise.all([
+    getProjectRunnerSettings({
+      siteBaseURL,
+      projectID,
+      token,
+      timeoutSeconds,
+    }),
+    listProjectChatDestinations({
+      siteBaseURL,
+      projectID,
+      token,
+      timeoutSeconds,
+    }),
+  ]);
+  const activeDestinations = ensureArray(destinations)
+    .map((item) => normalizeChatDestination(item))
+    .filter((item) => item.isActive && item.provider === provider);
+  const requestedRouteKind = hasRunnerFlag(flags, "route-kind")
+    ? normalizeRunnerRouteKind(flags["route-kind"])
+    : "";
+  const dmAllowed = isRunnerDirectMessageBotAllowed(projectSettings, botSelection?.username);
+  const routeKind = requestedRouteKind || (!activeDestinations.length && dmAllowed ? "dm" : "room");
+  if (routeKind === "dm") {
+    if (!dmAllowed) {
+      const allowedBots = ensureArray(projectSettings.directMessageBotUsernames)
+        .map((value) => `@${normalizeTelegramBotUsername(value)}`)
+        .filter((value) => value !== "@")
+        .join(", ");
+      throw new Error(
+        projectSettings.directMessagesEnabled === true
+          ? `Bot ${String(botSelection?.username || botSelection?.name || botSelection?.id || "").trim() || "-"} is not enabled for project direct messages${allowedBots ? ` (allowed: ${allowedBots})` : ""}.`
+          : `Project ${projectID} does not have 1:1 direct messages enabled.`,
+      );
+    }
+    const envConfig = loadProviderEnvConfig(provider, {
+      serverBotID: botSelection?.id,
+      botName: botSelection?.name,
+      botUsername: botSelection?.username,
+    });
+    if (!envConfig.ok) {
+      throw new Error(`Direct message route requires a local ${providerEnvConfig(provider).label} bot binding for ${String(botSelection?.name || botSelection?.username || botSelection?.id || "").trim() || "-"}. ${String(envConfig.error || "").trim()}`);
+    }
+    return {
+      routeKind,
+      projectSettings,
+      activeDestinations,
+      destination: { id: "", label: "" },
+    };
+  }
+  return {
+    routeKind: "room",
+    projectSettings,
+    activeDestinations,
+    destination: await selectRunnerDestination(ui, {
+      projectID,
+      provider,
+      flags,
+      preloadedDestinations: activeDestinations,
+    }),
+  };
+}
 
-function buildRunnerRoutePayload({
-  currentRoute = null,
-  name = "",
-  enabled = true,
-  projectID = "",
-  provider = "",
+function buildRunnerRoutePayload({
+  currentRoute = null,
+  name = "",
+  enabled = true,
+  routeKind = "",
+  projectID = "",
+  provider = "",
   role = "",
   roleProfile = "",
   serverBotName = "",
@@ -11644,12 +13202,13 @@ function buildRunnerRoutePayload({
   const archivePolicy = currentRoute
     ? safeObject(currentRoute.archivePolicy)
     : defaultRunnerArchivePolicyForRole(roleProfile || role);
-  return normalizeRunnerRoute({
-    ...(currentRoute ? serializeRunnerRoute(currentRoute) : {}),
-    name,
-    enabled,
-    project_id: projectID,
-    provider,
+  return normalizeRunnerRoute({
+    ...(currentRoute ? serializeRunnerRoute(currentRoute) : {}),
+    name,
+    enabled,
+    route_kind: normalizeRunnerRouteKind(routeKind || currentRoute?.routeKind || currentRoute?.route_kind),
+    project_id: projectID,
+    provider,
     role,
     role_profile: roleProfile,
     server_bot_name: serverBotName,
@@ -11662,45 +13221,48 @@ function buildRunnerRoutePayload({
   });
 }
 
-async function runRunnerRouteAdd(flags) {
-  const ui = createPrompter();
-  try {
-    if (shouldRenderPromptChrome(flags)) {
-      ui.setFlow("RUNNER ROUTE ADD", "Create one executable runner route from server bot and destination");
-    }
-    const config = loadBotRunnerConfig({ persistIfNeeded: true });
-    const provider = await selectRunnerRouteProvider(ui, flags, "");
-    const projectID = await resolveRunnerRouteProjectID(ui, flags, config);
-    const role = await selectRunnerRole(ui, flags, "");
-    const botSelection = await selectRunnerServerBotProfile(ui, { provider, role, flags });
-    const destination = await selectRunnerDestination(ui, {
-      projectID,
-      provider,
-      flags,
-    });
-    const suggestedName = buildRunnerRouteNameSuggestion({
-      provider,
-      role,
-      botName: botSelection.name,
-    }, ensureArray(config.routes).map((route) => normalizeRunnerRoute(route).name));
-    const routeName = String(flags.name || "").trim() || suggestedName;
-    const pollIntervalMs = intFromRaw(flags["poll-interval-ms"], 5000) || 5000;
+async function runRunnerRouteAdd(flags) {
+  const ui = createPrompter();
+  try {
+    if (shouldRenderPromptChrome(flags)) {
+      ui.setFlow("RUNNER ROUTE ADD", "Create one executable runner route from server bot and target");
+    }
+    const config = loadBotRunnerConfig({ persistIfNeeded: true });
+    const provider = await selectRunnerRouteProvider(ui, flags, "");
+    const projectID = await resolveRunnerRouteProjectID(ui, flags, config);
+    const role = await selectRunnerRole(ui, flags, "");
+    const botSelection = await selectRunnerServerBotProfile(ui, { provider, role, flags });
+    const targetSelection = await resolveRunnerRouteTargetSelection(ui, {
+      projectID,
+      provider,
+      flags,
+      botSelection,
+    });
+    const suggestedName = buildRunnerRouteNameSuggestion({
+      provider,
+      role,
+      botName: botSelection.name,
+      routeKind: targetSelection.routeKind,
+    }, ensureArray(config.routes).map((route) => normalizeRunnerRoute(route).name));
+    const routeName = String(flags.name || "").trim() || suggestedName;
+    const pollIntervalMs = intFromRaw(flags["poll-interval-ms"], 5000) || 5000;
     const enabled = Object.prototype.hasOwnProperty.call(flags, "enabled")
       ? boolFromRaw(flags.enabled, true)
       : true;
-    const nextRoute = buildRunnerRoutePayload({
-      name: routeName,
-      enabled,
-      projectID,
-      provider,
-      role,
-      roleProfile: role,
-      serverBotName: botSelection.name,
-      serverBotID: botSelection.id,
-      destinationID: destination.id,
-      destinationLabel: destination.label,
-      pollIntervalMs,
-    });
+    const nextRoute = buildRunnerRoutePayload({
+      name: routeName,
+      enabled,
+      routeKind: targetSelection.routeKind,
+      projectID,
+      provider,
+      role,
+      roleProfile: role,
+      serverBotName: botSelection.name,
+      serverBotID: botSelection.id,
+      destinationID: targetSelection.destination.id,
+      destinationLabel: targetSelection.destination.label,
+      pollIntervalMs,
+    });
     const saved = upsertRunnerRouteConfig(config, nextRoute);
     const filePath = saveBotRunnerConfig(saved, config.filePath);
     if (!String(flags.name || "").trim()) {
@@ -11786,24 +13348,28 @@ async function runRunnerRouteEdit(flags) {
       })
       : { name: currentRoute.botName, id: currentRoute.botID };
 
-    const destinationAction = await promptChoice(
-      ui,
-      "Project chat destination",
-      [
-        { value: "keep", label: "Keep current destination", description: currentRoute.destinationLabel || currentRoute.destinationID || "-" },
-        { value: "change", label: "Change destination", description: "select another active project destination" },
-      ],
-      { defaultIndex: projectID !== currentRoute.projectID ? 1 : 0 },
-    );
-    const destination = destinationAction?.value === "change" || projectID !== currentRoute.projectID
-      ? await selectRunnerDestination(ui, {
-        projectID,
-        provider: currentRoute.provider,
-        flags: {},
-        currentDestinationID: currentRoute.destinationID,
-        currentDestinationLabel: currentRoute.destinationLabel,
-      })
-      : { id: currentRoute.destinationID, label: currentRoute.destinationLabel };
+    const destination = currentRoute.routeKind === "dm"
+      ? { id: "", label: "" }
+      : await (async () => {
+        const destinationAction = await promptChoice(
+          ui,
+          "Project chat destination",
+          [
+            { value: "keep", label: "Keep current destination", description: currentRoute.destinationLabel || currentRoute.destinationID || "-" },
+            { value: "change", label: "Change destination", description: "select another active project destination" },
+          ],
+          { defaultIndex: projectID !== currentRoute.projectID ? 1 : 0 },
+        );
+        return destinationAction?.value === "change" || projectID !== currentRoute.projectID
+          ? selectRunnerDestination(ui, {
+            projectID,
+            provider: currentRoute.provider,
+            flags: {},
+            currentDestinationID: currentRoute.destinationID,
+            currentDestinationLabel: currentRoute.destinationLabel,
+          })
+          : { id: currentRoute.destinationID, label: currentRoute.destinationLabel };
+      })();
 
     const pollAction = await promptChoice(
       ui,
@@ -11842,12 +13408,13 @@ async function runRunnerRouteEdit(flags) {
       process.stdout.write("Cancelled.\n");
       return;
     }
-    const nextRoute = buildRunnerRoutePayload({
-      currentRoute,
-      name: routeName,
-      enabled,
-      projectID,
-      provider: currentRoute.provider,
+    const nextRoute = buildRunnerRoutePayload({
+      currentRoute,
+      name: routeName,
+      enabled,
+      routeKind: currentRoute.routeKind,
+      projectID,
+      provider: currentRoute.provider,
       role,
       roleProfile: role,
       serverBotName: botSelection.name,
@@ -11911,30 +13478,37 @@ function parseRunnerProjectUpRoles(flags) {
   return ordered;
 }
 
-function runnerProjectUpScopeKey({ projectID, provider, destinationID = "", destinationLabel = "", botIdentity = "" }) {
-  return [
-    String(projectID || "").trim() || "-",
-    String(provider || "").trim() || "-",
-    String(destinationID || "").trim() || normalizeRunnerRouteIdentityText(destinationLabel) || "-",
-    normalizeRunnerRouteIdentityText(botIdentity) || "-",
-  ].join("::");
-}
-
-function routeMatchesRunnerProjectUpScope(routeRaw, scopeRaw) {
-  const route = normalizeRunnerRoute(routeRaw);
-  const scope = safeObject(scopeRaw);
-  if (String(route.projectID || "").trim() !== String(scope.projectID || "").trim()) return false;
-  if (String(route.provider || "").trim() !== String(scope.provider || "").trim()) return false;
-  const routeDestinationID = String(route.destinationID || "").trim();
-  const scopeDestinationID = String(scope.destinationID || "").trim();
-  const routeDestinationLabel = normalizeRunnerRouteIdentityText(route.destinationLabel);
-  const scopeDestinationLabel = normalizeRunnerRouteIdentityText(scope.destinationLabel);
-  const destinationMatches = scopeDestinationID
-    ? (routeDestinationID === scopeDestinationID || (!routeDestinationID && routeDestinationLabel === scopeDestinationLabel))
-    : routeDestinationLabel === scopeDestinationLabel;
-  if (!destinationMatches) return false;
-  const routeBotName = normalizeRunnerRouteIdentityText(route.botName);
-  const scopeBotIdentity = normalizeRunnerRouteIdentityText(scope.botIdentity);
+function runnerProjectUpScopeKey({ projectID, provider, routeKind = "room", destinationID = "", destinationLabel = "", botIdentity = "" }) {
+  return [
+    String(projectID || "").trim() || "-",
+    String(provider || "").trim() || "-",
+    normalizeRunnerRouteKind(routeKind),
+    normalizeRunnerRouteKind(routeKind) === "dm"
+      ? "direct-messages"
+      : (String(destinationID || "").trim() || normalizeRunnerRouteIdentityText(destinationLabel) || "-"),
+    normalizeRunnerRouteIdentityText(botIdentity) || "-",
+  ].join("::");
+}
+
+function routeMatchesRunnerProjectUpScope(routeRaw, scopeRaw) {
+  const route = normalizeRunnerRoute(routeRaw);
+  const scope = safeObject(scopeRaw);
+  if (String(route.projectID || "").trim() !== String(scope.projectID || "").trim()) return false;
+  if (String(route.provider || "").trim() !== String(scope.provider || "").trim()) return false;
+  const scopeRouteKind = normalizeRunnerRouteKind(scope.routeKind, "room");
+  if ((route.routeKind || "room") !== scopeRouteKind) return false;
+  if (scopeRouteKind === "room") {
+    const routeDestinationID = String(route.destinationID || "").trim();
+    const scopeDestinationID = String(scope.destinationID || "").trim();
+    const routeDestinationLabel = normalizeRunnerRouteIdentityText(route.destinationLabel);
+    const scopeDestinationLabel = normalizeRunnerRouteIdentityText(scope.destinationLabel);
+    const destinationMatches = scopeDestinationID
+      ? (routeDestinationID === scopeDestinationID || (!routeDestinationID && routeDestinationLabel === scopeDestinationLabel))
+      : routeDestinationLabel === scopeDestinationLabel;
+    if (!destinationMatches) return false;
+  }
+  const routeBotName = normalizeRunnerRouteIdentityText(route.botName);
+  const scopeBotIdentity = normalizeRunnerRouteIdentityText(scope.botIdentity);
   const routeBotID = String(route.botID || "").trim();
   const scopeRoleIDs = new Set(
     Object.values(safeObject(scope.serverRoleIDs))
@@ -11947,17 +13521,24 @@ function routeMatchesRunnerProjectUpScope(routeRaw, scopeRaw) {
   );
 }
 
-function resolveRunnerConversationPeers(routeRaw) {
-  const normalizedRoute = normalizeRunnerRoute(routeRaw);
-  const config = loadBotRunnerConfig({ persistIfNeeded: true });
+function resolveRunnerConversationPeers(routeRaw) {
+  const normalizedRoute = normalizeRunnerRoute(routeRaw);
+  if (normalizedRoute.routeKind === "dm") {
+    return [{
+      id: String(normalizedRoute.botID || "").trim(),
+      name: String(normalizedRoute.botName || "").trim(),
+    }].filter((item) => item.id || item.name);
+  }
+  const config = loadBotRunnerConfig({ persistIfNeeded: true });
   const seen = new Set();
   const peers = [];
   ensureArray(config.routes)
     .map((rawRoute) => normalizeRunnerRoute(rawRoute))
-    .filter((route) => route.enabled)
-    .filter((route) => String(route.projectID || "").trim() === String(normalizedRoute.projectID || "").trim())
-    .filter((route) => String(route.provider || "").trim() === String(normalizedRoute.provider || "").trim())
-    .filter((route) => {
+    .filter((route) => route.enabled)
+    .filter((route) => String(route.projectID || "").trim() === String(normalizedRoute.projectID || "").trim())
+    .filter((route) => String(route.provider || "").trim() === String(normalizedRoute.provider || "").trim())
+    .filter((route) => (route.routeKind || "room") === (normalizedRoute.routeKind || "room"))
+    .filter((route) => {
       const routeDestinationID = String(route.destinationID || "").trim();
       const targetDestinationID = String(normalizedRoute.destinationID || "").trim();
       const routeDestinationLabel = normalizeRunnerRouteIdentityText(route.destinationLabel);
@@ -11978,17 +13559,33 @@ function resolveRunnerConversationPeers(routeRaw) {
   return peers;
 }
 
-function resolveRunnerConversationManagedBots(routeRaw, availableBots = []) {
-  const normalizedRoute = normalizeRunnerRoute(routeRaw);
-  const config = loadBotRunnerConfig({ persistIfNeeded: true });
+function resolveRunnerConversationManagedBots(routeRaw, availableBots = []) {
+  const normalizedRoute = normalizeRunnerRoute(routeRaw);
+  if (normalizedRoute.routeKind === "dm") {
+    try {
+      const bot = selectRunnerBot(availableBots, normalizedRoute);
+      const username = String(bot?.username || bot?.name || normalizedRoute.botName || "").trim().replace(/^@+/, "").toLowerCase();
+      return username ? [{
+        username,
+        display_name: String(bot?.name || bot?.username || normalizedRoute.botName || username).trim(),
+        route_name: String(normalizedRoute.name || "").trim(),
+        route: normalizedRoute,
+        bot,
+      }] : [];
+    } catch {
+      return [];
+    }
+  }
+  const config = loadBotRunnerConfig({ persistIfNeeded: true });
   const seen = new Set();
   const managed = [];
   ensureArray(config.routes)
     .map((rawRoute) => normalizeRunnerRoute(rawRoute))
-    .filter((route) => route.enabled)
-    .filter((route) => String(route.projectID || "").trim() === String(normalizedRoute.projectID || "").trim())
-    .filter((route) => String(route.provider || "").trim() === String(normalizedRoute.provider || "").trim())
-    .filter((route) => {
+    .filter((route) => route.enabled)
+    .filter((route) => String(route.projectID || "").trim() === String(normalizedRoute.projectID || "").trim())
+    .filter((route) => String(route.provider || "").trim() === String(normalizedRoute.provider || "").trim())
+    .filter((route) => (route.routeKind || "room") === (normalizedRoute.routeKind || "room"))
+    .filter((route) => {
       const routeDestinationID = String(route.destinationID || "").trim();
       const targetDestinationID = String(normalizedRoute.destinationID || "").trim();
       const routeDestinationLabel = normalizeRunnerRouteIdentityText(route.destinationLabel);
@@ -12039,20 +13636,22 @@ function applyRunnerProjectUpRouteSuggestions(routeSuggestions) {
   desiredRoutes.forEach((suggestionRaw) => {
     const suggestion = safeObject(suggestionRaw);
     const routePayload = normalizeRunnerRoute(suggestion.routePayload);
-    const scopeKey = runnerProjectUpScopeKey({
-      projectID: routePayload.projectID,
-      provider: routePayload.provider,
-      destinationID: routePayload.destinationID,
-      destinationLabel: routePayload.destinationLabel,
-      botIdentity: suggestion.botIdentity || suggestion.serverBotName || routePayload.botName,
+    const scopeKey = runnerProjectUpScopeKey({
+      projectID: routePayload.projectID,
+      provider: routePayload.provider,
+      routeKind: routePayload.routeKind,
+      destinationID: routePayload.destinationID,
+      destinationLabel: routePayload.destinationLabel,
+      botIdentity: suggestion.botIdentity || suggestion.serverBotName || routePayload.botName,
     });
     if (!scopeGroups.has(scopeKey)) {
       scopeGroups.set(scopeKey, {
-        projectID: routePayload.projectID,
-        provider: routePayload.provider,
-        destinationID: routePayload.destinationID,
-        destinationLabel: routePayload.destinationLabel,
-        botIdentity: suggestion.botIdentity || suggestion.serverBotName || routePayload.botName,
+        projectID: routePayload.projectID,
+        provider: routePayload.provider,
+        routeKind: routePayload.routeKind,
+        destinationID: routePayload.destinationID,
+        destinationLabel: routePayload.destinationLabel,
+        botIdentity: suggestion.botIdentity || suggestion.serverBotName || routePayload.botName,
         serverRoleIDs: { ...safeObject(suggestion.serverRoleIDs) },
         desiredSignatures: new Set(),
       });
@@ -12105,11 +13704,12 @@ function applyRunnerProjectUpRouteSuggestions(routeSuggestions) {
   };
 }
 
-function resolveRunnerProjectUpRoutes({
-  projectID,
-  provider,
-  destinationID,
-  destinationLabel,
+function resolveRunnerProjectUpRoutes({
+  projectID,
+  provider,
+  routeKind = "",
+  destinationID,
+  destinationLabel,
   botName = "",
   botID = "",
   roleFilter = [],
@@ -12117,20 +13717,22 @@ function resolveRunnerProjectUpRoutes({
   const config = loadBotRunnerConfig({ persistIfNeeded: true });
   const telegramEntries = ensureArray(readTelegramEnvState().entries);
   const normalizedRoles = ensureArray(roleFilter).map((value) => normalizeBotRole(value)).filter(Boolean);
-  const selectionFlags = {
-    "project-id": projectID,
-    provider,
-    "destination-id": destinationID,
-    "destination-label": destinationLabel,
+  const selectionFlags = {
+    "project-id": projectID,
+    provider,
+    ...(routeKind ? { "route-kind": routeKind } : {}),
+    "destination-id": destinationID,
+    "destination-label": destinationLabel,
     ...(botName ? { "bot-name": botName } : {}),
     ...(botID ? { "bot-id": botID } : {}),
   };
-  const selectionRoute = normalizeRunnerRoute({
-    project_id: projectID,
-    provider,
-    destination_id: destinationID,
-    destination_label: destinationLabel,
-    server_bot_name: botName,
+  const selectionRoute = normalizeRunnerRoute({
+    project_id: projectID,
+    provider,
+    ...(routeKind ? { route_kind: routeKind } : {}),
+    destination_id: destinationID,
+    destination_label: destinationLabel,
+    server_bot_name: botName,
     server_bot_id: botID,
   });
   const matched = ensureArray(config.routes)
@@ -12142,10 +13744,12 @@ function resolveRunnerProjectUpRoutes({
     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}`;
+  return matched.filter((route) => {
+    const botIdentity = String(route.serverBotID || route.botID || route.botName || route.serverBotName || "").trim().toLowerCase();
+    const targetIdentity = route.routeKind === "dm"
+      ? `${route.routeKind || "dm"}`
+      : String(route.destinationID || route.destinationLabel || "").trim().toLowerCase();
+    const dedupeKey = `${botIdentity}::${targetIdentity}`;
     if (!dedupeKey || dedupeKey === "::") return true;
     if (seenBotDestinations.has(dedupeKey)) return false;
     seenBotDestinations.set(dedupeKey, true);
@@ -12227,6 +13831,95 @@ async function runRunnerProjectUp(flags) {
   });
 }
 
+function resolveRunnerProjectUpDirectMessageBotUsername(botRaw, telegramEntries = []) {
+  const bot = safeObject(botRaw);
+  const directUsername = normalizeTelegramBotUsername(bot.username);
+  if (directUsername) return directUsername;
+  const matchedEntry = ensureArray(telegramEntries).find((entryRaw) => {
+    const entry = safeObject(entryRaw);
+    return (
+      (bot.id && entry.serverBotID && entry.serverBotID === bot.id)
+      || (bot.name && normalizeRunnerRouteIdentityText(entry.serverBotName) === normalizeRunnerRouteIdentityText(bot.name))
+    );
+  });
+  return normalizeTelegramBotUsername(matchedEntry?.username);
+}
+
+function buildRunnerProjectUpDirectMessageRouteSuggestions({
+  projectID,
+  provider,
+  projectSettings,
+  availableBots,
+  telegramEntries = [],
+  botNameFilter = "",
+  botIDFilter = "",
+  roleFilter = [],
+}) {
+  const config = loadBotRunnerConfig({ persistIfNeeded: true });
+  const allowedBotUsernames = new Set(
+    ensureArray(safeObject(projectSettings).directMessageBotUsernames)
+      .map((value) => normalizeTelegramBotUsername(value))
+      .filter(Boolean),
+  );
+  const desiredRoles = ensureArray(roleFilter).length
+    ? ensureArray(roleFilter).map((value) => normalizeBotRole(value)).filter(Boolean)
+    : ["monitor"];
+  const existingRoutes = ensureArray(config.routes).map((route) => normalizeRunnerRoute(route));
+  return ensureArray(availableBots)
+    .filter((bot) => bot && bot.isActive && bot.provider === provider)
+    .map((bot) => ({
+      ...bot,
+      username: resolveRunnerProjectUpDirectMessageBotUsername(bot, telegramEntries),
+      hasLocalBinding: Boolean(
+        ensureArray(telegramEntries).find((entryRaw) => {
+          const entry = safeObject(entryRaw);
+          return (
+            (bot.id && entry.serverBotID && entry.serverBotID === bot.id)
+            || (bot.name && normalizeRunnerRouteIdentityText(entry.serverBotName) === normalizeRunnerRouteIdentityText(bot.name))
+            || (resolveRunnerProjectUpDirectMessageBotUsername(bot, telegramEntries) && normalizeTelegramBotUsername(entry.username) === resolveRunnerProjectUpDirectMessageBotUsername(bot, telegramEntries))
+          );
+        }),
+      ),
+    }))
+    .filter((bot) => bot.username && allowedBotUsernames.has(bot.username))
+    .filter((bot) => bot.hasLocalBinding)
+    .filter((bot) => !botIDFilter || String(bot.id || "").trim() === botIDFilter)
+    .filter((bot) => !botNameFilter || matchesRunnerRouteText(bot.name, botNameFilter) || matchesRunnerRouteText(bot.username, botNameFilter))
+    .filter((bot) => !desiredRoles.length || desiredRoles.includes(normalizeBotRole(bot.role)))
+    .map((bot) => {
+      const routePayload = buildRunnerRoutePayload({
+        name: buildRunnerRouteNameSuggestion({
+          provider,
+          role: normalizeBotRole(bot.role) || "monitor",
+          botName: bot.name,
+          routeKind: "dm",
+        }, existingRoutes.map((route) => route.name)),
+        enabled: true,
+        routeKind: "dm",
+        projectID,
+        provider,
+        role: normalizeBotRole(bot.role) || "monitor",
+        roleProfile: normalizeBotRole(bot.role) || "monitor",
+        serverBotName: String(bot.name || "").trim(),
+        serverBotID: String(bot.id || "").trim(),
+        destinationID: "",
+        destinationLabel: "",
+      });
+      const logicalSignature = runnerRouteLogicalSignature(routePayload);
+      const existing = existingRoutes.find((route) => route.enabled !== false && runnerRouteLogicalSignature(route) === logicalSignature);
+      return {
+        status: existing ? "existing" : "create",
+        routeName: String((existing || routePayload).name || "").trim(),
+        logicalSignature,
+        serverBotName: String(bot.name || "").trim(),
+        role: normalizeBotRole(bot.role) || "monitor",
+        botIdentity: bot.username,
+        serverRoleIDs: bot.id ? { [normalizeBotRole(bot.role) || "monitor"]: String(bot.id || "").trim() } : {},
+        routePayload,
+      };
+    });
+}
+
 function resolveRunnerProjectTUIRuntimePolicy(flags = {}) {
   const explicitStartRequested = Object.prototype.hasOwnProperty.call(flags, "start");
   return {
@@ -12757,6 +14450,7 @@ function buildRunnerProjectUpNextSteps({
   shouldStartRunner,
   projectID,
   provider,
+  routeKind = "room",
   destinationID,
   matchingRoutes,
   startFlags,
@@ -12764,14 +14458,18 @@ function buildRunnerProjectUpNextSteps({
   const nextSteps = [];
   const routeNames = ensureArray(matchingRoutes).map((route) => normalizeRunnerRoute(route).name).filter(Boolean);
   if (!applyRequested) {
-    nextSteps.push(`${CLI_NAME} runner project up --project-id ${projectID} --provider ${provider} --destination-id ${destinationID} --apply true --start false`);
+    nextSteps.push(routeKind === "dm"
+      ? `${CLI_NAME} runner project up --project-id ${projectID} --provider ${provider} --route-kind dm --apply true --start false`
+      : `${CLI_NAME} runner project up --project-id ${projectID} --provider ${provider} --destination-id ${destinationID} --apply true --start false`);
   }
   if (!shouldStartRunner) {
     if (routeNames.length > 0) {
       nextSteps.push(`${CLI_NAME} runner show --route-name ${routeNames[0]}`);
       nextSteps.push(buildRunnerStartDetachedCommand(startFlags));
     } else if (applyRequested) {
-      nextSteps.push(`${CLI_NAME} runner project up --project-id ${projectID} --provider ${provider} --destination-id ${destinationID} --apply true --start false`);
+      nextSteps.push(routeKind === "dm"
+        ? `${CLI_NAME} runner project up --project-id ${projectID} --provider ${provider} --route-kind dm --apply true --start false`
+        : `${CLI_NAME} runner project up --project-id ${projectID} --provider ${provider} --destination-id ${destinationID} --apply true --start false`);
     }
     return nextSteps;
   }
@@ -12798,16 +14496,151 @@ async function buildRunnerProjectUpResult(flags = {}) {
       shouldStartRunner,
       foregroundStartRequested,
     } = resolveRunnerProjectUpExecutionPolicy(flags);
-    const roleFilter = parseRunnerProjectUpRoles(flags);
-    const botNameFilter = String(flags["bot-name"] || "").trim();
-    const botIDFilter = String(flags["bot-id"] || "").trim();
-    const auditPayload = await buildBotRoomAuditPayload(
-      ui,
-      {
-        ...flags,
-        provider,
-        apply: false,
-        json: false,
+    const roleFilter = parseRunnerProjectUpRoles(flags);
+    const botNameFilter = String(flags["bot-name"] || "").trim();
+    const botIDFilter = String(flags["bot-id"] || "").trim();
+    const config = loadBotRunnerConfig({ persistIfNeeded: true });
+    const projectID = await resolveRunnerRouteProjectID(ui, flags, config);
+    const timeoutSeconds = intFromRaw(flags["timeout-seconds"], 15) || 15;
+    const { siteBaseURL, token } = await resolveRunnerCommandToken(flags["base-url"], timeoutSeconds);
+    const [projectSettings, destinations] = await Promise.all([
+      getProjectRunnerSettings({
+        siteBaseURL,
+        projectID,
+        token,
+        timeoutSeconds,
+      }),
+      listProjectChatDestinations({
+        siteBaseURL,
+        projectID,
+        token,
+        timeoutSeconds,
+      }),
+    ]);
+    const activeDestinations = ensureArray(destinations)
+      .map((item) => normalizeChatDestination(item))
+      .filter((item) => item.isActive && item.provider === provider);
+    const requestedRouteKind = hasRunnerFlag(flags, "route-kind")
+      ? normalizeRunnerRouteKind(flags["route-kind"])
+      : "";
+    const useDirectMessageProjectUp = requestedRouteKind === "dm"
+      || (!activeDestinations.length && safeObject(projectSettings).directMessagesEnabled === true);
+    if (requestedRouteKind === "dm" && safeObject(projectSettings).directMessagesEnabled !== true) {
+      throw new Error(`project ${projectID} does not have 1:1 direct messages enabled`);
+    }
+    if (useDirectMessageProjectUp) {
+      const serverBots = await listUserBotsForRunner({
+        siteBaseURL,
+        token,
+        timeoutSeconds,
+      });
+      const telegramEntries = ensureArray(readTelegramEnvState().entries);
+      const filteredRouteSuggestions = buildRunnerProjectUpDirectMessageRouteSuggestions({
+        projectID,
+        provider,
+        projectSettings,
+        availableBots: serverBots,
+        telegramEntries,
+        botNameFilter,
+        botIDFilter,
+        roleFilter,
+      });
+      const applyResultRaw = applyRequested
+        ? applyRunnerProjectUpRouteSuggestions(filteredRouteSuggestions)
+        : null;
+      const applyResult = safeObject(applyResultRaw);
+      const matchingRoutes = resolveRunnerProjectUpRoutes({
+        projectID,
+        provider,
+        routeKind: "dm",
+        destinationID: "",
+        destinationLabel: "",
+        botName: botNameFilter,
+        botID: botIDFilter,
+        roleFilter,
+      });
+      const startFlags = {
+        ...flags,
+        provider,
+        "project-id": projectID,
+        "route-kind": "dm",
+        ...(botNameFilter ? { "bot-name": botNameFilter } : {}),
+        ...(botIDFilter ? { "bot-id": botIDFilter } : {}),
+      };
+      const applyFailureWarningOnly = canStartRunnerDespiteProjectUpApplyFailure({
+        applyRequested,
+        applyResult,
+        matchingRoutes,
+      });
+      const summaryPayload = {
+        ok: !applyRequested || applyResult.ok !== false || applyFailureWarningOnly,
+        provider,
+        route_kind: "dm",
+        project_id: projectID,
+        destination_label: "Direct Messages",
+        destination_id: "-",
+        room_probe_ok: true,
+        room_visible_bot_admins: 0,
+        my_server_bots: ensureArray(serverBots).filter((bot) => bot.provider === provider && bot.isActive).length,
+        my_local_bots: telegramEntries.length,
+        bot_name_filter: botNameFilter || "-",
+        bot_id_filter: botIDFilter || "-",
+        role_filter: roleFilter.join(", ") || "-",
+        route_suggestions_create_total: filteredRouteSuggestions.filter((item) => safeObject(item).status === "create").length,
+        route_suggestions_existing_total: filteredRouteSuggestions.filter((item) => safeObject(item).status === "existing").length,
+        route_suggestions_blocked_total: filteredRouteSuggestions.filter((item) => safeObject(item).status === "blocked").length,
+        route_apply_requested: applyRequested,
+        route_apply_changed: Boolean(applyResult.changed),
+        route_config_file: String(applyResult.filePath || config.filePath || "-").trim() || "-",
+        enabled_routes_for_selection: matchingRoutes.map((route) => normalizeRunnerRoute(route).name).filter(Boolean),
+        start_requested: startRequested,
+        start_detached_requested: startDetachedRequested,
+        next_steps: [],
+        applied_routes: ensureArray(applyResult.appliedRoutes).map((item) => safeObject(item)),
+        disabled_routes: ensureArray(applyResult.disabledRoutes).map((item) => safeObject(item)),
+      };
+      summaryPayload.next_steps.push(...buildRunnerProjectUpNextSteps({
+        applyRequested,
+        shouldStartRunner,
+        projectID: summaryPayload.project_id,
+        provider,
+        routeKind: "dm",
+        destinationID: "",
+        matchingRoutes,
+        startFlags,
+      }));
+      if (!filteredRouteSuggestions.length) {
+        summaryPayload.warning = "No eligible 1:1 DM bot matched the current filters. Enable at least one project DM bot and ensure the local Telegram bot binding exists.";
+      }
+      if (applyRequested && applyResult.ok === false && applyResult.error) {
+        if (applyFailureWarningOnly) {
+          summaryPayload.warning = String(applyResult.error || "").trim();
+        } else {
+          summaryPayload.error = String(applyResult.error || "").trim();
+        }
+      }
+      if (foregroundStartRequested && !summaryPayload.warning && !summaryPayload.error) {
+        summaryPayload.warning = "foreground runner start was explicitly requested; the runner stops when this terminal session ends. Use runner start-detached for persistent polling.";
+      }
+      return {
+        summaryPayload,
+        applyRequested,
+        applyResult,
+        shouldStartRunner,
+        startDetachedRequested,
+        matchingRoutes,
+        startFlags,
+        applyFailureBlocksStart: applyRequested && applyResult.ok === false && !applyFailureWarningOnly,
+      };
+    }
+    const auditPayload = await buildBotRoomAuditPayload(
+      ui,
+      {
+        ...flags,
+        "project-id": projectID,
+        provider,
+        apply: false,
+        json: false,
       },
       buildBotCommandDeps(),
     );
@@ -12839,12 +14672,13 @@ async function buildRunnerProjectUpResult(flags = {}) {
         })
       : null;
     const applyResult = safeObject(applyResultRaw);
-    const matchingRoutes = resolveRunnerProjectUpRoutes({
-      projectID: String(auditPayload.projectID || "").trim(),
-      provider,
-      destinationID: String(destination.destinationID || "").trim(),
-      destinationLabel: String(destination.destinationLabel || "").trim(),
-      botName: botNameFilter,
+    const matchingRoutes = resolveRunnerProjectUpRoutes({
+      projectID: String(auditPayload.projectID || "").trim(),
+      provider,
+      routeKind: "room",
+      destinationID: String(destination.destinationID || "").trim(),
+      destinationLabel: String(destination.destinationLabel || "").trim(),
+      botName: botNameFilter,
       botID: botIDFilter,
       roleFilter,
     });
@@ -12892,6 +14726,7 @@ async function buildRunnerProjectUpResult(flags = {}) {
       shouldStartRunner,
       projectID: summaryPayload.project_id,
       provider,
+      routeKind: "room",
       destinationID: summaryPayload.destination_id,
       matchingRoutes,
       startFlags,
@@ -12927,9 +14762,9 @@ async function runRunnerList(flags) {
     process.stdout.write(`${JSON.stringify({ ok: true, routes: rows }, null, 2)}\n`);
     return;
   }
-  process.stdout.write("Runner routes\n");
-  process.stdout.write("  note: routes are the executable unit. Use --route-name in production. --bot-name and --bot-id are convenience selectors that resolve one enabled route only when the match is unique.\n");
-  process.stdout.write("  note: do not create two enabled routes for the same project/provider/role/server-bot/destination target.\n");
+  process.stdout.write("Runner routes\n");
+  process.stdout.write("  note: routes are the executable unit. Use --route-name in production. --bot-name and --bot-id are convenience selectors that resolve one enabled route only when the match is unique.\n");
+  process.stdout.write("  note: do not create two enabled routes for the same project/provider/route-kind/server-bot/target.\n");
   if (!rows.length) {
     process.stdout.write("  none configured\n");
     return;
@@ -12940,9 +14775,10 @@ async function runRunnerList(flags) {
       [
         `  - ${row.name}${row.enabled ? "" : " [disabled]"}`,
         `    logical_signature: ${row.logicalSignature}`,
-        `    provider: ${row.provider}`,
-        `    project_id: ${row.projectID}`,
-        `    server_bot_name: ${row.botName}`,
+        `    provider: ${row.provider}`,
+        `    route_kind: ${row.routeKind}`,
+        `    project_id: ${row.projectID}`,
+        `    server_bot_name: ${row.botName}`,
         `    server_bot_name_source: ${row.botNameSource}`,
         `    server_bot_id: ${row.botID}`,
         `    role: ${row.role}`,
@@ -13166,6 +15002,25 @@ function runnerDetachedRouteSetSignature(routes) {
 
 function runnerSchedulingTargetKeyFromRouteKey(routeKey) {
   const parts = String(routeKey || "").trim().split("::").filter(Boolean);
+  if (parts.length >= 7) {
+    const projectID = String(parts[parts.length - 6] || "").trim();
+    const provider = String(parts[parts.length - 5] || "").trim();
+    const routeKind = normalizeRunnerRouteKind(parts[parts.length - 4], "room");
+    if (routeKind === "dm") {
+      return [
+        projectID,
+        provider,
+        routeKind,
+        String(parts[parts.length - 2] || "").trim(),
+      ].join("::");
+    }
+    return [
+      projectID,
+      provider,
+      routeKind,
+      String(parts[parts.length - 1] || "").trim(),
+    ].join("::");
+  }
   if (parts.length < 6) {
     return "";
   }
@@ -13261,8 +15116,8 @@ function classifyDetachedRunnerLaunchReuse(registry, routes) {
     ),
   );
   const detail = supersets.length > 1
-    ? `multiple detached runners already cover the requested route set for the same project/provider/destination target (${conflictingLaunches.map((entry) => describeDetachedRunnerLaunch(entry)).join(" | ")})`
-    : `another detached runner already owns the same project/provider/destination target (${conflictingLaunches.map((entry) => describeDetachedRunnerLaunch(entry)).join(" | ")}). Stop it first or use runner project tui so one detached runner owns the full route set for that destination`;
+    ? `multiple detached runners already cover the requested route set for the same project/provider/route target (${conflictingLaunches.map((entry) => describeDetachedRunnerLaunch(entry)).join(" | ")})`
+    : `another detached runner already owns the same project/provider/route target (${conflictingLaunches.map((entry) => describeDetachedRunnerLaunch(entry)).join(" | ")}). Stop it first or use runner project tui so one detached runner owns the full route set for that target`;
   return {
     kind: "conflict",
     detail,
@@ -18896,17 +20751,24 @@ TELEGRAM_BOT_REVIEW_TOKEN=review-token
     buildToolAliasMaps,
     rewriteAliasedToolCallToCanonical,
     normalizeBotRunnerConfigContents,
-    defaultLocalBotBridgeCommand,
-    resolveRunnerExecutionPlan,
-    resolveRunnerExecutionPlanForRole,
-    normalizeRunnerRoute,
+    defaultLocalBotBridgeCommand,
+    cliName: CLI_NAME,
+    resolveRunnerExecutionPlan,
+    resolveRunnerExecutionPlanForRole,
+    resolveRunnerLocalAIExecutionProfile,
+    normalizeRunnerRoute,
     buildRunnerRouteNameSuggestion,
-    buildRunnerRoutePayload,
-    upsertRunnerRouteConfig,
-    removeRunnerRouteFromConfig,
-    acquireRunnerRouteLease,
-    buildRunnerExecutionDeps,
-    defaultBotRunnerRoleProfiles,
+    buildRunnerRoutePayload,
+    upsertRunnerRouteConfig,
+    removeRunnerRouteFromConfig,
+    acquireRunnerRouteLease,
+    validateRunnerRoute,
+    runnerRouteSchedulingGroupKey,
+    buildRunnerProjectUpDirectMessageRouteSuggestions,
+    resolveRunnerProjectUpRoutes,
+    buildRunnerProjectUpNextSteps,
+    buildRunnerExecutionDeps,
+    defaultBotRunnerRoleProfiles,
     resolveRunnerRoutes,
     runnerRouteKey,
     runnerRouteLogicalSignature,
@@ -18962,6 +20824,9 @@ TELEGRAM_BOT_REVIEW_TOKEN=review-token
     formatTelegramInboundArchiveComment,
     findArchivedBotReplyRecord,
     parseArchivedChatComment,
+    normalizeLocalTelegramUpdate,
+    normalizeRunnerTelegramMessageEnvelope,
+    normalizeRunnerRecentLocalInboundReceiptEntry,
     intFromRawAllowZero,
     validateWorkspaceArtifacts,
   });
@@ -20013,7 +21878,7 @@ TELEGRAM_BOT_REVIEW_TOKEN=review-token
       "detached_runner_blocks_disjoint_same_target_parallel_launches",
       decision.kind === "conflict"
         && ensureArray(decision.overlapping_route_names).length === 0
-        && String(decision.detail || "").includes("same project/provider/destination target"),
+        && String(decision.detail || "").includes("same project/provider/route target"),
       `kind=${String(decision.kind || "")} overlap=${ensureArray(decision.overlapping_route_names).join(", ")} detail=${String(decision.detail || "")}`,
     );
   } catch (err) {