metheus-governance-mcp-cli 0.2.218 → 0.2.219

package/cli.mjs

@@ -184,6 +184,7 @@ import {
   runRunnerAIExecution,
 } from "./lib/runner-execution.mjs";
 import {
+  buildRunnerResponderAdjudicationFromHumanIntent,
   processRunnerSelectedRecord,
   resolveHumanIntentContext,
   resolveRunnerResponderAdjudication,
@@ -8287,7 +8288,14 @@ async function processRunnerRouteOnce(route, runtime, mode, options = {}) {
           executionPlan,
           deps: routingExecutionDeps,
         });
-        const adjudication = await resolveRunnerResponderAdjudication({
+        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 +8548,14 @@ async function processRunnerRouteOnce(route, runtime, mode, options = {}) {
         executionPlan,
         deps: routingExecutionDeps,
       });
-      const inlineAdjudication = await resolveRunnerResponderAdjudication({
+      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

@@ -4285,17 +4285,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 +4314,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 +4371,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 +4615,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.219",
   "description": "Metheus Governance MCP CLI (setup + stdio proxy)",
   "type": "module",
   "files": [