metheus-governance-mcp-cli 0.2.217 → 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,
@@ -4511,7 +4544,6 @@ export async function processRunnerSelectedRecord({
     ? executionDeps.explainExecutionFailureWithAI
     : null;
   const normalizedPrecomputedHumanIntentContext = safeObject(precomputedHumanIntentContext);
-  const normalizedPrecomputedHumanIntent = safeObject(normalizedPrecomputedHumanIntentContext.humanIntent);
   const validateWorkspaceArtifacts = typeof executionDeps.validateWorkspaceArtifacts === "function"
     ? executionDeps.validateWorkspaceArtifacts
     : null;
@@ -4547,17 +4579,65 @@ export async function processRunnerSelectedRecord({
       },
     };
   }
-  const responderAdjudication = Object.keys(safeObject(precomputedResponderAdjudication)).length > 0
-    ? safeObject(precomputedResponderAdjudication)
-    : await resolveRunnerResponderAdjudication({
+  const selectedRecordKind = String(safeObject(selectedRecord?.parsedArchive).kind || "").trim();
+  const shouldResolveHumanIntentFirst = ["telegram_message", "telegram_edited_message"].includes(selectedRecordKind)
+    && safeObject(selectedRecord?.parsedArchive).senderIsBot !== true;
+  const resolvedPreAdjudicationHumanIntentContext = Object.keys(normalizedPrecomputedHumanIntentContext).length > 0
+    ? normalizedPrecomputedHumanIntentContext
+    : shouldResolveHumanIntentFirst
+      ? await resolveHumanIntentContext({
+        selectedRecord,
+        normalizedRoute,
+        bot,
+        executionPlan,
+        deps: executionDeps,
+        persistedRequest: persistedHumanIntentRequest,
+      })
+      : null;
+  if (resolvedPreAdjudicationHumanIntentContext?.contractNeedsResolution === true) {
+    const reason = "human intent contract is incomplete and requires regeneration";
+    saveRunnerRouteState(
+      routeKey,
+      buildRunnerRouteStateFromComment(selectedRecord, {
+        last_action: "needs_contract",
+        last_reason: reason,
+      }),
+    );
+    return {
+      kind: "skipped",
+      skippedRecord: {
+        id: selectedRecord.id,
+        reason,
+        messageID: intFromRawAllowZero(selectedRecord?.parsedArchive?.messageID, 0),
+      },
+    };
+  }
+  const normalizedPrecomputedHumanIntent = safeObject(
+    resolvedPreAdjudicationHumanIntentContext?.humanIntent || normalizedPrecomputedHumanIntentContext.humanIntent,
+  );
+  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);
@@ -4586,8 +4666,8 @@ export async function processRunnerSelectedRecord({
     };
   }
 
-  const humanIntentContext = Object.keys(normalizedPrecomputedHumanIntentContext).length > 0
-    ? normalizedPrecomputedHumanIntentContext
+  const humanIntentContext = Object.keys(safeObject(resolvedPreAdjudicationHumanIntentContext)).length > 0
+    ? safeObject(resolvedPreAdjudicationHumanIntentContext)
     : await resolveHumanIntentContext({
       selectedRecord,
       normalizedRoute,

package/lib/selftest-runner-scenarios.mjs

@@ -12579,16 +12579,15 @@ export async function runSelftestRunnerScenarios(push, deps) {
         resolveConversationPeerBots: () => [],
       },
     });
-    push(
-      "runner_responder_adjudication_skips_unselected_bot",
-      processed.kind === "skipped"
-        && /selected_primary_addressee/i.test(String(processed.skippedRecord?.reason || ""))
-        && executionCalls === 0,
-      `kind=${String(processed.kind || "(none)")} reason=${String(processed.skippedRecord?.reason || "(none)")} execution_calls=${executionCalls}`,
-    );
-  } catch (err) {
-    push("runner_responder_adjudication_skips_unselected_bot", false, String(err?.message || err));
-  }
+    push(
+      "runner_contract_first_selection_overrides_responder_adjudicator_for_human_message",
+      processed.kind === "replied"
+        && executionCalls === 1,
+      `kind=${String(processed.kind || "(none)")} reason=${String(processed.skippedRecord?.reason || "(none)")} execution_calls=${executionCalls}`,
+    );
+  } catch (err) {
+    push("runner_contract_first_selection_overrides_responder_adjudicator_for_human_message", false, String(err?.message || err));
+  }
 
   try {
     let executionCalls = 0;

package/package.json

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