metheus-governance-mcp-cli 0.2.230 → 0.2.232

package/cli.mjs

@@ -15,7 +15,6 @@ import {
   adjudicateRunnerStartupLoopWithAI,
   analyzeHumanConversationIntentWithAI,
   auditRoleExecutionPlanWithAI,
-  auditDirectHumanReplyWithAI,
   explainExecutionFailureWithAI,
   normalizeExecutionArtifacts,
   planRoleExecutionWithAI,
@@ -1915,6 +1914,15 @@ function mergeRunnerStateRecords(preferred, fallback) {
     }
     return allowUndefined ? undefined : 0;
   };
+  const pickArrayField = (key, normalizer = (value) => String(value || "").trim()) => {
+    if (hasOwn(primary, key)) {
+      const value = uniqueOrderedStrings(ensureArray(primary[key]), normalizer).filter(Boolean);
+      if (value.length) {
+        return value;
+      }
+    }
+    return uniqueOrderedStrings(ensureArray(secondary[key]), normalizer).filter(Boolean);
+  };
   return {
     last_processed_comment_id: pickStringField("last_processed_comment_id"),
     last_processed_created_at: pickStringField("last_processed_created_at"),
@@ -1949,6 +1957,31 @@ function mergeRunnerStateRecords(preferred, fallback) {
     last_root_work_item_id: pickStringField("last_root_work_item_id"),
     last_root_work_item_title: pickStringField("last_root_work_item_title"),
     last_root_work_item_status: pickStringField("last_root_work_item_status"),
+    last_contract_validation_status: pickStringField("last_contract_validation_status"),
+    last_contract_validation_reason: pickStringField("last_contract_validation_reason"),
+    last_normalized_execution_contract_type: pickStringField("last_normalized_execution_contract_type"),
+    last_assignment_validation_status: pickStringField("last_assignment_validation_status"),
+    last_assignment_validation_reason: pickStringField("last_assignment_validation_reason"),
+    last_followup_ai_reply_preview: pickStringField("last_followup_ai_reply_preview"),
+    last_followup_execution_contract_type: pickStringField("last_followup_execution_contract_type"),
+    last_followup_normalized_execution_contract_type: pickStringField("last_followup_normalized_execution_contract_type"),
+    last_followup_response_contract_validation_status: pickStringField("last_followup_response_contract_validation_status"),
+    last_followup_response_contract_validation_reason: pickStringField("last_followup_response_contract_validation_reason"),
+    last_followup_assignment_validation_status: pickStringField("last_followup_assignment_validation_status"),
+    last_followup_assignment_validation_reason: pickStringField("last_followup_assignment_validation_reason"),
+    last_followup_delivery_status: pickStringField("last_followup_delivery_status"),
+    last_followup_archive_status: pickStringField("last_followup_archive_status"),
+    last_followup_transport_error: pickStringField("last_followup_transport_error"),
+    last_followup_archive_error: pickStringField("last_followup_archive_error"),
+    last_contract_validation_targets: pickArrayField("last_contract_validation_targets", normalizeTelegramMentionUsername),
+    last_normalized_execution_contract_targets: pickArrayField("last_normalized_execution_contract_targets", normalizeTelegramMentionUsername),
+    last_normalized_execution_next_responders: pickArrayField("last_normalized_execution_next_responders", normalizeTelegramMentionUsername),
+    last_followup_execution_contract_targets: pickArrayField("last_followup_execution_contract_targets", normalizeTelegramMentionUsername),
+    last_followup_next_expected_responders: pickArrayField("last_followup_next_expected_responders", normalizeTelegramMentionUsername),
+    last_followup_normalized_execution_contract_targets: pickArrayField("last_followup_normalized_execution_contract_targets", normalizeTelegramMentionUsername),
+    last_followup_normalized_execution_next_responders: pickArrayField("last_followup_normalized_execution_next_responders", normalizeTelegramMentionUsername),
+    last_followup_response_contract_validation_targets: pickArrayField("last_followup_response_contract_validation_targets", normalizeTelegramMentionUsername),
+    last_followup_assignment_validation_modes: pickArrayField("last_followup_assignment_validation_modes", (value) => String(value || "").trim().toLowerCase()),
     conversation_sessions: {
       ...safeObject(secondary.conversation_sessions),
       ...safeObject(primary.conversation_sessions),
@@ -2430,26 +2463,75 @@ function normalizeBotRunnerRequests(rawRequests, nowMs = Date.now()) {
       next_expected_responders: ensureArray(entry.next_expected_responders || entry.nextExpectedResponders)
         .map((value) => normalizeTelegramMentionUsername(value))
         .filter(Boolean),
+      normalized_execution_contract_type: String(entry.normalized_execution_contract_type || entry.normalizedExecutionContractType || "").trim().toLowerCase(),
+      normalized_execution_contract_targets: ensureArray(entry.normalized_execution_contract_targets || entry.normalizedExecutionContractTargets)
+        .map((value) => normalizeTelegramMentionUsername(value))
+        .filter(Boolean),
+      normalized_execution_next_responders: ensureArray(entry.normalized_execution_next_responders || entry.normalizedExecutionNextResponders)
+        .map((value) => normalizeTelegramMentionUsername(value))
+        .filter(Boolean),
       ai_reply_generated: boolFromRaw(
         entry.ai_reply_generated ?? entry.aiReplyGenerated,
         false,
       ),
       ai_reply_generated_at: firstNonEmptyString([entry.ai_reply_generated_at, entry.aiReplyGeneratedAt]),
       ai_reply_preview: String(entry.ai_reply_preview || entry.aiReplyPreview || "").trim(),
+      followup_ai_reply_preview: String(entry.followup_ai_reply_preview || entry.followupAiReplyPreview || "").trim(),
+      root_execution_contract_type: String(entry.root_execution_contract_type || entry.rootExecutionContractType || "").trim().toLowerCase(),
+      root_execution_contract_targets: ensureArray(entry.root_execution_contract_targets || entry.rootExecutionContractTargets)
+        .map((value) => normalizeTelegramMentionUsername(value))
+        .filter(Boolean),
+      root_next_expected_responders: ensureArray(entry.root_next_expected_responders || entry.rootNextExpectedResponders)
+        .map((value) => normalizeTelegramMentionUsername(value))
+        .filter(Boolean),
+      root_ai_reply_preview: String(entry.root_ai_reply_preview || entry.rootAiReplyPreview || "").trim(),
+      root_response_contract_validation_status: String(entry.root_response_contract_validation_status || entry.rootResponseContractValidationStatus || "").trim().toLowerCase(),
+      root_response_contract_validation_reason: String(entry.root_response_contract_validation_reason || entry.rootResponseContractValidationReason || "").trim(),
+      root_response_contract_validation_targets: ensureArray(entry.root_response_contract_validation_targets || entry.rootResponseContractValidationTargets)
+        .map((value) => normalizeTelegramMentionUsername(value))
+        .filter(Boolean),
       response_contract_validation_status: String(entry.response_contract_validation_status || entry.responseContractValidationStatus || "").trim().toLowerCase(),
       response_contract_validation_reason: String(entry.response_contract_validation_reason || entry.responseContractValidationReason || "").trim(),
       response_contract_validation_targets: ensureArray(entry.response_contract_validation_targets || entry.responseContractValidationTargets)
         .map((value) => normalizeTelegramMentionUsername(value))
         .filter(Boolean),
+      followup_execution_contract_type: String(entry.followup_execution_contract_type || entry.followupExecutionContractType || "").trim().toLowerCase(),
+      followup_execution_contract_targets: ensureArray(entry.followup_execution_contract_targets || entry.followupExecutionContractTargets)
+        .map((value) => normalizeTelegramMentionUsername(value))
+        .filter(Boolean),
+      followup_next_expected_responders: ensureArray(entry.followup_next_expected_responders || entry.followupNextExpectedResponders)
+        .map((value) => normalizeTelegramMentionUsername(value))
+        .filter(Boolean),
+      followup_normalized_execution_contract_type: String(entry.followup_normalized_execution_contract_type || entry.followupNormalizedExecutionContractType || "").trim().toLowerCase(),
+      followup_normalized_execution_contract_targets: ensureArray(entry.followup_normalized_execution_contract_targets || entry.followupNormalizedExecutionContractTargets)
+        .map((value) => normalizeTelegramMentionUsername(value))
+        .filter(Boolean),
+      followup_normalized_execution_next_responders: ensureArray(entry.followup_normalized_execution_next_responders || entry.followupNormalizedExecutionNextResponders)
+        .map((value) => normalizeTelegramMentionUsername(value))
+        .filter(Boolean),
+      followup_response_contract_validation_status: String(entry.followup_response_contract_validation_status || entry.followupResponseContractValidationStatus || "").trim().toLowerCase(),
+      followup_response_contract_validation_reason: String(entry.followup_response_contract_validation_reason || entry.followupResponseContractValidationReason || "").trim(),
+      followup_response_contract_validation_targets: ensureArray(entry.followup_response_contract_validation_targets || entry.followupResponseContractValidationTargets)
+        .map((value) => normalizeTelegramMentionUsername(value))
+        .filter(Boolean),
       assignment_validation_status: String(entry.assignment_validation_status || entry.assignmentValidationStatus || "").trim().toLowerCase(),
       assignment_validation_reason: String(entry.assignment_validation_reason || entry.assignmentValidationReason || "").trim(),
       assignment_validation_modes: ensureArray(entry.assignment_validation_modes || entry.assignmentValidationModes)
         .map((value) => String(value || "").trim().toLowerCase())
         .filter(Boolean),
+      followup_assignment_validation_status: String(entry.followup_assignment_validation_status || entry.followupAssignmentValidationStatus || "").trim().toLowerCase(),
+      followup_assignment_validation_reason: String(entry.followup_assignment_validation_reason || entry.followupAssignmentValidationReason || "").trim(),
+      followup_assignment_validation_modes: ensureArray(entry.followup_assignment_validation_modes || entry.followupAssignmentValidationModes)
+        .map((value) => String(value || "").trim().toLowerCase())
+        .filter(Boolean),
       delivery_status: String(entry.delivery_status || entry.deliveryStatus || "").trim().toLowerCase(),
       archive_status: String(entry.archive_status || entry.archiveStatus || "").trim().toLowerCase(),
       transport_error: String(entry.transport_error || entry.transportError || "").trim(),
       archive_error: String(entry.archive_error || entry.archiveError || "").trim(),
+      followup_delivery_status: String(entry.followup_delivery_status || entry.followupDeliveryStatus || "").trim().toLowerCase(),
+      followup_archive_status: String(entry.followup_archive_status || entry.followupArchiveStatus || "").trim().toLowerCase(),
+      followup_transport_error: String(entry.followup_transport_error || entry.followupTransportError || "").trim(),
+      followup_archive_error: String(entry.followup_archive_error || entry.followupArchiveError || "").trim(),
       normalized_intent: String(entry.normalized_intent || entry.normalizedIntent || "").trim().toLowerCase(),
       status,
       claimed_by_route: String(entry.claimed_by_route || entry.claimedByRoute || "").trim(),
@@ -3031,11 +3113,341 @@ function runnerRequestHasConversationContractData(entryRaw) {
     || ensureArray(entry.conversation_allowed_responders).length
     || entry.conversation_allow_bot_to_bot === true
     || String(entry.conversation_reply_expectation || "").trim()
-    || String(entry.execution_contract_type || "").trim()
-    || entry.execution_contract_actionable === true
-    || ensureArray(entry.execution_contract_targets).length
-    || ensureArray(entry.next_expected_responders).length
+    || runnerRequestPreferredExecutionContractType(entry)
+    || runnerRequestPreferredExecutionContractActionable(entry) === true
+    || runnerRequestPreferredExecutionContractTargets(entry).length
+    || runnerRequestPreferredNextExpectedResponders(entry).length
+  );
+}
+
+function runnerRequestPreferredExecutionContractType(entryRaw) {
+  const entry = safeObject(entryRaw);
+  return String(
+    entry.execution_contract_type
+      || entry.followup_execution_contract_type
+      || entry.root_execution_contract_type
+      || "",
+  ).trim().toLowerCase();
+}
+
+function runnerRequestPreferredExecutionContractActionable(entryRaw) {
+  const entry = safeObject(entryRaw);
+  return entry.execution_contract_actionable === true;
+}
+
+function runnerRequestPreferredExecutionContractTargets(entryRaw) {
+  const entry = safeObject(entryRaw);
+  return uniqueOrderedStrings(
+    ensureArray(entry.execution_contract_targets).length
+      ? entry.execution_contract_targets
+      : ensureArray(entry.followup_execution_contract_targets).length
+        ? entry.followup_execution_contract_targets
+        : ensureArray(entry.root_execution_contract_targets).length
+          ? entry.root_execution_contract_targets
+          : [],
+    normalizeTelegramMentionUsername,
+  );
+}
+
+function runnerRequestPreferredNextExpectedResponders(entryRaw) {
+  const entry = safeObject(entryRaw);
+  return uniqueOrderedStrings(
+    ensureArray(entry.next_expected_responders).length
+      ? entry.next_expected_responders
+      : ensureArray(entry.followup_next_expected_responders).length
+        ? entry.followup_next_expected_responders
+        : ensureArray(entry.root_next_expected_responders).length
+          ? entry.root_next_expected_responders
+          : [],
+    normalizeTelegramMentionUsername,
+  );
+}
+
+function runnerRequestPreferredAIReplyPreview(entryRaw) {
+  const entry = safeObject(entryRaw);
+  return String(
+    entry.ai_reply_preview
+      || entry.followup_ai_reply_preview
+      || entry.root_ai_reply_preview
+      || "",
+  ).trim();
+}
+
+function runnerRequestPreferredResponseContractValidationStatus(entryRaw) {
+  const entry = safeObject(entryRaw);
+  return String(
+    entry.response_contract_validation_status
+      || entry.followup_response_contract_validation_status
+      || entry.root_response_contract_validation_status
+      || "",
+  ).trim().toLowerCase();
+}
+
+function runnerRequestPreferredResponseContractValidationReason(entryRaw) {
+  const entry = safeObject(entryRaw);
+  return String(
+    entry.response_contract_validation_reason
+      || entry.followup_response_contract_validation_reason
+      || entry.root_response_contract_validation_reason
+      || "",
+  ).trim();
+}
+
+function runnerRequestPreferredResponseContractValidationTargets(entryRaw) {
+  const entry = safeObject(entryRaw);
+  return uniqueOrderedStrings(
+    ensureArray(entry.response_contract_validation_targets).length
+      ? entry.response_contract_validation_targets
+      : ensureArray(entry.followup_response_contract_validation_targets).length
+        ? entry.followup_response_contract_validation_targets
+        : ensureArray(entry.root_response_contract_validation_targets).length
+          ? entry.root_response_contract_validation_targets
+          : [],
+    normalizeTelegramMentionUsername,
+  );
+}
+
+function runnerRequestPreferredAssignmentValidationStatus(entryRaw) {
+  const entry = safeObject(entryRaw);
+  return String(
+    entry.assignment_validation_status
+      || entry.followup_assignment_validation_status
+      || "",
+  ).trim().toLowerCase();
+}
+
+function runnerRequestPreferredAssignmentValidationReason(entryRaw) {
+  const entry = safeObject(entryRaw);
+  return String(
+    entry.assignment_validation_reason
+      || entry.followup_assignment_validation_reason
+      || "",
+  ).trim();
+}
+
+function runnerRequestPreferredAssignmentValidationModes(entryRaw) {
+  const entry = safeObject(entryRaw);
+  return uniqueOrderedStrings(
+    ensureArray(entry.assignment_validation_modes).length
+      ? entry.assignment_validation_modes
+      : ensureArray(entry.followup_assignment_validation_modes).length
+        ? entry.followup_assignment_validation_modes
+        : [],
+    (value) => String(value || "").trim().toLowerCase(),
+  );
+}
+
+function runnerRequestPreferredDeliveryStatus(entryRaw) {
+  const entry = safeObject(entryRaw);
+  return String(
+    entry.delivery_status
+      || entry.followup_delivery_status
+      || "",
+  ).trim().toLowerCase();
+}
+
+function runnerRequestPreferredArchiveStatus(entryRaw) {
+  const entry = safeObject(entryRaw);
+  return String(
+    entry.archive_status
+      || entry.followup_archive_status
+      || "",
+  ).trim().toLowerCase();
+}
+
+function runnerRequestPreferredTransportError(entryRaw) {
+  const entry = safeObject(entryRaw);
+  return String(
+    entry.transport_error
+      || entry.followup_transport_error
+      || "",
+  ).trim();
+}
+
+function runnerRequestPreferredArchiveError(entryRaw) {
+  const entry = safeObject(entryRaw);
+  return String(
+    entry.archive_error
+      || entry.followup_archive_error
+      || "",
+  ).trim();
+}
+
+function buildRunnerValidationAndDeliverySummary({
+  aiReplyPreview = "",
+  executionContractType = "",
+  executionContractTargets = [],
+  nextExpectedResponders = [],
+  responseContractValidationStatus = "",
+  responseContractValidationReason = "",
+  responseContractValidationTargets = [],
+  assignmentValidationStatus = "",
+  assignmentValidationReason = "",
+  assignmentValidationModes = [],
+  deliveryStatus = "",
+  archiveStatus = "",
+  transportError = "",
+  archiveError = "",
+} = {}) {
+  return {
+    ai_reply_preview: String(aiReplyPreview || "").trim(),
+    execution_contract_type: String(executionContractType || "").trim().toLowerCase(),
+    execution_contract_targets: uniqueOrderedStrings(
+      ensureArray(executionContractTargets),
+      normalizeTelegramMentionUsername,
+    ),
+    next_expected_responders: uniqueOrderedStrings(
+      ensureArray(nextExpectedResponders),
+      normalizeTelegramMentionUsername,
+    ),
+    response_contract_validation_status: String(responseContractValidationStatus || "").trim().toLowerCase(),
+    response_contract_validation_reason: String(responseContractValidationReason || "").trim(),
+    response_contract_validation_targets: uniqueOrderedStrings(
+      ensureArray(responseContractValidationTargets),
+      normalizeTelegramMentionUsername,
+    ),
+    assignment_validation_status: String(assignmentValidationStatus || "").trim().toLowerCase(),
+    assignment_validation_reason: String(assignmentValidationReason || "").trim(),
+    assignment_validation_modes: uniqueOrderedStrings(
+      ensureArray(assignmentValidationModes),
+      (value) => String(value || "").trim().toLowerCase(),
+    ),
+    delivery_status: String(deliveryStatus || "").trim().toLowerCase(),
+    archive_status: String(archiveStatus || "").trim().toLowerCase(),
+    transport_error: String(transportError || "").trim(),
+    archive_error: String(archiveError || "").trim(),
+  };
+}
+
+function buildRunnerRequestRootWorkItemSummary(entryRaw) {
+  const entry = safeObject(entryRaw);
+  const rootWorkItemID = String(entry.root_work_item_id || "").trim();
+  if (!rootWorkItemID) {
+    return null;
+  }
+  return {
+    id: rootWorkItemID,
+    title: String(entry.root_work_item_title || "").trim(),
+    status: normalizeRunnerWorkItemStatus(entry.root_work_item_status),
+    thread_id: String(entry.root_thread_id || "").trim(),
+  };
+}
+
+function buildRunnerRouteLastResultSummary(routeStateRaw) {
+  const routeState = safeObject(routeStateRaw);
+  const executionContractType = String(
+    routeState.last_followup_execution_contract_type
+      || routeState.last_normalized_execution_contract_type
+      || "",
+  ).trim().toLowerCase();
+  const executionContractTargets = uniqueOrderedStrings(
+    ensureArray(routeState.last_followup_execution_contract_targets).length
+      ? routeState.last_followup_execution_contract_targets
+      : ensureArray(routeState.last_normalized_execution_contract_targets),
+    normalizeTelegramMentionUsername,
+  );
+  const nextExpectedResponders = uniqueOrderedStrings(
+    ensureArray(routeState.last_followup_next_expected_responders).length
+      ? routeState.last_followup_next_expected_responders
+      : ensureArray(routeState.last_normalized_execution_next_responders),
+    normalizeTelegramMentionUsername,
+  );
+  const responseContractValidationStatus = String(
+    routeState.last_followup_response_contract_validation_status
+      || routeState.last_contract_validation_status
+      || "",
+  ).trim().toLowerCase();
+  const responseContractValidationReason = String(
+    routeState.last_followup_response_contract_validation_reason
+      || routeState.last_contract_validation_reason
+      || "",
+  ).trim();
+  const responseContractValidationTargets = uniqueOrderedStrings(
+    ensureArray(routeState.last_followup_response_contract_validation_targets).length
+      ? routeState.last_followup_response_contract_validation_targets
+      : ensureArray(routeState.last_contract_validation_targets),
+    normalizeTelegramMentionUsername,
+  );
+  const assignmentValidationStatus = String(
+    routeState.last_followup_assignment_validation_status
+      || routeState.last_assignment_validation_status
+      || "",
+  ).trim().toLowerCase();
+  const assignmentValidationReason = String(
+    routeState.last_followup_assignment_validation_reason
+      || routeState.last_assignment_validation_reason
+      || "",
+  ).trim();
+  const assignmentValidationModes = uniqueOrderedStrings(
+    ensureArray(routeState.last_followup_assignment_validation_modes),
+    (value) => String(value || "").trim().toLowerCase(),
   );
+  return {
+    action: String(routeState.last_action || "").trim(),
+    reason: String(routeState.last_reason || "").trim(),
+    intent_type: String(routeState.last_intent_type || "").trim(),
+    ...buildRunnerValidationAndDeliverySummary({
+      aiReplyPreview: routeState.last_followup_ai_reply_preview,
+      executionContractType,
+      executionContractTargets,
+      nextExpectedResponders,
+      responseContractValidationStatus,
+      responseContractValidationReason,
+      responseContractValidationTargets,
+      assignmentValidationStatus,
+      assignmentValidationReason,
+      assignmentValidationModes,
+      deliveryStatus: routeState.last_followup_delivery_status,
+      archiveStatus: routeState.last_followup_archive_status,
+      transportError: routeState.last_followup_transport_error,
+      archiveError: routeState.last_followup_archive_error,
+    }),
+    workspace_dir: String(routeState.last_workspace_dir || "").trim(),
+    artifact_validation: String(routeState.last_artifact_validation || "").trim(),
+    artifact_paths: ensureArray(routeState.last_artifact_paths).map((item) => String(item || "").trim()).filter(Boolean),
+    artifact_errors: ensureArray(routeState.last_artifact_errors).map((item) => String(item || "").trim()).filter(Boolean),
+    boundary_violations: ensureArray(routeState.last_boundary_violations).map((item) => safeObject(item)),
+  };
+}
+
+function buildRunnerStatusLookupWorkItemSummary({
+  relatedRequest,
+  routeState,
+  currentConversationID,
+}) {
+  const requestRootWorkItem = buildRunnerRequestRootWorkItemSummary(relatedRequest);
+  const safeRouteState = safeObject(routeState);
+  const routeConversationID = String(safeRouteState.last_conversation_id || "").trim();
+  const activeRootWorkItemID = String(safeRouteState.active_root_work_item_id || "").trim();
+  const activeRootWorkItemTitle = String(safeRouteState.active_root_work_item_title || "").trim();
+  const activeRootWorkItemStatus = normalizeRunnerWorkItemStatus(safeRouteState.active_root_work_item_status);
+  const routeRootWorkItemID = String(safeRouteState.last_root_work_item_id || "").trim();
+  const routeRootWorkItemTitle = String(safeRouteState.last_root_work_item_title || "").trim();
+  const routeRootWorkItemStatus = normalizeRunnerWorkItemStatus(safeRouteState.last_root_work_item_status);
+  const routeWorkItemIDs = ensureArray(safeRouteState.last_work_item_ids).map((item) => String(item || "").trim()).filter(Boolean);
+  const routeWorkItemTitles = ensureArray(safeRouteState.last_work_item_titles).map((item) => String(item || "").trim()).filter(Boolean);
+  return {
+    root_work_item: requestRootWorkItem
+      || (activeRootWorkItemID
+        ? {
+            id: activeRootWorkItemID,
+            title: activeRootWorkItemTitle,
+            status: activeRootWorkItemStatus,
+          }
+        : currentConversationID && routeConversationID === currentConversationID && routeRootWorkItemID
+          ? {
+              id: routeRootWorkItemID,
+              title: routeRootWorkItemTitle,
+              status: routeRootWorkItemStatus,
+            }
+          : null),
+    route_work_items: currentConversationID && routeConversationID === currentConversationID && (routeWorkItemIDs.length > 0 || routeWorkItemTitles.length > 0)
+      ? {
+          ids: routeWorkItemIDs,
+          titles: routeWorkItemTitles,
+        }
+      : null,
+  };
 }
 
 function pickRunnerSharedConversationSourceRequest(entries = [], excludeRequestKey = "") {
@@ -3628,28 +4040,26 @@ async function claimRunnerRequestForHumanComment({
         || referencedRequest.conversation_reply_expectation
         || "",
     ).trim().toLowerCase(),
-    execution_contract_type: String(
-      existing.execution_contract_type || sharedConversationSource.execution_contract_type || referencedRequest.execution_contract_type || "",
-    ).trim().toLowerCase(),
-    execution_contract_actionable: existing.execution_contract_actionable === true
-      || sharedConversationSource.execution_contract_actionable === true
-      || referencedRequest.execution_contract_actionable === true,
+    execution_contract_type: runnerRequestPreferredExecutionContractType(existing)
+      || runnerRequestPreferredExecutionContractType(sharedConversationSource)
+      || runnerRequestPreferredExecutionContractType(referencedRequest),
+    execution_contract_actionable: runnerRequestPreferredExecutionContractActionable(existing)
+      || runnerRequestPreferredExecutionContractActionable(sharedConversationSource)
+      || runnerRequestPreferredExecutionContractActionable(referencedRequest),
     execution_contract_targets: uniqueOrderedStrings(
-      ensureArray(existing.execution_contract_targets).length
-        ? existing.execution_contract_targets
-        : ensureArray(sharedConversationSource.execution_contract_targets).length
-          ? sharedConversationSource.execution_contract_targets
-          : referencedRequest.execution_contract_targets,
+      runnerRequestPreferredExecutionContractTargets(existing).length
+        ? runnerRequestPreferredExecutionContractTargets(existing)
+        : runnerRequestPreferredExecutionContractTargets(sharedConversationSource).length
+          ? runnerRequestPreferredExecutionContractTargets(sharedConversationSource)
+          : runnerRequestPreferredExecutionContractTargets(referencedRequest),
       normalizeTelegramMentionUsername,
     ),
     next_expected_responders: uniqueOrderedStrings(
-      ensureArray(existing.next_expected_responders).length
-        ? existing.next_expected_responders
-        : ensureArray(sharedConversationSource.next_expected_responders).length
-          ? sharedConversationSource.next_expected_responders
-          : ensureArray(referencedRequest.next_expected_responders).length
-            ? referencedRequest.next_expected_responders
-            : [],
+      runnerRequestPreferredNextExpectedResponders(existing).length
+        ? runnerRequestPreferredNextExpectedResponders(existing)
+        : runnerRequestPreferredNextExpectedResponders(sharedConversationSource).length
+          ? runnerRequestPreferredNextExpectedResponders(sharedConversationSource)
+          : runnerRequestPreferredNextExpectedResponders(referencedRequest),
       normalizeTelegramMentionUsername,
     ),
     normalized_intent: String(preferredNormalizedIntent || existing.normalized_intent || "").trim().toLowerCase(),
@@ -3698,92 +4108,15 @@ async function claimRunnerRequestForHumanComment({
   };
 }
 
-function isActionableRunnerRequestIntent(rawIntent) {
-  const normalizedIntent = String(rawIntent || "").trim().toLowerCase();
-  return Boolean(normalizedIntent) && !isInformationalRunnerRequestIntent(normalizedIntent);
-}
-
-function runnerRequestHasConversationContract(requestRaw) {
-  const request = safeObject(requestRaw);
-  return Boolean(
-    String(request.conversation_id || "").trim()
-    || String(request.conversation_intent_mode || "").trim()
-    || String(request.conversation_reply_expectation || "").trim()
-    || ensureArray(request.conversation_participants).length
-    || ensureArray(request.conversation_initial_responders).length
-    || ensureArray(request.conversation_allowed_responders).length
-  );
-}
-
-function runnerRequestHasCompleteConversationContract(requestRaw) {
-  const request = safeObject(requestRaw);
-  const intentMode = String(request.conversation_intent_mode || "").trim().toLowerCase();
-  const conversationID = String(request.conversation_id || "").trim();
-  const replyExpectation = String(request.conversation_reply_expectation || "").trim().toLowerCase();
-  const participants = ensureArray(request.conversation_participants);
-  const initialResponders = ensureArray(request.conversation_initial_responders);
-  const allowedResponders = ensureArray(request.conversation_allowed_responders);
-  if (!runnerRequestHasConversationContract(request)) {
-    return false;
-  }
-  if (!conversationID || !intentMode || !replyExpectation) {
-    return false;
-  }
-  if (intentMode === "single_bot") {
-    return allowedResponders.length > 0 || participants.length > 0;
-  }
-  return participants.length > 0 && initialResponders.length > 0 && allowedResponders.length > 0;
-}
-
-function runnerRequestHasExecutionContract(requestRaw) {
-  const request = safeObject(requestRaw);
-  return Boolean(
-    String(request.execution_contract_type || "").trim()
-    || request.execution_contract_actionable === true
-    || ensureArray(request.execution_contract_targets).length
-    || ensureArray(request.next_expected_responders).length
-  );
-}
-
-function runnerRequestHasCompleteExecutionContract(requestRaw) {
-  const request = safeObject(requestRaw);
-  const executionContractType = String(request.execution_contract_type || "").trim().toLowerCase();
-  const executionTargets = ensureArray(request.execution_contract_targets);
-  const nextExpectedResponders = ensureArray(request.next_expected_responders);
-  if (!runnerRequestHasExecutionContract(request)) {
-    return false;
-  }
-  if (!executionContractType) {
-    return false;
-  }
-  if (executionContractType === "delegation") {
-    return executionTargets.length > 0 || nextExpectedResponders.length > 0;
-  }
-  if (executionContractType === "summary_request") {
-    return nextExpectedResponders.length > 0 || executionTargets.length > 0;
-  }
-  return true;
-}
-
-function runnerRequestHasContractSignals(requestRaw) {
-  const request = safeObject(requestRaw);
-  return runnerRequestHasConversationContract(request) || runnerRequestHasExecutionContract(request);
-}
-
 function runnerRequestRequiresActionableContract(requestRaw) {
   const request = safeObject(requestRaw);
-  const replyExpectation = String(request.conversation_reply_expectation || "").trim().toLowerCase();
-  const executionContractType = String(request.execution_contract_type || "").trim().toLowerCase();
-  const intentMode = String(request.conversation_intent_mode || "").trim().toLowerCase();
-  if (request.execution_contract_actionable === true) {
+  const executionContractType = runnerRequestPreferredExecutionContractType(request);
+  if (runnerRequestPreferredExecutionContractActionable(request) === true) {
     return true;
   }
   if (["delegation", "direct_result", "summary_request", "final_summary"].includes(executionContractType)) {
     return true;
   }
-  if (intentMode === "single_bot" && replyExpectation === "actionable") {
-    return true;
-  }
   return false;
 }
 
@@ -3816,13 +4149,9 @@ function truncateRunnerWorkItemTitleText(rawText, maxLength = 96) {
 
 function buildRunnerRootWorkItemTitle({ selectedRecord, request }) {
   const parsed = safeObject(selectedRecord?.parsedArchive);
-  const intent = String(safeObject(request).normalized_intent || "").trim().toLowerCase();
+  void request;
   const requestBody = truncateRunnerWorkItemTitleText(parsed.body || "", 84);
-  const prefix = intent === "ctxpack_mutation"
-    ? "Ctxpack request"
-    : intent === "workitem_mutation"
-      ? "Work item request"
-      : "Runner request";
+  const prefix = "Runner request";
   if (requestBody) {
     return `${prefix}: ${requestBody}`;
   }
@@ -4270,6 +4599,52 @@ function buildRunnerRootWorkItemTransitionPath(currentStatusRaw, targetStatusRaw
   return [];
 }
 
+function buildRunnerRouteFollowupSnapshotPatch(selectedRecordRaw, resultRaw = {}) {
+  const parsed = safeObject(safeObject(selectedRecordRaw).parsedArchive);
+  const commentKind = String(parsed.kind || "").trim().toLowerCase();
+  if (["telegram_message", "telegram_edited_message"].includes(commentKind)) {
+    return {};
+  }
+  const result = safeObject(resultRaw);
+  return cleanupRunnerStateRecord({
+    last_followup_ai_reply_preview: String(result.ai_reply_preview || "").trim(),
+    last_followup_execution_contract_type: String(result.execution_contract_type || "").trim().toLowerCase(),
+    last_followup_execution_contract_targets: uniqueOrderedStrings(
+      ensureArray(result.execution_contract_targets),
+      normalizeTelegramMentionUsername,
+    ),
+    last_followup_next_expected_responders: uniqueOrderedStrings(
+      ensureArray(result.next_expected_responders),
+      normalizeTelegramMentionUsername,
+    ),
+    last_followup_normalized_execution_contract_type: String(result.normalized_execution_contract_type || "").trim().toLowerCase(),
+    last_followup_normalized_execution_contract_targets: uniqueOrderedStrings(
+      ensureArray(result.normalized_execution_contract_targets),
+      normalizeTelegramMentionUsername,
+    ),
+    last_followup_normalized_execution_next_responders: uniqueOrderedStrings(
+      ensureArray(result.normalized_execution_next_responders),
+      normalizeTelegramMentionUsername,
+    ),
+    last_followup_response_contract_validation_status: String(result.response_contract_validation_status || "").trim().toLowerCase(),
+    last_followup_response_contract_validation_reason: String(result.response_contract_validation_reason || "").trim(),
+    last_followup_response_contract_validation_targets: uniqueOrderedStrings(
+      ensureArray(result.response_contract_validation_targets),
+      normalizeTelegramMentionUsername,
+    ),
+    last_followup_assignment_validation_status: String(result.assignment_validation_status || "").trim().toLowerCase(),
+    last_followup_assignment_validation_reason: String(result.assignment_validation_reason || "").trim(),
+    last_followup_assignment_validation_modes: uniqueOrderedStrings(
+      ensureArray(result.assignment_validation_modes),
+      (value) => String(value || "").trim().toLowerCase(),
+    ),
+    last_followup_delivery_status: String(result.delivery_status || "").trim().toLowerCase(),
+    last_followup_archive_status: String(result.archive_status || "").trim().toLowerCase(),
+    last_followup_transport_error: String(result.transport_error || "").trim(),
+    last_followup_archive_error: String(result.archive_error || "").trim(),
+  });
+}
+
 function buildRunnerRequestRecoveryPatchFromRouteState(currentStateRaw, requestRaw, routeKeyHint = "") {
   const currentState = safeObject(currentStateRaw);
   const request = safeObject(requestRaw);
@@ -4314,6 +4689,44 @@ function buildRunnerRequestRecoveryPatchFromRouteState(currentStateRaw, requestR
         || routeState.last_root_work_item_status,
       );
     }
+    const setFollowupStringPatch = (requestField, routeFields = []) => {
+      if (String(request[requestField] || "").trim()) {
+        return;
+      }
+      const recovered = firstNonEmptyString(routeFields.map((field) => routeState[field]));
+      if (recovered) {
+        patch[requestField] = recovered;
+      }
+    };
+    const setFollowupArrayPatch = (requestField, routeFields = [], normalizer = normalizeTelegramMentionUsername) => {
+      if (ensureArray(request[requestField]).length) {
+        return;
+      }
+      for (const field of ensureArray(routeFields)) {
+        const recovered = uniqueOrderedStrings(ensureArray(routeState[field]), normalizer).filter(Boolean);
+        if (recovered.length) {
+          patch[requestField] = recovered;
+          return;
+        }
+      }
+    };
+    setFollowupStringPatch("followup_ai_reply_preview", ["last_followup_ai_reply_preview"]);
+    setFollowupStringPatch("followup_execution_contract_type", ["last_followup_execution_contract_type"]);
+    setFollowupArrayPatch("followup_execution_contract_targets", ["last_followup_execution_contract_targets"]);
+    setFollowupArrayPatch("followup_next_expected_responders", ["last_followup_next_expected_responders"]);
+    setFollowupStringPatch("followup_normalized_execution_contract_type", ["last_followup_normalized_execution_contract_type", "last_normalized_execution_contract_type"]);
+    setFollowupArrayPatch("followup_normalized_execution_contract_targets", ["last_followup_normalized_execution_contract_targets", "last_normalized_execution_contract_targets"]);
+    setFollowupArrayPatch("followup_normalized_execution_next_responders", ["last_followup_normalized_execution_next_responders", "last_normalized_execution_next_responders"]);
+    setFollowupStringPatch("followup_response_contract_validation_status", ["last_followup_response_contract_validation_status", "last_contract_validation_status"]);
+    setFollowupStringPatch("followup_response_contract_validation_reason", ["last_followup_response_contract_validation_reason", "last_contract_validation_reason"]);
+    setFollowupArrayPatch("followup_response_contract_validation_targets", ["last_followup_response_contract_validation_targets", "last_contract_validation_targets"]);
+    setFollowupStringPatch("followup_assignment_validation_status", ["last_followup_assignment_validation_status", "last_assignment_validation_status"]);
+    setFollowupStringPatch("followup_assignment_validation_reason", ["last_followup_assignment_validation_reason", "last_assignment_validation_reason"]);
+    setFollowupArrayPatch("followup_assignment_validation_modes", ["last_followup_assignment_validation_modes"], (value) => String(value || "").trim().toLowerCase());
+    setFollowupStringPatch("followup_delivery_status", ["last_followup_delivery_status"]);
+    setFollowupStringPatch("followup_archive_status", ["last_followup_archive_status"]);
+    setFollowupStringPatch("followup_transport_error", ["last_followup_transport_error"]);
+    setFollowupStringPatch("followup_archive_error", ["last_followup_archive_error"]);
     const requestStatus = normalizeRunnerRequestStatus(request.status);
     if (!isFinalRunnerRequestStatus(requestStatus)) {
       const routeAction = String(routeState.last_action || "").trim().toLowerCase();
@@ -4597,6 +5010,9 @@ function markRunnerRequestLifecycle({
   aiReplyGenerated = false,
   aiReplyGeneratedAt = "",
   aiReplyPreview = "",
+  normalizedExecutionContractType = "",
+  normalizedExecutionContractTargets = [],
+  normalizedExecutionNextResponders = [],
   responseContractValidationStatus = "",
   responseContractValidationReason = "",
   responseContractValidationTargets = [],
@@ -4668,6 +5084,9 @@ 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 = {
     conversation_id: conversationID,
     conversation_participants: uniqueOrderedStrings(
@@ -4713,39 +5132,217 @@ function markRunnerRequestLifecycle({
       ensureArray(nextExpectedResponders).length ? nextExpectedResponders : existing.next_expected_responders,
       normalizeTelegramMentionUsername,
     ),
+    normalized_execution_contract_type: String(
+      normalizedExecutionContractType || existing.normalized_execution_contract_type || "",
+    ).trim().toLowerCase(),
+    normalized_execution_contract_targets: uniqueOrderedStrings(
+      ensureArray(normalizedExecutionContractTargets).length
+        ? normalizedExecutionContractTargets
+        : existing.normalized_execution_contract_targets,
+      normalizeTelegramMentionUsername,
+    ),
+    normalized_execution_next_responders: uniqueOrderedStrings(
+      ensureArray(normalizedExecutionNextResponders).length
+        ? normalizedExecutionNextResponders
+        : existing.normalized_execution_next_responders,
+      normalizeTelegramMentionUsername,
+    ),
     ai_reply_generated: aiReplyGenerated === true || existing.ai_reply_generated === true,
     ai_reply_generated_at: aiReplyGenerated === true
       ? firstNonEmptyString([aiReplyGeneratedAt, existing.ai_reply_generated_at, nowISO])
       : String(existing.ai_reply_generated_at || "").trim(),
-    ai_reply_preview: String(aiReplyPreview || existing.ai_reply_preview || "").trim(),
-    response_contract_validation_status: String(
-      responseContractValidationStatus || existing.response_contract_validation_status || "",
-    ).trim().toLowerCase(),
+    ai_reply_preview: String(
+      isRootHumanComment
+        ? aiReplyPreview || existing.ai_reply_preview || ""
+        : existing.ai_reply_preview || "",
+    ).trim(),
+    followup_ai_reply_preview: String(
+      isFollowupComment
+        ? 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 && ensureArray(executionContractTargets).length
+        ? executionContractTargets
+        : ensureArray(existing.root_execution_contract_targets).length
+          ? existing.root_execution_contract_targets
+          : existing.execution_contract_targets,
+      normalizeTelegramMentionUsername,
+    ),
+    root_next_expected_responders: uniqueOrderedStrings(
+      isRootHumanComment && ensureArray(nextExpectedResponders).length
+        ? nextExpectedResponders
+        : ensureArray(existing.root_next_expected_responders).length
+          ? existing.root_next_expected_responders
+          : existing.next_expected_responders,
+      normalizeTelegramMentionUsername,
+    ),
+    root_ai_reply_preview: String(
+      isRootHumanComment
+        ? aiReplyPreview || existing.root_ai_reply_preview || existing.ai_reply_preview || ""
+        : existing.root_ai_reply_preview || existing.ai_reply_preview || "",
+    ).trim(),
+    root_response_contract_validation_status: String(
+      isRootHumanComment
+        ? responseContractValidationStatus || existing.root_response_contract_validation_status || existing.response_contract_validation_status || ""
+        : existing.root_response_contract_validation_status || existing.response_contract_validation_status || "",
+    ).trim().toLowerCase(),
+    root_response_contract_validation_reason: String(
+      isRootHumanComment
+        ? responseContractValidationReason || existing.root_response_contract_validation_reason || existing.response_contract_validation_reason || ""
+        : existing.root_response_contract_validation_reason || existing.response_contract_validation_reason || "",
+    ).trim(),
+    root_response_contract_validation_targets: uniqueOrderedStrings(
+      isRootHumanComment && ensureArray(responseContractValidationTargets).length
+        ? responseContractValidationTargets
+        : ensureArray(existing.root_response_contract_validation_targets).length
+          ? existing.root_response_contract_validation_targets
+          : existing.response_contract_validation_targets,
+      normalizeTelegramMentionUsername,
+    ),
+    response_contract_validation_status: String(
+      isRootHumanComment
+        ? responseContractValidationStatus || existing.response_contract_validation_status || ""
+        : existing.response_contract_validation_status || "",
+    ).trim().toLowerCase(),
     response_contract_validation_reason: String(
-      responseContractValidationReason || existing.response_contract_validation_reason || "",
+      isRootHumanComment
+        ? responseContractValidationReason || existing.response_contract_validation_reason || ""
+        : existing.response_contract_validation_reason || "",
     ).trim(),
     response_contract_validation_targets: uniqueOrderedStrings(
-      ensureArray(responseContractValidationTargets).length
+      isRootHumanComment && ensureArray(responseContractValidationTargets).length
         ? responseContractValidationTargets
         : existing.response_contract_validation_targets,
       normalizeTelegramMentionUsername,
     ),
+    followup_execution_contract_type: String(
+      isFollowupComment
+        ? nextExecutionContractType || existing.followup_execution_contract_type || ""
+        : existing.followup_execution_contract_type || "",
+    ).trim().toLowerCase(),
+    followup_execution_contract_targets: uniqueOrderedStrings(
+      isFollowupComment && ensureArray(executionContractTargets).length
+        ? executionContractTargets
+        : existing.followup_execution_contract_targets,
+      normalizeTelegramMentionUsername,
+    ),
+    followup_next_expected_responders: uniqueOrderedStrings(
+      isFollowupComment && ensureArray(nextExpectedResponders).length
+        ? nextExpectedResponders
+        : existing.followup_next_expected_responders,
+      normalizeTelegramMentionUsername,
+    ),
+    followup_normalized_execution_contract_type: String(
+      isFollowupComment
+        ? normalizedExecutionContractType || existing.followup_normalized_execution_contract_type || ""
+        : existing.followup_normalized_execution_contract_type || "",
+    ).trim().toLowerCase(),
+    followup_normalized_execution_contract_targets: uniqueOrderedStrings(
+      isFollowupComment && ensureArray(normalizedExecutionContractTargets).length
+        ? normalizedExecutionContractTargets
+        : existing.followup_normalized_execution_contract_targets,
+      normalizeTelegramMentionUsername,
+    ),
+    followup_normalized_execution_next_responders: uniqueOrderedStrings(
+      isFollowupComment && ensureArray(normalizedExecutionNextResponders).length
+        ? normalizedExecutionNextResponders
+        : existing.followup_normalized_execution_next_responders,
+      normalizeTelegramMentionUsername,
+    ),
+    followup_response_contract_validation_status: String(
+      isFollowupComment
+        ? responseContractValidationStatus || existing.followup_response_contract_validation_status || ""
+        : existing.followup_response_contract_validation_status || "",
+    ).trim().toLowerCase(),
+    followup_response_contract_validation_reason: String(
+      isFollowupComment
+        ? responseContractValidationReason || existing.followup_response_contract_validation_reason || ""
+        : existing.followup_response_contract_validation_reason || "",
+    ).trim(),
+    followup_response_contract_validation_targets: uniqueOrderedStrings(
+      isFollowupComment && ensureArray(responseContractValidationTargets).length
+        ? responseContractValidationTargets
+        : existing.followup_response_contract_validation_targets,
+      normalizeTelegramMentionUsername,
+    ),
     assignment_validation_status: String(
-      assignmentValidationStatus || existing.assignment_validation_status || "",
+      isRootHumanComment
+        ? assignmentValidationStatus || existing.assignment_validation_status || ""
+        : existing.assignment_validation_status || "",
     ).trim().toLowerCase(),
     assignment_validation_reason: String(
-      assignmentValidationReason || existing.assignment_validation_reason || "",
+      isRootHumanComment
+        ? assignmentValidationReason || existing.assignment_validation_reason || ""
+        : existing.assignment_validation_reason || "",
     ).trim(),
     assignment_validation_modes: uniqueOrderedStrings(
-      ensureArray(assignmentValidationModes).length
+      isRootHumanComment && ensureArray(assignmentValidationModes).length
         ? assignmentValidationModes
         : existing.assignment_validation_modes,
       (value) => String(value || "").trim().toLowerCase(),
     ),
-    delivery_status: String(deliveryStatus || existing.delivery_status || "").trim().toLowerCase(),
-    archive_status: String(archiveStatus || existing.archive_status || "").trim().toLowerCase(),
-    transport_error: String(transportError || existing.transport_error || "").trim(),
-    archive_error: String(archiveError || existing.archive_error || "").trim(),
+    followup_assignment_validation_status: String(
+      isFollowupComment
+        ? assignmentValidationStatus || existing.followup_assignment_validation_status || ""
+        : existing.followup_assignment_validation_status || "",
+    ).trim().toLowerCase(),
+    followup_assignment_validation_reason: String(
+      isFollowupComment
+        ? assignmentValidationReason || existing.followup_assignment_validation_reason || ""
+        : existing.followup_assignment_validation_reason || "",
+    ).trim(),
+    followup_assignment_validation_modes: uniqueOrderedStrings(
+      isFollowupComment && ensureArray(assignmentValidationModes).length
+        ? assignmentValidationModes
+        : existing.followup_assignment_validation_modes,
+      (value) => String(value || "").trim().toLowerCase(),
+    ),
+    delivery_status: String(
+      isRootHumanComment
+        ? deliveryStatus || existing.delivery_status || ""
+        : existing.delivery_status || "",
+    ).trim().toLowerCase(),
+    archive_status: String(
+      isRootHumanComment
+        ? archiveStatus || existing.archive_status || ""
+        : existing.archive_status || "",
+    ).trim().toLowerCase(),
+    transport_error: String(
+      isRootHumanComment
+        ? transportError || existing.transport_error || ""
+        : existing.transport_error || "",
+    ).trim(),
+    archive_error: String(
+      isRootHumanComment
+        ? archiveError || existing.archive_error || ""
+        : existing.archive_error || "",
+    ).trim(),
+    followup_delivery_status: String(
+      isFollowupComment
+        ? deliveryStatus || existing.followup_delivery_status || ""
+        : existing.followup_delivery_status || "",
+    ).trim().toLowerCase(),
+    followup_archive_status: String(
+      isFollowupComment
+        ? archiveStatus || existing.followup_archive_status || ""
+        : existing.followup_archive_status || "",
+    ).trim().toLowerCase(),
+    followup_transport_error: String(
+      isFollowupComment
+        ? transportError || existing.followup_transport_error || ""
+        : existing.followup_transport_error || "",
+    ).trim(),
+    followup_archive_error: String(
+      isFollowupComment
+        ? archiveError || existing.followup_archive_error || ""
+        : existing.followup_archive_error || "",
+    ).trim(),
     normalized_intent: nextNormalizedIntent,
     status: nextStatus,
     started_at: firstNonEmptyString([existing.started_at, nowISO]),
@@ -4962,23 +5559,55 @@ function mergeRunnerRequestForServerHydration(localEntryRaw, serverEntryRaw) {
   preserveLocalStringWhenServerBlank("conversation_summary_bot");
   preserveLocalStringWhenServerBlank("conversation_reply_expectation");
   preserveLocalStringWhenServerBlank("execution_contract_type");
+  preserveLocalStringWhenServerBlank("normalized_execution_contract_type");
+  preserveLocalStringWhenServerBlank("ai_reply_generated_at");
+  preserveLocalStringWhenServerBlank("ai_reply_preview");
   preserveLocalStringWhenServerBlank("root_work_item_id");
   preserveLocalStringWhenServerBlank("root_work_item_title");
   preserveLocalStringWhenServerBlank("root_work_item_status");
   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("followup_assignment_validation_reason");
+  preserveLocalStringWhenServerBlank("followup_delivery_status");
+  preserveLocalStringWhenServerBlank("followup_archive_status");
+  preserveLocalStringWhenServerBlank("followup_transport_error");
+  preserveLocalStringWhenServerBlank("followup_archive_error");
   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("followup_response_contract_validation_targets");
+  preserveLocalArrayWhenServerEmpty("followup_assignment_validation_modes");
   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;
   }
+  if (serverEntry.ai_reply_generated !== true && localEntry.ai_reply_generated === true) {
+    merged.ai_reply_generated = true;
+  }
   const localStatus = normalizeRunnerRequestStatus(localEntry.status);
   const serverStatus = normalizeRunnerRequestStatus(serverEntry.status);
   if (isFinalRunnerRequestStatus(localStatus) && !isFinalRunnerRequestStatus(serverStatus)) {
@@ -7366,17 +7995,26 @@ function summarizeRunnerRequestForStatusLookup(entryRaw) {
     updated_at: String(entry.updated_at || "").trim(),
     source_message_id: intFromRawAllowZero(entry.source_message_id, 0) || undefined,
     last_source_message_id: intFromRawAllowZero(entry.last_source_message_id, 0) || undefined,
+    ...buildRunnerValidationAndDeliverySummary({
+      aiReplyPreview: runnerRequestPreferredAIReplyPreview(entry),
+      executionContractType: runnerRequestPreferredExecutionContractType(entry),
+      executionContractTargets: runnerRequestPreferredExecutionContractTargets(entry),
+      nextExpectedResponders: runnerRequestPreferredNextExpectedResponders(entry),
+      responseContractValidationStatus: runnerRequestPreferredResponseContractValidationStatus(entry),
+      responseContractValidationReason: runnerRequestPreferredResponseContractValidationReason(entry),
+      responseContractValidationTargets: runnerRequestPreferredResponseContractValidationTargets(entry),
+      assignmentValidationStatus: runnerRequestPreferredAssignmentValidationStatus(entry),
+      assignmentValidationReason: runnerRequestPreferredAssignmentValidationReason(entry),
+      assignmentValidationModes: runnerRequestPreferredAssignmentValidationModes(entry),
+      deliveryStatus: runnerRequestPreferredDeliveryStatus(entry),
+      archiveStatus: runnerRequestPreferredArchiveStatus(entry),
+      transportError: runnerRequestPreferredTransportError(entry),
+      archiveError: runnerRequestPreferredArchiveError(entry),
+    }),
     selected_bot_usernames: ensureArray(entry.selected_bot_usernames)
       .map((value) => normalizeTelegramMentionUsername(value))
       .filter(Boolean),
-    root_work_item: String(entry.root_work_item_id || "").trim()
-      ? {
-          id: String(entry.root_work_item_id || "").trim(),
-          title: String(entry.root_work_item_title || "").trim(),
-          status: normalizeRunnerWorkItemStatus(entry.root_work_item_status),
-          thread_id: String(entry.root_thread_id || "").trim(),
-        }
-      : null,
+    root_work_item: buildRunnerRequestRootWorkItemSummary(entry),
   };
 }
 
@@ -7435,6 +8073,150 @@ function pickPreferredStatusLookupRequest(entries = []) {
   return candidates[0];
 }
 
+function resolveRunnerStatusLookupRequests({
+  runnerState,
+  route,
+  routeKey,
+  selfBotUsername,
+  currentMessageID,
+  currentConversationID,
+  currentChatID,
+  activeRequestKey,
+  replyChainContext,
+}) {
+  const requestMatchesCurrentRoute = (entry) => requestEligibleForStatusLookup(
+    entry,
+    routeKey,
+    selfBotUsername,
+    currentMessageID,
+  );
+  const referencedRequestCandidate = safeObject(replyChainContext?.referencedRequest);
+  const selectors = currentConversationID
+    ? { conversationID: currentConversationID, chatID: currentChatID }
+    : { chatID: currentChatID };
+  let scopedRequests = findRunnerRequestsForScope(runnerState, route, selectors);
+  if (!scopedRequests.length && currentConversationID) {
+    scopedRequests = findRunnerRequestsForScope(runnerState, route, { chatID: currentChatID });
+  }
+  if (!scopedRequests.length && activeRequestKey) {
+    scopedRequests = findRunnerRequestsForScope(runnerState, route, { requestKey: activeRequestKey });
+  }
+  const statusLookupCandidates = scopedRequests.filter(requestMatchesCurrentRoute);
+  if (
+    Object.keys(referencedRequestCandidate).length > 0
+    && requestMatchesCurrentRoute(referencedRequestCandidate)
+    && !statusLookupCandidates.some(
+      (entry) => String(safeObject(entry).request_key || "").trim() === String(referencedRequestCandidate.request_key || "").trim(),
+    )
+  ) {
+    statusLookupCandidates.push(referencedRequestCandidate);
+  }
+  return {
+    related_active_request: statusLookupCandidates
+      .filter((entry) => isActiveRunnerRequestStatus(entry.status))[0] || null,
+    related_request: pickPreferredStatusLookupRequest(statusLookupCandidates),
+  };
+}
+
+function buildRunnerShowLastRunPayload(lastRunSummaryRaw) {
+  const lastRunSummary = safeObject(lastRunSummaryRaw);
+  return {
+    action: lastRunSummary.action || "-",
+    reason: lastRunSummary.reason || "-",
+    intent_type: lastRunSummary.intent_type || "-",
+    ai_reply_preview: lastRunSummary.ai_reply_preview || "-",
+    execution_contract_type: lastRunSummary.execution_contract_type || "-",
+    execution_contract_targets: ensureArray(lastRunSummary.execution_contract_targets),
+    next_expected_responders: ensureArray(lastRunSummary.next_expected_responders),
+    response_contract_validation_status: lastRunSummary.response_contract_validation_status || "-",
+    response_contract_validation_reason: lastRunSummary.response_contract_validation_reason || "-",
+    response_contract_validation_targets: ensureArray(lastRunSummary.response_contract_validation_targets),
+    assignment_validation_status: lastRunSummary.assignment_validation_status || "-",
+    assignment_validation_reason: lastRunSummary.assignment_validation_reason || "-",
+    assignment_validation_modes: ensureArray(lastRunSummary.assignment_validation_modes),
+    delivery_status: lastRunSummary.delivery_status || "-",
+    archive_status: lastRunSummary.archive_status || "-",
+    transport_error: lastRunSummary.transport_error || "-",
+    archive_error: lastRunSummary.archive_error || "-",
+    workspace_dir: lastRunSummary.workspace_dir || "-",
+    artifact_validation: lastRunSummary.artifact_validation || "-",
+    artifact_paths: ensureArray(lastRunSummary.artifact_paths),
+    artifact_errors: ensureArray(lastRunSummary.artifact_errors),
+    boundary_violations: ensureArray(lastRunSummary.boundary_violations),
+  };
+}
+
+function buildRunnerShowActiveExecutionPayload(activeExecutionStateRaw) {
+  const activeExecutionState = safeObject(activeExecutionStateRaw);
+  return {
+    active: activeExecutionState.active === true,
+    stale: activeExecutionState.stale === true,
+    stuck: activeExecutionState.stuck === true,
+    comment_id: String(activeExecutionState.commentID || "").trim(),
+    source_message_id: intFromRawAllowZero(activeExecutionState.sourceMessageID, 0),
+    started_at: String(activeExecutionState.startedAt || "").trim(),
+    age_seconds: intFromRawAllowZero(activeExecutionState.ageSeconds, 0),
+    warning: String(activeExecutionState.warning || "").trim(),
+  };
+}
+
+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",
+    },
+    workspace_mapping: {
+      workspace_dir: diagnostics.workspaceDir || "-",
+      workspace_source: diagnostics.workspaceSource || "-",
+    },
+    execution_profile: {
+      route_role: normalizedRoute.role || "-",
+      role_profile_name: diagnostics.roleProfileName || "-",
+      client: String(diagnostics.roleProfile?.client || "").trim() || "-",
+      model: String(diagnostics.roleProfile?.model || "").trim() || "-",
+      permission_mode: String(diagnostics.roleProfile?.permissionMode || "").trim() || "-",
+      reasoning_effort: String(diagnostics.roleProfile?.reasoningEffort || "").trim() || "-",
+    },
+  };
+}
+
+function buildRunnerStatusReplyChainResolution(replyChainContextRaw) {
+  const replyChainContext = safeObject(replyChainContextRaw);
+  return {
+    reason: String(replyChainContext.reason || "").trim(),
+    reply_to_message_id: intFromRawAllowZero(replyChainContext.replyToMessageID, 0) || undefined,
+    anchor_message_id: intFromRawAllowZero(replyChainContext.anchorMessageID, 0) || undefined,
+  };
+}
+
+function buildRunnerStatusActiveExecutionSummary(activeExecutionRaw, selfBusyFiltered = false) {
+  const activeExecution = safeObject(activeExecutionRaw);
+  if (!(activeExecution.active && !selfBusyFiltered)) {
+    return null;
+  }
+  return {
+    started_at: String(activeExecution.startedAt || "").trim(),
+    age_seconds: intFromRawAllowZero(activeExecution.ageSeconds, 0),
+    stale: activeExecution.stale === true,
+    stuck: activeExecution.stuck === true,
+    warning: String(activeExecution.warning || "").trim(),
+  };
+}
+
 function buildRunnerStatusQueryLookup({ route, routeState, selectedRecord, runnerStateOverride = null }) {
   const parsed = safeObject(selectedRecord?.parsedArchive);
   const currentMessageID = intFromRawAllowZero(parsed.messageID, 0);
@@ -7464,109 +8246,156 @@ function buildRunnerStatusQueryLookup({ route, routeState, selectedRecord, runne
   const replyChainContext = resolveRunnerReplyChainConversationContext(runnerState, route, selectedRecord);
   const currentConversationID = String(parsed.conversationID || replyChainContext.conversationID || "").trim();
   const activeRequestKey = String(safeObject(routeState).active_request_key || "").trim();
-  const requestMatchesCurrentRoute = (entry) => requestEligibleForStatusLookup(
-    entry,
+  const { related_active_request: relatedActiveRequest, related_request: relatedRequest } = resolveRunnerStatusLookupRequests({
+    runnerState,
+    route,
     routeKey,
     selfBotUsername,
     currentMessageID,
-  );
-  const referencedRequestCandidate = safeObject(replyChainContext.referencedRequest);
-  let relatedActiveRequest = null;
-  let relatedRequest = null;
-  const selectors = currentConversationID
-    ? { conversationID: currentConversationID, chatID: currentChatID }
-    : { chatID: currentChatID };
-  let scopedRequests = findRunnerRequestsForScope(runnerState, route, selectors);
-  if (!scopedRequests.length && currentConversationID) {
-    scopedRequests = findRunnerRequestsForScope(runnerState, route, { chatID: currentChatID });
-  }
-  if (!scopedRequests.length && activeRequestKey) {
-    scopedRequests = findRunnerRequestsForScope(runnerState, route, { requestKey: activeRequestKey });
-  }
-  const eligibleScopedRequests = scopedRequests.filter(requestMatchesCurrentRoute);
-  const statusLookupCandidates = [...eligibleScopedRequests];
-  if (
-    Object.keys(referencedRequestCandidate).length > 0
-    && requestMatchesCurrentRoute(referencedRequestCandidate)
-    && !statusLookupCandidates.some(
-      (entry) => String(safeObject(entry).request_key || "").trim() === String(referencedRequestCandidate.request_key || "").trim(),
-    )
-  ) {
-    statusLookupCandidates.push(referencedRequestCandidate);
-  }
-  relatedActiveRequest = statusLookupCandidates
-    .filter((entry) => isActiveRunnerRequestStatus(entry.status))[0] || null;
-  relatedRequest = pickPreferredStatusLookupRequest(statusLookupCandidates);
-  const lastAction = String(safeObject(routeState).last_action || "").trim();
-  const lastReason = String(safeObject(routeState).last_reason || "").trim();
-  const lastIntentType = String(safeObject(routeState).last_intent_type || "").trim();
-  const routeConversationID = String(safeObject(routeState).last_conversation_id || "").trim();
-  const activeRootWorkItemID = String(safeObject(routeState).active_root_work_item_id || "").trim();
-  const activeRootWorkItemTitle = String(safeObject(routeState).active_root_work_item_title || "").trim();
-  const activeRootWorkItemStatus = normalizeRunnerWorkItemStatus(safeObject(routeState).active_root_work_item_status);
-  const routeRootWorkItemID = String(safeObject(routeState).last_root_work_item_id || "").trim();
-  const routeRootWorkItemTitle = String(safeObject(routeState).last_root_work_item_title || "").trim();
-  const routeRootWorkItemStatus = normalizeRunnerWorkItemStatus(safeObject(routeState).last_root_work_item_status);
-  const routeWorkItemIDs = ensureArray(safeObject(routeState).last_work_item_ids).map((item) => String(item || "").trim()).filter(Boolean);
-  const routeWorkItemTitles = ensureArray(safeObject(routeState).last_work_item_titles).map((item) => String(item || "").trim()).filter(Boolean);
-  const requestRootWorkItem = String(safeObject(relatedRequest).root_work_item_id || "").trim()
-    ? {
-        id: String(safeObject(relatedRequest).root_work_item_id || "").trim(),
-        title: String(safeObject(relatedRequest).root_work_item_title || "").trim(),
-        status: normalizeRunnerWorkItemStatus(safeObject(relatedRequest).root_work_item_status),
-        thread_id: String(safeObject(relatedRequest).root_thread_id || "").trim(),
-      }
-    : null;
+    currentConversationID,
+    currentChatID,
+    activeRequestKey,
+    replyChainContext,
+  });
+  const lastRouteResult = buildRunnerRouteLastResultSummary(routeState);
+  const workItemSummary = buildRunnerStatusLookupWorkItemSummary({
+    relatedRequest,
+    routeState,
+    currentConversationID,
+  });
   return {
     kind: "runner_status",
     status: (!selfBusyFiltered && activeExecution.active) || relatedActiveRequest
       ? "running"
       : String(safeObject(relatedRequest).status || "").trim() || "idle",
     resolved_conversation_id: currentConversationID,
-    reply_chain_resolution: {
-      reason: String(replyChainContext.reason || "").trim(),
-      reply_to_message_id: intFromRawAllowZero(replyChainContext.replyToMessageID, 0) || undefined,
-      anchor_message_id: intFromRawAllowZero(replyChainContext.anchorMessageID, 0) || undefined,
-    },
+    reply_chain_resolution: buildRunnerStatusReplyChainResolution(replyChainContext),
     self_busy_filtered: selfBusyFiltered,
-    active_execution: activeExecution.active && !selfBusyFiltered
-      ? {
-          started_at: String(activeExecution.startedAt || "").trim(),
-          age_seconds: intFromRawAllowZero(activeExecution.ageSeconds, 0),
-          stale: activeExecution.stale === true,
-          stuck: activeExecution.stuck === true,
-          warning: String(activeExecution.warning || "").trim(),
-        }
-      : null,
+    active_execution: buildRunnerStatusActiveExecutionSummary(activeExecution, selfBusyFiltered),
     related_active_request: relatedActiveRequest ? summarizeRunnerRequestForStatusLookup(relatedActiveRequest) : null,
     related_request: relatedRequest ? summarizeRunnerRequestForStatusLookup(relatedRequest) : null,
-    root_work_item: String(safeObject(requestRootWorkItem).id || "").trim()
-      ? requestRootWorkItem
-      : activeRootWorkItemID
-        ? {
-            id: activeRootWorkItemID,
-            title: activeRootWorkItemTitle,
-            status: activeRootWorkItemStatus,
-          }
-        : currentConversationID && routeConversationID === currentConversationID && routeRootWorkItemID
-          ? {
-              id: routeRootWorkItemID,
-              title: routeRootWorkItemTitle,
-              status: routeRootWorkItemStatus,
-            }
-          : null,
-    route_work_items: currentConversationID && routeConversationID === currentConversationID && (routeWorkItemIDs.length > 0 || routeWorkItemTitles.length > 0)
-      ? {
-          ids: routeWorkItemIDs,
-          titles: routeWorkItemTitles,
-        }
-      : null,
-    last_route_result: {
-      action: lastAction,
-      reason: lastReason,
-      intent_type: lastIntentType,
-    },
+    root_work_item: workItemSummary.root_work_item,
+    route_work_items: workItemSummary.route_work_items,
+    last_route_result: lastRouteResult,
+  };
+}
+
+function buildProjectWorkspaceLookupResponse({ route, executionPlan, executionOverride }) {
+  const workspace = resolveProjectWorkspaceBindingSummary(
+    route?.projectID,
+    executionPlan?.workspaceDir || route?.workspaceDir || "",
+  );
+  return buildLookupOnlyInformationalReply("project.workspace", {
+    ...workspace,
+  }, executionOverride);
+}
+
+function buildSmallTalkLookupResponse({ route, messageText, executionOverride }) {
+  return buildLookupOnlyInformationalReply("small_talk", {
+    intent_type: "small_talk",
+    user_message: messageText,
+    bot_name: firstNonEmptyString([route?.botName, route?.serverBotName, route?.server_bot_name, route?.name]),
+    bot_role: String(route?.role || route?.roleProfile || "").trim(),
+  }, executionOverride);
+}
+
+function buildProjectBotRolesLookupResponse({ route, executionOverride }) {
+  const payload = buildProjectBotRolesPayload({
+    projectID: route?.projectID,
+    provider: route?.provider,
+    destinationID: route?.destinationID,
+    destinationLabel: route?.destinationLabel,
+  });
+  return buildLookupOnlyInformationalReply("project.bot_roles", {
+    ...payload,
+  }, executionOverride);
+}
+
+async function buildRunnerStatusLookupOnlyResponse({
+  route,
+  routeState,
+  selectedRecord,
+  runtime,
+  executionOverride,
+}) {
+  let hydratedRunnerState = null;
+  try {
+    hydratedRunnerState = await hydrateRunnerRequestLedgerFromServer({
+      normalizedRoute: route,
+      runtime,
+    });
+  } catch {}
+  const lookup = buildRunnerStatusQueryLookup({
+    route,
+    routeState,
+    selectedRecord,
+    runnerStateOverride: hydratedRunnerState,
+  });
+  return buildLookupOnlyInformationalReply("runner.status", lookup, executionOverride);
+}
+
+async function buildArtifactLocationLookupResponse({
+  route,
+  runtime,
+  messageText,
+  executionOverride,
+}) {
+  const payload = await locateProjectFilesForQuery({
+    siteBaseURL: runtime.baseURL,
+    projectID: route?.projectID,
+    token: runtime.token,
+    timeoutSeconds: runtime.timeoutSeconds,
+    query: messageText,
+  });
+  return buildLookupOnlyInformationalReply("project.file.locate", {
+    ...payload,
+  }, executionOverride);
+}
+
+async function resolveLookupOnlyInformationalReply({
+  normalizedIntentType,
+  route,
+  routeState,
+  selectedRecord,
+  runtime,
+  executionPlan,
+  messageText,
+  executionOverride,
+}) {
+  const lookupHandlers = {
+    small_talk: () => buildSmallTalkLookupResponse({ route, messageText, executionOverride }),
+    workspace_query: () => buildProjectWorkspaceLookupResponse({ route, executionPlan, executionOverride }),
+    bot_role_query: () => buildProjectBotRolesLookupResponse({ route, executionOverride }),
+    status_query: () => buildRunnerStatusLookupOnlyResponse({
+      route,
+      routeState,
+      selectedRecord,
+      runtime,
+      executionOverride,
+    }),
+    artifact_location_query: () => buildArtifactLocationLookupResponse({
+      route,
+      runtime,
+      messageText,
+      executionOverride,
+    }),
+  };
+  const handler = lookupHandlers[normalizedIntentType];
+  return typeof handler === "function" ? handler() : null;
+}
+
+function buildLookupOnlyInformationalReply(source, lookup, executionOverride = null) {
+  const response = {
+    handled: true,
+    source: String(source || "").trim(),
+    response_mode: "lookup_only",
+    reply: "",
+    lookup: safeObject(lookup),
   };
+  if (executionOverride && typeof executionOverride === "object") {
+    response.execution_override = executionOverride;
+  }
+  return response;
 }
 
 async function resolveInformationalQueryReply({
@@ -7580,20 +8409,19 @@ async function resolveInformationalQueryReply({
   const normalizedIntentType = String(intentType || "").trim();
   const messageText = String(safeObject(selectedRecord?.parsedArchive).body || "").trim();
   const executionOverride = buildInformationalMiniExecutionOverride({ route, executionPlan });
+  const lookupOnlyResponse = await resolveLookupOnlyInformationalReply({
+    normalizedIntentType,
+    route,
+    routeState,
+    selectedRecord,
+    runtime,
+    executionPlan,
+    messageText,
+    executionOverride,
+  });
+  return lookupOnlyResponse || null;
   if (normalizedIntentType === "small_talk") {
-    return {
-      handled: true,
-      response_mode: "lookup_only",
-      reply: "",
-      source: "small_talk",
-      lookup: {
-        intent_type: "small_talk",
-        user_message: messageText,
-        bot_name: firstNonEmptyString([route?.botName, route?.serverBotName, route?.server_bot_name, route?.name]),
-        bot_role: String(route?.role || route?.roleProfile || "").trim(),
-      },
-      execution_override: executionOverride,
-    };
+    return buildSmallTalkLookupResponse({ route, messageText, executionOverride });
   }
   /* Dead legacy direct small_talk branch kept commented for reference.
   if (false && normalizedIntentType === "small_talk") {
@@ -7605,41 +8433,31 @@ async function resolveInformationalQueryReply({
   }
   */
   if (normalizedIntentType === "workspace_query") {
+    return buildProjectWorkspaceLookupResponse({
+      route,
+      executionPlan,
+      executionOverride,
+    });
     const workspace = resolveProjectWorkspaceBindingSummary(route?.projectID, executionPlan?.workspaceDir || route?.workspaceDir || "");
     const workspaceDir = String(workspace.workspace_dir || "").trim();
     const reply = workspaceDir
       ? `현재 이 프로젝트에 바인딩된 로컬 작업 폴더는 "${workspaceDir}" 입니다.`
       : "현재 이 프로젝트는 project-workspaces.json에 로컬 작업 폴더가 바인딩되어 있지 않습니다.";
-    return {
-      handled: true,
-      response_mode: "lookup_only",
-      reply: "",
-      source: "project.workspace",
-      lookup: {
-        ...workspace,
-      },
-      execution_override: executionOverride,
-    };
+    return buildLookupOnlyInformationalReply("project.workspace", {
+      ...workspace,
+    }, executionOverride);
   }
   if (normalizedIntentType === "bot_role_query") {
-    const payload = buildProjectBotRolesPayload({
-      projectID: route?.projectID,
-      provider: route?.provider,
-      destinationID: route?.destinationID,
-      destinationLabel: route?.destinationLabel,
-    });
-    return {
-      handled: true,
-      response_mode: "lookup_only",
-      reply: "",
-      source: "project.bot_roles",
-      lookup: {
-        ...payload,
-      },
-      execution_override: executionOverride,
-    };
+    return buildProjectBotRolesLookupResponse({ route, executionOverride });
   }
   if (normalizedIntentType === "status_query") {
+    return buildRunnerStatusLookupOnlyResponse({
+      route,
+      routeState,
+      selectedRecord,
+      runtime,
+      executionOverride,
+    });
     let hydratedRunnerState = null;
     try {
       hydratedRunnerState = await hydrateRunnerRequestLedgerFromServer({
@@ -7647,18 +8465,13 @@ async function resolveInformationalQueryReply({
         runtime,
       });
     } catch {}
-    return {
-      handled: true,
-      source: "runner.status",
-      response_mode: "lookup_only",
-      reply: "",
-      lookup: buildRunnerStatusQueryLookup({
-        route,
-        routeState,
-        selectedRecord,
-        runnerStateOverride: hydratedRunnerState,
-      }),
-    };
+    const lookup = buildRunnerStatusQueryLookup({
+      route,
+      routeState,
+      selectedRecord,
+      runnerStateOverride: hydratedRunnerState,
+    });
+    return buildLookupOnlyInformationalReply("runner.status", lookup, executionOverride);
     const activeExecution = resolveRunnerActiveExecutionState(routeState);
     if (activeExecution.active) {
       const startedAt = String(activeExecution.startedAt || "").trim();
@@ -7690,23 +8503,12 @@ async function resolveInformationalQueryReply({
     };
   }
   if (normalizedIntentType === "artifact_location_query") {
-    const payload = await locateProjectFilesForQuery({
-      siteBaseURL: runtime.baseURL,
-      projectID: route?.projectID,
-      token: runtime.token,
-      timeoutSeconds: runtime.timeoutSeconds,
-      query: messageText,
+    return buildArtifactLocationLookupResponse({
+      route,
+      runtime,
+      messageText,
+      executionOverride,
     });
-    return {
-      handled: true,
-      response_mode: "lookup_only",
-      reply: "",
-      source: "project.file.locate",
-      lookup: {
-        ...payload,
-      },
-      execution_override: executionOverride,
-    };
   }
   return null;
 }
@@ -7717,7 +8519,6 @@ function buildRunnerExecutionDeps() {
     adjudicateRunnerStartupLoopWithAI,
     analyzeHumanConversationIntentWithAI,
     auditRoleExecutionPlanWithAI,
-    auditDirectHumanReplyWithAI,
     planRoleExecutionWithAI,
     repairRoleExecutionPlanWithAI,
     normalizeRunnerRoleProfileName,
@@ -8317,6 +9118,74 @@ async function processRunnerRouteOnce(route, runtime, mode, options = {}) {
       }
       return null;
     };
+    const buildSelectedRecordSkippedRecord = (selectedRecord, reason, extra = {}) => ({
+      id: selectedRecord.id,
+      reason: String(reason || "").trim(),
+      messageID: intFromRawAllowZero(selectedRecord?.parsedArchive?.messageID, 0),
+      ...safeObject(extra),
+    });
+    const saveSelectedRecordSkipState = (selectedRecord, {
+      action,
+      reason,
+      trigger = "",
+      statePatch = {},
+    }) => {
+      saveRunnerRouteState(
+        routeKey,
+        buildRunnerRouteStateFromComment(selectedRecord, {
+          last_action: String(action || "").trim(),
+          last_reason: String(reason || "").trim(),
+          last_trigger: String(trigger || "").trim(),
+          ...safeObject(statePatch),
+        }),
+      );
+    };
+    const pushSelectedRecordSkip = (skippedRecords, selectedRecord, {
+      action,
+      reason,
+      trigger = "",
+      statePatch = {},
+      recordPatch = {},
+    }) => {
+      saveSelectedRecordSkipState(selectedRecord, {
+        action,
+        reason,
+        trigger,
+        statePatch,
+      });
+      skippedRecords.push(
+        buildSelectedRecordSkippedRecord(selectedRecord, reason, recordPatch),
+      );
+    };
+    const finalizeSkippedPendingRecords = async (skippedRecords) => {
+      if (!ensureArray(skippedRecords).length) {
+        return null;
+      }
+      await archiveRunnerDiagnosticComments({
+        comments,
+        skippedRecords,
+        normalizedRoute,
+        bot,
+        archiveThread,
+        runtime,
+      });
+      const distinctReasons = Array.from(new Set(skippedRecords.map((item) => item.reason).filter(Boolean)));
+      const lastSkipped = skippedRecords[skippedRecords.length - 1];
+      return {
+        route_key: routeKey,
+        route_name: normalizedRoute.name,
+        logical_signature: runnerRouteLogicalSignature(normalizedRoute),
+        outcome: "skipped",
+        detail: distinctReasons.join("; ") || "all pending messages were skipped",
+        archive_source: String(archiveThread.source || "").trim() || "-",
+        archive_work_item_id: String(archiveThread.workItemID || "").trim() || "",
+        thread_id: archiveThread.threadID,
+        comment_id: lastSkipped.id,
+        skipped_count: skippedRecords.length,
+        execution_mode: executionPlan.mode,
+        role_profile: executionPlan.roleProfileName,
+      };
+    };
     const prepareRunnerRequestClaim = async (selectedRecord, selectedResponderSelectors = [], sharedHumanIntent = null) => {
       const parsed = safeObject(selectedRecord?.parsedArchive);
       const kind = String(parsed.kind || "").trim().toLowerCase();
@@ -8353,316 +9222,122 @@ async function processRunnerRouteOnce(route, runtime, mode, options = {}) {
         archiveThreadID: archiveThread.threadID,
       });
     };
-    if (deferExecution) {
-      const skippedRecords = [];
-      for (const selectedRecord of pending.pending) {
-        const duplicateArchivedSkip = maybeBuildDuplicateArchivedSkip(selectedRecord, refreshedState);
-        if (duplicateArchivedSkip) {
-          saveRunnerRouteState(
-            routeKey,
-            buildRunnerRouteStateFromComment(selectedRecord, {
-              last_action: "duplicate_skipped",
-              last_reason: String(duplicateArchivedSkip.reason || "duplicate_archived_source_message").trim(),
-              last_trigger: "archive_dedupe",
-            }),
-          );
-          skippedRecords.push(duplicateArchivedSkip);
-          continue;
-        }
-        const triggerDecision = evaluateTelegramRunnerTrigger(selectedRecord, normalizedRoute, bot);
-        if (triggerDecision.shouldRespond !== true) {
-          saveRunnerRouteState(
-            routeKey,
-            buildRunnerRouteStateFromComment(selectedRecord, {
-              last_action: "trigger_skipped",
-              last_reason: String(triggerDecision.reason || "trigger policy skipped message").trim() || "trigger policy skipped message",
-              last_trigger: String(triggerDecision.trigger || "").trim() || "trigger_policy",
-            }),
-          );
-          skippedRecords.push({
-            id: selectedRecord.id,
-            reason: String(triggerDecision.reason || "trigger policy skipped message").trim() || "trigger policy skipped message",
-            messageID: intFromRawAllowZero(selectedRecord?.parsedArchive?.messageID, 0),
-            suppressDiagnostic: true,
-          });
-          continue;
-        }
-        const startupLoopSkipped = await maybeHandleRunnerStartupLoopCandidate({
-          routeKey,
-          normalizedRoute,
-          selectedRecord,
-          pendingOrdered: pending.ordered,
-          bot,
-          managedConversationBots,
-          representativeExecutionPlan,
-          importOutcome,
-          archiveThread,
-          runtime,
-          suppressDiagnostic: representativeBotSelector
-            ? currentBotSelector !== representativeBotSelector
-            : false,
-        });
-        if (startupLoopSkipped) {
-          skippedRecords.push(startupLoopSkipped.skippedRecord);
-          continue;
-        }
-        const routingExecutionDeps = {
-          ...buildRunnerExecutionDeps(),
-          managedConversationBots,
-          resolveConversationPeerBots: resolveRunnerConversationPeers,
-        };
-        const sharedHumanIntentContext = await resolveHumanIntentContext({
-          selectedRecord,
-          normalizedRoute,
-          bot,
-          executionPlan,
-          deps: routingExecutionDeps,
-        });
-        if (safeObject(sharedHumanIntentContext).contractNeedsResolution === true) {
-          const reason = "human intent contract is incomplete and requires regeneration";
-          saveRunnerRouteState(
-            routeKey,
-            buildRunnerRouteStateFromComment(selectedRecord, {
-              last_action: "needs_contract",
-              last_reason: reason,
-              last_trigger: "human_intent_contract",
-            }),
-          );
-          skippedRecords.push({
-            id: selectedRecord.id,
-            reason,
-            messageID: intFromRawAllowZero(selectedRecord?.parsedArchive?.messageID, 0),
-          });
-          continue;
-        }
-        const precomputedAdjudication = buildRunnerResponderAdjudicationFromHumanIntent({
-          selectedRecord,
-          normalizedRoute,
-          bot,
-          deps: routingExecutionDeps,
-          precomputedHumanIntent: safeObject(sharedHumanIntentContext).humanIntent || null,
-        });
-        const adjudication = precomputedAdjudication || await resolveRunnerResponderAdjudication({
-          selectedRecord,
-          pendingOrdered: pending.ordered,
-          normalizedRoute,
-          bot,
-          executionPlan,
-          deps: routingExecutionDeps,
-          precomputedHumanIntent: safeObject(sharedHumanIntentContext).humanIntent || null,
-        });
-        const currentBotSelected = ensureArray(adjudication.selected_bot_usernames)
-          .map((value) => String(value || "").trim().replace(/^@+/, "").toLowerCase())
-          .includes(currentBotSelector);
-        if (!currentBotSelected) {
-          saveRunnerRouteState(
+    const buildContinuationResponderAdjudication = (selectedRecord, requestRaw) => {
+      const request = safeObject(requestRaw);
+      const referencedBotUsernames = ensureArray(safeObject(selectedRecord?.parsedArchive).mentionUsernames)
+        .map((value) => normalizeTelegramMentionUsername(value))
+        .filter(Boolean);
+      const selectedBotUsernames = uniqueOrderedStrings(
+        ensureArray(request.next_expected_responders).length
+          ? request.next_expected_responders
+          : ensureArray(request.conversation_allowed_responders).length
+            ? request.conversation_allowed_responders
+            : ensureArray(request.selected_bot_usernames).length
+              ? request.selected_bot_usernames
+              : request.conversation_initial_responders,
+        normalizeTelegramMentionUsername,
+      );
+      return {
+        decision: selectedBotUsernames.length > 1
+          ? "multiple_responders"
+          : selectedBotUsernames.length === 1
+            ? "single_responder"
+            : "no_responder",
+        selected_bot_usernames: selectedBotUsernames,
+        referenced_bot_usernames: referencedBotUsernames,
+        confidence: "high",
+        reason_code: selectedBotUsernames.length > 0
+          ? "continuation_request_contract"
+          : "continuation_request_contract_no_responder",
+        clarification: "",
+      };
+    };
+    const finalizePreparedRunnerRequest = async (selectedRecord, requestClaim) => {
+      const inheritedRootReference = await inheritRunnerReferenceRootWorkItemForRequest({
+        normalizedRoute,
+        selectedRecord,
+        runtime,
+        requestKey: requestClaim.requestKey,
+      });
+      const rootWorkItemClaim = await ensureRunnerRootWorkItemForRequest({
+        normalizedRoute,
+        routeKey,
+        selectedRecord,
+        runtime,
+        requestKey: requestClaim.requestKey,
+      });
+      const claimedRequest = safeObject(
+        loadRunnerRequestByKey(requestClaim.requestKey)
+        || rootWorkItemClaim.request
+        || inheritedRootReference.request
+        || requestClaim.request,
+      );
+      const missingRequiredRootWorkItem = actionableRunnerRequestMissingRootWorkItem(claimedRequest);
+      if (!rootWorkItemClaim.ok || missingRequiredRootWorkItem) {
+        const rootWorkItemFailure = String(
+          rootWorkItemClaim.error
+          || rootWorkItemClaim.reason
+          || (missingRequiredRootWorkItem ? "root_work_item_missing" : "root_work_item_create_failed"),
+        ).trim() || "root_work_item_create_failed";
+        if (String(requestClaim.requestKey || "").trim()) {
+          markRunnerRequestLifecycle({
+            normalizedRoute,
+            requestKey: requestClaim.requestKey,
+            selectedRecord,
             routeKey,
-            buildRunnerRouteStateFromComment(selectedRecord, {
-              last_action: "adjudication_skipped",
-              last_reason: String(adjudication.reason_code || "").trim() || "not_selected_by_adjudicator",
-              last_trigger: "responder_adjudication",
-            }),
-          );
-          skippedRecords.push({
-            id: selectedRecord.id,
-            reason: String(adjudication.reason_code || "").trim() || "not_selected_by_adjudicator",
-            messageID: intFromRawAllowZero(selectedRecord?.parsedArchive?.messageID, 0),
+            outcome: "closed",
+            closedReason: rootWorkItemFailure,
           });
-          continue;
-        }
-        const requestClaim = await prepareRunnerRequestClaim(
-          selectedRecord,
-          adjudication.selected_bot_usernames,
-          safeObject(sharedHumanIntentContext).humanIntent || null,
-        );
-        if (!requestClaim.ok) {
           await syncRunnerRequestLedgerForProjectToServer({
             normalizedRoute,
             runtime,
           });
-          saveRunnerRouteState(
-            routeKey,
-            buildRunnerRouteStateFromComment(selectedRecord, {
-              last_action: "request_skipped",
-              last_reason: String(requestClaim.reason || "request_unavailable").trim() || "request_unavailable",
-              last_trigger: "request_ledger",
-            }),
-          );
-          skippedRecords.push({
-            id: selectedRecord.id,
-            reason: String(requestClaim.reason || "request_unavailable").trim() || "request_unavailable",
-            messageID: intFromRawAllowZero(selectedRecord?.parsedArchive?.messageID, 0),
-            diagnosticType: "skip",
-            contextExcluded: String(requestClaim.reason || "").trim() === "bot_reply_without_active_request",
-            action: "skip_invalid_request_state",
-            closedReason: String(requestClaim.reason || "").trim(),
-          });
-          continue;
-        }
-        const inheritedRootReference = await inheritRunnerReferenceRootWorkItemForRequest({
-          normalizedRoute,
-          selectedRecord,
-          runtime,
-          requestKey: requestClaim.requestKey,
-        });
-        const rootWorkItemClaim = await ensureRunnerRootWorkItemForRequest({
-          normalizedRoute,
-          routeKey,
-          selectedRecord,
-          runtime,
-          requestKey: requestClaim.requestKey,
-        });
-        const claimedRequest = safeObject(
-          loadRunnerRequestByKey(requestClaim.requestKey)
-          || rootWorkItemClaim.request
-          || inheritedRootReference.request
-          || requestClaim.request,
-        );
-        const missingRequiredRootWorkItem = actionableRunnerRequestMissingRootWorkItem(claimedRequest);
-        if (!rootWorkItemClaim.ok || missingRequiredRootWorkItem) {
-          const rootWorkItemFailure = String(
-            rootWorkItemClaim.error
-            || rootWorkItemClaim.reason
-            || (missingRequiredRootWorkItem ? "root_work_item_missing" : "root_work_item_create_failed"),
-          ).trim() || "root_work_item_create_failed";
-          if (String(requestClaim.requestKey || "").trim()) {
-            markRunnerRequestLifecycle({
-              normalizedRoute,
-              requestKey: requestClaim.requestKey,
-              selectedRecord,
-              routeKey,
-              outcome: "closed",
-              closedReason: rootWorkItemFailure,
-            });
-            await syncRunnerRequestLedgerForProjectToServer({
-              normalizedRoute,
-              runtime,
-            });
-          }
-          saveRunnerRouteState(
-            routeKey,
-            buildRunnerRouteStateFromComment(selectedRecord, {
-              last_action: "request_skipped",
-              last_reason: rootWorkItemFailure,
-              last_trigger: "work_item_root",
-              last_request_key: String(requestClaim.requestKey || "").trim(),
-            }),
-          );
-          skippedRecords.push({
-            id: selectedRecord.id,
-            reason: rootWorkItemFailure,
-            messageID: intFromRawAllowZero(selectedRecord?.parsedArchive?.messageID, 0),
-            diagnosticType: "skip",
-            action: "skip_missing_root_work_item",
-            closedReason: rootWorkItemFailure,
-          });
-          continue;
         }
-        saveRunnerRouteState(routeKey, {
-          ...buildRunnerActiveExecutionPatch(selectedRecord, requestClaim.requestKey, {
-            id: String(claimedRequest.root_work_item_id || "").trim(),
-            title: String(claimedRequest.root_work_item_title || "").trim(),
-            status: String(claimedRequest.root_work_item_status || "").trim(),
-          }),
-          last_request_key: String(requestClaim.requestKey || "").trim(),
-          last_root_work_item_id: String(claimedRequest.root_work_item_id || "").trim(),
-          last_root_work_item_title: String(claimedRequest.root_work_item_title || "").trim(),
-          last_root_work_item_status: String(claimedRequest.root_work_item_status || "").trim(),
-        });
-        await syncRunnerRequestLedgerForProjectToServer({
-          normalizedRoute,
-          runtime,
-        });
         return {
-          route_key: routeKey,
-          route_name: normalizedRoute.name,
-          logical_signature: runnerRouteLogicalSignature(normalizedRoute),
-          outcome: "accepted",
-          detail: `accepted comment ${selectedRecord.id} for background execution`,
-          archive_source: String(archiveThread.source || "").trim() || "-",
-          archive_work_item_id: String(archiveThread.workItemID || "").trim() || "",
-          thread_id: archiveThread.threadID,
-          comment_id: selectedRecord.id,
-          execution_mode: executionPlan.mode,
-          role_profile: executionPlan.roleProfileName,
-          deferred_execution: {
-            routeKey,
-            normalizedRoute,
-            routeState: safeObject(loadBotRunnerState().routes[routeKey]),
-            selectedRecord,
-            pendingOrdered: pending.ordered,
-            bot,
-            destination,
-            archiveThread,
-            executionPlan,
-            runtime,
-            managedConversationBots,
-            requestKey: String(requestClaim.requestKey || "").trim(),
-            triggerDecision,
-            responderAdjudication: adjudication,
-            humanIntentContext: sharedHumanIntentContext,
+          ok: false,
+          skip: {
+            kind: "skip",
+            skipAction: "request_skipped",
+            skipReason: rootWorkItemFailure,
+            skipTrigger: "work_item_root",
+            skipStatePatch: {
+              last_request_key: String(requestClaim.requestKey || "").trim(),
+            },
+            skipRecordPatch: {
+              diagnosticType: "skip",
+              action: "skip_missing_root_work_item",
+              closedReason: rootWorkItemFailure,
+            },
           },
         };
       }
-      if (skippedRecords.length > 0) {
-        await archiveRunnerDiagnosticComments({
-          comments,
-          skippedRecords,
-          normalizedRoute,
-          bot,
-          archiveThread,
-          runtime,
-        });
-        const distinctReasons = Array.from(new Set(skippedRecords.map((item) => item.reason).filter(Boolean)));
-        const lastSkipped = skippedRecords[skippedRecords.length - 1];
-        return {
-          route_key: routeKey,
-          route_name: normalizedRoute.name,
-          logical_signature: runnerRouteLogicalSignature(normalizedRoute),
-          outcome: "skipped",
-          detail: distinctReasons.join("; ") || "all pending messages were skipped",
-          archive_source: String(archiveThread.source || "").trim() || "-",
-          archive_work_item_id: String(archiveThread.workItemID || "").trim() || "",
-          thread_id: archiveThread.threadID,
-          comment_id: lastSkipped.id,
-          skipped_count: skippedRecords.length,
-          execution_mode: executionPlan.mode,
-          role_profile: executionPlan.roleProfileName,
-        };
-      }
-    }
-    const skippedRecords = [];
-    for (const selectedRecord of pending.pending) {
+      return {
+        ok: true,
+        claimedRequest,
+      };
+    };
+    const prepareRunnerSelectedRecordForExecution = async (selectedRecord) => {
       const duplicateArchivedSkip = maybeBuildDuplicateArchivedSkip(selectedRecord, refreshedState);
       if (duplicateArchivedSkip) {
-        saveRunnerRouteState(
-          routeKey,
-          buildRunnerRouteStateFromComment(selectedRecord, {
-            last_action: "duplicate_skipped",
-            last_reason: String(duplicateArchivedSkip.reason || "duplicate_archived_source_message").trim(),
-            last_trigger: "archive_dedupe",
-          }),
-        );
-        skippedRecords.push(duplicateArchivedSkip);
-        continue;
+        return {
+          kind: "skip",
+          skipAction: "duplicate_skipped",
+          skipReason: String(duplicateArchivedSkip.reason || "duplicate_archived_source_message").trim(),
+          skipTrigger: "archive_dedupe",
+          skipRecordPatch: duplicateArchivedSkip,
+        };
       }
       const triggerDecision = evaluateTelegramRunnerTrigger(selectedRecord, normalizedRoute, bot);
       if (triggerDecision.shouldRespond !== true) {
-        saveRunnerRouteState(
-          routeKey,
-          buildRunnerRouteStateFromComment(selectedRecord, {
-            last_action: "trigger_skipped",
-            last_reason: String(triggerDecision.reason || "trigger policy skipped message").trim() || "trigger policy skipped message",
-            last_trigger: String(triggerDecision.trigger || "").trim() || "trigger_policy",
-          }),
-        );
-        skippedRecords.push({
-          id: selectedRecord.id,
-          reason: String(triggerDecision.reason || "trigger policy skipped message").trim() || "trigger policy skipped message",
-          messageID: intFromRawAllowZero(selectedRecord?.parsedArchive?.messageID, 0),
-          suppressDiagnostic: true,
-        });
-        continue;
+        return {
+          kind: "skip",
+          skipAction: "trigger_skipped",
+          skipReason: String(triggerDecision.reason || "trigger policy skipped message").trim() || "trigger policy skipped message",
+          skipTrigger: String(triggerDecision.trigger || "").trim() || "trigger_policy",
+          skipRecordPatch: {
+            suppressDiagnostic: true,
+          },
+        };
       }
       const startupLoopSkipped = await maybeHandleRunnerStartupLoopCandidate({
         routeKey,
@@ -8680,14 +9355,66 @@ async function processRunnerRouteOnce(route, runtime, mode, options = {}) {
           : false,
       });
       if (startupLoopSkipped) {
-        skippedRecords.push(startupLoopSkipped.skippedRecord);
-        continue;
+        return {
+          kind: "startup_loop_skipped",
+          skippedRecord: startupLoopSkipped.skippedRecord,
+        };
       }
       const routingExecutionDeps = {
         ...buildRunnerExecutionDeps(),
         managedConversationBots,
         resolveConversationPeerBots: resolveRunnerConversationPeers,
       };
+      const selectedRecordKind = String(safeObject(selectedRecord?.parsedArchive).kind || "").trim().toLowerCase();
+      if (selectedRecordKind === "bot_reply") {
+        const requestClaim = await prepareRunnerRequestClaim(selectedRecord);
+        if (!requestClaim.ok) {
+          await syncRunnerRequestLedgerForProjectToServer({
+            normalizedRoute,
+            runtime,
+          });
+          return {
+            kind: "skip",
+            skipAction: "request_skipped",
+            skipReason: String(requestClaim.reason || "request_unavailable").trim() || "request_unavailable",
+            skipTrigger: "request_ledger",
+            skipRecordPatch: {
+              diagnosticType: "skip",
+              contextExcluded: String(requestClaim.reason || "").trim() === "bot_reply_without_active_request",
+              action: "skip_invalid_request_state",
+              closedReason: String(requestClaim.reason || "").trim(),
+            },
+          };
+        }
+        const continuationAdjudication = buildContinuationResponderAdjudication(
+          selectedRecord,
+          requestClaim.request,
+        );
+        const currentBotSelected = ensureArray(continuationAdjudication.selected_bot_usernames)
+          .map((value) => String(value || "").trim().replace(/^@+/, "").toLowerCase())
+          .includes(currentBotSelector);
+        if (!currentBotSelected) {
+          return {
+            kind: "skip",
+            skipAction: "adjudication_skipped",
+            skipReason: String(continuationAdjudication.reason_code || "").trim() || "not_selected_by_request_contract",
+            skipTrigger: "request_contract",
+          };
+        }
+        const finalizedRequest = await finalizePreparedRunnerRequest(selectedRecord, requestClaim);
+        if (!finalizedRequest.ok) {
+          return finalizedRequest.skip;
+        }
+        return {
+          kind: "ready",
+          triggerDecision,
+          routingExecutionDeps,
+          sharedHumanIntentContext: null,
+          adjudication: continuationAdjudication,
+          requestClaim,
+          claimedRequest: finalizedRequest.claimedRequest,
+        };
+      }
       const sharedHumanIntentContext = await resolveHumanIntentContext({
         selectedRecord,
         normalizedRoute,
@@ -8696,30 +9423,31 @@ async function processRunnerRouteOnce(route, runtime, mode, options = {}) {
         deps: routingExecutionDeps,
       });
       if (safeObject(sharedHumanIntentContext).contractNeedsResolution === true) {
-        const reason = "human intent contract is incomplete and requires regeneration";
-        saveRunnerRouteState(
-          routeKey,
-          buildRunnerRouteStateFromComment(selectedRecord, {
-            last_action: "needs_contract",
-            last_reason: reason,
-            last_trigger: "human_intent_contract",
-          }),
-        );
-        skippedRecords.push({
-          id: selectedRecord.id,
-          reason,
-          messageID: intFromRawAllowZero(selectedRecord?.parsedArchive?.messageID, 0),
-        });
-        continue;
+        return {
+          kind: "skip",
+          skipAction: "needs_contract",
+          skipReason: "human intent contract is incomplete and requires regeneration",
+          skipTrigger: "human_intent_contract",
+        };
       }
-      const precomputedInlineAdjudication = buildRunnerResponderAdjudicationFromHumanIntent({
+      const precomputedAdjudication = buildRunnerResponderAdjudicationFromHumanIntent({
         selectedRecord,
         normalizedRoute,
         bot,
         deps: routingExecutionDeps,
         precomputedHumanIntent: safeObject(sharedHumanIntentContext).humanIntent || null,
       });
-      const inlineAdjudication = precomputedInlineAdjudication || await resolveRunnerResponderAdjudication({
+      const shouldRequireContractDrivenResponderSelection = selectedRecordKind !== "bot_reply"
+        && safeObject(selectedRecord?.parsedArchive).senderIsBot !== true;
+      if (!precomputedAdjudication && shouldRequireContractDrivenResponderSelection) {
+        return {
+          kind: "skip",
+          skipAction: "needs_contract",
+          skipReason: "human intent contract did not select any responder",
+          skipTrigger: "human_intent_contract",
+        };
+      }
+      const adjudication = precomputedAdjudication || await resolveRunnerResponderAdjudication({
         selectedRecord,
         pendingOrdered: pending.ordered,
         normalizedRoute,
@@ -8728,29 +9456,20 @@ async function processRunnerRouteOnce(route, runtime, mode, options = {}) {
         deps: routingExecutionDeps,
         precomputedHumanIntent: safeObject(sharedHumanIntentContext).humanIntent || null,
       });
-      const inlineCurrentBotSelected = ensureArray(inlineAdjudication.selected_bot_usernames)
+      const currentBotSelected = ensureArray(adjudication.selected_bot_usernames)
         .map((value) => String(value || "").trim().replace(/^@+/, "").toLowerCase())
         .includes(currentBotSelector);
-      if (!inlineCurrentBotSelected) {
-        saveRunnerRouteState(
-          routeKey,
-          buildRunnerRouteStateFromComment(selectedRecord, {
-            last_action: "adjudication_skipped",
-            last_reason: String(inlineAdjudication.reason_code || "").trim() || "not_selected_by_adjudicator",
-            last_trigger: "responder_adjudication",
-          }),
-        );
-        skippedRecords.push({
-          id: selectedRecord.id,
-          reason: String(inlineAdjudication.reason_code || "").trim() || "not_selected_by_adjudicator",
-          messageID: intFromRawAllowZero(selectedRecord?.parsedArchive?.messageID, 0),
-        });
-        continue;
+      if (!currentBotSelected) {
+        return {
+          kind: "skip",
+          skipAction: "adjudication_skipped",
+          skipReason: String(adjudication.reason_code || "").trim() || "not_selected_by_adjudicator",
+          skipTrigger: "responder_adjudication",
+        };
       }
-      const currentRouteState = safeObject(loadBotRunnerState().routes[routeKey]);
       const requestClaim = await prepareRunnerRequestClaim(
         selectedRecord,
-        inlineAdjudication.selected_bot_usernames,
+        adjudication.selected_bot_usernames,
         safeObject(sharedHumanIntentContext).humanIntent || null,
       );
       if (!requestClaim.ok) {
@@ -8758,84 +9477,136 @@ async function processRunnerRouteOnce(route, runtime, mode, options = {}) {
           normalizedRoute,
           runtime,
         });
-        saveRunnerRouteState(
-          routeKey,
-          buildRunnerRouteStateFromComment(selectedRecord, {
-            last_action: "request_skipped",
-            last_reason: String(requestClaim.reason || "request_unavailable").trim() || "request_unavailable",
-            last_trigger: "request_ledger",
+        return {
+          kind: "skip",
+          skipAction: "request_skipped",
+          skipReason: String(requestClaim.reason || "request_unavailable").trim() || "request_unavailable",
+          skipTrigger: "request_ledger",
+          skipRecordPatch: {
+            diagnosticType: "skip",
+            contextExcluded: String(requestClaim.reason || "").trim() === "bot_reply_without_active_request",
+            action: "skip_invalid_request_state",
+            closedReason: String(requestClaim.reason || "").trim(),
+          },
+        };
+      }
+      const finalizedRequest = await finalizePreparedRunnerRequest(selectedRecord, requestClaim);
+      if (!finalizedRequest.ok) {
+        return finalizedRequest.skip;
+      }
+      return {
+        kind: "ready",
+        triggerDecision,
+        routingExecutionDeps,
+        sharedHumanIntentContext,
+        adjudication,
+        requestClaim,
+        claimedRequest: finalizedRequest.claimedRequest,
+      };
+    };
+    if (deferExecution) {
+      const skippedRecords = [];
+      for (const selectedRecord of pending.pending) {
+        const preparation = await prepareRunnerSelectedRecordForExecution(selectedRecord);
+        if (preparation.kind === "skip") {
+          pushSelectedRecordSkip(skippedRecords, selectedRecord, {
+            action: preparation.skipAction,
+            reason: preparation.skipReason,
+            trigger: preparation.skipTrigger,
+            statePatch: preparation.skipStatePatch,
+            recordPatch: preparation.skipRecordPatch,
+          });
+          continue;
+        }
+        if (preparation.kind === "startup_loop_skipped") {
+          skippedRecords.push(preparation.skippedRecord);
+          continue;
+        }
+        const {
+          triggerDecision,
+          sharedHumanIntentContext,
+          adjudication,
+          requestClaim,
+          claimedRequest,
+        } = preparation;
+        saveRunnerRouteState(routeKey, {
+          ...buildRunnerActiveExecutionPatch(selectedRecord, requestClaim.requestKey, {
+            id: String(claimedRequest.root_work_item_id || "").trim(),
+            title: String(claimedRequest.root_work_item_title || "").trim(),
+            status: String(claimedRequest.root_work_item_status || "").trim(),
           }),
-        );
-        skippedRecords.push({
-          id: selectedRecord.id,
-          reason: String(requestClaim.reason || "request_unavailable").trim() || "request_unavailable",
-          messageID: intFromRawAllowZero(selectedRecord?.parsedArchive?.messageID, 0),
-          diagnosticType: "skip",
-          contextExcluded: String(requestClaim.reason || "").trim() === "bot_reply_without_active_request",
-          action: "skip_invalid_request_state",
-          closedReason: String(requestClaim.reason || "").trim(),
+          last_request_key: String(requestClaim.requestKey || "").trim(),
+          last_root_work_item_id: String(claimedRequest.root_work_item_id || "").trim(),
+          last_root_work_item_title: String(claimedRequest.root_work_item_title || "").trim(),
+          last_root_work_item_status: String(claimedRequest.root_work_item_status || "").trim(),
         });
-        continue;
-      }
-      const inheritedRootReference = await inheritRunnerReferenceRootWorkItemForRequest({
-        normalizedRoute,
-        selectedRecord,
-        runtime,
-        requestKey: requestClaim.requestKey,
-      });
-      const rootWorkItemClaim = await ensureRunnerRootWorkItemForRequest({
-        normalizedRoute,
-        routeKey,
-        selectedRecord,
-        runtime,
-        requestKey: requestClaim.requestKey,
-      });
-      const claimedRequest = safeObject(
-        loadRunnerRequestByKey(requestClaim.requestKey)
-        || rootWorkItemClaim.request
-        || inheritedRootReference.request
-        || requestClaim.request,
-      );
-      const missingRequiredRootWorkItem = actionableRunnerRequestMissingRootWorkItem(claimedRequest);
-      if (!rootWorkItemClaim.ok || missingRequiredRootWorkItem) {
-        const rootWorkItemFailure = String(
-          rootWorkItemClaim.error
-          || rootWorkItemClaim.reason
-          || (missingRequiredRootWorkItem ? "root_work_item_missing" : "root_work_item_create_failed"),
-        ).trim() || "root_work_item_create_failed";
-        if (String(requestClaim.requestKey || "").trim()) {
-          markRunnerRequestLifecycle({
-            normalizedRoute,
-            requestKey: requestClaim.requestKey,
-            selectedRecord,
+        await syncRunnerRequestLedgerForProjectToServer({
+          normalizedRoute,
+          runtime,
+        });
+        return {
+          route_key: routeKey,
+          route_name: normalizedRoute.name,
+          logical_signature: runnerRouteLogicalSignature(normalizedRoute),
+          outcome: "accepted",
+          detail: `accepted comment ${selectedRecord.id} for background execution`,
+          archive_source: String(archiveThread.source || "").trim() || "-",
+          archive_work_item_id: String(archiveThread.workItemID || "").trim() || "",
+          thread_id: archiveThread.threadID,
+          comment_id: selectedRecord.id,
+          execution_mode: executionPlan.mode,
+          role_profile: executionPlan.roleProfileName,
+          deferred_execution: {
             routeKey,
-            outcome: "closed",
-            closedReason: rootWorkItemFailure,
-          });
-          await syncRunnerRequestLedgerForProjectToServer({
             normalizedRoute,
+            routeState: safeObject(loadBotRunnerState().routes[routeKey]),
+            selectedRecord,
+            pendingOrdered: pending.ordered,
+            bot,
+            destination,
+            archiveThread,
+            executionPlan,
             runtime,
-          });
+            managedConversationBots,
+            requestKey: String(requestClaim.requestKey || "").trim(),
+            triggerDecision,
+            responderAdjudication: adjudication,
+            humanIntentContext: sharedHumanIntentContext,
+          },
+        };
+      }
+      {
+        const skippedOutcome = await finalizeSkippedPendingRecords(skippedRecords);
+        if (skippedOutcome) {
+          return skippedOutcome;
         }
-        saveRunnerRouteState(
-          routeKey,
-          buildRunnerRouteStateFromComment(selectedRecord, {
-            last_action: "request_skipped",
-            last_reason: rootWorkItemFailure,
-            last_trigger: "work_item_root",
-            last_request_key: String(requestClaim.requestKey || "").trim(),
-          }),
-        );
-        skippedRecords.push({
-          id: selectedRecord.id,
-          reason: rootWorkItemFailure,
-          messageID: intFromRawAllowZero(selectedRecord?.parsedArchive?.messageID, 0),
-          diagnosticType: "skip",
-          action: "skip_missing_root_work_item",
-          closedReason: rootWorkItemFailure,
+      }
+    }
+    const skippedRecords = [];
+    for (const selectedRecord of pending.pending) {
+      const preparation = await prepareRunnerSelectedRecordForExecution(selectedRecord);
+      if (preparation.kind === "skip") {
+        pushSelectedRecordSkip(skippedRecords, selectedRecord, {
+          action: preparation.skipAction,
+          reason: preparation.skipReason,
+          trigger: preparation.skipTrigger,
+          statePatch: preparation.skipStatePatch,
+          recordPatch: preparation.skipRecordPatch,
         });
         continue;
       }
+      if (preparation.kind === "startup_loop_skipped") {
+        skippedRecords.push(preparation.skippedRecord);
+        continue;
+      }
+      const currentRouteState = safeObject(loadBotRunnerState().routes[routeKey]);
+      const {
+        triggerDecision,
+        sharedHumanIntentContext,
+        adjudication: inlineAdjudication,
+        requestClaim,
+        claimedRequest,
+      } = preparation;
       saveRunnerRouteState(routeKey, {
         ...buildRunnerActiveExecutionPatch(selectedRecord, requestClaim.requestKey, {
           id: String(claimedRequest.root_work_item_id || "").trim(),
@@ -8967,6 +9738,9 @@ async function processRunnerRouteOnce(route, runtime, mode, options = {}) {
           executionContractActionable: processed.result?.execution_contract_actionable === true,
           executionContractTargets: ensureArray(processed.result?.execution_contract_targets),
           nextExpectedResponders: ensureArray(processed.result?.next_expected_responders),
+          normalizedExecutionContractType: String(processed.result?.normalized_execution_contract_type || "").trim(),
+          normalizedExecutionContractTargets: ensureArray(processed.result?.normalized_execution_contract_targets),
+          normalizedExecutionNextResponders: ensureArray(processed.result?.normalized_execution_next_responders),
           currentBotSelector,
           conversationIntentMode: String(processed.result?.conversation_intent_mode || "").trim(),
           normalizedIntent: resolvedIntentType,
@@ -9019,31 +9793,11 @@ async function processRunnerRouteOnce(route, runtime, mode, options = {}) {
       };
     }
 
-    if (skippedRecords.length > 0) {
-      await archiveRunnerDiagnosticComments({
-        comments,
-        skippedRecords,
-        normalizedRoute,
-        bot,
-        archiveThread,
-        runtime,
-      });
-      const lastSkipped = skippedRecords[skippedRecords.length - 1];
-      const distinctReasons = Array.from(new Set(skippedRecords.map((item) => item.reason).filter(Boolean)));
-      return {
-        route_key: routeKey,
-        route_name: normalizedRoute.name,
-        logical_signature: runnerRouteLogicalSignature(normalizedRoute),
-        outcome: "skipped",
-        detail: distinctReasons.join("; ") || "all pending messages were skipped",
-        archive_source: String(archiveThread.source || "").trim() || "-",
-        archive_work_item_id: String(archiveThread.workItemID || "").trim() || "",
-        thread_id: archiveThread.threadID,
-        comment_id: lastSkipped.id,
-        skipped_count: skippedRecords.length,
-        execution_mode: executionPlan.mode,
-        role_profile: executionPlan.roleProfileName,
-      };
+    {
+      const skippedOutcome = await finalizeSkippedPendingRecords(skippedRecords);
+      if (skippedOutcome) {
+        return skippedOutcome;
+      }
     }
 
     return {
@@ -10266,70 +11020,40 @@ function buildRunnerShowPayload(route, flags = {}) {
   const resolvedServerBotName = firstNonEmptyString([
     normalizedRoute.botName,
     matchedTelegramEntry?.serverBotName,
-    "-",
-  ]);
-  const envConfig = normalizedRoute.provider
-    ? loadProviderEnvConfig(normalizedRoute.provider, {
-      botID: normalizedRoute.botID,
-      botName: resolvedServerBotName !== "-" ? resolvedServerBotName : "",
-      route: normalizedRoute,
-    })
-    : null;
-  return {
-    ok: diagnostics.errors.length === 0,
-    route_name: normalizedRoute.name || runnerRouteKey(normalizedRoute),
-    route_key: runnerRouteKey(normalizedRoute),
-    logical_signature: runnerRouteLogicalSignature(normalizedRoute),
-    route_config_file: runnerConfig.filePath,
-    workspace_registry_file: String(runnerConfig.workspaceRegistryFilePath || botRunnerWorkspaceRegistryFilePath()).trim() || "-",
-    route_config: serializeRunnerRoute(normalizedRoute),
-    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",
-    },
-    workspace_mapping: {
-      workspace_dir: diagnostics.workspaceDir || "-",
-      workspace_source: diagnostics.workspaceSource || "-",
-    },
-    execution_profile: {
-      route_role: normalizedRoute.role || "-",
-      role_profile_name: diagnostics.roleProfileName || "-",
-      client: String(diagnostics.roleProfile?.client || "").trim() || "-",
-      model: String(diagnostics.roleProfile?.model || "").trim() || "-",
-      permission_mode: String(diagnostics.roleProfile?.permissionMode || "").trim() || "-",
-      reasoning_effort: String(diagnostics.roleProfile?.reasoningEffort || "").trim() || "-",
-    },
-    last_run: {
-      action: String(routeState.last_action || "").trim() || "-",
-      reason: String(routeState.last_reason || "").trim() || "-",
-      intent_type: String(routeState.last_intent_type || "").trim() || "-",
-      workspace_dir: String(routeState.last_workspace_dir || "").trim() || "-",
-      artifact_validation: String(routeState.last_artifact_validation || "").trim() || "-",
-      artifact_paths: ensureArray(routeState.last_artifact_paths).map((item) => String(item || "").trim()).filter(Boolean),
-      artifact_errors: ensureArray(routeState.last_artifact_errors).map((item) => String(item || "").trim()).filter(Boolean),
-      boundary_violations: ensureArray(routeState.last_boundary_violations).map((item) => safeObject(item)),
-    },
-    active_execution: {
-      active: activeExecutionState.active === true,
-      stale: activeExecutionState.stale === true,
-      stuck: activeExecutionState.stuck === true,
-      comment_id: String(activeExecutionState.commentID || "").trim(),
-      source_message_id: intFromRawAllowZero(activeExecutionState.sourceMessageID, 0),
-      started_at: String(activeExecutionState.startedAt || "").trim(),
-      age_seconds: intFromRawAllowZero(activeExecutionState.ageSeconds, 0),
-      warning: String(activeExecutionState.warning || "").trim(),
-    },
+    "-",
+  ]);
+  const envConfig = normalizedRoute.provider
+    ? loadProviderEnvConfig(normalizedRoute.provider, {
+        botID: normalizedRoute.botID,
+        botName: resolvedServerBotName !== "-" ? resolvedServerBotName : "",
+        route: normalizedRoute,
+      })
+    : null;
+  const lastRunSummary = buildRunnerRouteLastResultSummary(routeState);
+  const lastRunPayload = buildRunnerShowLastRunPayload(lastRunSummary);
+  const activeExecutionPayload = buildRunnerShowActiveExecutionPayload(activeExecutionState);
+  const resolvedContext = buildRunnerShowResolvedContext({
+    normalizedRoute,
+    diagnostics,
+    envConfig,
+    resolvedServerBotName,
+    botNameSource,
+  });
+  return {
+    ok: diagnostics.errors.length === 0,
+    route_name: normalizedRoute.name || runnerRouteKey(normalizedRoute),
+    route_key: runnerRouteKey(normalizedRoute),
+    logical_signature: runnerRouteLogicalSignature(normalizedRoute),
+    route_config_file: runnerConfig.filePath,
+    workspace_registry_file: String(runnerConfig.workspaceRegistryFilePath || botRunnerWorkspaceRegistryFilePath()).trim() || "-",
+    route_config: serializeRunnerRoute(normalizedRoute),
+    ...resolvedContext,
+    last_run: lastRunPayload,
+    active_execution: activeExecutionPayload,
     route_selection_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.",
     warnings: [
       ...ensureArray(diagnostics.warnings),
-      ...(activeExecutionState.stuck ? [activeExecutionState.warning] : []),
+      ...(activeExecutionPayload.stuck && activeExecutionPayload.warning ? [activeExecutionPayload.warning] : []),
     ],
     errors: diagnostics.errors,
   };
@@ -10381,6 +11105,20 @@ async function runRunnerShow(flags) {
       `    action: ${payload.last_run.action}`,
       `    reason: ${payload.last_run.reason}`,
       `    intent_type: ${payload.last_run.intent_type}`,
+      `    ai_reply_preview: ${payload.last_run.ai_reply_preview}`,
+      `    execution_contract_type: ${payload.last_run.execution_contract_type}`,
+      `    execution_contract_targets: ${payload.last_run.execution_contract_targets.length ? payload.last_run.execution_contract_targets.join(", ") : "-"}`,
+      `    next_expected_responders: ${payload.last_run.next_expected_responders.length ? payload.last_run.next_expected_responders.join(", ") : "-"}`,
+      `    response_contract_validation_status: ${payload.last_run.response_contract_validation_status}`,
+      `    response_contract_validation_reason: ${payload.last_run.response_contract_validation_reason}`,
+      `    response_contract_validation_targets: ${payload.last_run.response_contract_validation_targets.length ? payload.last_run.response_contract_validation_targets.join(", ") : "-"}`,
+      `    assignment_validation_status: ${payload.last_run.assignment_validation_status}`,
+      `    assignment_validation_reason: ${payload.last_run.assignment_validation_reason}`,
+      `    assignment_validation_modes: ${payload.last_run.assignment_validation_modes.length ? payload.last_run.assignment_validation_modes.join(", ") : "-"}`,
+      `    delivery_status: ${payload.last_run.delivery_status}`,
+      `    archive_status: ${payload.last_run.archive_status}`,
+      `    transport_error: ${payload.last_run.transport_error}`,
+      `    archive_error: ${payload.last_run.archive_error}`,
       `    workspace_dir: ${payload.last_run.workspace_dir}`,
       `    artifact_validation: ${payload.last_run.artifact_validation}`,
       `    artifact_paths: ${payload.last_run.artifact_paths.length ? payload.last_run.artifact_paths.join(", ") : "-"}`,
@@ -10926,6 +11664,161 @@ function summarizeRunnerTUIPhases(routes = []) {
   return { counts, warningCount };
 }
 
+function buildRunnerTUISummaryLine(phaseSummary) {
+  const summary = safeObject(phaseSummary);
+  const counts = safeObject(summary.counts);
+  return `Summary: waiting=${intFromRawAllowZero(counts.waiting, 0)} polling=${intFromRawAllowZero(counts.polling, 0)} running=${intFromRawAllowZero(counts.running, 0)} busy=${intFromRawAllowZero(counts.busy, 0)} replied=${intFromRawAllowZero(counts.replied, 0)} error=${intFromRawAllowZero(counts.error, 0)} warnings=${intFromRawAllowZero(summary.warningCount, 0)}`;
+}
+
+function buildRunnerTUIRouteTableHeader() {
+  return [
+    bootstrapPadRight("Route", 24),
+    bootstrapPadRight("Phase", 18),
+    bootstrapPadRight("Age", 7),
+    bootstrapPadRight("AI", 20),
+    bootstrapPadRight("Intent", 18),
+    bootstrapPadRight("Msg", 8),
+    bootstrapPadRight("Next", 8),
+    bootstrapPadRight("Warn", 6),
+  ].join(" ");
+}
+
+function buildRunnerTUIRouteRow(route, now, useColor) {
+  const currentRoute = safeObject(route);
+  const phase = normalizeRunnerTUIPhase(currentRoute.phase);
+  const aiLabel = truncateRunnerTUIText(
+    currentRoute.client
+      ? `${String(currentRoute.client || "").trim()}/${String(currentRoute.model || "").trim() || "-"}`
+      : "-",
+    20,
+  );
+  const ageLabel = formatRunnerTUIAge(now, currentRoute.phase_started_at || currentRoute.updated_at || now);
+  const nextSeconds = Number.isFinite(Number(currentRoute.next_run_at)) && Number(currentRoute.next_run_at) > now
+    ? `${Math.max(0, Math.ceil((Number(currentRoute.next_run_at) - now) / 1000))}s`
+    : phase === "ai_running" || phase === "delivering" || phase === "context_suggesting"
+      ? "run"
+      : "-";
+  const warningLabel = String(currentRoute.warning || currentRoute.last_error || "").trim() ? "yes" : "-";
+  return [
+    bootstrapPadRight(truncateRunnerTUIText(currentRoute.route_name, 24), 24),
+    colorizeRunnerTUIPhase(phase, 18, useColor),
+    bootstrapPadRight(ageLabel, 7),
+    bootstrapPadRight(aiLabel, 20),
+    bootstrapPadRight(truncateRunnerTUIText(currentRoute.intent_type || "-", 18), 18),
+    bootstrapPadRight(String(currentRoute.source_message_id || "-"), 8),
+    bootstrapPadRight(nextSeconds, 8),
+    bootstrapPadRight(warningLabel, 6),
+  ].join(" ");
+}
+
+function buildRunnerTUIRouteDetailLine(route) {
+  const currentRoute = safeObject(route);
+  const detailParts = [
+    String(currentRoute.detail || "").trim(),
+    String(currentRoute.planner_client || "").trim() || String(currentRoute.planner_model || "").trim()
+      ? `planner=${String(currentRoute.planner_client || "").trim() || "-"}/${String(currentRoute.planner_model || "").trim() || "-"}`
+      : "",
+    String(currentRoute.context_suggestion_status || "").trim()
+      ? `context=${String(currentRoute.context_suggestion_status || "").trim()}`
+      : "",
+    String(currentRoute.warning || "").trim()
+      ? `warning=${String(currentRoute.warning || "").trim()}`
+      : "",
+    String(currentRoute.last_error || "").trim()
+      ? `error=${String(currentRoute.last_error || "").trim()}`
+      : "",
+  ].filter(Boolean);
+  return `  ${truncateRunnerTUIText(detailParts.join(" | ") || "-", 116)}`;
+}
+
+function buildRunnerTUIRecentEventLine(event) {
+  const currentEvent = safeObject(event);
+  return `  [${String(currentEvent.time || "").trim() || "--:--:--"}] ${truncateRunnerTUIText(currentEvent.route_name, 24)} ${bootstrapPadRight(String(currentEvent.outcome || "-").trim(), 12)} ${truncateRunnerTUIText(currentEvent.detail || "-", 74)}`;
+}
+
+function buildRunnerTUIRecentEvent(event, fallbackRouteName = "runner", fallbackOutcome = "-", fallbackDetail = "") {
+  const currentEvent = safeObject(event);
+  return {
+    time: new Date().toLocaleTimeString("en-US", { hour12: false }),
+    route_name: String(currentEvent.route_name || fallbackRouteName || "runner").trim(),
+    outcome: String(currentEvent.outcome || fallbackOutcome || "-").trim(),
+    detail: String(currentEvent.detail || fallbackDetail || "").trim(),
+  };
+}
+
+function buildRunnerTUIInitialRouteState(route) {
+  const normalizedRoute = normalizeRunnerRoute(route);
+  const routeKey = runnerRouteKey(normalizedRoute);
+  const now = Date.now();
+  return {
+    route_key: routeKey,
+    route_name: normalizedRoute.name,
+    phase: "waiting",
+    detail: "awaiting next poll",
+    client: "",
+    model: "",
+    planner_client: "",
+    planner_model: "",
+    intent_type: "",
+    source_message_id: "",
+    next_run_at: 0,
+    context_suggestion_status: "",
+    warning: "",
+    last_error: "",
+    phase_started_at: now,
+    updated_at: now,
+  };
+}
+
+function appendRunnerTUIRecentEvent(recentEvents, event, fallbackRouteName = "runner", fallbackOutcome = "-", fallbackDetail = "") {
+  const nextEvents = ensureArray(recentEvents);
+  nextEvents.unshift(buildRunnerTUIRecentEvent(event, fallbackRouteName, fallbackOutcome, fallbackDetail));
+  if (nextEvents.length > 8) {
+    nextEvents.length = 8;
+  }
+}
+
+function buildRunnerTUIRouteStatePatchFromResult(result, routeState = null, currentRouteState = null) {
+  const current = safeObject(currentRouteState);
+  const currentRouteSnapshot = safeObject(routeState);
+  return {
+    phase: mapRunnerTUIPhaseFromOutcome(result?.outcome),
+    detail: String(result?.detail || "").trim(),
+    intent_type: String(currentRouteSnapshot.last_intent_type || current.intent_type || "").trim(),
+    source_message_id: intFromRawAllowZero(currentRouteSnapshot.last_source_message_id, intFromRawAllowZero(current.source_message_id, 0)) || current.source_message_id,
+    context_suggestion_status: String(result?.context_suggestion_status || currentRouteSnapshot.last_context_suggestion_status || current.context_suggestion_status || "").trim(),
+    warning: String(currentRouteSnapshot.active_execution_warning || result?.warning || "").trim(),
+    last_error: String(currentRouteSnapshot.last_error || "").trim(),
+  };
+}
+
+function buildRunnerTUIRouteStatePatchFromExecutionStage({ executionPlan, selectedRecord, phase, detail, warning = "", contextSuggestionStatus = "", intentType = "" }) {
+  const currentExecutionPlan = safeObject(executionPlan);
+  const normalizedPhase = normalizeRunnerTUIPhase(phase);
+  const clearLastError = ["ai_running", "delivering", "context_suggesting", "replied"].includes(normalizedPhase);
+  const plannerFallbackClient = String(currentExecutionPlan.roleProfile?.client || "").trim();
+  const plannerFallbackModel = String(currentExecutionPlan.roleProfile?.model || "").trim();
+  const plannerClient = resolveRolePlannerClient({ env: process.env }) || plannerFallbackClient;
+  const plannerModel = resolveRolePlannerModelDisplayName({
+    env: process.env,
+    fallbackClient: plannerFallbackClient,
+    fallbackModel: plannerFallbackModel,
+  });
+  return {
+    phase: normalizedPhase,
+    detail: String(detail || "").trim(),
+    client: plannerFallbackClient,
+    model: plannerFallbackModel,
+    planner_client: String(plannerClient || "").trim(),
+    planner_model: String(plannerModel || "").trim(),
+    source_message_id: intFromRawAllowZero(safeObject(selectedRecord).parsedArchive?.messageID, 0),
+    intent_type: String(intentType || currentExecutionPlan.intentType || "").trim(),
+    warning: String(warning || "").trim(),
+    context_suggestion_status: String(contextSuggestionStatus || "").trim(),
+    last_error: clearLastError ? "" : undefined,
+  };
+}
+
 function buildRunnerTUIFrame({ routes = [], recentEvents = [], concurrency = 1, now = Date.now(), stopping = false, useColor = false, sourceLabel = "runner start", logFilePath = "" }) {
   const lines = [];
   const activeCount = ensureArray(routes).filter((item) => ["polling", "ai_running", "delivering", "context_suggesting", "busy"].includes(normalizeRunnerTUIPhase(item.phase))).length;
@@ -10935,65 +11828,14 @@ function buildRunnerTUIFrame({ routes = [], recentEvents = [], concurrency = 1,
   if (String(logFilePath || "").trim()) {
     lines.push(`Log: ${truncateRunnerTUIText(String(logFilePath || "").trim(), 112)}`);
   }
-  lines.push(`Summary: waiting=${phaseSummary.counts.waiting} polling=${phaseSummary.counts.polling} running=${phaseSummary.counts.running} busy=${phaseSummary.counts.busy} replied=${phaseSummary.counts.replied} error=${phaseSummary.counts.error} warnings=${phaseSummary.warningCount}`);
+  lines.push(buildRunnerTUISummaryLine(phaseSummary));
   lines.push("Ctrl+C to stop. Foreground runner state is shown below.");
   lines.push("");
-  lines.push(
-    [
-      bootstrapPadRight("Route", 24),
-      bootstrapPadRight("Phase", 18),
-      bootstrapPadRight("Age", 7),
-      bootstrapPadRight("AI", 20),
-      bootstrapPadRight("Intent", 18),
-      bootstrapPadRight("Msg", 8),
-      bootstrapPadRight("Next", 8),
-      bootstrapPadRight("Warn", 6),
-    ].join(" "),
-  );
+  lines.push(buildRunnerTUIRouteTableHeader());
   lines.push("-".repeat(120));
   for (const route of ensureArray(routes)) {
-    const phase = normalizeRunnerTUIPhase(route.phase);
-    const aiLabel = truncateRunnerTUIText(
-      route.client
-        ? `${String(route.client || "").trim()}/${String(route.model || "").trim() || "-"}`
-        : "-",
-      20,
-    );
-    const ageLabel = formatRunnerTUIAge(now, route.phase_started_at || route.updated_at || now);
-    const nextSeconds = Number.isFinite(Number(route.next_run_at)) && Number(route.next_run_at) > now
-      ? `${Math.max(0, Math.ceil((Number(route.next_run_at) - now) / 1000))}s`
-      : phase === "ai_running" || phase === "delivering" || phase === "context_suggesting"
-        ? "run"
-        : "-";
-    const warningLabel = String(route.warning || route.last_error || "").trim() ? "yes" : "-";
-    lines.push(
-      [
-        bootstrapPadRight(truncateRunnerTUIText(route.route_name, 24), 24),
-        colorizeRunnerTUIPhase(phase, 18, useColor),
-        bootstrapPadRight(ageLabel, 7),
-        bootstrapPadRight(aiLabel, 20),
-        bootstrapPadRight(truncateRunnerTUIText(route.intent_type || "-", 18), 18),
-        bootstrapPadRight(String(route.source_message_id || "-"), 8),
-        bootstrapPadRight(nextSeconds, 8),
-        bootstrapPadRight(warningLabel, 6),
-      ].join(" "),
-    );
-    const detailParts = [
-      String(route.detail || "").trim(),
-      String(route.planner_client || "").trim() || String(route.planner_model || "").trim()
-        ? `planner=${String(route.planner_client || "").trim() || "-"}/${String(route.planner_model || "").trim() || "-"}`
-        : "",
-      String(route.context_suggestion_status || "").trim()
-        ? `context=${String(route.context_suggestion_status || "").trim()}`
-        : "",
-      String(route.warning || "").trim()
-        ? `warning=${String(route.warning || "").trim()}`
-        : "",
-      String(route.last_error || "").trim()
-        ? `error=${String(route.last_error || "").trim()}`
-        : "",
-    ].filter(Boolean);
-    lines.push(`  ${truncateRunnerTUIText(detailParts.join(" | ") || "-", 116)}`);
+    lines.push(buildRunnerTUIRouteRow(route, now, useColor));
+    lines.push(buildRunnerTUIRouteDetailLine(route));
   }
   lines.push("");
   lines.push(useColor ? bootstrapColorText("Recent Events", "35") : "Recent Events");
@@ -11001,9 +11843,7 @@ function buildRunnerTUIFrame({ routes = [], recentEvents = [], concurrency = 1,
     lines.push("  (none yet)");
   } else {
     for (const event of ensureArray(recentEvents).slice(0, 8)) {
-      lines.push(
-        `  [${String(event.time || "").trim() || "--:--:--"}] ${truncateRunnerTUIText(event.route_name, 24)} ${bootstrapPadRight(String(event.outcome || "-").trim(), 12)} ${truncateRunnerTUIText(event.detail || "-", 74)}`,
-      );
+      lines.push(buildRunnerTUIRecentEventLine(event));
     }
   }
   return lines.join("\n");
@@ -11015,37 +11855,15 @@ function createRunnerStartTUI({ routes, flags, jsonMode, concurrency, sourceLabe
     return null;
   }
   const useColor = bootstrapSupportsANSIColors();
-  const routeStates = new Map();
+  const routeStates = new Map(
+    ensureArray(routes).map((route) => {
+      const routeState = buildRunnerTUIInitialRouteState(route);
+      return [routeState.route_key, routeState];
+    }),
+  );
   const recentEvents = [];
-  for (const route of ensureArray(routes)) {
-    const normalizedRoute = normalizeRunnerRoute(route);
-    const routeKey = runnerRouteKey(normalizedRoute);
-    routeStates.set(routeKey, {
-      route_key: routeKey,
-      route_name: normalizedRoute.name,
-      phase: "waiting",
-      detail: "awaiting next poll",
-      client: "",
-      model: "",
-      planner_client: "",
-      planner_model: "",
-      intent_type: "",
-      source_message_id: "",
-      next_run_at: 0,
-      context_suggestion_status: "",
-      warning: "",
-      last_error: "",
-      phase_started_at: Date.now(),
-      updated_at: Date.now(),
-    });
-  }
   if (bootstrapEvent && typeof bootstrapEvent === "object") {
-    recentEvents.unshift({
-      time: new Date().toLocaleTimeString("en-US", { hour12: false }),
-      route_name: String(bootstrapEvent.route_name || sourceLabel || "runner").trim(),
-      outcome: String(bootstrapEvent.outcome || "prepared").trim(),
-      detail: String(bootstrapEvent.detail || "").trim(),
-    });
+    recentEvents.unshift(buildRunnerTUIRecentEvent(bootstrapEvent, sourceLabel, "prepared"));
   }
   let intervalHandle = null;
   let disposed = false;
@@ -11084,57 +11902,27 @@ function createRunnerStartTUI({ routes, flags, jsonMode, concurrency, sourceLabe
     const routeKey = String(result?.route_key || "").trim();
     if (routeKey && routeStates.has(routeKey)) {
       const current = safeObject(routeStates.get(routeKey));
-      setRouteState(routeKey, {
-        phase: mapRunnerTUIPhaseFromOutcome(result?.outcome),
-        detail: String(result?.detail || "").trim(),
-        intent_type: String(routeState?.last_intent_type || current.intent_type || "").trim(),
-        source_message_id: intFromRawAllowZero(routeState?.last_source_message_id, intFromRawAllowZero(current.source_message_id, 0)) || current.source_message_id,
-        context_suggestion_status: String(result?.context_suggestion_status || routeState?.last_context_suggestion_status || current.context_suggestion_status || "").trim(),
-        warning: String(safeObject(routeState).active_execution_warning || result?.warning || "").trim(),
-        last_error: String(routeState?.last_error || "").trim(),
-      });
+      setRouteState(routeKey, buildRunnerTUIRouteStatePatchFromResult(result, routeState, current));
     }
     if (!result || ["idle", "busy"].includes(String(result.outcome || "").trim().toLowerCase())) {
       return;
     }
-    recentEvents.unshift({
-      time: new Date().toLocaleTimeString("en-US", { hour12: false }),
-      route_name: String(result.route_name || result.route_key || "").trim(),
-      outcome: String(result.outcome || "").trim(),
-      detail: String(result.detail || "").trim(),
-    });
-    if (recentEvents.length > 8) {
-      recentEvents.length = 8;
-    }
+    appendRunnerTUIRecentEvent(recentEvents, result, String(result.route_name || result.route_key || "").trim());
     render(false);
   };
 
   const reportExecutionStage = ({ routeKey, executionPlan, selectedRecord, phase, detail, warning = "", contextSuggestionStatus = "", intentType = "" }) => {
     const normalizedRouteKey = String(routeKey || "").trim();
     if (!normalizedRouteKey || !routeStates.has(normalizedRouteKey)) return;
-    const normalizedPhase = normalizeRunnerTUIPhase(phase);
-    const clearLastError = ["ai_running", "delivering", "context_suggesting", "replied"].includes(normalizedPhase);
-    const plannerFallbackClient = String(safeObject(executionPlan).roleProfile?.client || "").trim();
-    const plannerFallbackModel = String(safeObject(executionPlan).roleProfile?.model || "").trim();
-    const plannerClient = resolveRolePlannerClient({ env: process.env }) || plannerFallbackClient;
-    const plannerModel = resolveRolePlannerModelDisplayName({
-      env: process.env,
-      fallbackClient: plannerFallbackClient,
-      fallbackModel: plannerFallbackModel,
-    });
-    setRouteState(normalizedRouteKey, {
-      phase: normalizedPhase,
-      detail: String(detail || "").trim(),
-      client: plannerFallbackClient,
-      model: plannerFallbackModel,
-      planner_client: String(plannerClient || "").trim(),
-      planner_model: String(plannerModel || "").trim(),
-      source_message_id: intFromRawAllowZero(safeObject(selectedRecord).parsedArchive?.messageID, 0),
-      intent_type: String(intentType || safeObject(executionPlan).intentType || "").trim(),
-      warning: String(warning || "").trim(),
-      context_suggestion_status: String(contextSuggestionStatus || "").trim(),
-      last_error: clearLastError ? "" : undefined,
-    });
+    setRouteState(normalizedRouteKey, buildRunnerTUIRouteStatePatchFromExecutionStage({
+      executionPlan,
+      selectedRecord,
+      phase,
+      detail,
+      warning,
+      contextSuggestionStatus,
+      intentType,
+    }));
   };
 
   const updateNextRunAt = (routeKey, nextRunAt) => {
@@ -11161,6 +11949,550 @@ function createRunnerStartTUI({ routes, flags, jsonMode, concurrency, sourceLabe
   };
 }
 
+function beginRunnerStartRoutePoll({ routeKey, normalizedRoute, tui, runnerLogger }) {
+  tui?.setRouteState(routeKey, {
+    phase: "polling",
+    detail: "checking inbound messages and archive thread",
+  });
+  runnerLogger?.append("route_poll", {
+    route_key: routeKey,
+    route_name: normalizedRoute.name,
+    logical_signature: runnerRouteLogicalSignature(normalizedRoute),
+  });
+}
+
+function buildRunnerStartRouteResultLogPayload(result, routeKey, routeName) {
+  return {
+    route_key: String(result?.route_key || routeKey).trim(),
+    route_name: String(result?.route_name || routeName || "").trim(),
+    outcome: String(result?.outcome || "").trim(),
+    detail: String(result?.detail || "").trim(),
+    comment_id: String(result?.comment_id || "").trim(),
+  };
+}
+
+function publishRunnerStartRouteResult({ result, routeState = null, routeKey, routeName, runnerLogger, tui, jsonMode }) {
+  runnerLogger?.append("route_result", buildRunnerStartRouteResultLogPayload(result, routeKey, routeName));
+  if (tui) {
+    tui.recordResult(result, routeState);
+    return;
+  }
+  printRunnerResult("start", result, jsonMode);
+}
+
+function buildRunnerStartCycleErrorResult({ normalizedRoute, routeKey, errorText, fatalArchiveBootstrapError = false }) {
+  return {
+    route_key: routeKey,
+    route_name: normalizedRoute.name,
+    logical_signature: runnerRouteLogicalSignature(normalizedRoute),
+    outcome: fatalArchiveBootstrapError ? "blocked" : "error",
+    detail: errorText,
+  };
+}
+
+function finalizeRunnerStartRouteCycle({ routeKey, normalizedRoute, cycleOutcome, schedules, tui }) {
+  let routeState = safeObject(loadBotRunnerState().routes[routeKey]);
+  let activeExecutionState = resolveRunnerActiveExecutionState(routeState);
+  const successfulCycleOutcome = [
+    "accepted",
+    "busy",
+    "idle",
+    "primed",
+    "skipped",
+    "replied",
+    "dry_run",
+    "delivery_failed_after_generation",
+  ].includes(cycleOutcome);
+  const shouldClearLastError = successfulCycleOutcome
+    && String(routeState.last_error || "").trim();
+  const shouldClearStaleActiveExecution = !activeExecutionState.active
+    && successfulCycleOutcome
+    && String(routeState.active_comment_id || "").trim();
+  if (shouldClearLastError || shouldClearStaleActiveExecution) {
+    saveRunnerRouteState(routeKey, {
+      ...(shouldClearStaleActiveExecution ? emptyRunnerActiveExecutionPatch() : {}),
+      ...(shouldClearLastError ? { last_error: "" } : {}),
+    });
+    routeState = safeObject(loadBotRunnerState().routes[routeKey]);
+    activeExecutionState = resolveRunnerActiveExecutionState(routeState);
+  }
+  tui?.setRouteState(routeKey, {
+    intent_type: String(routeState.last_intent_type || "").trim(),
+    source_message_id: intFromRawAllowZero(routeState.last_source_message_id, 0),
+    warning: String(activeExecutionState.warning || "").trim(),
+    last_error: String(routeState.last_error || "").trim(),
+  });
+  const lastErrorText = String(routeState.last_error || "").trim();
+  const isFatalArchiveBootstrapError = lastErrorText.includes("Archive thread is missing")
+    && lastErrorText.includes("write access is denied");
+  const nextRunAt = Date.now() + (isFatalArchiveBootstrapError
+    ? 60000
+    : Math.max(1000, normalizedRoute.pollIntervalMs));
+  schedules.set(routeKey, nextRunAt);
+  tui?.updateNextRunAt(routeKey, nextRunAt);
+}
+
+async function syncRunnerDeferredExecutionRunningState(deferredExecution) {
+  if (!String(deferredExecution?.requestKey || "").trim()) {
+    return;
+  }
+  markRunnerRequestLifecycle({
+    normalizedRoute: deferredExecution.normalizedRoute,
+    requestKey: deferredExecution.requestKey,
+    selectedRecord: deferredExecution.selectedRecord,
+    routeKey: deferredExecution.routeKey,
+    outcome: "running",
+  });
+  const rootWorkItemSync = await syncRunnerRequestRootWorkItemForOutcome({
+    normalizedRoute: deferredExecution.normalizedRoute,
+    runtime: deferredExecution.runtime,
+    requestKey: deferredExecution.requestKey,
+  });
+  const syncedRequest = safeObject(rootWorkItemSync.request);
+  if (String(syncedRequest.root_work_item_id || "").trim()) {
+    saveRunnerRouteState(deferredExecution.routeKey, {
+      active_root_work_item_id: String(syncedRequest.root_work_item_id || "").trim(),
+      active_root_work_item_title: String(syncedRequest.root_work_item_title || "").trim(),
+      active_root_work_item_status: String(syncedRequest.root_work_item_status || "").trim(),
+      last_root_work_item_id: String(syncedRequest.root_work_item_id || "").trim(),
+      last_root_work_item_title: String(syncedRequest.root_work_item_title || "").trim(),
+      last_root_work_item_status: String(syncedRequest.root_work_item_status || "").trim(),
+    });
+  }
+  await syncRunnerRequestLedgerForProjectToServer({
+    normalizedRoute: deferredExecution.normalizedRoute,
+    runtime: deferredExecution.runtime,
+  });
+}
+
+async function finalizeRunnerDeferredExecutionSkipped(deferredExecution, processed) {
+  if (String(deferredExecution?.requestKey || "").trim()) {
+    markRunnerRequestLifecycle({
+      normalizedRoute: deferredExecution.normalizedRoute,
+      requestKey: deferredExecution.requestKey,
+      selectedRecord: deferredExecution.selectedRecord,
+      routeKey: deferredExecution.routeKey,
+      outcome: "skipped",
+      closedReason: String(processed?.skippedRecord?.reason || "skipped").trim() || "skipped",
+    });
+    const rootWorkItemSync = await syncRunnerRequestRootWorkItemForOutcome({
+      normalizedRoute: deferredExecution.normalizedRoute,
+      runtime: deferredExecution.runtime,
+      requestKey: deferredExecution.requestKey,
+    });
+    const syncedRequest = safeObject(rootWorkItemSync.request);
+    if (String(syncedRequest.root_work_item_id || "").trim()) {
+      saveRunnerRouteState(deferredExecution.routeKey, {
+        last_root_work_item_id: String(syncedRequest.root_work_item_id || "").trim(),
+        last_root_work_item_title: String(syncedRequest.root_work_item_title || "").trim(),
+        last_root_work_item_status: String(syncedRequest.root_work_item_status || "").trim(),
+      });
+    }
+    await syncRunnerRequestLedgerForProjectToServer({
+      normalizedRoute: deferredExecution.normalizedRoute,
+      runtime: deferredExecution.runtime,
+    });
+  }
+  return {
+    route_key: deferredExecution.routeKey,
+    route_name: deferredExecution.normalizedRoute.name,
+    logical_signature: runnerRouteLogicalSignature(deferredExecution.normalizedRoute),
+    outcome: "skipped",
+    detail: String(processed?.skippedRecord?.reason || "trigger policy skipped message").trim(),
+    archive_source: String(deferredExecution.archiveThread.source || "").trim() || "-",
+    archive_work_item_id: String(deferredExecution.archiveThread.workItemID || "").trim() || "",
+    thread_id: deferredExecution.archiveThread.threadID,
+    comment_id: deferredExecution.selectedRecord.id,
+    execution_mode: deferredExecution.executionPlan.mode,
+    role_profile: deferredExecution.executionPlan.roleProfileName,
+  };
+}
+
+async function finalizeRunnerDeferredExecutionProcessed(deferredExecution, processed) {
+  if (String(deferredExecution?.requestKey || "").trim()) {
+    const resolvedIntentType = String(
+      safeObject(loadBotRunnerState().routes[deferredExecution.routeKey]).last_intent_type || "",
+    ).trim();
+    markRunnerRequestLifecycle({
+      normalizedRoute: deferredExecution.normalizedRoute,
+      requestKey: deferredExecution.requestKey,
+      selectedRecord: deferredExecution.selectedRecord,
+      routeKey: deferredExecution.routeKey,
+      outcome: processed.kind === "delivery_failed"
+        ? "delivery_failed_after_generation"
+        : String(processed.result?.outcome || "replied").trim().toLowerCase(),
+      conversationIDRaw: String(processed.result?.conversation_id || "").trim(),
+      conversationParticipants: ensureArray(processed.result?.conversation_participants),
+      conversationInitialResponders: ensureArray(processed.result?.conversation_initial_responders),
+      allowedResponders: ensureArray(processed.result?.conversation_allowed_responders),
+      conversationLeadBot: String(processed.result?.conversation_lead_bot || "").trim(),
+      conversationSummaryBot: String(processed.result?.conversation_summary_bot || "").trim(),
+      conversationAllowBotToBot: processed.result?.conversation_allow_bot_to_bot === true,
+      conversationReplyExpectation: String(processed.result?.conversation_reply_expectation || "").trim(),
+      executionContractType: String(processed.result?.execution_contract_type || "").trim(),
+      executionContractActionable: processed.result?.execution_contract_actionable === true,
+      executionContractTargets: ensureArray(processed.result?.execution_contract_targets),
+      nextExpectedResponders: ensureArray(processed.result?.next_expected_responders),
+      normalizedExecutionContractType: String(processed.result?.normalized_execution_contract_type || "").trim(),
+      normalizedExecutionContractTargets: ensureArray(processed.result?.normalized_execution_contract_targets),
+      normalizedExecutionNextResponders: ensureArray(processed.result?.normalized_execution_next_responders),
+      currentBotSelector: normalizeTelegramMentionUsername(
+        deferredExecution.bot?.username || deferredExecution.bot?.name,
+      ),
+      conversationIntentMode: String(processed.result?.conversation_intent_mode || "").trim(),
+      normalizedIntent: resolvedIntentType,
+      aiReplyGenerated: processed.result?.ai_reply_generated === true,
+      aiReplyGeneratedAt: String(processed.result?.ai_reply_generated_at || "").trim(),
+      aiReplyPreview: String(processed.result?.ai_reply_preview || "").trim(),
+      responseContractValidationStatus: String(processed.result?.response_contract_validation_status || "").trim(),
+      responseContractValidationReason: String(processed.result?.response_contract_validation_reason || "").trim(),
+      responseContractValidationTargets: ensureArray(processed.result?.response_contract_validation_targets),
+      assignmentValidationStatus: String(processed.result?.assignment_validation_status || "").trim(),
+      assignmentValidationReason: String(processed.result?.assignment_validation_reason || "").trim(),
+      assignmentValidationModes: ensureArray(processed.result?.assignment_validation_modes),
+      deliveryStatus: String(processed.result?.delivery_status || "").trim(),
+      archiveStatus: String(processed.result?.archive_status || "").trim(),
+      transportError: String(processed.result?.transport_error || "").trim(),
+      archiveError: String(processed.result?.archive_error || "").trim(),
+    });
+    if (processed.kind !== "delivery_failed") {
+      await ensureRunnerRootWorkItemForRequest({
+        normalizedRoute: deferredExecution.normalizedRoute,
+        routeKey: deferredExecution.routeKey,
+        selectedRecord: deferredExecution.selectedRecord,
+        runtime: deferredExecution.runtime,
+        requestKey: deferredExecution.requestKey,
+      });
+    }
+    const rootWorkItemSync = await syncRunnerRequestRootWorkItemForOutcome({
+      normalizedRoute: deferredExecution.normalizedRoute,
+      runtime: deferredExecution.runtime,
+      requestKey: deferredExecution.requestKey,
+    });
+    const syncedRequest = safeObject(rootWorkItemSync.request);
+    const followupRoutePatch = buildRunnerRouteFollowupSnapshotPatch(
+      deferredExecution.selectedRecord,
+      processed.result,
+    );
+    if (String(syncedRequest.root_work_item_id || "").trim()) {
+      saveRunnerRouteState(deferredExecution.routeKey, {
+        last_root_work_item_id: String(syncedRequest.root_work_item_id || "").trim(),
+        last_root_work_item_title: String(syncedRequest.root_work_item_title || "").trim(),
+        last_root_work_item_status: String(syncedRequest.root_work_item_status || "").trim(),
+        ...followupRoutePatch,
+      });
+    } else if (Object.keys(followupRoutePatch).length) {
+      saveRunnerRouteState(deferredExecution.routeKey, followupRoutePatch);
+    }
+    await syncRunnerRequestLedgerForProjectToServer({
+      normalizedRoute: deferredExecution.normalizedRoute,
+      runtime: deferredExecution.runtime,
+    });
+  }
+  return {
+    logical_signature: runnerRouteLogicalSignature(deferredExecution.normalizedRoute),
+    archive_source: String(deferredExecution.archiveThread.source || "").trim() || "-",
+    archive_work_item_id: String(deferredExecution.archiveThread.workItemID || "").trim() || "",
+    ...processed.result,
+  };
+}
+
+async function finalizeRunnerDeferredExecutionError(deferredExecution, errorText) {
+  const currentRouteState = safeObject(loadBotRunnerState().routes[deferredExecution.routeKey]);
+  saveRunnerRouteState(deferredExecution.routeKey, {
+    ...currentRouteState,
+    ...emptyRunnerActiveExecutionPatch(),
+    last_error: errorText,
+  });
+  if (String(deferredExecution?.requestKey || "").trim()) {
+    const currentRequest = safeObject(loadRunnerRequestByKey(deferredExecution.requestKey));
+    const resolvedIntentType = String(
+      safeObject(loadBotRunnerState().routes[deferredExecution.routeKey]).last_intent_type
+      || currentRequest.normalized_intent
+      || "",
+    ).trim();
+    markRunnerRequestLifecycle({
+      normalizedRoute: deferredExecution.normalizedRoute,
+      requestKey: deferredExecution.requestKey,
+      selectedRecord: deferredExecution.selectedRecord,
+      routeKey: deferredExecution.routeKey,
+      outcome: "error",
+      closedReason: errorText || "execution_error",
+      normalizedIntent: resolvedIntentType,
+    });
+    await ensureRunnerRootWorkItemForRequest({
+      normalizedRoute: deferredExecution.normalizedRoute,
+      routeKey: deferredExecution.routeKey,
+      selectedRecord: deferredExecution.selectedRecord,
+      runtime: deferredExecution.runtime,
+      requestKey: deferredExecution.requestKey,
+    });
+    const rootWorkItemSync = await syncRunnerRequestRootWorkItemForOutcome({
+      normalizedRoute: deferredExecution.normalizedRoute,
+      runtime: deferredExecution.runtime,
+      requestKey: deferredExecution.requestKey,
+    });
+    const syncedRequest = safeObject(rootWorkItemSync.request);
+    if (String(syncedRequest.root_work_item_id || "").trim()) {
+      saveRunnerRouteState(deferredExecution.routeKey, {
+        last_root_work_item_id: String(syncedRequest.root_work_item_id || "").trim(),
+        last_root_work_item_title: String(syncedRequest.root_work_item_title || "").trim(),
+        last_root_work_item_status: String(syncedRequest.root_work_item_status || "").trim(),
+      });
+    }
+    await syncRunnerRequestLedgerForProjectToServer({
+      normalizedRoute: deferredExecution.normalizedRoute,
+      runtime: deferredExecution.runtime,
+    });
+  }
+  return {
+    route_key: deferredExecution.routeKey,
+    route_name: deferredExecution.normalizedRoute.name,
+    logical_signature: runnerRouteLogicalSignature(deferredExecution.normalizedRoute),
+    outcome: "error",
+    detail: errorText,
+    archive_source: String(deferredExecution.archiveThread.source || "").trim() || "-",
+    archive_work_item_id: String(deferredExecution.archiveThread.workItemID || "").trim() || "",
+    thread_id: deferredExecution.archiveThread.threadID,
+    comment_id: deferredExecution.selectedRecord.id,
+  };
+}
+
+function reportRunnerDeferredExecutionAccepted({ deferredExecution, runnerLogger, tui }) {
+  tui?.reportExecutionStage({
+    routeKey: deferredExecution.routeKey,
+    executionPlan: deferredExecution.executionPlan,
+    selectedRecord: deferredExecution.selectedRecord,
+    phase: "ai_running",
+    detail: `running local AI client for comment ${String(deferredExecution.selectedRecord?.id || "").trim() || "-"}`,
+  });
+  runnerLogger?.append("execution_accepted", {
+    route_key: deferredExecution.routeKey,
+    route_name: deferredExecution.normalizedRoute?.name,
+    comment_id: String(deferredExecution.selectedRecord?.id || "").trim(),
+    source_message_id: intFromRawAllowZero(deferredExecution.selectedRecord?.parsedArchive?.messageID, 0),
+    execution_mode: String(deferredExecution.executionPlan?.mode || "").trim(),
+    role_profile: String(deferredExecution.executionPlan?.roleProfileName || "").trim(),
+  });
+}
+
+function createRunnerDeferredExecutionStageReporter({ deferredExecution, runnerLogger, tui }) {
+  return (stage) => {
+    runnerLogger?.append("execution_stage", {
+      route_key: deferredExecution.routeKey,
+      route_name: deferredExecution.normalizedRoute?.name,
+      comment_id: String(deferredExecution.selectedRecord?.id || "").trim(),
+      source_message_id: intFromRawAllowZero(deferredExecution.selectedRecord?.parsedArchive?.messageID, 0),
+      phase: String(safeObject(stage).phase || "").trim(),
+      detail: String(safeObject(stage).detail || "").trim(),
+      intent_type: String(safeObject(stage).intentType || "").trim(),
+      context_suggestion_status: String(safeObject(stage).contextSuggestionStatus || "").trim(),
+    });
+    tui?.reportExecutionStage({
+      routeKey: deferredExecution.routeKey,
+      executionPlan: deferredExecution.executionPlan,
+      selectedRecord: deferredExecution.selectedRecord,
+      ...safeObject(stage),
+    });
+  };
+}
+
+function publishRunnerDeferredExecutionFinalResult({
+  deferredExecution,
+  finalResult,
+  runnerLogger,
+  tui,
+  jsonMode,
+}) {
+  const latestRouteState = safeObject(loadBotRunnerState().routes[deferredExecution.routeKey]);
+  runnerLogger?.append("execution_result", {
+    route_key: String(finalResult?.route_key || deferredExecution.routeKey).trim(),
+    route_name: String(finalResult?.route_name || deferredExecution.normalizedRoute?.name || "").trim(),
+    outcome: String(finalResult?.outcome || "").trim(),
+    detail: String(finalResult?.detail || "").trim(),
+    comment_id: String(finalResult?.comment_id || deferredExecution.selectedRecord?.id || "").trim(),
+    source_message_id: intFromRawAllowZero(
+      latestRouteState?.last_source_message_id,
+      intFromRawAllowZero(deferredExecution.selectedRecord?.parsedArchive?.messageID, 0),
+    ),
+    intent_type: String(latestRouteState?.last_intent_type || "").trim(),
+    context_suggestion_status: String(
+      finalResult?.context_suggestion_status || latestRouteState?.last_context_suggestion_status || "",
+    ).trim(),
+  });
+  if (tui) {
+    tui.recordResult(finalResult, latestRouteState);
+    return;
+  }
+  printRunnerResult("start", finalResult, jsonMode);
+}
+
+function handleRunnerStartRouteCycleError({
+  normalizedRoute,
+  routeKey,
+  errorText,
+  runnerLogger,
+  tui,
+  jsonMode,
+}) {
+  const fatalArchiveBootstrapError = errorText.includes("Archive thread is missing")
+    && errorText.includes("write access is denied");
+  saveRunnerRouteState(routeKey, {
+    ...safeObject(loadBotRunnerState().routes[routeKey]),
+    last_error: errorText,
+  });
+  const result = buildRunnerStartCycleErrorResult({
+    normalizedRoute,
+    routeKey,
+    errorText,
+    fatalArchiveBootstrapError,
+  });
+  publishRunnerStartRouteResult({
+    result,
+    routeKey,
+    routeName: normalizedRoute.name,
+    runnerLogger,
+    tui,
+    jsonMode,
+  });
+  return fatalArchiveBootstrapError ? "blocked" : "error";
+}
+
+function publishRunnerStartImmediateResult({
+  result,
+  routeKey,
+  normalizedRoute,
+  runnerLogger,
+  tui,
+  jsonMode,
+}) {
+  publishRunnerStartRouteResult({
+    result,
+    routeKey,
+    routeName: normalizedRoute.name,
+    runnerLogger,
+    tui,
+    jsonMode,
+  });
+}
+
+function resolveRunnerStartDueRoutes(routes, schedules, now = Date.now()) {
+  const dueRoutes = [];
+  let nextSleepMs = 5000;
+  for (const route of routes) {
+    const normalizedRoute = normalizeRunnerRoute(route);
+    const routeKey = runnerRouteKey(normalizedRoute);
+    const nextAt = Number(schedules.get(routeKey) || 0);
+    if (nextAt > now) {
+      nextSleepMs = Math.min(nextSleepMs, Math.max(250, nextAt - now));
+      continue;
+    }
+    dueRoutes.push(normalizedRoute);
+  }
+  return {
+    dueRoutes,
+    nextSleepMs,
+  };
+}
+
+function refreshRunnerStartNextSleepMs(routes, schedules, currentNextSleepMs, now = Date.now()) {
+  let nextSleepMs = currentNextSleepMs;
+  for (const route of routes) {
+    const normalizedRoute = normalizeRunnerRoute(route);
+    const routeKey = runnerRouteKey(normalizedRoute);
+    const nextAt = Number(schedules.get(routeKey) || 0);
+    if (nextAt > now) {
+      nextSleepMs = Math.min(nextSleepMs, Math.max(250, nextAt - now));
+    }
+  }
+  return nextSleepMs;
+}
+
+function finalizeRunnerDeferredExecutionLoopState({
+  deferredExecution,
+  executionHeartbeat,
+  inFlightExecutions,
+  schedules,
+  tui,
+}) {
+  executionHeartbeat.stop();
+  inFlightExecutions.delete(deferredExecution.routeKey);
+  const nextRunAt = Date.now() + 250;
+  schedules.set(deferredExecution.routeKey, nextRunAt);
+  tui?.updateNextRunAt(deferredExecution.routeKey, nextRunAt);
+}
+
+function createRunnerDeferredExecutionPromise({
+  deferredExecution,
+  executionHeartbeat,
+  inFlightExecutions,
+  schedules,
+  tui,
+  runnerLogger,
+  jsonMode,
+  reportRunnerStage,
+}) {
+  return (async () => {
+    try {
+      const processed = await processRunnerSelectedRecord({
+        routeKey: deferredExecution.routeKey,
+        normalizedRoute: deferredExecution.normalizedRoute,
+        routeState: deferredExecution.routeState,
+        selectedRecord: deferredExecution.selectedRecord,
+        pendingOrdered: deferredExecution.pendingOrdered,
+        bot: deferredExecution.bot,
+        destination: deferredExecution.destination,
+        archiveThread: deferredExecution.archiveThread,
+        executionPlan: deferredExecution.executionPlan,
+        runtime: deferredExecution.runtime,
+        triggerDecision: deferredExecution.triggerDecision,
+        responderAdjudication: deferredExecution.responderAdjudication,
+        persistedHumanIntentRequest: loadRunnerRequestByKey(deferredExecution.requestKey),
+        precomputedHumanIntentContext: safeObject(deferredExecution.humanIntentContext),
+        deps: {
+          saveRunnerRouteState,
+          startRunnerTypingHeartbeat,
+          runRunnerAIExecution,
+          explainExecutionFailureWithAI,
+          performLocalBotDelivery,
+          serializeRunnerTriggerPolicy,
+          serializeRunnerArchivePolicy,
+          buildRunnerExecutionDeps,
+          buildRunnerDeliveryDeps,
+          buildRunnerRuntimeDeps,
+          managedConversationBots: deferredExecution.managedConversationBots,
+          resolveConversationPeerBots: resolveRunnerConversationPeers,
+          reportRunnerStage,
+        },
+      });
+      if (processed.kind === "skipped") {
+        return await finalizeRunnerDeferredExecutionSkipped(deferredExecution, processed);
+      }
+      return await finalizeRunnerDeferredExecutionProcessed(deferredExecution, processed);
+    } catch (err) {
+      const errorText = String(err?.message || err).trim();
+      return await finalizeRunnerDeferredExecutionError(deferredExecution, errorText);
+    } finally {
+      finalizeRunnerDeferredExecutionLoopState({
+        deferredExecution,
+        executionHeartbeat,
+        inFlightExecutions,
+        schedules,
+        tui,
+      });
+    }
+  })().then((finalResult) => {
+    publishRunnerDeferredExecutionFinalResult({
+      deferredExecution,
+      finalResult,
+      runnerLogger,
+      tui,
+      jsonMode,
+    });
+    return finalResult;
+  });
+}
+
 async function runRunnerStartResolvedRoutes(routes, flags, options = {}) {
   const jsonMode = boolFromRaw(flags.json, false);
   const sourceLabel = String(safeObject(options).sourceLabel || "runner start").trim() || "runner start";
@@ -11190,460 +12522,92 @@ async function runRunnerStartResolvedRoutes(routes, flags, options = {}) {
     }
     tui?.start();
     while (!stopRequested) {
-      const now = Date.now();
-      const dueRoutes = [];
-      let nextSleepMs = 5000;
-      for (const route of routes) {
-        const normalizedRoute = normalizeRunnerRoute(route);
-        const routeKey = runnerRouteKey(normalizedRoute);
-        const nextAt = Number(schedules.get(routeKey) || 0);
-        if (nextAt > now) {
-          nextSleepMs = Math.min(nextSleepMs, Math.max(250, nextAt - now));
-          continue;
-        }
-        dueRoutes.push(normalizedRoute);
-      }
+      const { dueRoutes, nextSleepMs: initialNextSleepMs } = resolveRunnerStartDueRoutes(routes, schedules, Date.now());
+      let nextSleepMs = initialNextSleepMs;
       if (dueRoutes.length > 0) {
         const runtime = await resolveRunnerContext(flags);
         const dueRouteGroups = groupRunnerRoutesBySchedulingTarget(dueRoutes);
         await runTasksWithConcurrencyLimit(dueRouteGroups, concurrency, async (routeGroup) => {
           for (const normalizedRoute of ensureArray(routeGroup)) {
             const routeKey = runnerRouteKey(normalizedRoute);
-            tui?.setRouteState(routeKey, {
-              phase: "polling",
-              detail: "checking inbound messages and archive thread",
-            });
-            runnerLogger?.append("route_poll", {
-              route_key: routeKey,
-              route_name: normalizedRoute.name,
-              logical_signature: runnerRouteLogicalSignature(normalizedRoute),
-            });
+            beginRunnerStartRoutePoll({ routeKey, normalizedRoute, tui, runnerLogger });
             let cycleOutcome = "polling";
             try {
               const result = await processRunnerRouteOnce(normalizedRoute, runtime, "start", { deferExecution: true });
               cycleOutcome = String(result?.outcome || "").trim().toLowerCase() || "idle";
               const deferredExecution = safeObject(result.deferred_execution);
               if (deferredExecution.routeKey) {
-                tui?.reportExecutionStage({
-                  routeKey: deferredExecution.routeKey,
-                  executionPlan: deferredExecution.executionPlan,
-                  selectedRecord: deferredExecution.selectedRecord,
-                  phase: "ai_running",
-                  detail: `running local AI client for comment ${String(deferredExecution.selectedRecord?.id || "").trim() || "-"}`,
-                });
-                runnerLogger?.append("execution_accepted", {
-                  route_key: deferredExecution.routeKey,
-                  route_name: deferredExecution.normalizedRoute?.name,
-                  comment_id: String(deferredExecution.selectedRecord?.id || "").trim(),
-                  source_message_id: intFromRawAllowZero(deferredExecution.selectedRecord?.parsedArchive?.messageID, 0),
-                  execution_mode: String(deferredExecution.executionPlan?.mode || "").trim(),
-                  role_profile: String(deferredExecution.executionPlan?.roleProfileName || "").trim(),
+                reportRunnerDeferredExecutionAccepted({
+                  deferredExecution,
+                  runnerLogger,
+                  tui,
                 });
                 const executionHeartbeat = startRunnerExecutionHeartbeat(
                   deferredExecution.routeKey,
                   deferredExecution.selectedRecord,
                 );
-                if (String(deferredExecution.requestKey || "").trim()) {
-                  markRunnerRequestLifecycle({
-                    normalizedRoute: deferredExecution.normalizedRoute,
-                    requestKey: deferredExecution.requestKey,
-                    selectedRecord: deferredExecution.selectedRecord,
-                    routeKey: deferredExecution.routeKey,
-                    outcome: "running",
-                  });
-                  const rootWorkItemSync = await syncRunnerRequestRootWorkItemForOutcome({
-                    normalizedRoute: deferredExecution.normalizedRoute,
-                    runtime: deferredExecution.runtime,
-                    requestKey: deferredExecution.requestKey,
-                  });
-                  const syncedRequest = safeObject(rootWorkItemSync.request);
-                  if (String(syncedRequest.root_work_item_id || "").trim()) {
-                    saveRunnerRouteState(deferredExecution.routeKey, {
-                      active_root_work_item_id: String(syncedRequest.root_work_item_id || "").trim(),
-                      active_root_work_item_title: String(syncedRequest.root_work_item_title || "").trim(),
-                      active_root_work_item_status: String(syncedRequest.root_work_item_status || "").trim(),
-                      last_root_work_item_id: String(syncedRequest.root_work_item_id || "").trim(),
-                      last_root_work_item_title: String(syncedRequest.root_work_item_title || "").trim(),
-                      last_root_work_item_status: String(syncedRequest.root_work_item_status || "").trim(),
-                    });
-                  }
-                  await syncRunnerRequestLedgerForProjectToServer({
-                    normalizedRoute: deferredExecution.normalizedRoute,
-                    runtime: deferredExecution.runtime,
-                  });
-                }
-                const executionPromise = (async () => {
-                  try {
-                    const processed = await processRunnerSelectedRecord({
-                      routeKey: deferredExecution.routeKey,
-                      normalizedRoute: deferredExecution.normalizedRoute,
-                      routeState: deferredExecution.routeState,
-                      selectedRecord: deferredExecution.selectedRecord,
-                      pendingOrdered: deferredExecution.pendingOrdered,
-                      bot: deferredExecution.bot,
-                      destination: deferredExecution.destination,
-                      archiveThread: deferredExecution.archiveThread,
-                      executionPlan: deferredExecution.executionPlan,
-                      runtime: deferredExecution.runtime,
-                      triggerDecision: deferredExecution.triggerDecision,
-                      responderAdjudication: deferredExecution.responderAdjudication,
-                      persistedHumanIntentRequest: loadRunnerRequestByKey(deferredExecution.requestKey),
-                      precomputedHumanIntentContext: safeObject(deferredExecution.humanIntentContext),
-                      deps: {
-                        saveRunnerRouteState,
-                        startRunnerTypingHeartbeat,
-                        runRunnerAIExecution,
-                        explainExecutionFailureWithAI,
-                        performLocalBotDelivery,
-                        serializeRunnerTriggerPolicy,
-                        serializeRunnerArchivePolicy,
-                        buildRunnerExecutionDeps,
-                        buildRunnerDeliveryDeps,
-                        buildRunnerRuntimeDeps,
-                        managedConversationBots: deferredExecution.managedConversationBots,
-                        resolveConversationPeerBots: resolveRunnerConversationPeers,
-                        reportRunnerStage: (stage) => {
-                          runnerLogger?.append("execution_stage", {
-                            route_key: deferredExecution.routeKey,
-                            route_name: deferredExecution.normalizedRoute?.name,
-                            comment_id: String(deferredExecution.selectedRecord?.id || "").trim(),
-                            source_message_id: intFromRawAllowZero(deferredExecution.selectedRecord?.parsedArchive?.messageID, 0),
-                            phase: String(safeObject(stage).phase || "").trim(),
-                            detail: String(safeObject(stage).detail || "").trim(),
-                            intent_type: String(safeObject(stage).intentType || "").trim(),
-                            context_suggestion_status: String(safeObject(stage).contextSuggestionStatus || "").trim(),
-                          });
-                          tui?.reportExecutionStage({
-                            routeKey: deferredExecution.routeKey,
-                            executionPlan: deferredExecution.executionPlan,
-                            selectedRecord: deferredExecution.selectedRecord,
-                            ...safeObject(stage),
-                          });
-                        },
-                      },
-                    });
-                    if (processed.kind === "skipped") {
-                      if (String(deferredExecution.requestKey || "").trim()) {
-                        markRunnerRequestLifecycle({
-                          normalizedRoute: deferredExecution.normalizedRoute,
-                          requestKey: deferredExecution.requestKey,
-                          selectedRecord: deferredExecution.selectedRecord,
-                          routeKey: deferredExecution.routeKey,
-                          outcome: "skipped",
-                          closedReason: String(processed.skippedRecord?.reason || "skipped").trim() || "skipped",
-                        });
-                        const rootWorkItemSync = await syncRunnerRequestRootWorkItemForOutcome({
-                          normalizedRoute: deferredExecution.normalizedRoute,
-                          runtime: deferredExecution.runtime,
-                          requestKey: deferredExecution.requestKey,
-                        });
-                        const syncedRequest = safeObject(rootWorkItemSync.request);
-                        if (String(syncedRequest.root_work_item_id || "").trim()) {
-                          saveRunnerRouteState(deferredExecution.routeKey, {
-                            last_root_work_item_id: String(syncedRequest.root_work_item_id || "").trim(),
-                            last_root_work_item_title: String(syncedRequest.root_work_item_title || "").trim(),
-                            last_root_work_item_status: String(syncedRequest.root_work_item_status || "").trim(),
-                          });
-                        }
-                        await syncRunnerRequestLedgerForProjectToServer({
-                          normalizedRoute: deferredExecution.normalizedRoute,
-                          runtime: deferredExecution.runtime,
-                        });
-                      }
-                      return {
-                        route_key: deferredExecution.routeKey,
-                        route_name: deferredExecution.normalizedRoute.name,
-                        logical_signature: runnerRouteLogicalSignature(deferredExecution.normalizedRoute),
-                        outcome: "skipped",
-                        detail: String(processed.skippedRecord?.reason || "trigger policy skipped message").trim(),
-                        archive_source: String(deferredExecution.archiveThread.source || "").trim() || "-",
-                        archive_work_item_id: String(deferredExecution.archiveThread.workItemID || "").trim() || "",
-                        thread_id: deferredExecution.archiveThread.threadID,
-                        comment_id: deferredExecution.selectedRecord.id,
-                        execution_mode: deferredExecution.executionPlan.mode,
-                        role_profile: deferredExecution.executionPlan.roleProfileName,
-                      };
-                    }
-                    if (String(deferredExecution.requestKey || "").trim()) {
-                      const resolvedIntentType = String(
-                        safeObject(loadBotRunnerState().routes[deferredExecution.routeKey]).last_intent_type || "",
-                      ).trim();
-                      markRunnerRequestLifecycle({
-                        normalizedRoute: deferredExecution.normalizedRoute,
-                        requestKey: deferredExecution.requestKey,
-                        selectedRecord: deferredExecution.selectedRecord,
-                        routeKey: deferredExecution.routeKey,
-                        outcome: processed.kind === "delivery_failed"
-                          ? "delivery_failed_after_generation"
-                          : String(processed.result?.outcome || "replied").trim().toLowerCase(),
-                        conversationIDRaw: String(processed.result?.conversation_id || "").trim(),
-                        conversationParticipants: ensureArray(processed.result?.conversation_participants),
-                        conversationInitialResponders: ensureArray(processed.result?.conversation_initial_responders),
-                        allowedResponders: ensureArray(processed.result?.conversation_allowed_responders),
-                        conversationLeadBot: String(processed.result?.conversation_lead_bot || "").trim(),
-                        conversationSummaryBot: String(processed.result?.conversation_summary_bot || "").trim(),
-                        conversationAllowBotToBot: processed.result?.conversation_allow_bot_to_bot === true,
-                        conversationReplyExpectation: String(processed.result?.conversation_reply_expectation || "").trim(),
-                        executionContractType: String(processed.result?.execution_contract_type || "").trim(),
-                        executionContractActionable: processed.result?.execution_contract_actionable === true,
-                        executionContractTargets: ensureArray(processed.result?.execution_contract_targets),
-                        nextExpectedResponders: ensureArray(processed.result?.next_expected_responders),
-                        currentBotSelector: normalizeTelegramMentionUsername(
-                          deferredExecution.bot?.username || deferredExecution.bot?.name,
-                        ),
-                        conversationIntentMode: String(processed.result?.conversation_intent_mode || "").trim(),
-                        normalizedIntent: resolvedIntentType,
-                        aiReplyGenerated: processed.result?.ai_reply_generated === true,
-                        aiReplyGeneratedAt: String(processed.result?.ai_reply_generated_at || "").trim(),
-                        aiReplyPreview: String(processed.result?.ai_reply_preview || "").trim(),
-                        responseContractValidationStatus: String(processed.result?.response_contract_validation_status || "").trim(),
-                        responseContractValidationReason: String(processed.result?.response_contract_validation_reason || "").trim(),
-                        responseContractValidationTargets: ensureArray(processed.result?.response_contract_validation_targets),
-                        assignmentValidationStatus: String(processed.result?.assignment_validation_status || "").trim(),
-                        assignmentValidationReason: String(processed.result?.assignment_validation_reason || "").trim(),
-                        assignmentValidationModes: ensureArray(processed.result?.assignment_validation_modes),
-                        deliveryStatus: String(processed.result?.delivery_status || "").trim(),
-                        archiveStatus: String(processed.result?.archive_status || "").trim(),
-                        transportError: String(processed.result?.transport_error || "").trim(),
-                        archiveError: String(processed.result?.archive_error || "").trim(),
-                      });
-                      if (processed.kind !== "delivery_failed") {
-                        await ensureRunnerRootWorkItemForRequest({
-                          normalizedRoute: deferredExecution.normalizedRoute,
-                          routeKey: deferredExecution.routeKey,
-                          selectedRecord: deferredExecution.selectedRecord,
-                          runtime: deferredExecution.runtime,
-                          requestKey: deferredExecution.requestKey,
-                        });
-                      }
-                      const rootWorkItemSync = await syncRunnerRequestRootWorkItemForOutcome({
-                        normalizedRoute: deferredExecution.normalizedRoute,
-                        runtime: deferredExecution.runtime,
-                        requestKey: deferredExecution.requestKey,
-                      });
-                      const syncedRequest = safeObject(rootWorkItemSync.request);
-                      if (String(syncedRequest.root_work_item_id || "").trim()) {
-                        saveRunnerRouteState(deferredExecution.routeKey, {
-                          last_root_work_item_id: String(syncedRequest.root_work_item_id || "").trim(),
-                          last_root_work_item_title: String(syncedRequest.root_work_item_title || "").trim(),
-                          last_root_work_item_status: String(syncedRequest.root_work_item_status || "").trim(),
-                        });
-                      }
-                      await syncRunnerRequestLedgerForProjectToServer({
-                        normalizedRoute: deferredExecution.normalizedRoute,
-                        runtime: deferredExecution.runtime,
-                      });
-                    }
-                    return {
-                      logical_signature: runnerRouteLogicalSignature(deferredExecution.normalizedRoute),
-                      archive_source: String(deferredExecution.archiveThread.source || "").trim() || "-",
-                      archive_work_item_id: String(deferredExecution.archiveThread.workItemID || "").trim() || "",
-                      ...processed.result,
-                    };
-                  } catch (err) {
-                    const currentRouteState = safeObject(loadBotRunnerState().routes[deferredExecution.routeKey]);
-                    const errorText = String(err?.message || err).trim();
-                    saveRunnerRouteState(deferredExecution.routeKey, {
-                      ...currentRouteState,
-                      ...emptyRunnerActiveExecutionPatch(),
-                      last_error: errorText,
-                    });
-                    if (String(deferredExecution.requestKey || "").trim()) {
-                      const currentRequest = safeObject(loadRunnerRequestByKey(deferredExecution.requestKey));
-                      const resolvedIntentType = String(
-                        safeObject(loadBotRunnerState().routes[deferredExecution.routeKey]).last_intent_type
-                        || currentRequest.normalized_intent
-                        || "",
-                      ).trim();
-                      markRunnerRequestLifecycle({
-                        normalizedRoute: deferredExecution.normalizedRoute,
-                        requestKey: deferredExecution.requestKey,
-                        selectedRecord: deferredExecution.selectedRecord,
-                        routeKey: deferredExecution.routeKey,
-                        outcome: "error",
-                        closedReason: errorText || "execution_error",
-                        normalizedIntent: resolvedIntentType,
-                      });
-                      await ensureRunnerRootWorkItemForRequest({
-                        normalizedRoute: deferredExecution.normalizedRoute,
-                        routeKey: deferredExecution.routeKey,
-                        selectedRecord: deferredExecution.selectedRecord,
-                        runtime: deferredExecution.runtime,
-                        requestKey: deferredExecution.requestKey,
-                      });
-                      const rootWorkItemSync = await syncRunnerRequestRootWorkItemForOutcome({
-                        normalizedRoute: deferredExecution.normalizedRoute,
-                        runtime: deferredExecution.runtime,
-                        requestKey: deferredExecution.requestKey,
-                      });
-                      const syncedRequest = safeObject(rootWorkItemSync.request);
-                      if (String(syncedRequest.root_work_item_id || "").trim()) {
-                        saveRunnerRouteState(deferredExecution.routeKey, {
-                          last_root_work_item_id: String(syncedRequest.root_work_item_id || "").trim(),
-                          last_root_work_item_title: String(syncedRequest.root_work_item_title || "").trim(),
-                          last_root_work_item_status: String(syncedRequest.root_work_item_status || "").trim(),
-                        });
-                      }
-                      await syncRunnerRequestLedgerForProjectToServer({
-                        normalizedRoute: deferredExecution.normalizedRoute,
-                        runtime: deferredExecution.runtime,
-                      });
-                    }
-                    return {
-                      route_key: deferredExecution.routeKey,
-                      route_name: deferredExecution.normalizedRoute.name,
-                      logical_signature: runnerRouteLogicalSignature(deferredExecution.normalizedRoute),
-                      outcome: "error",
-                      detail: errorText,
-                      archive_source: String(deferredExecution.archiveThread.source || "").trim() || "-",
-                      archive_work_item_id: String(deferredExecution.archiveThread.workItemID || "").trim() || "",
-                      thread_id: deferredExecution.archiveThread.threadID,
-                      comment_id: deferredExecution.selectedRecord.id,
-                    };
-                  } finally {
-                    executionHeartbeat.stop();
-                    inFlightExecutions.delete(deferredExecution.routeKey);
-                    schedules.set(deferredExecution.routeKey, Date.now() + 250);
-                    tui?.updateNextRunAt(deferredExecution.routeKey, Date.now() + 250);
-                  }
-                })();
-                inFlightExecutions.set(routeKey, executionPromise);
-                executionPromise.then((finalResult) => {
-                  const latestRouteState = safeObject(loadBotRunnerState().routes[deferredExecution.routeKey]);
-                  runnerLogger?.append("execution_result", {
-                    route_key: String(finalResult?.route_key || deferredExecution.routeKey).trim(),
-                    route_name: String(finalResult?.route_name || deferredExecution.normalizedRoute?.name || "").trim(),
-                    outcome: String(finalResult?.outcome || "").trim(),
-                    detail: String(finalResult?.detail || "").trim(),
-                    comment_id: String(finalResult?.comment_id || deferredExecution.selectedRecord?.id || "").trim(),
-                    source_message_id: intFromRawAllowZero(latestRouteState?.last_source_message_id, intFromRawAllowZero(deferredExecution.selectedRecord?.parsedArchive?.messageID, 0)),
-                    intent_type: String(latestRouteState?.last_intent_type || "").trim(),
-                    context_suggestion_status: String(finalResult?.context_suggestion_status || latestRouteState?.last_context_suggestion_status || "").trim(),
-                  });
-                  if (tui) {
-                    tui.recordResult(finalResult, latestRouteState);
-                  } else {
-                    printRunnerResult("start", finalResult, jsonMode);
-                  }
+                await syncRunnerDeferredExecutionRunningState(deferredExecution);
+                const reportRunnerStage = createRunnerDeferredExecutionStageReporter({
+                  deferredExecution,
+                  runnerLogger,
+                  tui,
                 });
+                const executionPromise = createRunnerDeferredExecutionPromise({
+                  deferredExecution,
+                  executionHeartbeat,
+                  inFlightExecutions,
+                  schedules,
+                  tui,
+                  runnerLogger,
+                  jsonMode,
+                  reportRunnerStage,
+                });
+                inFlightExecutions.set(routeKey, executionPromise);
                 const acceptedResult = {
                   ...result,
                   deferred_execution: undefined,
                 };
                 cycleOutcome = String(acceptedResult?.outcome || "accepted").trim().toLowerCase() || "accepted";
-                runnerLogger?.append("route_result", {
-                  route_key: String(acceptedResult?.route_key || routeKey).trim(),
-                  route_name: String(acceptedResult?.route_name || normalizedRoute.name || "").trim(),
-                  outcome: String(acceptedResult?.outcome || "").trim(),
-                  detail: String(acceptedResult?.detail || "").trim(),
+                publishRunnerStartImmediateResult({
+                  result: acceptedResult,
+                  routeKey,
+                  normalizedRoute,
+                  runnerLogger,
+                  tui,
+                  jsonMode,
                 });
-                if (tui) {
-                  tui.recordResult(acceptedResult);
-                } else {
-                  printRunnerResult("start", acceptedResult, jsonMode);
-                }
-              } else if (result.outcome !== "busy") {
-                runnerLogger?.append("route_result", {
-                  route_key: String(result?.route_key || routeKey).trim(),
-                  route_name: String(result?.route_name || normalizedRoute.name || "").trim(),
-                  outcome: String(result?.outcome || "").trim(),
-                  detail: String(result?.detail || "").trim(),
-                  comment_id: String(result?.comment_id || "").trim(),
-                });
-                if (tui) {
-                  tui.recordResult(result);
-                } else {
-                  printRunnerResult("start", result, jsonMode);
-                }
               } else {
-                runnerLogger?.append("route_result", {
-                  route_key: String(result?.route_key || routeKey).trim(),
-                  route_name: String(result?.route_name || normalizedRoute.name || "").trim(),
-                  outcome: "busy",
-                  detail: String(result?.detail || "").trim(),
-                  comment_id: String(result?.comment_id || "").trim(),
+                publishRunnerStartImmediateResult({
+                  result,
+                  routeKey,
+                  normalizedRoute,
+                  runnerLogger,
+                  tui,
+                  jsonMode,
                 });
-                tui?.recordResult(result);
               }
             } catch (err) {
-              const errorText = String(err?.message || err);
-              const fatalArchiveBootstrapError = errorText.includes("Archive thread is missing")
-                && errorText.includes("write access is denied");
-              cycleOutcome = fatalArchiveBootstrapError ? "blocked" : "error";
-              saveRunnerRouteState(routeKey, {
-                ...safeObject(loadBotRunnerState().routes[routeKey]),
-                last_error: errorText,
-              });
-              const result = {
-                route_key: routeKey,
-                route_name: normalizedRoute.name,
-                logical_signature: runnerRouteLogicalSignature(normalizedRoute),
-                outcome: fatalArchiveBootstrapError ? "blocked" : "error",
-                detail: errorText,
-              };
-              runnerLogger?.append("route_result", {
-                route_key: routeKey,
-                route_name: normalizedRoute.name,
-                outcome: String(result.outcome || "error").trim(),
-                detail: errorText,
+              cycleOutcome = handleRunnerStartRouteCycleError({
+                normalizedRoute,
+                routeKey,
+                errorText: String(err?.message || err),
+                runnerLogger,
+                tui,
+                jsonMode,
               });
-              if (tui) {
-                tui.recordResult(result);
-              } else {
-                printRunnerResult("start", result, jsonMode);
-              }
             } finally {
-              let routeState = safeObject(loadBotRunnerState().routes[routeKey]);
-              let activeExecutionState = resolveRunnerActiveExecutionState(routeState);
-              const successfulCycleOutcome = [
-                "accepted",
-                "busy",
-                "idle",
-                "primed",
-                "skipped",
-                "replied",
-                "dry_run",
-                "delivery_failed_after_generation",
-              ].includes(cycleOutcome);
-              const shouldClearLastError = successfulCycleOutcome
-                && String(routeState.last_error || "").trim();
-              const shouldClearStaleActiveExecution = !activeExecutionState.active
-                && successfulCycleOutcome
-                && String(routeState.active_comment_id || "").trim();
-              if (shouldClearLastError || shouldClearStaleActiveExecution) {
-                saveRunnerRouteState(routeKey, {
-                  ...(shouldClearStaleActiveExecution ? emptyRunnerActiveExecutionPatch() : {}),
-                  ...(shouldClearLastError ? { last_error: "" } : {}),
-                });
-                routeState = safeObject(loadBotRunnerState().routes[routeKey]);
-                activeExecutionState = resolveRunnerActiveExecutionState(routeState);
-              }
-              tui?.setRouteState(routeKey, {
-                intent_type: String(routeState.last_intent_type || "").trim(),
-                source_message_id: intFromRawAllowZero(routeState.last_source_message_id, 0),
-                warning: String(activeExecutionState.warning || "").trim(),
-                last_error: String(routeState.last_error || "").trim(),
+              finalizeRunnerStartRouteCycle({
+                routeKey,
+                normalizedRoute,
+                cycleOutcome,
+                schedules,
+                tui,
               });
-              const lastErrorText = String(routeState.last_error || "").trim();
-              const isFatalArchiveBootstrapError = lastErrorText.includes("Archive thread is missing")
-                && lastErrorText.includes("write access is denied");
-              const nextRunAt = Date.now() + (isFatalArchiveBootstrapError
-                ? 60000
-                : Math.max(1000, normalizedRoute.pollIntervalMs));
-              schedules.set(routeKey, nextRunAt);
-              tui?.updateNextRunAt(routeKey, nextRunAt);
             }
           }
         });
       }
-      for (const route of routes) {
-        const normalizedRoute = normalizeRunnerRoute(route);
-        const routeKey = runnerRouteKey(normalizedRoute);
-        const nextAt = Number(schedules.get(routeKey) || 0);
-        if (nextAt > Date.now()) {
-          nextSleepMs = Math.min(nextSleepMs, Math.max(250, nextAt - Date.now()));
-        }
-      }
+      nextSleepMs = refreshRunnerStartNextSleepMs(routes, schedules, nextSleepMs, Date.now());
       if (!stopRequested) {
         await sleep(Math.max(250, nextSleepMs));
       }