metheus-governance-mcp-cli 0.2.293 → 0.2.295

package/cli.mjs

@@ -151,6 +151,9 @@ import {
   selectPendingArchiveComments,
   printRunnerResult,
 } from "./lib/runner-helpers.mjs";
+import {
+  normalizeRunnerRecentLocalInboundReceiptMap,
+} from "./lib/runner-local-inbound-receipts.mjs";
 import {
   normalizeRunnerConversationDecisionBundle,
   validateRunnerConversationDecisionBundle,
@@ -1966,88 +1969,6 @@ function prefersRunnerStateRecord(candidate, current) {
   return false;
 }
 
-function normalizeRunnerRecentLocalInboundReceiptRecord(rawReceipt, fallbackKey = "") {
-  const receipt = safeObject(rawReceipt);
-  const chatID = String(receipt.chat_id || receipt.chatID || "").trim();
-  const messageID = intFromRawAllowZero(receipt.message_id ?? receipt.messageID, 0);
-  const receiptKey = String(fallbackKey || `${chatID}:${messageID}`).trim();
-  if (!receiptKey || !chatID || !(messageID > 0)) {
-    return null;
-  }
-  const normalized = {
-    chat_id: chatID,
-    message_id: messageID,
-    receipt_origin: firstNonEmptyString([
-      receipt.receipt_origin,
-      receipt.receiptOrigin,
-      receipt.source_origin,
-      receipt.sourceOrigin,
-      "local_telegram_inbound",
-    ]),
-    receipt_route_key: firstNonEmptyString([
-      receipt.receipt_route_key,
-      receipt.receiptRouteKey,
-      receipt.source_route_key,
-      receipt.sourceRouteKey,
-    ]),
-    receipt_bot_username: normalizeTelegramMentionUsername(
-      firstNonEmptyString([
-        receipt.receipt_bot_username,
-        receipt.receiptBotUsername,
-        receipt.source_bot_username,
-        receipt.sourceBotUsername,
-      ]),
-    ),
-    kind: firstNonEmptyString([receipt.kind, "telegram_message"]),
-    sender: firstNonEmptyString([receipt.sender, receipt.from_name, receipt.fromName]),
-    sender_username: firstNonEmptyString([
-      receipt.sender_username,
-      receipt.senderUsername,
-      receipt.from_username,
-      receipt.fromUsername,
-    ]),
-    sender_is_bot: Boolean(receipt.sender_is_bot ?? receipt.senderIsBot ?? false),
-    body: firstNonEmptyString([receipt.body, receipt.text]),
-    occurred_at: firstNonEmptyString([receipt.occurred_at, receipt.occurredAt]),
-    received_at: firstNonEmptyString([receipt.received_at, receipt.receivedAt, new Date().toISOString()]),
-  };
-  const senderID = firstNonEmptyString([receipt.sender_id, receipt.senderID, receipt.from_id, receipt.fromID]);
-  if (senderID) {
-    normalized.sender_id = senderID;
-  }
-  const updateID = intFromRawAllowZero(receipt.update_id ?? receipt.updateID, 0);
-  if (updateID > 0) {
-    normalized.update_id = updateID;
-  }
-  const messageThreadID = intFromRawAllowZero(receipt.message_thread_id ?? receipt.messageThreadID, 0);
-  if (messageThreadID > 0) {
-    normalized.message_thread_id = messageThreadID;
-  }
-  const replyToMessageID = intFromRawAllowZero(receipt.reply_to_message_id ?? receipt.replyToMessageID, 0);
-  if (replyToMessageID > 0) {
-    normalized.reply_to_message_id = replyToMessageID;
-  }
-  const chatType = firstNonEmptyString([receipt.chat_type, receipt.chatType]);
-  if (chatType) {
-    normalized.chat_type = chatType;
-  }
-  const chatTitle = firstNonEmptyString([receipt.chat_title, receipt.chatTitle]);
-  if (chatTitle) {
-    normalized.chat_title = chatTitle;
-  }
-  return [receiptKey, normalized];
-}
-
-function normalizeRunnerRecentLocalInboundReceiptMap(rawReceipts) {
-  const normalizedEntries = [];
-  for (const [key, value] of Object.entries(safeObject(rawReceipts))) {
-    const normalizedEntry = normalizeRunnerRecentLocalInboundReceiptRecord(value, key);
-    if (!normalizedEntry) continue;
-    normalizedEntries.push(normalizedEntry);
-  }
-  return Object.fromEntries(normalizedEntries);
-}
-
 function mergeRunnerStateRecords(preferred, fallback) {
   const primary = safeObject(preferred);
   const secondary = safeObject(fallback);
@@ -10711,10 +10632,10 @@ async function processRunnerRouteOnce(route, runtime, mode, options = {}) {
       latestRunnerState.consumedComments || latestRunnerState.consumed_comments,
     );
     const requests = normalizeBotRunnerRequests(latestRunnerState.requests);
-    const commentsForPending = ensureArray(comments).filter((comment) => {
-      const normalizedComment = normalizeArchiveCommentRecord(comment, parseArchivedChatComment);
-      const commentID = String(normalizedComment.id || "").trim();
-      const parsed = safeObject(normalizedComment.parsedArchive);
+    const commentsForPending = ensureArray(comments).filter((comment) => {
+      const normalizedComment = normalizeArchiveCommentRecord(comment, parseArchivedChatComment);
+      const commentID = String(normalizedComment.id || "").trim();
+      const parsed = safeObject(normalizedComment.parsedArchive);
       const commentKind = String(parsed.kind || "").trim().toLowerCase();
       if (commentID && safeObject(excludedComments)[commentID]) {
         return false;
@@ -10742,22 +10663,45 @@ async function processRunnerRouteOnce(route, runtime, mode, options = {}) {
         }
         const sessionMatch = findScopedConversationSessionState(latestRunnerState, normalizedRoute, conversationID);
         return sessionAllowsConversationResponder(sessionMatch.session, currentBotSelector);
-      }
-      return true;
-    });
+      }
+      return true;
+    });
+    const followupRequestsForPending = Object.values(requests).filter((entryRaw) => {
+      const entry = safeObject(entryRaw);
+      const nextExpectedResponders = ensureArray(entry.next_expected_responders)
+        .map((value) => normalizeTelegramMentionUsername(value))
+        .filter(Boolean);
+      if (!nextExpectedResponders.includes(currentBotSelector)) {
+        return false;
+      }
+      if (!isActiveRunnerRequestStatus(entry.status)) {
+        return false;
+      }
+      if (
+        String(entry.project_id || "").trim() !== String(normalizedRoute.projectID || "").trim()
+        || String(entry.provider || "").trim() !== String(normalizedRoute.provider || "").trim()
+        || String(entry.chat_id || "").trim() !== String(destination.chatID || "").trim()
+      ) {
+        return false;
+      }
+      const lastReplyEnvelope = safeObject(entry.last_reply_message_envelope);
+      return intFromRawAllowZero(lastReplyEnvelope.message_id || lastReplyEnvelope.messageID, 0) > 0;
+    });
     const pendingWork = selectRunnerPendingWork({
       comments: commentsForPending,
       importOutcome,
       refreshedState,
-      mode,
+      mode,
       parseArchivedChatComment,
       pendingSelectionOptions: {
         maxPendingAgeMs: BOT_RUNNER_PENDING_COMMENT_MAX_AGE_MS,
       },
-      deps: {
-        applyPendingAgeSelection,
-        normalizeArchiveCommentRecord,
-      },
+      deps: {
+        applyPendingAgeSelection,
+        normalizeArchiveCommentRecord,
+      },
+      followupRequests: followupRequestsForPending,
+      currentBotSelector,
     });
     const pending = pendingWork.pending;
     if (pending.staleSkippedLatest) {

package/lib/local-ai-adapters.mjs

@@ -2143,6 +2143,11 @@ export function buildLocalBotPrompt(payload, { terse = true } = {}) {
         "Do not mention another managed bot unless the contract explicitly names that bot in assignments or next_responders.",
         "Without a matching contract, mentioned bots will not act.",
         "When delegating to another managed bot, use contract.type=\"delegation\" with actionable=true, assignments, and next_responders.",
+        "Decision bundle consistency rules:",
+        "- If execution_contract_type is \"delegation\", conversation_intent_mode must be \"delegated_single_lead\".",
+        "- If execution_contract_type is \"delegation\", initial_responders must contain only the lead bot. Delegated target bots belong in next_expected_responders, not initial_responders.",
+        "- If multiple bots should each answer the opening human message, do not set should_close_after_reply=true on the first reply. Keep should_close_after_reply=false and list the remaining bots in next_expected_responders until the multi-bot opening is complete.",
+        "- Never combine conversation_intent_mode=\"multi_bot_direct\" with execution_contract_type=\"delegation\".",
         "Each assignment must declare whether it is a conversational contribution or a real execution task.",
         "Use assignment.mode=\"conversation_contribution\" for opinions, discussion, review, comparison, synthesis, greetings, or other room-visible contributions that do not require workspace artifacts.",
         "Use assignment.mode=\"execution_task\" only when the delegated bot must change workspace files, create artifacts, update ctxpack, or produce other concrete project outputs. If it is an execution task, also set artifacts_required=true.",

package/lib/runner-local-inbound-receipts.mjs

@@ -0,0 +1,212 @@
+import {
+  buildCanonicalHumanInboundKey,
+} from "./runner-helpers.mjs";
+
+function safeObject(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return {};
+  }
+  return value;
+}
+
+function ensureArray(value) {
+  return Array.isArray(value) ? value : [];
+}
+
+function intFromRawAllowZero(raw, fallback = 0) {
+  if (raw === null || raw === undefined || raw === "") {
+    return fallback;
+  }
+  const parsed = Number.parseInt(String(raw).trim(), 10);
+  return Number.isFinite(parsed) ? parsed : fallback;
+}
+
+function firstNonEmptyString(values) {
+  for (const value of ensureArray(values)) {
+    const normalized = String(value ?? "").trim();
+    if (normalized) return normalized;
+  }
+  return "";
+}
+
+function normalizeMentionSelector(value) {
+  return String(value || "").trim().replace(/^@+/, "").toLowerCase();
+}
+
+function buildRunnerInboundTargetSelectorSuffix(selector) {
+  const normalizedSelector = normalizeMentionSelector(selector);
+  return normalizedSelector ? `:${normalizedSelector}` : "";
+}
+
+export function buildRunnerRecentLocalInboundReceiptKey(chatID, messageID) {
+  return `${String(chatID || "").trim()}:${intFromRawAllowZero(messageID, 0)}`;
+}
+
+export function normalizeRunnerRecentLocalInboundReceiptEntry(rawReceipt, fallbackKey = "") {
+  const receipt = safeObject(rawReceipt);
+  const chatID = String(receipt.chat_id || receipt.chatID || "").trim();
+  const messageID = intFromRawAllowZero(receipt.message_id ?? receipt.messageID, 0);
+  const receiptKey = String(fallbackKey || buildRunnerRecentLocalInboundReceiptKey(chatID, messageID)).trim();
+  if (!receiptKey || !chatID || !(messageID > 0)) {
+    return null;
+  }
+  const normalized = {
+    chat_id: chatID,
+    message_id: messageID,
+    receipt_origin: firstNonEmptyString([
+      receipt.receipt_origin,
+      receipt.receiptOrigin,
+      receipt.source_origin,
+      receipt.sourceOrigin,
+      "local_telegram_inbound",
+    ]),
+    receipt_route_key: firstNonEmptyString([
+      receipt.receipt_route_key,
+      receipt.receiptRouteKey,
+      receipt.source_route_key,
+      receipt.sourceRouteKey,
+    ]),
+    receipt_bot_username: normalizeMentionSelector(
+      firstNonEmptyString([
+        receipt.receipt_bot_username,
+        receipt.receiptBotUsername,
+        receipt.source_bot_username,
+        receipt.sourceBotUsername,
+      ]),
+    ),
+    kind: firstNonEmptyString([receipt.kind, "telegram_message"]),
+    sender: firstNonEmptyString([receipt.sender, receipt.from_name, receipt.fromName]),
+    sender_username: firstNonEmptyString([
+      receipt.sender_username,
+      receipt.senderUsername,
+      receipt.from_username,
+      receipt.fromUsername,
+    ]),
+    sender_is_bot: Boolean(receipt.sender_is_bot ?? receipt.senderIsBot ?? false),
+    body: firstNonEmptyString([receipt.body, receipt.text]),
+    occurred_at: firstNonEmptyString([receipt.occurred_at, receipt.occurredAt]),
+    received_at: firstNonEmptyString([receipt.received_at, receipt.receivedAt, new Date().toISOString()]),
+  };
+  const senderID = firstNonEmptyString([receipt.sender_id, receipt.senderID, receipt.from_id, receipt.fromID]);
+  if (senderID) {
+    normalized.sender_id = senderID;
+  }
+  const updateID = intFromRawAllowZero(receipt.update_id ?? receipt.updateID, 0);
+  if (updateID > 0) {
+    normalized.update_id = updateID;
+  }
+  const messageThreadID = intFromRawAllowZero(receipt.message_thread_id ?? receipt.messageThreadID, 0);
+  if (messageThreadID > 0) {
+    normalized.message_thread_id = messageThreadID;
+  }
+  const replyToMessageID = intFromRawAllowZero(receipt.reply_to_message_id ?? receipt.replyToMessageID, 0);
+  if (replyToMessageID > 0) {
+    normalized.reply_to_message_id = replyToMessageID;
+  }
+  const replyToFromUsername = firstNonEmptyString([
+    receipt.reply_to_from_username,
+    receipt.replyToFromUsername,
+    receipt.reply_to_username,
+    receipt.replyToUsername,
+  ]);
+  if (replyToFromUsername) {
+    normalized.reply_to_from_username = replyToFromUsername;
+  }
+  if (receipt.reply_to_from_is_bot === true || receipt.replyToFromIsBot === true) {
+    normalized.reply_to_from_is_bot = true;
+  }
+  const chatType = firstNonEmptyString([receipt.chat_type, receipt.chatType]);
+  if (chatType) {
+    normalized.chat_type = chatType;
+  }
+  const chatTitle = firstNonEmptyString([receipt.chat_title, receipt.chatTitle]);
+  if (chatTitle) {
+    normalized.chat_title = chatTitle;
+  }
+  const canonicalHumanMessageKey = String(buildCanonicalHumanInboundKey({
+    chat_id: normalized.chat_id,
+    message_id: normalized.message_id,
+    message_thread_id: normalized.message_thread_id,
+    reply_to_message_id: normalized.reply_to_message_id,
+    kind: normalized.kind,
+    sender_id: normalized.sender_id,
+    sender_username: normalized.sender_username,
+    sender_is_bot: normalized.sender_is_bot === true,
+    body: normalized.body,
+    occurred_at: normalized.occurred_at,
+    canonical_human_message_key: firstNonEmptyString([
+      receipt.canonical_human_message_key,
+      receipt.canonicalHumanMessageKey,
+    ]),
+  }) || "").trim();
+  if (canonicalHumanMessageKey) {
+    normalized.canonical_human_message_key = canonicalHumanMessageKey;
+  }
+  return [receiptKey, normalized];
+}
+
+export function normalizeRunnerRecentLocalInboundReceipt(rawReceipt, fallbackKey = "") {
+  const normalizedEntry = normalizeRunnerRecentLocalInboundReceiptEntry(rawReceipt, fallbackKey);
+  return normalizedEntry ? safeObject(normalizedEntry[1]) : {};
+}
+
+export function normalizeRunnerRecentLocalInboundReceiptMap(rawReceipts) {
+  const normalizedEntries = [];
+  for (const [key, value] of Object.entries(safeObject(rawReceipts))) {
+    const normalizedEntry = normalizeRunnerRecentLocalInboundReceiptEntry(value, key);
+    if (!normalizedEntry) continue;
+    normalizedEntries.push(normalizedEntry);
+  }
+  return Object.fromEntries(normalizedEntries);
+}
+
+export function buildRunnerLocalInboundReceiptKey(receiptRaw, { resolveTargetSelector = null } = {}) {
+  const receipt = normalizeRunnerRecentLocalInboundReceipt(receiptRaw);
+  const canonicalHumanKey = String(receipt.canonical_human_message_key || "").trim();
+  if (canonicalHumanKey) {
+    return `human:${canonicalHumanKey}`;
+  }
+  const chatID = String(receipt.chat_id || "").trim();
+  const messageID = intFromRawAllowZero(receipt.message_id, 0);
+  if (!chatID || !(messageID > 0)) {
+    return "";
+  }
+  const targetSelector = typeof resolveTargetSelector === "function"
+    ? normalizeMentionSelector(resolveTargetSelector(receiptRaw))
+    : normalizeMentionSelector(receipt.receipt_bot_username || "");
+  return `${chatID}:${messageID}${buildRunnerInboundTargetSelectorSuffix(targetSelector)}`;
+}
+
+export function findRecentTelegramInboundReceipt(rawMap, {
+  chatID = "",
+  messageID = 0,
+  canonicalHumanMessageKey = "",
+} = {}) {
+  const normalizedChatID = String(chatID || "").trim();
+  const normalizedMessageID = intFromRawAllowZero(messageID, 0);
+  const normalizedCanonicalHumanMessageKey = String(canonicalHumanMessageKey || "").trim();
+  if (!normalizedChatID || (!(normalizedMessageID > 0) && !normalizedCanonicalHumanMessageKey)) {
+    return {};
+  }
+  if (normalizedMessageID > 0) {
+    const exactReceipt = normalizeRunnerRecentLocalInboundReceipt(
+      safeObject(safeObject(rawMap)[buildRunnerRecentLocalInboundReceiptKey(normalizedChatID, normalizedMessageID)]),
+    );
+    if (Object.keys(exactReceipt).length > 0) {
+      return exactReceipt;
+    }
+  }
+  if (!normalizedCanonicalHumanMessageKey) {
+    return {};
+  }
+  for (const value of Object.values(safeObject(rawMap))) {
+    const normalizedReceipt = normalizeRunnerRecentLocalInboundReceipt(value);
+    if (
+      String(normalizedReceipt.chat_id || "").trim() === normalizedChatID
+      && String(normalizedReceipt.canonical_human_message_key || "").trim() === normalizedCanonicalHumanMessageKey
+    ) {
+      return normalizedReceipt;
+    }
+  }
+  return {};
+}

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

@@ -132,6 +132,14 @@ export function validateRunnerConversationDecisionBundle(bundleRaw) {
       bundle,
     };
   }
+  if (bundle.should_close_after_reply === true && bundle.initial_responders.length > 1) {
+    return {
+      ok: false,
+      status: "contradictory_multi_initial_close_state",
+      reason: "should_close_after_reply cannot be true when multiple initial_responders are expected to answer the opening turn",
+      bundle,
+    };
+  }
   if (
     bundle.conversation_intent_mode === "single_bot"
     && bundle.allowed_responders.length > 1
@@ -154,6 +162,28 @@ export function validateRunnerConversationDecisionBundle(bundleRaw) {
       bundle,
     };
   }
+  if (
+    bundle.conversation_intent_mode === "delegated_single_lead"
+    && bundle.initial_responders.length !== 1
+  ) {
+    return {
+      ok: false,
+      status: "invalid_delegated_single_lead_initial_responders",
+      reason: "delegated_single_lead requires exactly one initial responder",
+      bundle,
+    };
+  }
+  if (
+    bundle.execution_contract_type === "delegation"
+    && bundle.conversation_intent_mode === "multi_bot_direct"
+  ) {
+    return {
+      ok: false,
+      status: "contradictory_delegation_intent_mode",
+      reason: "multi_bot_direct cannot be combined with a delegation contract",
+      bundle,
+    };
+  }
   if (bundle.visible_handoff_required === true && bundle.visible_handoff_targets.length === 0) {
     return {
       ok: false,