metheus-governance-mcp-cli 0.2.279 → 0.2.281

package/cli.mjs

@@ -148,10 +148,14 @@ import {
   normalizeTelegramMessageEnvelope as normalizeRunnerTelegramMessageEnvelope,
   normalizeArchiveCommentRecord,
   selectPendingArchiveComments,
-  printRunnerResult,
-} from "./lib/runner-helpers.mjs";
-import {
-  createProjectContextItem as createProjectContextItemImpl,
+  printRunnerResult,
+} from "./lib/runner-helpers.mjs";
+import {
+  normalizeRunnerConversationDecisionBundle,
+  validateRunnerConversationDecisionBundle,
+} from "./lib/runner-orchestration-decision-bundle.mjs";
+import {
+  createProjectContextItem as createProjectContextItemImpl,
   createProjectEvidence as createProjectEvidenceImpl,
   createProjectWorkItem as createProjectWorkItemImpl,
   createThreadComment as createThreadCommentImpl,
@@ -3154,13 +3158,26 @@ function normalizeBotRunnerRequests(rawRequests, nowMs = Date.now()) {
       root_comment_id: String(entry.root_comment_id || entry.rootCommentID || "").trim(),
       root_comment_kind: String(entry.root_comment_kind || entry.rootCommentKind || "").trim().toLowerCase(),
       conversation_id: String(entry.conversation_id || entry.conversationId || "").trim(),
-      reply_chain_context: normalizeRunnerReplyChainContext(entry.reply_chain_context || entry.replyChainContext),
-      selected_bot_usernames: ensureArray(entry.selected_bot_usernames || entry.selectedBotUsernames)
-        .map((value) => normalizeTelegramMentionUsername(value))
-        .filter(Boolean),
-      conversation_allowed_responders: ensureArray(entry.conversation_allowed_responders || entry.conversationAllowedResponders)
-        .map((value) => normalizeTelegramMentionUsername(value))
-        .filter(Boolean),
+      reply_chain_context: normalizeRunnerReplyChainContext(entry.reply_chain_context || entry.replyChainContext),
+      selected_bot_usernames: ensureArray(entry.selected_bot_usernames || entry.selectedBotUsernames)
+        .map((value) => normalizeTelegramMentionUsername(value))
+        .filter(Boolean),
+      authoritative_decision_bundle: Object.keys(
+        safeObject(entry.authoritative_decision_bundle || entry.authoritativeDecisionBundle),
+      ).length
+        ? normalizeRunnerConversationDecisionBundle(
+          entry.authoritative_decision_bundle || entry.authoritativeDecisionBundle,
+        )
+        : {},
+      decision_bundle_validation_status: String(
+        entry.decision_bundle_validation_status || entry.decisionBundleValidationStatus || "",
+      ).trim().toLowerCase(),
+      decision_bundle_validation_reason: String(
+        entry.decision_bundle_validation_reason || entry.decisionBundleValidationReason || "",
+      ).trim(),
+      conversation_allowed_responders: ensureArray(entry.conversation_allowed_responders || entry.conversationAllowedResponders)
+        .map((value) => normalizeTelegramMentionUsername(value))
+        .filter(Boolean),
       conversation_intent_mode: String(entry.conversation_intent_mode || entry.conversationIntentMode || "").trim().toLowerCase(),
       conversation_lead_bot: normalizeTelegramMentionUsername(entry.conversation_lead_bot || entry.conversationLeadBot),
       conversation_summary_bot: normalizeTelegramMentionUsername(entry.conversation_summary_bot || entry.conversationSummaryBot),
@@ -3870,10 +3887,10 @@ async function findServerRunnerRequestForMessageID({
   }
 }
 
-function runnerRequestHasConversationContractData(entryRaw) {
-  const entry = safeObject(entryRaw);
-  return Boolean(
-    String(entry.conversation_intent_mode || "").trim()
+function runnerRequestHasConversationContractData(entryRaw) {
+  const entry = safeObject(entryRaw);
+  return Boolean(
+    String(entry.conversation_intent_mode || "").trim()
     || String(entry.conversation_lead_bot || "").trim()
     || String(entry.conversation_summary_bot || "").trim()
     || ensureArray(entry.conversation_participants).length
@@ -3885,51 +3902,63 @@ function runnerRequestHasConversationContractData(entryRaw) {
     || 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 runnerRequestAuthoritativeDecisionBundle(entryRaw) {
+  const entry = safeObject(entryRaw);
+  const validation = validateRunnerConversationDecisionBundle(
+    safeObject(entry.authoritative_decision_bundle || entry.authoritativeDecisionBundle),
+  );
+  return validation.ok ? safeObject(validation.bundle) : {};
+}
+
+function runnerRequestPreferredExecutionContractType(entryRaw) {
+  const entry = safeObject(entryRaw);
+  const decisionBundle = runnerRequestAuthoritativeDecisionBundle(entry);
+  return String(
+    decisionBundle.execution_contract_type
+      || entry.execution_contract_type
+      || entry.root_execution_contract_type
+      || "",
+  ).trim().toLowerCase();
+}
 
-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 runnerRequestPreferredExecutionContractActionable(entryRaw) {
+  const entry = safeObject(entryRaw);
+  const decisionBundle = runnerRequestAuthoritativeDecisionBundle(entry);
+  return decisionBundle.execution_contract_actionable === true || entry.execution_contract_actionable === true;
+}
+
+function runnerRequestPreferredExecutionContractTargets(entryRaw) {
+  const entry = safeObject(entryRaw);
+  const decisionBundle = runnerRequestAuthoritativeDecisionBundle(entry);
+  return uniqueOrderedStrings(
+    ensureArray(decisionBundle.execution_contract_targets).length
+      ? decisionBundle.execution_contract_targets
+      : ensureArray(entry.execution_contract_targets).length
+      ? entry.execution_contract_targets
+      : ensureArray(entry.root_execution_contract_targets).length
+        ? entry.root_execution_contract_targets
+        : [],
+    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 runnerRequestPreferredNextExpectedResponders(entryRaw) {
+  const entry = safeObject(entryRaw);
+  const decisionBundle = runnerRequestAuthoritativeDecisionBundle(entry);
+  return uniqueOrderedStrings(
+    ensureArray(decisionBundle.next_expected_responders).length
+      ? decisionBundle.next_expected_responders
+      : ensureArray(entry.next_expected_responders).length
+      ? entry.next_expected_responders
+      : ensureArray(entry.root_next_expected_responders).length
+        ? entry.root_next_expected_responders
+        : [],
+    normalizeTelegramMentionUsername,
+  );
+}
 
 function runnerRequestPreferredAuthoritySelectedBotUsernames(entryRaw) {
   const entry = safeObject(entryRaw);
@@ -4968,17 +4997,18 @@ function resolveRunnerHumanCommentAuthorityContext({
   };
 }
 
-async function claimRunnerRequestForHumanComment({
-  normalizedRoute,
-  routeKey,
-  selectedRecord,
-  selectedBotUsernames = [],
-  normalizedIntent = "",
-  sharedHumanIntent = null,
-  runtime = null,
-  archiveThreadID = "",
-  authoritativeSourceMessageEnvelope = {},
-}) {
+async function claimRunnerRequestForHumanComment({
+  normalizedRoute,
+  routeKey,
+  selectedRecord,
+  selectedBotUsernames = [],
+  normalizedIntent = "",
+  sharedHumanIntent = null,
+  decisionBundle = null,
+  runtime = null,
+  archiveThreadID = "",
+  authoritativeSourceMessageEnvelope = {},
+}) {
   const parsed = safeObject(selectedRecord?.parsedArchive);
   const commentKind = String(parsed.kind || "").trim().toLowerCase();
   if (!isInboundArchiveKind(commentKind)) {
@@ -5060,9 +5090,9 @@ async function claimRunnerRequestForHumanComment({
       excludeRequestKey: provisionalRequestKey,
     }));
   }
-  const authorityContext = resolveRunnerHumanCommentAuthorityContext({
-    normalizedRoute,
-    selectedRecord,
+  const authorityContext = resolveRunnerHumanCommentAuthorityContext({
+    normalizedRoute,
+    selectedRecord,
     replyChainContext,
     referencedRequest,
     sharedConversationSource,
@@ -5070,24 +5100,44 @@ async function claimRunnerRequestForHumanComment({
     normalizedSharedHumanIntent,
     resolvedNormalizedIntent,
   });
-  const authoritySource = safeObject(authorityContext.authoritySource);
-  const authorityReplyChainContext = await buildRunnerAuthorityReplyChainContext({
-    selectedRecord,
-    replyChainContext,
+  const authoritySource = safeObject(authorityContext.authoritySource);
+  const decisionBundleValidation = validateRunnerConversationDecisionBundle(decisionBundle);
+  if (
+    Object.keys(safeObject(decisionBundle)).length > 0
+    && decisionBundleValidation.ok !== true
+  ) {
+    return {
+      ok: false,
+      reason: "invalid_decision_bundle",
+      detail: String(decisionBundleValidation.reason || "").trim() || "invalid_decision_bundle",
+    };
+  }
+  const authoritativeDecisionBundle = decisionBundleValidation.ok === true
+    ? safeObject(decisionBundleValidation.bundle)
+    : {};
+  const authorityReplyChainContext = await buildRunnerAuthorityReplyChainContext({
+    selectedRecord,
+    replyChainContext,
     authoritySource,
     runtime,
     archiveThreadID,
   });
   const resolvedConversationID = String(authorityContext.conversationID || "").trim();
   const preferredNormalizedIntent = String(authorityContext.normalizedIntent || "").trim().toLowerCase();
-  const requestSelectedBotUsernames = ensureArray(authorityContext.selectedBotUsernames);
-  const requestKey = buildRunnerRequestKey({
-    normalizedRoute,
-    selectedRecord,
-    selectedBotUsernames: requestSelectedBotUsernames,
-    normalizedIntent: preferredNormalizedIntent,
-    conversationID: resolvedConversationID,
-  });
+  const requestSelectedBotUsernames = ensureArray(authorityContext.selectedBotUsernames);
+  const effectiveSelectedBotUsernames = uniqueOrderedStrings(
+    ensureArray(authoritativeDecisionBundle.selected_bot_usernames).length
+      ? authoritativeDecisionBundle.selected_bot_usernames
+      : requestSelectedBotUsernames,
+    normalizeTelegramMentionUsername,
+  );
+  const requestKey = buildRunnerRequestKey({
+    normalizedRoute,
+    selectedRecord,
+    selectedBotUsernames: effectiveSelectedBotUsernames,
+    normalizedIntent: preferredNormalizedIntent,
+    conversationID: resolvedConversationID,
+  });
   const requests = normalizeBotRunnerRequests(stateForClaim.requests);
   const existing = safeObject(requests[requestKey]);
   if (isFinalRunnerRequestStatus(existing.status)) {
@@ -5115,7 +5165,20 @@ async function claimRunnerRequestForHumanComment({
   const sourceMessageEnvelope = Object.keys(normalizedAuthoritativeSourceMessageEnvelope).length
     ? normalizedAuthoritativeSourceMessageEnvelope
     : normalizeRunnerTelegramMessageEnvelope(existing.source_message_envelope);
-  const { requests: nextRequests, request } = upsertRunnerRequest(stateForClaim, requestKey, {
+  const decisionConversationParticipants = uniqueOrderedStrings(
+    ensureArray(authoritativeDecisionBundle.participants),
+    normalizeTelegramMentionUsername,
+  );
+  const decisionInitialResponders = uniqueOrderedStrings(
+    ensureArray(authoritativeDecisionBundle.initial_responders),
+    normalizeTelegramMentionUsername,
+  );
+  const decisionAllowedResponders = uniqueOrderedStrings(
+    ensureArray(authoritativeDecisionBundle.allowed_responders),
+    normalizeTelegramMentionUsername,
+  );
+  const hasAuthoritativeConversationDecision = Object.keys(authoritativeDecisionBundle).length > 0;
+  const { requests: nextRequests, request } = upsertRunnerRequest(stateForClaim, requestKey, {
     project_id: String(normalizedRoute?.projectID || "").trim(),
     provider: String(normalizedRoute?.provider || "").trim(),
     chat_id: String(parsed.chatID || parsed.chatId || "").trim(),
@@ -5126,81 +5189,118 @@ async function claimRunnerRequestForHumanComment({
     source_message_route_key: String(sourceMessageEnvelope.source_route_key || "").trim(),
     source_message_bot_username: normalizeTelegramMentionUsername(sourceMessageEnvelope.source_bot_username),
     source_message_envelope: sourceMessageEnvelope,
-    root_comment_id: String(selectedRecord?.id || "").trim(),
-    root_comment_kind: commentKind,
-    conversation_id: resolvedConversationID,
-    reply_chain_context: authorityReplyChainContext,
-    selected_bot_usernames: uniqueOrderedStrings(requestSelectedBotUsernames, normalizeTelegramMentionUsername),
-    conversation_intent_mode: String(
-      normalizedSharedHumanIntent.intentMode
-        || existing.conversation_intent_mode
-        || authoritySource.conversation_intent_mode
-        || "",
-    ).trim().toLowerCase(),
-    conversation_lead_bot: normalizeTelegramMentionUsername(
-      normalizedSharedHumanIntent.leadBotSelector
-        || existing.conversation_lead_bot
-        || authoritySource.conversation_lead_bot,
-    ),
-    conversation_summary_bot: normalizeTelegramMentionUsername(
-      normalizedSharedHumanIntent.summaryBotSelector
-        || existing.conversation_summary_bot
-        || authoritySource.conversation_summary_bot,
-    ),
-    conversation_participants: uniqueOrderedStrings(
-      ensureArray(normalizedSharedHumanIntent.participantSelectors).length
-        ? normalizedSharedHumanIntent.participantSelectors
-        : ensureArray(existing.conversation_participants).length
-          ? existing.conversation_participants
+    root_comment_id: String(selectedRecord?.id || "").trim(),
+    root_comment_kind: commentKind,
+    conversation_id: resolvedConversationID,
+    reply_chain_context: authorityReplyChainContext,
+    selected_bot_usernames: effectiveSelectedBotUsernames,
+    authoritative_decision_bundle: authoritativeDecisionBundle,
+    decision_bundle_validation_status: String(decisionBundleValidation.status || "").trim(),
+    decision_bundle_validation_reason: String(decisionBundleValidation.reason || "").trim(),
+    conversation_intent_mode: String(
+      (hasAuthoritativeConversationDecision
+        ? authoritativeDecisionBundle.conversation_intent_mode
+        : "")
+        || normalizedSharedHumanIntent.intentMode
+        || existing.conversation_intent_mode
+        || authoritySource.conversation_intent_mode
+        || "",
+    ).trim().toLowerCase(),
+    conversation_lead_bot: normalizeTelegramMentionUsername(
+      (hasAuthoritativeConversationDecision
+        ? authoritativeDecisionBundle.conversation_lead_bot
+        : "")
+        || normalizedSharedHumanIntent.leadBotSelector
+        || existing.conversation_lead_bot
+        || authoritySource.conversation_lead_bot,
+    ),
+    conversation_summary_bot: normalizeTelegramMentionUsername(
+      (hasAuthoritativeConversationDecision
+        ? authoritativeDecisionBundle.conversation_summary_bot
+        : "")
+        || normalizedSharedHumanIntent.summaryBotSelector
+        || existing.conversation_summary_bot
+        || authoritySource.conversation_summary_bot,
+    ),
+    conversation_participants: uniqueOrderedStrings(
+      hasAuthoritativeConversationDecision && decisionConversationParticipants.length
+        ? decisionConversationParticipants
+        : ensureArray(normalizedSharedHumanIntent.participantSelectors).length
+        ? normalizedSharedHumanIntent.participantSelectors
+        : ensureArray(existing.conversation_participants).length
+          ? existing.conversation_participants
           : ensureArray(authoritySource.conversation_participants).length
             ? authoritySource.conversation_participants
             : [],
       normalizeTelegramMentionUsername,
-    ),
-    conversation_initial_responders: uniqueOrderedStrings(
-      ensureArray(normalizedSharedHumanIntent.initialResponderSelectors).length
-        ? normalizedSharedHumanIntent.initialResponderSelectors
-        : ensureArray(existing.conversation_initial_responders).length
-          ? existing.conversation_initial_responders
+    ),
+    conversation_initial_responders: uniqueOrderedStrings(
+      hasAuthoritativeConversationDecision && decisionInitialResponders.length
+        ? decisionInitialResponders
+        : ensureArray(normalizedSharedHumanIntent.initialResponderSelectors).length
+        ? normalizedSharedHumanIntent.initialResponderSelectors
+        : ensureArray(existing.conversation_initial_responders).length
+          ? existing.conversation_initial_responders
           : ensureArray(authoritySource.conversation_initial_responders).length
             ? authoritySource.conversation_initial_responders
             : [],
       normalizeTelegramMentionUsername,
-    ),
-    conversation_allowed_responders: uniqueOrderedStrings(
-      ensureArray(normalizedSharedHumanIntent.allowedResponderSelectors).length
-        ? normalizedSharedHumanIntent.allowedResponderSelectors
-        : ensureArray(existing.conversation_allowed_responders).length
-          ? existing.conversation_allowed_responders
+    ),
+    conversation_allowed_responders: uniqueOrderedStrings(
+      hasAuthoritativeConversationDecision && decisionAllowedResponders.length
+        ? decisionAllowedResponders
+        : ensureArray(normalizedSharedHumanIntent.allowedResponderSelectors).length
+        ? normalizedSharedHumanIntent.allowedResponderSelectors
+        : ensureArray(existing.conversation_allowed_responders).length
+          ? existing.conversation_allowed_responders
           : ensureArray(authoritySource.conversation_allowed_responders).length
             ? authoritySource.conversation_allowed_responders
             : [],
-      normalizeTelegramMentionUsername,
-    ),
-    conversation_allow_bot_to_bot: normalizedSharedHumanIntent.allowBotToBot === true
-      || existing.conversation_allow_bot_to_bot === true
-      || authoritySource.conversation_allow_bot_to_bot === true,
-    conversation_reply_expectation: String(
-      normalizedSharedHumanIntent.replyExpectation
-        || existing.conversation_reply_expectation
-        || authoritySource.conversation_reply_expectation
-        || "",
-    ).trim().toLowerCase(),
-    execution_contract_type: runnerRequestPreferredExecutionContractType(existing)
-      || runnerRequestPreferredExecutionContractType(authoritySource),
-    execution_contract_actionable: runnerRequestPreferredExecutionContractActionable(existing)
-      || runnerRequestPreferredExecutionContractActionable(authoritySource),
-    execution_contract_targets: uniqueOrderedStrings(
-      runnerRequestPreferredExecutionContractTargets(existing).length
-        ? runnerRequestPreferredExecutionContractTargets(existing)
-        : runnerRequestPreferredExecutionContractTargets(authoritySource),
-      normalizeTelegramMentionUsername,
-    ),
-    next_expected_responders: uniqueOrderedStrings(
-      runnerRequestPreferredNextExpectedResponders(existing).length
-        ? runnerRequestPreferredNextExpectedResponders(existing)
-        : runnerRequestPreferredNextExpectedResponders(authoritySource),
-      normalizeTelegramMentionUsername,
+      normalizeTelegramMentionUsername,
+    ),
+    conversation_allow_bot_to_bot: (hasAuthoritativeConversationDecision
+      ? authoritativeDecisionBundle.allow_bot_to_bot === true
+      : false)
+      || normalizedSharedHumanIntent.allowBotToBot === true
+      || existing.conversation_allow_bot_to_bot === true
+      || authoritySource.conversation_allow_bot_to_bot === true,
+    conversation_reply_expectation: String(
+      (hasAuthoritativeConversationDecision
+        ? authoritativeDecisionBundle.conversation_reply_expectation
+        : "")
+        || normalizedSharedHumanIntent.replyExpectation
+        || existing.conversation_reply_expectation
+        || authoritySource.conversation_reply_expectation
+        || "",
+    ).trim().toLowerCase(),
+    execution_contract_type: String(
+      (hasAuthoritativeConversationDecision
+        ? authoritativeDecisionBundle.execution_contract_type
+        : "")
+        || runnerRequestPreferredExecutionContractType(existing)
+        || runnerRequestPreferredExecutionContractType(authoritySource)
+        || "",
+    ).trim().toLowerCase(),
+    execution_contract_actionable: (hasAuthoritativeConversationDecision
+      ? authoritativeDecisionBundle.execution_contract_actionable === true
+      : false)
+      || runnerRequestPreferredExecutionContractActionable(existing)
+      || runnerRequestPreferredExecutionContractActionable(authoritySource),
+    execution_contract_targets: uniqueOrderedStrings(
+      hasAuthoritativeConversationDecision && ensureArray(authoritativeDecisionBundle.execution_contract_targets).length
+        ? authoritativeDecisionBundle.execution_contract_targets
+        : runnerRequestPreferredExecutionContractTargets(existing).length
+        ? runnerRequestPreferredExecutionContractTargets(existing)
+        : runnerRequestPreferredExecutionContractTargets(authoritySource),
+      normalizeTelegramMentionUsername,
+    ),
+    next_expected_responders: uniqueOrderedStrings(
+      hasAuthoritativeConversationDecision && ensureArray(authoritativeDecisionBundle.next_expected_responders).length
+        ? authoritativeDecisionBundle.next_expected_responders
+        : runnerRequestPreferredNextExpectedResponders(existing).length
+        ? runnerRequestPreferredNextExpectedResponders(existing)
+        : runnerRequestPreferredNextExpectedResponders(authoritySource),
+      normalizeTelegramMentionUsername,
     ),
     normalized_intent: String(preferredNormalizedIntent || existing.normalized_intent || "").trim().toLowerCase(),
     status: "claimed",
@@ -5677,6 +5777,7 @@ async function prepareRunnerRequestClaimForExecution({
   selectedRecord,
   selectedResponderSelectors = [],
   sharedHumanIntent = null,
+  decisionBundle = null,
   authoritativeSourceMessageEnvelope = {},
   runtime = null,
   archiveThreadID = "",
@@ -5688,6 +5789,7 @@ async function prepareRunnerRequestClaimForExecution({
     selectedBotUsernames: selectedResponderSelectors,
     normalizedIntent: String(safeObject(sharedHumanIntent).intentType || "").trim().toLowerCase(),
     sharedHumanIntent,
+    decisionBundle,
     runtime,
     archiveThreadID,
     authoritativeSourceMessageEnvelope,
@@ -5826,6 +5928,7 @@ async function finalizePreparedRunnerSelectedRecordExecutionContext({
       selectedRecord,
       selectedResponderSelectors: ensureArray(requestPreparation.selectedResponderSelectors),
       sharedHumanIntent: requestPreparation.sharedHumanIntent || null,
+      decisionBundle: safeObject(requestPreparation.decisionBundle),
       authoritativeSourceMessageEnvelope: safeObject(requestPreparation.authoritativeSourceMessageEnvelope),
       runtime,
       archiveThreadID,
@@ -6216,11 +6319,14 @@ function markRunnerRequestLifecycle({
   closedReason = "",
   aiReplyGenerated = false,
   aiReplyGeneratedAt = "",
-  aiReplyPreview = "",
-  normalizedExecutionContractType = "",
-  normalizedExecutionContractTargets = [],
-  normalizedExecutionNextResponders = [],
-  responseContractValidationStatus = "",
+  aiReplyPreview = "",
+  normalizedExecutionContractType = "",
+  normalizedExecutionContractTargets = [],
+  normalizedExecutionNextResponders = [],
+  decisionBundle = null,
+  decisionBundleValidationStatus = "",
+  decisionBundleValidationReason = "",
+  responseContractValidationStatus = "",
   responseContractValidationReason = "",
   responseContractValidationTargets = [],
   assignmentValidationStatus = "",
@@ -6255,7 +6361,19 @@ function markRunnerRequestLifecycle({
   const sourceMessageEnvelope = Object.keys(normalizedAuthoritativeSourceMessageEnvelope).length
     ? normalizedAuthoritativeSourceMessageEnvelope
     : normalizeRunnerTelegramMessageEnvelope(existing.source_message_envelope);
-  const effectiveReplyToMessageID = intFromRawAllowZero(
+  const normalizedDecisionBundle = normalizeRunnerConversationDecisionBundle(decisionBundle);
+  const resolvedDecisionBundleValidation = Object.keys(safeObject(decisionBundle)).length > 0
+    ? validateRunnerConversationDecisionBundle(normalizedDecisionBundle)
+    : {
+        ok: false,
+        status: String(decisionBundleValidationStatus || "").trim() || "missing",
+        reason: String(decisionBundleValidationReason || "").trim(),
+        bundle: {},
+      };
+  const authoritativeDecisionBundle = resolvedDecisionBundleValidation.ok === true
+    ? safeObject(resolvedDecisionBundleValidation.bundle)
+    : runnerRequestAuthoritativeDecisionBundle(existing);
+  const effectiveReplyToMessageID = intFromRawAllowZero(
     replyToMessageID,
     intFromRawAllowZero(existing.last_reply_to_message_id, 0),
   );
@@ -6287,55 +6405,78 @@ function markRunnerRequestLifecycle({
     || intFromRawAllowZero(replyToMessageID, 0) > 0
     || intFromRawAllowZero(lastReplyMessageThreadID, 0) > 0
   );
-  const rootEffectiveExecutionContractTargets = uniqueOrderedStrings(
-    [
-      ...ensureArray(executionContractTargets),
-      ...ensureArray(normalizedExecutionContractTargets),
-      ...ensureArray(responseContractValidationTargets),
+  const rootEffectiveExecutionContractTargets = uniqueOrderedStrings(
+    [
+      ...ensureArray(authoritativeDecisionBundle.execution_contract_targets),
+      ...ensureArray(executionContractTargets),
+      ...ensureArray(normalizedExecutionContractTargets),
+      ...ensureArray(responseContractValidationTargets),
     ],
     normalizeTelegramMentionUsername,
   );
-  const rootEffectiveNextExpectedResponders = uniqueOrderedStrings(
-    [
-      ...ensureArray(nextExpectedResponders),
-      ...ensureArray(normalizedExecutionNextResponders),
-      ...ensureArray(responseContractValidationTargets),
+  const rootEffectiveNextExpectedResponders = uniqueOrderedStrings(
+    [
+      ...ensureArray(authoritativeDecisionBundle.next_expected_responders),
+      ...ensureArray(nextExpectedResponders),
+      ...ensureArray(normalizedExecutionNextResponders),
+      ...ensureArray(responseContractValidationTargets),
     ],
     normalizeTelegramMentionUsername,
   );
-  const continuationSelectors = uniqueOrderedStrings(
-    [
-      ...ensureArray(executionContractTargets).length
-        ? ensureArray(executionContractTargets)
-        : ensureArray(existing.execution_contract_targets),
-      ...ensureArray(nextExpectedResponders).length
-        ? ensureArray(nextExpectedResponders)
-        : ensureArray(existing.next_expected_responders),
-    ],
-    normalizeTelegramMentionUsername,
-  ).filter((selector) => selector && selector !== normalizedCurrentBotSelector);
-  const shouldRemainRunningAfterReply = continuationSelectors.length > 0;
-  const nextConversationIntentMode = String(
-    conversationIntentMode
-    || existing.conversation_intent_mode
-    || "",
-  ).trim().toLowerCase();
-  const nextExecutionContractType = String(
-    executionContractType
-    || existing.execution_contract_type
-    || "",
-  ).trim().toLowerCase();
-  const nextNormalizedIntent = (() => {
-    const explicitIntent = String(normalizedIntent || "").trim().toLowerCase();
+  const continuationSelectors = uniqueOrderedStrings(
+    [
+      ...ensureArray(authoritativeDecisionBundle.execution_contract_targets).length
+        ? ensureArray(authoritativeDecisionBundle.execution_contract_targets)
+        : ensureArray(executionContractTargets).length
+        ? ensureArray(executionContractTargets)
+        : ensureArray(existing.execution_contract_targets),
+      ...ensureArray(authoritativeDecisionBundle.next_expected_responders).length
+        ? ensureArray(authoritativeDecisionBundle.next_expected_responders)
+        : ensureArray(nextExpectedResponders).length
+        ? ensureArray(nextExpectedResponders)
+        : ensureArray(existing.next_expected_responders),
+    ],
+    normalizeTelegramMentionUsername,
+  ).filter((selector) => selector && selector !== normalizedCurrentBotSelector);
+  const nextExecutionContractType = String(
+    authoritativeDecisionBundle.execution_contract_type
+    || executionContractType
+    || existing.execution_contract_type
+    || "",
+  ).trim().toLowerCase();
+  const normalizedOutcome = String(outcome || "").trim().toLowerCase();
+  const shouldRemainRunningAfterReply = authoritativeDecisionBundle.should_close_after_reply === true
+    ? false
+    : authoritativeDecisionBundle.should_close_after_reply === false
+      ? true
+      : continuationSelectors.length > 0;
+  const shouldRemainRunningAfterSkip = normalizedOutcome === "skipped"
+    && parsedKind === "bot_reply"
+    && authoritativeDecisionBundle.should_close_after_reply !== true
+    && (
+      nextExecutionContractType === "delegation"
+      || rootEffectiveExecutionContractTargets.length > 0
+      || rootEffectiveNextExpectedResponders.length > 0
+      || continuationSelectors.length > 0
+    );
+  const nextConversationIntentMode = String(
+    authoritativeDecisionBundle.conversation_intent_mode
+    || conversationIntentMode
+    || existing.conversation_intent_mode
+    || "",
+  ).trim().toLowerCase();
+  const nextNormalizedIntent = (() => {
+    const explicitIntent = String(
+      authoritativeDecisionBundle.normalized_intent || normalizedIntent || "",
+    ).trim().toLowerCase();
     if (explicitIntent) {
       return explicitIntent;
     }
     if (nextConversationIntentMode && !nextExecutionContractType) {
       return "";
-    }
-    return String(existing.normalized_intent || "").trim().toLowerCase();
-  })();
-  const normalizedOutcome = String(outcome || "").trim().toLowerCase();
+    }
+    return String(existing.normalized_intent || "").trim().toLowerCase();
+  })();
   const nextStatus = (() => {
     if (normalizedOutcome === "claimed") return "claimed";
     if (normalizedOutcome === "running") return "running";
@@ -6345,9 +6486,11 @@ function markRunnerRequestLifecycle({
     }
     if (normalizedOutcome === "loop_closed") return "loop_closed";
     if (normalizedOutcome === "expired") return "expired";
+    if (normalizedOutcome === "skipped") {
+      return shouldRemainRunningAfterSkip ? "running" : "closed";
+    }
     if (
       normalizedOutcome === "error"
-      || normalizedOutcome === "skipped"
       || normalizedOutcome === "closed"
       || normalizedOutcome === "execution_failed"
       || normalizedOutcome === "policy_violation"
@@ -6356,60 +6499,94 @@ 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(
-      ensureArray(conversationParticipants).length ? conversationParticipants : existing.conversation_participants,
-      normalizeTelegramMentionUsername,
-    ),
-    conversation_initial_responders: uniqueOrderedStrings(
-      ensureArray(conversationInitialResponders).length
-        ? conversationInitialResponders
-        : existing.conversation_initial_responders,
-      normalizeTelegramMentionUsername,
-    ),
-    conversation_allowed_responders: uniqueOrderedStrings(
-      ensureArray(allowedResponders).length ? allowedResponders : existing.conversation_allowed_responders,
-      normalizeTelegramMentionUsername,
-    ),
-    conversation_intent_mode: nextConversationIntentMode,
-    conversation_lead_bot: normalizeTelegramMentionUsername(
-      conversationLeadBot
-      || existing.conversation_lead_bot
-      || "",
-    ),
-    conversation_summary_bot: normalizeTelegramMentionUsername(
-      conversationSummaryBot
-      || existing.conversation_summary_bot
-      || "",
-    ),
-    conversation_allow_bot_to_bot: conversationAllowBotToBot === true
-      || existing.conversation_allow_bot_to_bot === true,
-    conversation_reply_expectation: String(
-      conversationReplyExpectation
-      || existing.conversation_reply_expectation
-      || "",
-    ).trim().toLowerCase(),
-    execution_contract_type: nextExecutionContractType,
-    execution_contract_actionable: executionContractActionable === true
-      || existing.execution_contract_actionable === true,
-    execution_contract_targets: uniqueOrderedStrings(
-      isRootHumanComment && rootEffectiveExecutionContractTargets.length
-        ? rootEffectiveExecutionContractTargets
-        : ensureArray(executionContractTargets).length
-          ? executionContractTargets
+  const nowISO = new Date().toISOString();
+  const commentKind = String(parsed.kind || "").trim().toLowerCase();
+  const isRootHumanComment = ["telegram_message", "telegram_edited_message"].includes(commentKind);
+  const isFollowupComment = !isRootHumanComment;
+  const patch = {
+    authoritative_decision_bundle: Object.keys(authoritativeDecisionBundle).length > 0
+      ? authoritativeDecisionBundle
+      : safeObject(existing.authoritative_decision_bundle),
+    decision_bundle_validation_status: String(
+      resolvedDecisionBundleValidation.status
+      || decisionBundleValidationStatus
+      || existing.decision_bundle_validation_status
+      || "",
+    ).trim(),
+    decision_bundle_validation_reason: String(
+      resolvedDecisionBundleValidation.reason
+      || decisionBundleValidationReason
+      || existing.decision_bundle_validation_reason
+      || "",
+    ).trim(),
+    conversation_id: conversationID,
+    conversation_participants: uniqueOrderedStrings(
+      ensureArray(authoritativeDecisionBundle.participants).length
+        ? authoritativeDecisionBundle.participants
+        : ensureArray(conversationParticipants).length
+          ? conversationParticipants
+          : existing.conversation_participants,
+      normalizeTelegramMentionUsername,
+    ),
+    conversation_initial_responders: uniqueOrderedStrings(
+      ensureArray(authoritativeDecisionBundle.initial_responders).length
+        ? authoritativeDecisionBundle.initial_responders
+        : ensureArray(conversationInitialResponders).length
+        ? conversationInitialResponders
+        : existing.conversation_initial_responders,
+      normalizeTelegramMentionUsername,
+    ),
+    conversation_allowed_responders: uniqueOrderedStrings(
+      ensureArray(authoritativeDecisionBundle.allowed_responders).length
+        ? authoritativeDecisionBundle.allowed_responders
+        : ensureArray(allowedResponders).length
+          ? allowedResponders
+          : existing.conversation_allowed_responders,
+      normalizeTelegramMentionUsername,
+    ),
+    conversation_intent_mode: nextConversationIntentMode,
+    conversation_lead_bot: normalizeTelegramMentionUsername(
+      authoritativeDecisionBundle.conversation_lead_bot
+      || conversationLeadBot
+      || existing.conversation_lead_bot
+      || "",
+    ),
+    conversation_summary_bot: normalizeTelegramMentionUsername(
+      authoritativeDecisionBundle.conversation_summary_bot
+      || conversationSummaryBot
+      || existing.conversation_summary_bot
+      || "",
+    ),
+    conversation_allow_bot_to_bot: authoritativeDecisionBundle.allow_bot_to_bot === true
+      || conversationAllowBotToBot === true
+      || existing.conversation_allow_bot_to_bot === true,
+    conversation_reply_expectation: String(
+      authoritativeDecisionBundle.conversation_reply_expectation
+      || conversationReplyExpectation
+      || existing.conversation_reply_expectation
+      || "",
+    ).trim().toLowerCase(),
+    execution_contract_type: nextExecutionContractType,
+    execution_contract_actionable: authoritativeDecisionBundle.execution_contract_actionable === true
+      || executionContractActionable === true
+      || existing.execution_contract_actionable === true,
+    execution_contract_targets: uniqueOrderedStrings(
+      ensureArray(authoritativeDecisionBundle.execution_contract_targets).length
+        ? authoritativeDecisionBundle.execution_contract_targets
+        : isRootHumanComment && rootEffectiveExecutionContractTargets.length
+        ? rootEffectiveExecutionContractTargets
+        : ensureArray(executionContractTargets).length
+          ? executionContractTargets
           : existing.execution_contract_targets,
       normalizeTelegramMentionUsername,
-    ),
-    next_expected_responders: uniqueOrderedStrings(
-      isRootHumanComment && rootEffectiveNextExpectedResponders.length
-        ? rootEffectiveNextExpectedResponders
-        : ensureArray(nextExpectedResponders).length
-          ? nextExpectedResponders
+    ),
+    next_expected_responders: uniqueOrderedStrings(
+      ensureArray(authoritativeDecisionBundle.next_expected_responders).length
+        ? authoritativeDecisionBundle.next_expected_responders
+        : isRootHumanComment && rootEffectiveNextExpectedResponders.length
+        ? rootEffectiveNextExpectedResponders
+        : ensureArray(nextExpectedResponders).length
+          ? nextExpectedResponders
           : existing.next_expected_responders,
       normalizeTelegramMentionUsername,
     ),
@@ -6893,11 +7070,13 @@ function mergeRunnerRequestForServerHydration(localEntryRaw, serverEntryRaw) {
   preserveLocalObjectWhenServerBlank("last_reply_message_envelope");
   preserveLocalObjectWhenServerBlank("attempted_delivery_envelope");
   preserveLocalStringWhenServerBlank("conversation_id");
-  preserveLocalStringWhenServerBlank("conversation_intent_mode");
-  preserveLocalStringWhenServerBlank("conversation_lead_bot");
-  preserveLocalStringWhenServerBlank("conversation_summary_bot");
-  preserveLocalStringWhenServerBlank("conversation_reply_expectation");
-  preserveLocalStringWhenServerBlank("execution_contract_type");
+  preserveLocalStringWhenServerBlank("conversation_intent_mode");
+  preserveLocalStringWhenServerBlank("conversation_lead_bot");
+  preserveLocalStringWhenServerBlank("conversation_summary_bot");
+  preserveLocalStringWhenServerBlank("conversation_reply_expectation");
+  preserveLocalStringWhenServerBlank("decision_bundle_validation_status");
+  preserveLocalStringWhenServerBlank("decision_bundle_validation_reason");
+  preserveLocalStringWhenServerBlank("execution_contract_type");
   preserveLocalStringWhenServerBlank("normalized_execution_contract_type");
   preserveLocalStringWhenServerBlank("ai_reply_generated_at");
   preserveLocalStringWhenServerBlank("ai_reply_preview");
@@ -6922,9 +7101,9 @@ function mergeRunnerRequestForServerHydration(localEntryRaw, serverEntryRaw) {
   preserveLocalStringWhenServerBlank("followup_archive_status");
   preserveLocalStringWhenServerBlank("followup_transport_error");
   preserveLocalStringWhenServerBlank("followup_archive_error");
-  preserveLocalArrayWhenServerEmpty("conversation_participants");
-  preserveLocalArrayWhenServerEmpty("conversation_initial_responders");
-  preserveLocalArrayWhenServerEmpty("conversation_allowed_responders");
+  preserveLocalArrayWhenServerEmpty("conversation_participants");
+  preserveLocalArrayWhenServerEmpty("conversation_initial_responders");
+  preserveLocalArrayWhenServerEmpty("conversation_allowed_responders");
   preserveLocalArrayWhenServerEmpty("execution_contract_targets");
   preserveLocalArrayWhenServerEmpty("next_expected_responders");
   preserveLocalArrayWhenServerEmpty("normalized_execution_contract_targets");
@@ -6936,9 +7115,10 @@ function mergeRunnerRequestForServerHydration(localEntryRaw, serverEntryRaw) {
   preserveLocalArrayWhenServerEmpty("followup_next_expected_responders");
   preserveLocalArrayWhenServerEmpty("followup_normalized_execution_contract_targets");
   preserveLocalArrayWhenServerEmpty("followup_normalized_execution_next_responders");
-  preserveLocalArrayWhenServerEmpty("followup_response_contract_validation_targets");
-  preserveLocalArrayWhenServerEmpty("followup_assignment_validation_modes");
-  preserveLocalObjectWhenServerBlank("reply_chain_context");
+  preserveLocalArrayWhenServerEmpty("followup_response_contract_validation_targets");
+  preserveLocalArrayWhenServerEmpty("followup_assignment_validation_modes");
+  preserveLocalObjectWhenServerBlank("authoritative_decision_bundle");
+  preserveLocalObjectWhenServerBlank("reply_chain_context");
   if (serverEntry.conversation_allow_bot_to_bot !== true && localEntry.conversation_allow_bot_to_bot === true) {
     merged.conversation_allow_bot_to_bot = true;
   }