metheus-governance-mcp-cli 0.2.218 → 0.2.220

package/cli.mjs

@@ -184,6 +184,7 @@ import {
   runRunnerAIExecution,
 } from "./lib/runner-execution.mjs";
 import {
+  buildRunnerResponderAdjudicationFromHumanIntent,
   processRunnerSelectedRecord,
   resolveHumanIntentContext,
   resolveRunnerResponderAdjudication,
@@ -8287,7 +8288,31 @@ async function processRunnerRouteOnce(route, runtime, mode, options = {}) {
           executionPlan,
           deps: routingExecutionDeps,
         });
-        const adjudication = await resolveRunnerResponderAdjudication({
+        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,
@@ -8540,7 +8565,31 @@ async function processRunnerRouteOnce(route, runtime, mode, options = {}) {
         executionPlan,
         deps: routingExecutionDeps,
       });
-      const inlineAdjudication = await resolveRunnerResponderAdjudication({
+      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 precomputedInlineAdjudication = buildRunnerResponderAdjudicationFromHumanIntent({
+        selectedRecord,
+        normalizedRoute,
+        bot,
+        deps: routingExecutionDeps,
+        precomputedHumanIntent: safeObject(sharedHumanIntentContext).humanIntent || null,
+      });
+      const inlineAdjudication = precomputedInlineAdjudication || await resolveRunnerResponderAdjudication({
         selectedRecord,
         pendingOrdered: pending.ordered,
         normalizedRoute,

package/lib/runner-orchestration.mjs

@@ -1310,6 +1310,7 @@ function buildDirectHumanResponseContract({
   conversationContext,
   currentBotSelector,
 }) {
+  void currentBotSelector;
   const humanIntent = safeObject(humanIntentContext?.humanIntent);
   const conversation = safeObject(conversationContext);
   const preferConversationContract = Boolean(
@@ -1320,8 +1321,7 @@ function buildDirectHumanResponseContract({
     || String(conversation.summaryBotUsername || "").trim()
     || String(conversation.replyExpectation || "").trim(),
   );
-  const source = preferConversationContract ? conversation : humanIntent;
-  const secondary = preferConversationContract ? humanIntent : conversation;
+  const source = safeObject(preferConversationContract ? conversation : humanIntent);
   const normalizedAllowedResponderSelectors = uniqueOrdered(
     ensureArray(source.allowedResponderSelectors)
       .map((item) => normalizeMentionSelector(item))
@@ -1332,35 +1332,29 @@ function buildDirectHumanResponseContract({
       .map((item) => normalizeMentionSelector(item))
       .filter(Boolean),
   );
-  const intentMode = String(source.intentMode || secondary.intentMode || "").trim();
-  const allowBotToBot = source.allowBotToBot === true
-    || (source.allowBotToBot !== false && secondary.allowBotToBot === true);
+  const intentMode = String(source.intentMode || "").trim();
+  const allowBotToBot = source.allowBotToBot === true;
   const leadBotSelector = normalizeMentionSelector(
-    source.leadBotUsername || source.leadBotSelector || secondary.leadBotUsername || secondary.leadBotSelector,
+    source.leadBotUsername || source.leadBotSelector,
   );
   const summaryBotSelector = normalizeMentionSelector(
-    source.summaryBotUsername || source.summaryBotSelector || secondary.summaryBotUsername || secondary.summaryBotSelector,
+    source.summaryBotUsername || source.summaryBotSelector,
   );
   const replyExpectation = normalizeReplyExpectation(
-    source.replyExpectation || secondary.replyExpectation,
+    source.replyExpectation,
     "",
   );
   const intentType = normalizeHumanIntentType(
-    source.intentType || secondary.intentType,
+    source.intentType,
     "",
   );
   const allowedContractTypes = uniqueOrdered(
-    ensureArray(source.allowedContractTypes || secondary.allowedContractTypes)
+    ensureArray(source.allowedContractTypes)
       .map((item) => String(item || "").trim().toLowerCase())
       .filter(Boolean),
   );
   const requiresActionableContract = source.requiresActionableContract === true
-    || source.require_actionable_contract === true
-    || (
-      source.requiresActionableContract !== false
-      && source.require_actionable_contract !== false
-      && (secondary.requiresActionableContract === true || secondary.require_actionable_contract === true)
-    );
+    || source.require_actionable_contract === true;
   return {
     intentMode,
     allowBotToBot,
@@ -4285,17 +4279,20 @@ export async function resolveRunnerResponderAdjudication({
     ? deps.adjudicateRunnerRespondersWithAI
     : null;
   const promise = (async () => {
-  const managedBots = buildResponderAdjudicationManagedBots({
+    const managedBots = buildResponderAdjudicationManagedBots({
       selectedRecord,
       normalizedRoute,
       bot,
       deps,
     });
-    const managedBotSelectors = new Set(
-      managedBots
-        .map((entry) => normalizeMentionSelector(entry.username))
-        .filter(Boolean),
-    );
+    const contractAdjudication = buildRunnerResponderAdjudicationFromHumanIntent({
+      selectedRecord,
+      managedBots,
+      precomputedHumanIntent,
+    });
+    if (contractAdjudication) {
+      return contractAdjudication;
+    }
     const triggerFacts = {
       message_kind: String(safeObject(selectedRecord?.parsedArchive).kind || "").trim(),
       chat_type: String(safeObject(selectedRecord?.parsedArchive).chatType || "").trim(),
@@ -4311,60 +4308,6 @@ export async function resolveRunnerResponderAdjudication({
         trigger_reason: String(entry.trigger_reason || "").trim(),
       })),
     };
-    const humanIntent = safeObject(precomputedHumanIntent);
-    const contractInitialResponders = uniqueOrdered(
-      ensureArray(humanIntent.initialResponderSelectors)
-        .map((value) => normalizeMentionSelector(value))
-        .filter((value) => value && managedBotSelectors.has(value)),
-    );
-    const contractAllowedResponders = uniqueOrdered(
-      ensureArray(humanIntent.allowedResponderSelectors)
-        .map((value) => normalizeMentionSelector(value))
-        .filter((value) => value && managedBotSelectors.has(value)),
-    );
-    const contractParticipants = uniqueOrdered(
-      ensureArray(humanIntent.participantSelectors)
-        .map((value) => normalizeMentionSelector(value))
-        .filter((value) => value && managedBotSelectors.has(value)),
-    );
-    const contractLeadBot = normalizeMentionSelector(humanIntent.leadBotSelector);
-    const selectedFromContract = uniqueOrdered(
-      (
-        contractInitialResponders.length
-          ? contractInitialResponders
-          : contractAllowedResponders.length
-            ? contractAllowedResponders
-            : contractParticipants.length
-              ? contractParticipants
-              : contractLeadBot && managedBotSelectors.has(contractLeadBot)
-                ? [contractLeadBot]
-                : []
-      ).filter(Boolean),
-    );
-    if (selectedFromContract.length > 0) {
-      return {
-        decision: selectedFromContract.length > 1 ? "multiple_responders" : "single_responder",
-        selected_bot_usernames: selectedFromContract,
-        referenced_bot_usernames: triggerFacts.mentioned_bot_usernames,
-        confidence: "high",
-        reason_code: "precomputed_human_intent_contract",
-        clarification: "",
-        managed_bots: managedBots,
-      };
-    }
-    if (hasHumanIntentContractSignals(humanIntent)) {
-      return {
-        decision: "no_responder",
-        selected_bot_usernames: [],
-        referenced_bot_usernames: triggerFacts.mentioned_bot_usernames,
-        confidence: "high",
-        reason_code: isCompleteHumanIntentContract(humanIntent)
-          ? "precomputed_human_intent_contract_no_responder"
-          : "incomplete_human_intent_contract",
-        clarification: "",
-        managed_bots: managedBots,
-      };
-    }
     if (!adjudicator) {
       const fallbackSelected = managedBots
         .filter((entry) => entry.trigger_eligible === true)
@@ -4422,6 +4365,90 @@ export async function resolveRunnerResponderAdjudication({
   runnerResponderAdjudicationPromises.set(cacheKey, promise);
   return promise;
 }
+
+export function buildRunnerResponderAdjudicationFromHumanIntent({
+  selectedRecord,
+  managedBots = [],
+  normalizedRoute = null,
+  bot = null,
+  deps = null,
+  precomputedHumanIntent = null,
+}) {
+  const humanIntent = safeObject(precomputedHumanIntent);
+  if (!hasHumanIntentContractSignals(humanIntent)) {
+    return null;
+  }
+  const fallbackManagedBots = ensureArray(managedBots).length
+    ? managedBots
+    : buildResponderAdjudicationManagedBots({
+      selectedRecord,
+      normalizedRoute,
+      bot,
+      deps,
+    });
+  const normalizedManagedBots = ensureArray(fallbackManagedBots)
+    .map((entry) => safeObject(entry))
+    .filter((entry) => normalizeMentionSelector(entry.username));
+  const managedBotSelectors = new Set(
+    normalizedManagedBots
+      .map((entry) => normalizeMentionSelector(entry.username))
+      .filter(Boolean),
+  );
+  const referencedBotUsernames = ensureArray(safeObject(selectedRecord?.parsedArchive).mentionUsernames)
+    .map((value) => normalizeMentionSelector(value))
+    .filter(Boolean);
+  const contractInitialResponders = uniqueOrdered(
+    ensureArray(humanIntent.initialResponderSelectors)
+      .map((value) => normalizeMentionSelector(value))
+      .filter((value) => value && managedBotSelectors.has(value)),
+  );
+  const contractAllowedResponders = uniqueOrdered(
+    ensureArray(humanIntent.allowedResponderSelectors)
+      .map((value) => normalizeMentionSelector(value))
+      .filter((value) => value && managedBotSelectors.has(value)),
+  );
+  const contractParticipants = uniqueOrdered(
+    ensureArray(humanIntent.participantSelectors)
+      .map((value) => normalizeMentionSelector(value))
+      .filter((value) => value && managedBotSelectors.has(value)),
+  );
+  const contractLeadBot = normalizeMentionSelector(humanIntent.leadBotSelector);
+  const selectedFromContract = uniqueOrdered(
+    (
+      contractInitialResponders.length
+        ? contractInitialResponders
+        : contractAllowedResponders.length
+          ? contractAllowedResponders
+          : contractParticipants.length
+            ? contractParticipants
+            : contractLeadBot && managedBotSelectors.has(contractLeadBot)
+              ? [contractLeadBot]
+              : []
+    ).filter(Boolean),
+  );
+  if (selectedFromContract.length > 0) {
+    return {
+      decision: selectedFromContract.length > 1 ? "multiple_responders" : "single_responder",
+      selected_bot_usernames: selectedFromContract,
+      referenced_bot_usernames: referencedBotUsernames,
+      confidence: "high",
+      reason_code: "precomputed_human_intent_contract",
+      clarification: "",
+      managed_bots: normalizedManagedBots,
+    };
+  }
+  return {
+    decision: "no_responder",
+    selected_bot_usernames: [],
+    referenced_bot_usernames: referencedBotUsernames,
+    confidence: "high",
+    reason_code: isCompleteHumanIntentContract(humanIntent)
+      ? "precomputed_human_intent_contract_no_responder"
+      : "incomplete_human_intent_contract",
+    clarification: "",
+    managed_bots: normalizedManagedBots,
+  };
+}
 
 export function selectRunnerPendingWork({
   comments,
@@ -4582,17 +4609,29 @@ export async function processRunnerSelectedRecord({
   const normalizedPrecomputedHumanIntent = safeObject(
     resolvedPreAdjudicationHumanIntentContext?.humanIntent || normalizedPrecomputedHumanIntentContext.humanIntent,
   );
-  const responderAdjudication = Object.keys(safeObject(precomputedResponderAdjudication)).length > 0
-    ? safeObject(precomputedResponderAdjudication)
-    : await resolveRunnerResponderAdjudication({
+  const precomputedResponderSelection = buildRunnerResponderAdjudicationFromHumanIntent({
+    selectedRecord,
+    managedBots: buildResponderAdjudicationManagedBots({
       selectedRecord,
-      pendingOrdered,
       normalizedRoute,
       bot,
-      executionPlan,
       deps: executionDeps,
-      precomputedHumanIntent: normalizedPrecomputedHumanIntent,
-    });
+    }),
+    precomputedHumanIntent: normalizedPrecomputedHumanIntent,
+  });
+  const responderAdjudication = Object.keys(safeObject(precomputedResponderAdjudication)).length > 0
+    ? safeObject(precomputedResponderAdjudication)
+    : precomputedResponderSelection
+      ? precomputedResponderSelection
+      : await resolveRunnerResponderAdjudication({
+        selectedRecord,
+        pendingOrdered,
+        normalizedRoute,
+        bot,
+        executionPlan,
+        deps: executionDeps,
+        precomputedHumanIntent: normalizedPrecomputedHumanIntent,
+      });
   const selectedResponderSelectors = ensureArray(responderAdjudication.selected_bot_usernames)
     .map((value) => normalizeMentionSelector(value))
     .filter(Boolean);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "metheus-governance-mcp-cli",
-  "version": "0.2.218",
+  "version": "0.2.220",
   "description": "Metheus Governance MCP CLI (setup + stdio proxy)",
   "type": "module",
   "files": [