metheus-governance-mcp-cli 0.2.295 → 0.2.298

package/cli.mjs

@@ -3874,68 +3874,83 @@ function runnerRequestAuthoritativeDecisionBundle(entryRaw) {
 function runnerRequestPreferredExecutionContractType(entryRaw) {
   const entry = safeObject(entryRaw);
   const decisionBundle = runnerRequestAuthoritativeDecisionBundle(entry);
+  const hasAuthoritativeDecisionBundle = Object.keys(decisionBundle).length > 0;
   return String(
-    decisionBundle.execution_contract_type
+    (hasAuthoritativeDecisionBundle
+      ? decisionBundle.execution_contract_type
+      : "")
       || entry.execution_contract_type
       || entry.root_execution_contract_type
       || "",
   ).trim().toLowerCase();
 }
-
+
 function runnerRequestPreferredExecutionContractActionable(entryRaw) {
   const entry = safeObject(entryRaw);
   const decisionBundle = runnerRequestAuthoritativeDecisionBundle(entry);
-  return decisionBundle.execution_contract_actionable === true || entry.execution_contract_actionable === true;
+  const hasAuthoritativeDecisionBundle = Object.keys(decisionBundle).length > 0;
+  if (hasAuthoritativeDecisionBundle) {
+    return decisionBundle.execution_contract_actionable === true;
+  }
+  return entry.execution_contract_actionable === true;
 }
 
 function runnerRequestPreferredExecutionContractTargets(entryRaw) {
   const entry = safeObject(entryRaw);
   const decisionBundle = runnerRequestAuthoritativeDecisionBundle(entry);
+  const hasAuthoritativeDecisionBundle = Object.keys(decisionBundle).length > 0;
   return uniqueOrderedStrings(
-    ensureArray(decisionBundle.execution_contract_targets).length
+    hasAuthoritativeDecisionBundle
       ? decisionBundle.execution_contract_targets
       : ensureArray(entry.execution_contract_targets).length
-      ? entry.execution_contract_targets
-      : ensureArray(entry.root_execution_contract_targets).length
-        ? entry.root_execution_contract_targets
-        : [],
+        ? entry.execution_contract_targets
+        : ensureArray(entry.root_execution_contract_targets).length
+          ? entry.root_execution_contract_targets
+          : [],
     normalizeTelegramMentionUsername,
   );
 }
-
+
 function runnerRequestPreferredNextExpectedResponders(entryRaw) {
   const entry = safeObject(entryRaw);
   const decisionBundle = runnerRequestAuthoritativeDecisionBundle(entry);
+  const hasAuthoritativeDecisionBundle = Object.keys(decisionBundle).length > 0;
   return uniqueOrderedStrings(
-    ensureArray(decisionBundle.next_expected_responders).length
+    hasAuthoritativeDecisionBundle
       ? decisionBundle.next_expected_responders
       : ensureArray(entry.next_expected_responders).length
-      ? entry.next_expected_responders
-      : ensureArray(entry.root_next_expected_responders).length
-        ? entry.root_next_expected_responders
-        : [],
+        ? entry.next_expected_responders
+        : ensureArray(entry.root_next_expected_responders).length
+          ? entry.root_next_expected_responders
+          : [],
     normalizeTelegramMentionUsername,
   );
 }
-
+
 function runnerRequestPreferredAuthoritySelectedBotUsernames(entryRaw) {
   const entry = safeObject(entryRaw);
+  const decisionBundle = runnerRequestAuthoritativeDecisionBundle(entry);
+  const hasAuthoritativeDecisionBundle = Object.keys(decisionBundle).length > 0;
   const normalizedSummaryBot = normalizeTelegramMentionUsername(entry.conversation_summary_bot);
   return uniqueOrderedStrings(
-    runnerRequestPreferredNextExpectedResponders(entry).length
-      ? runnerRequestPreferredNextExpectedResponders(entry)
-      : runnerRequestPreferredExecutionContractTargets(entry).length
-        ? runnerRequestPreferredExecutionContractTargets(entry)
-        : ensureArray(entry.selected_bot_usernames).length
-          ? entry.selected_bot_usernames
-          : ensureArray(entry.conversation_initial_responders).length
-            ? entry.conversation_initial_responders
-            : normalizedSummaryBot
-              ? [normalizedSummaryBot]
-              : [],
-    normalizeTelegramMentionUsername,
-  );
-}
+    runnerRequestPreferredNextExpectedResponders(entry).length
+      ? runnerRequestPreferredNextExpectedResponders(entry)
+      : runnerRequestPreferredExecutionContractTargets(entry).length
+        ? runnerRequestPreferredExecutionContractTargets(entry)
+        : hasAuthoritativeDecisionBundle && ensureArray(decisionBundle.selected_bot_usernames).length
+          ? decisionBundle.selected_bot_usernames
+          : hasAuthoritativeDecisionBundle && ensureArray(decisionBundle.initial_responders).length
+            ? decisionBundle.initial_responders
+            : ensureArray(entry.selected_bot_usernames).length
+              ? entry.selected_bot_usernames
+              : ensureArray(entry.conversation_initial_responders).length
+                ? entry.conversation_initial_responders
+                : normalizedSummaryBot
+                  ? [normalizedSummaryBot]
+                  : [],
+    normalizeTelegramMentionUsername,
+  );
+}
 
 function extractRunnerExplicitSelectedBotUsernamesFromParsed(parsedArchiveRaw) {
   const parsedArchive = safeObject(parsedArchiveRaw);
@@ -3956,6 +3971,8 @@ function runnerRequestAllowsSharedHumanClaimTakeover({
   canonicalHumanMessageKey = "",
 }) {
   const entry = safeObject(entryRaw);
+  const decisionBundle = runnerRequestAuthoritativeDecisionBundle(entry);
+  const hasAuthoritativeDecisionBundle = Object.keys(decisionBundle).length > 0;
   const normalizedCurrentBotUsername = normalizeTelegramMentionUsername(currentBotUsername);
   const normalizedCanonicalHumanMessageKey = String(canonicalHumanMessageKey || "").trim();
   if (!normalizedCurrentBotUsername || !normalizedCanonicalHumanMessageKey) {
@@ -3969,11 +3986,17 @@ function runnerRequestAllowsSharedHumanClaimTakeover({
     return pendingResponders.includes(normalizedCurrentBotUsername);
   }
   const directHumanResponders = uniqueOrderedStrings(
-    [
-      ...ensureArray(entry.selected_bot_usernames),
-      ...ensureArray(entry.conversation_initial_responders),
-      ...ensureArray(entry.conversation_allowed_responders),
-    ],
+    hasAuthoritativeDecisionBundle
+      ? [
+        ...ensureArray(decisionBundle.selected_bot_usernames),
+        ...ensureArray(decisionBundle.initial_responders),
+        ...ensureArray(decisionBundle.allowed_responders),
+      ]
+      : [
+        ...ensureArray(entry.selected_bot_usernames),
+        ...ensureArray(entry.conversation_initial_responders),
+        ...ensureArray(entry.conversation_allowed_responders),
+      ],
     normalizeTelegramMentionUsername,
   );
   return directHumanResponders.includes(normalizedCurrentBotUsername);
@@ -7096,18 +7119,30 @@ function mergeRunnerRequestForServerHydration(localEntryRaw, serverEntryRaw) {
       merged[fieldName] = localValue;
     }
   };
-  const preserveLocalArrayWhenServerEmpty = (fieldName) => {
-    const serverValues = ensureArray(serverEntry[fieldName]).filter(Boolean);
-    const localValues = ensureArray(localEntry[fieldName]).filter(Boolean);
-    if (serverValues.length === 0 && localValues.length > 0) {
-      merged[fieldName] = localValues;
-    }
-  };
-  const preserveLocalObjectWhenServerBlank = (fieldName) => {
-    const serverValue = safeObject(serverEntry[fieldName]);
-    const localValue = safeObject(localEntry[fieldName]);
-    if (!Object.keys(serverValue).length && Object.keys(localValue).length) {
-      merged[fieldName] = localValue;
+  const preserveLocalArrayWhenServerEmpty = (fieldName) => {
+    const serverValues = ensureArray(serverEntry[fieldName]).filter(Boolean);
+    const localValues = ensureArray(localEntry[fieldName]).filter(Boolean);
+    if (serverValues.length === 0 && localValues.length > 0) {
+      merged[fieldName] = localValues;
+    }
+  };
+  const clearMergedStringWhenServerBlank = (fieldName) => {
+    const serverValue = String(serverEntry[fieldName] || "").trim();
+    if (!serverValue) {
+      delete merged[fieldName];
+    }
+  };
+  const clearMergedArrayWhenServerEmpty = (fieldName) => {
+    const serverValues = ensureArray(serverEntry[fieldName]).filter(Boolean);
+    if (serverValues.length === 0) {
+      delete merged[fieldName];
+    }
+  };
+  const preserveLocalObjectWhenServerBlank = (fieldName) => {
+    const serverValue = safeObject(serverEntry[fieldName]);
+    const localValue = safeObject(localEntry[fieldName]);
+    if (!Object.keys(serverValue).length && Object.keys(localValue).length) {
+      merged[fieldName] = localValue;
     }
   };
   preserveLocalNumberWhenServerMissing("source_message_id");
@@ -7136,16 +7171,13 @@ function mergeRunnerRequestForServerHydration(localEntryRaw, serverEntryRaw) {
   preserveLocalStringWhenServerBlank("root_thread_id");
   preserveLocalStringWhenServerBlank("root_work_item_created_at");
   preserveLocalStringWhenServerBlank("root_work_item_last_error");
-  preserveLocalStringWhenServerBlank("root_execution_contract_type");
-  preserveLocalStringWhenServerBlank("root_ai_reply_preview");
-  preserveLocalStringWhenServerBlank("root_response_contract_validation_status");
-  preserveLocalStringWhenServerBlank("root_response_contract_validation_reason");
-  preserveLocalStringWhenServerBlank("followup_ai_reply_preview");
-  preserveLocalStringWhenServerBlank("followup_execution_contract_type");
-  preserveLocalStringWhenServerBlank("followup_normalized_execution_contract_type");
-  preserveLocalStringWhenServerBlank("followup_response_contract_validation_status");
-  preserveLocalStringWhenServerBlank("followup_response_contract_validation_reason");
-  preserveLocalStringWhenServerBlank("followup_assignment_validation_status");
+  preserveLocalStringWhenServerBlank("root_ai_reply_preview");
+  preserveLocalStringWhenServerBlank("root_response_contract_validation_status");
+  preserveLocalStringWhenServerBlank("root_response_contract_validation_reason");
+  preserveLocalStringWhenServerBlank("followup_ai_reply_preview");
+  preserveLocalStringWhenServerBlank("followup_response_contract_validation_status");
+  preserveLocalStringWhenServerBlank("followup_response_contract_validation_reason");
+  preserveLocalStringWhenServerBlank("followup_assignment_validation_status");
   preserveLocalStringWhenServerBlank("followup_assignment_validation_reason");
   preserveLocalStringWhenServerBlank("followup_delivery_status");
   preserveLocalStringWhenServerBlank("followup_archive_status");
@@ -7154,24 +7186,23 @@ function mergeRunnerRequestForServerHydration(localEntryRaw, serverEntryRaw) {
   preserveLocalArrayWhenServerEmpty("conversation_participants");
   preserveLocalArrayWhenServerEmpty("conversation_initial_responders");
   preserveLocalArrayWhenServerEmpty("conversation_allowed_responders");
-  preserveLocalArrayWhenServerEmpty("execution_contract_targets");
-  preserveLocalArrayWhenServerEmpty("next_expected_responders");
-  preserveLocalArrayWhenServerEmpty("normalized_execution_contract_targets");
-  preserveLocalArrayWhenServerEmpty("normalized_execution_next_responders");
-  preserveLocalArrayWhenServerEmpty("root_execution_contract_targets");
-  preserveLocalArrayWhenServerEmpty("root_next_expected_responders");
-  preserveLocalArrayWhenServerEmpty("root_response_contract_validation_targets");
-  preserveLocalArrayWhenServerEmpty("followup_execution_contract_targets");
-  preserveLocalArrayWhenServerEmpty("followup_next_expected_responders");
-  preserveLocalArrayWhenServerEmpty("followup_normalized_execution_contract_targets");
-  preserveLocalArrayWhenServerEmpty("followup_normalized_execution_next_responders");
+  preserveLocalArrayWhenServerEmpty("root_response_contract_validation_targets");
   preserveLocalArrayWhenServerEmpty("followup_response_contract_validation_targets");
   preserveLocalArrayWhenServerEmpty("followup_assignment_validation_modes");
   preserveLocalObjectWhenServerBlank("authoritative_decision_bundle");
   preserveLocalObjectWhenServerBlank("reply_chain_context");
-  if (serverEntry.conversation_allow_bot_to_bot !== true && localEntry.conversation_allow_bot_to_bot === true) {
-    merged.conversation_allow_bot_to_bot = true;
-  }
+  clearMergedStringWhenServerBlank("root_execution_contract_type");
+  clearMergedArrayWhenServerEmpty("root_execution_contract_targets");
+  clearMergedArrayWhenServerEmpty("root_next_expected_responders");
+  clearMergedStringWhenServerBlank("followup_execution_contract_type");
+  clearMergedStringWhenServerBlank("followup_normalized_execution_contract_type");
+  clearMergedArrayWhenServerEmpty("followup_execution_contract_targets");
+  clearMergedArrayWhenServerEmpty("followup_next_expected_responders");
+  clearMergedArrayWhenServerEmpty("followup_normalized_execution_contract_targets");
+  clearMergedArrayWhenServerEmpty("followup_normalized_execution_next_responders");
+  if (serverEntry.conversation_allow_bot_to_bot !== true && localEntry.conversation_allow_bot_to_bot === true) {
+    merged.conversation_allow_bot_to_bot = true;
+  }
   if (serverEntry.execution_contract_actionable !== true && localEntry.execution_contract_actionable === true) {
     merged.execution_contract_actionable = true;
   }

package/lib/runner-orchestration-adjudication.mjs

@@ -6,6 +6,10 @@ import {
 } from "./runner-orchestration-visibility.mjs";
 import {
   resolveRunnerConversationDecisionBundle,
+  deriveRunnerConversationContinuationKind,
+  normalizeRunnerConversationDecisionBundle,
+  resolveRunnerConversationDecisionBundleCurrentTurnResponders,
+  validateRunnerConversationDecisionBundle,
 } from "./runner-orchestration-decision-bundle.mjs";
 
 function safeObject(value) {
@@ -75,6 +79,36 @@ function isRunnerBotReplyContinuationAuthorizedForCurrentBot({
   if (normalizedSenderSelectors.includes(normalizedCurrentBotSelector)) {
     return false;
   }
+  const parsedAuthoritativeDecisionBundle = safeObject(parsed.authoritativeDecisionBundle);
+  const requestAuthoritativeDecisionBundle = safeObject(safeObject(persistedRequest).authoritative_decision_bundle);
+  const parsedAuthoritativeDecisionBundleValidation = Object.keys(parsedAuthoritativeDecisionBundle).length > 0
+    ? validateRunnerConversationDecisionBundle(parsedAuthoritativeDecisionBundle)
+    : null;
+  const requestAuthoritativeDecisionBundleValidation = Object.keys(requestAuthoritativeDecisionBundle).length > 0
+    ? validateRunnerConversationDecisionBundle(requestAuthoritativeDecisionBundle)
+    : null;
+  const authoritativeDecisionBundle = parsedAuthoritativeDecisionBundleValidation?.ok
+    ? parsedAuthoritativeDecisionBundleValidation.bundle
+    : requestAuthoritativeDecisionBundleValidation?.ok
+      ? requestAuthoritativeDecisionBundleValidation.bundle
+      : {};
+  if (Object.keys(authoritativeDecisionBundle).length > 0) {
+    const continuationKind = deriveRunnerConversationContinuationKind(authoritativeDecisionBundle);
+    const currentTurnResponders = resolveRunnerConversationDecisionBundleCurrentTurnResponders(
+      authoritativeDecisionBundle,
+      normalizedCurrentBotSelector,
+    );
+    if (currentTurnResponders.includes(normalizedCurrentBotSelector)) {
+      return true;
+    }
+    if (continuationKind === "public_multi_bot_followup") {
+      return ensureArray(authoritativeDecisionBundle.next_expected_responders).includes(normalizedCurrentBotSelector);
+    }
+    if (continuationKind === "delegation_followup") {
+      return ensureArray(authoritativeDecisionBundle.execution_contract_targets).includes(normalizedCurrentBotSelector)
+        || ensureArray(authoritativeDecisionBundle.next_expected_responders).includes(normalizedCurrentBotSelector);
+    }
+  }
   const explicitReplyTargets = ensureArray([
     ...(Array.isArray(parsed.mentionUsernames) ? parsed.mentionUsernames : []),
     parsed.replyToBotUsername,
@@ -87,11 +121,7 @@ function isRunnerBotReplyContinuationAuthorizedForCurrentBot({
   if (explicitReplyTargets.includes(normalizedCurrentBotSelector)) {
     return true;
   }
-  const request = safeObject(persistedRequest);
-  const nextExpectedResponders = ensureArray(request.next_expected_responders)
-    .map((value) => normalizeMentionSelector(value))
-    .filter(Boolean);
-  return nextExpectedResponders.includes(normalizedCurrentBotSelector);
+  return false;
 }
 
 export async function resolveRunnerPrecomputedResponderAdjudication({

package/lib/runner-orchestration-decision-bundle.mjs

@@ -44,6 +44,23 @@ function normalizeBoolean(value, fallback = false) {
   return fallback;
 }
 
+function intFromRawAllowZero(raw, fallback = 0) {
+  const text = String(raw ?? "").trim();
+  if (!text) {
+    return fallback;
+  }
+  const parsed = Number.parseInt(text, 10);
+  return Number.isFinite(parsed) ? parsed : fallback;
+}
+
+function normalizeContinuationKind(value) {
+  return String(value || "").trim().toLowerCase();
+}
+
+function normalizeReplyAnchorKind(value) {
+  return String(value || "").trim().toLowerCase();
+}
+
 function normalizeContractAssignments(assignmentsRaw) {
   return uniqueOrderedSelectors(
     ensureArray(assignmentsRaw).map((item) => {
@@ -70,6 +87,24 @@ export function normalizeRunnerConversationDecisionBundle(bundleRaw) {
       ? bundle.selected_bot_usernames
       : initialResponders,
   );
+  const replyToMessageID = intFromRawAllowZero(
+    bundle.reply_to_message_id
+      || bundle.replyToMessageID,
+    0,
+  );
+  const replyAnchorSource = String(
+    bundle.reply_anchor_source
+      || bundle.replyAnchorSource
+      || "",
+  ).trim().toLowerCase();
+  const replyAnchorKind = normalizeReplyAnchorKind(
+    bundle.reply_anchor_kind
+      || bundle.replyAnchorKind,
+  );
+  const continuationKind = normalizeContinuationKind(
+    bundle.continuation_kind
+      || bundle.continuationKind,
+  );
   return {
     schema_version: String(bundle.schema_version || "runner_conversation_decision.v1").trim(),
     decision_type: String(bundle.decision_type || "unspecified").trim().toLowerCase(),
@@ -87,6 +122,10 @@ export function normalizeRunnerConversationDecisionBundle(bundleRaw) {
     execution_contract_actionable: normalizeBoolean(bundle.execution_contract_actionable, false),
     execution_contract_targets: executionContractTargets,
     next_expected_responders: nextExpectedResponders,
+    reply_to_message_id: replyToMessageID > 0 ? replyToMessageID : 0,
+    reply_anchor_source: replyAnchorSource,
+    reply_anchor_kind: replyAnchorKind,
+    continuation_kind: continuationKind,
     should_close_after_reply: typeof bundle.should_close_after_reply === "boolean"
       ? bundle.should_close_after_reply
       : false,
@@ -98,6 +137,59 @@ export function normalizeRunnerConversationDecisionBundle(bundleRaw) {
   };
 }
 
+export function deriveRunnerConversationContinuationKind(bundleRaw) {
+  const bundle = normalizeRunnerConversationDecisionBundle(bundleRaw);
+  if (bundle.continuation_kind) {
+    return bundle.continuation_kind;
+  }
+  if (bundle.execution_contract_type === "delegation" && (
+    bundle.execution_contract_targets.length > 0
+    || bundle.next_expected_responders.length > 0
+  )) {
+    return "delegation_followup";
+  }
+  if (bundle.conversation_intent_mode === "multi_bot_direct" && bundle.next_expected_responders.length > 0) {
+    return "public_multi_bot_followup";
+  }
+  if (bundle.allow_bot_to_bot === true && bundle.next_expected_responders.length > 0) {
+    return "relay_followup";
+  }
+  return "";
+}
+
+export function resolveRunnerConversationDecisionBundleReplyAnchor(bundleRaw) {
+  const bundle = normalizeRunnerConversationDecisionBundle(bundleRaw);
+  return {
+    replyToMessageID: intFromRawAllowZero(bundle.reply_to_message_id, 0),
+    replyAnchorSource: String(bundle.reply_anchor_source || "").trim().toLowerCase(),
+    replyAnchorKind: normalizeReplyAnchorKind(bundle.reply_anchor_kind),
+  };
+}
+
+export function resolveRunnerConversationDecisionBundleCurrentTurnResponders(bundleRaw, currentBotSelector = "") {
+  const bundle = normalizeRunnerConversationDecisionBundle(bundleRaw);
+  const normalizedCurrentBotSelector = normalizeMentionSelector(currentBotSelector);
+  const continuationKind = deriveRunnerConversationContinuationKind(bundle);
+  const candidateResponders = uniqueOrderedSelectors(
+    ensureArray(bundle.next_expected_responders).length
+      ? bundle.next_expected_responders
+      : ensureArray(bundle.execution_contract_targets).length
+        ? bundle.execution_contract_targets
+        : bundle.selected_bot_usernames,
+  );
+  if (!normalizedCurrentBotSelector) {
+    return continuationKind ? candidateResponders : bundle.selected_bot_usernames;
+  }
+  if (continuationKind) {
+    return candidateResponders.includes(normalizedCurrentBotSelector)
+      ? [normalizedCurrentBotSelector]
+      : [];
+  }
+  return bundle.selected_bot_usernames.includes(normalizedCurrentBotSelector)
+    ? [normalizedCurrentBotSelector]
+    : [];
+}
+
 export function validateRunnerConversationDecisionBundle(bundleRaw) {
   const bundle = normalizeRunnerConversationDecisionBundle(bundleRaw);
   if (!Object.keys(safeObject(bundleRaw)).length) {
@@ -184,6 +276,14 @@ export function validateRunnerConversationDecisionBundle(bundleRaw) {
       bundle,
     };
   }
+  if (!(bundle.reply_to_message_id > 0) && (bundle.reply_anchor_source || bundle.reply_anchor_kind)) {
+    return {
+      ok: false,
+      status: "invalid_reply_anchor_without_message_id",
+      reason: "reply anchor metadata requires reply_to_message_id",
+      bundle,
+    };
+  }
   if (bundle.visible_handoff_required === true && bundle.visible_handoff_targets.length === 0) {
     return {
       ok: false,
@@ -212,6 +312,9 @@ export function buildRunnerConversationDecisionBundle({
   normalizedExecutionContractType = "",
   normalizedExecutionTargets = [],
   normalizedExecutionNextResponders = [],
+  replyToMessageID = 0,
+  replyAnchorSource = "",
+  replyAnchorKind = "",
   shouldCloseAfterReply,
   reasoningSummary = "",
 }) {
@@ -270,6 +373,9 @@ export function buildRunnerConversationDecisionBundle({
     execution_contract_actionable: contract.actionable === true,
     execution_contract_targets: ensureArray(normalizedExecutionTargets),
     next_expected_responders: ensureArray(normalizedExecutionNextResponders),
+    reply_to_message_id: intFromRawAllowZero(replyToMessageID, 0) || undefined,
+    reply_anchor_source: String(replyAnchorSource || "").trim().toLowerCase(),
+    reply_anchor_kind: normalizeReplyAnchorKind(replyAnchorKind),
     should_close_after_reply: typeof shouldCloseAfterReply === "boolean"
       ? shouldCloseAfterReply
       : undefined,