metheus-governance-mcp-cli 0.2.203 → 0.2.205

package/cli.mjs

@@ -184,6 +184,7 @@ import {
 } from "./lib/runner-execution.mjs";
 import {
   processRunnerSelectedRecord,
+  resolveHumanIntentContext,
   resolveRunnerResponderAdjudication,
   resolveRunnerStartupLoopAdjudication,
   selectRunnerPendingWork,
@@ -2986,6 +2987,7 @@ async function claimRunnerRequestForHumanComment({
   selectedRecord,
   selectedBotUsernames = [],
   normalizedIntent = "",
+  sharedHumanIntent = null,
   runtime = null,
   archiveThreadID = "",
 }) {
@@ -3039,6 +3041,7 @@ async function claimRunnerRequestForHumanComment({
   }
   const requests = normalizeBotRunnerRequests(stateForClaim.requests);
   const existing = safeObject(requests[requestKey]);
+  const normalizedSharedHumanIntent = safeObject(sharedHumanIntent);
   const currentMessageID = intFromRawAllowZero(parsed.messageID, 0);
   let sharedConversationSource = currentMessageID > 0
     ? pickRunnerSharedConversationSourceRequest(
@@ -3097,20 +3100,22 @@ async function claimRunnerRequestForHumanComment({
     conversation_id: resolvedConversationID,
     selected_bot_usernames: uniqueOrderedStrings(selectedBotUsernames, normalizeTelegramMentionUsername),
     conversation_intent_mode: String(
-      existing.conversation_intent_mode || sharedConversationSource.conversation_intent_mode || referencedRequest.conversation_intent_mode || "",
+      existing.conversation_intent_mode || sharedConversationSource.conversation_intent_mode || referencedRequest.conversation_intent_mode || normalizedSharedHumanIntent.intentMode || "",
     ).trim().toLowerCase(),
     conversation_lead_bot: normalizeTelegramMentionUsername(
-      existing.conversation_lead_bot || sharedConversationSource.conversation_lead_bot || referencedRequest.conversation_lead_bot,
+      existing.conversation_lead_bot || sharedConversationSource.conversation_lead_bot || referencedRequest.conversation_lead_bot || normalizedSharedHumanIntent.leadBotSelector,
     ),
     conversation_summary_bot: normalizeTelegramMentionUsername(
-      existing.conversation_summary_bot || sharedConversationSource.conversation_summary_bot || referencedRequest.conversation_summary_bot,
+      existing.conversation_summary_bot || sharedConversationSource.conversation_summary_bot || referencedRequest.conversation_summary_bot || normalizedSharedHumanIntent.summaryBotSelector,
     ),
     conversation_participants: uniqueOrderedStrings(
       ensureArray(existing.conversation_participants).length
         ? existing.conversation_participants
         : ensureArray(sharedConversationSource.conversation_participants).length
           ? sharedConversationSource.conversation_participants
-          : referencedRequest.conversation_participants,
+          : ensureArray(referencedRequest.conversation_participants).length
+            ? referencedRequest.conversation_participants
+            : normalizedSharedHumanIntent.participantSelectors,
       normalizeTelegramMentionUsername,
     ),
     conversation_initial_responders: uniqueOrderedStrings(
@@ -3118,7 +3123,9 @@ async function claimRunnerRequestForHumanComment({
         ? existing.conversation_initial_responders
         : ensureArray(sharedConversationSource.conversation_initial_responders).length
           ? sharedConversationSource.conversation_initial_responders
-          : referencedRequest.conversation_initial_responders,
+          : ensureArray(referencedRequest.conversation_initial_responders).length
+            ? referencedRequest.conversation_initial_responders
+            : normalizedSharedHumanIntent.initialResponderSelectors,
       normalizeTelegramMentionUsername,
     ),
     conversation_allowed_responders: uniqueOrderedStrings(
@@ -3126,14 +3133,17 @@ async function claimRunnerRequestForHumanComment({
         ? existing.conversation_allowed_responders
         : ensureArray(sharedConversationSource.conversation_allowed_responders).length
           ? sharedConversationSource.conversation_allowed_responders
-          : referencedRequest.conversation_allowed_responders,
+          : ensureArray(referencedRequest.conversation_allowed_responders).length
+            ? referencedRequest.conversation_allowed_responders
+            : normalizedSharedHumanIntent.allowedResponderSelectors,
       normalizeTelegramMentionUsername,
     ),
     conversation_allow_bot_to_bot: existing.conversation_allow_bot_to_bot === true
       || sharedConversationSource.conversation_allow_bot_to_bot === true
-      || referencedRequest.conversation_allow_bot_to_bot === true,
+      || referencedRequest.conversation_allow_bot_to_bot === true
+      || normalizedSharedHumanIntent.allowBotToBot === true,
     conversation_reply_expectation: String(
-      existing.conversation_reply_expectation || sharedConversationSource.conversation_reply_expectation || referencedRequest.conversation_reply_expectation || "",
+      existing.conversation_reply_expectation || sharedConversationSource.conversation_reply_expectation || referencedRequest.conversation_reply_expectation || normalizedSharedHumanIntent.replyExpectation || "",
     ).trim().toLowerCase(),
     execution_contract_type: String(
       existing.execution_contract_type || sharedConversationSource.execution_contract_type || referencedRequest.execution_contract_type || "",
@@ -3154,7 +3164,9 @@ async function claimRunnerRequestForHumanComment({
         ? existing.next_expected_responders
         : ensureArray(sharedConversationSource.next_expected_responders).length
           ? sharedConversationSource.next_expected_responders
-          : referencedRequest.next_expected_responders,
+          : ensureArray(referencedRequest.next_expected_responders).length
+            ? referencedRequest.next_expected_responders
+            : normalizedSharedHumanIntent.initialResponderSelectors,
       normalizeTelegramMentionUsername,
     ),
     normalized_intent: resolvedNormalizedIntent,
@@ -7592,7 +7604,7 @@ async function processRunnerRouteOnce(route, runtime, mode, options = {}) {
       }
       return null;
     };
-    const prepareRunnerRequestClaim = async (selectedRecord, selectedResponderSelectors = []) => {
+    const prepareRunnerRequestClaim = async (selectedRecord, selectedResponderSelectors = [], sharedHumanIntent = null) => {
       const parsed = safeObject(selectedRecord?.parsedArchive);
       const kind = String(parsed.kind || "").trim().toLowerCase();
       if (kind === "bot_reply") {
@@ -7622,6 +7634,8 @@ async function processRunnerRouteOnce(route, runtime, mode, options = {}) {
         routeKey,
         selectedRecord,
         selectedBotUsernames: selectedResponderSelectors,
+        normalizedIntent: String(safeObject(sharedHumanIntent).intentType || "").trim().toLowerCase(),
+        sharedHumanIntent,
         runtime,
         archiveThreadID: archiveThread.threadID,
       });
@@ -7679,17 +7693,26 @@ async function processRunnerRouteOnce(route, runtime, mode, options = {}) {
           skippedRecords.push(startupLoopSkipped.skippedRecord);
           continue;
         }
+        const routingExecutionDeps = {
+          ...buildRunnerExecutionDeps(),
+          managedConversationBots,
+          resolveConversationPeerBots: resolveRunnerConversationPeers,
+        };
+        const sharedHumanIntentContext = await resolveHumanIntentContext({
+          selectedRecord,
+          normalizedRoute,
+          bot,
+          executionPlan,
+          deps: routingExecutionDeps,
+        });
         const adjudication = await resolveRunnerResponderAdjudication({
           selectedRecord,
           pendingOrdered: pending.ordered,
           normalizedRoute,
           bot,
           executionPlan,
-          deps: {
-            ...buildRunnerExecutionDeps(),
-            managedConversationBots,
-            resolveConversationPeerBots: resolveRunnerConversationPeers,
-          },
+          deps: routingExecutionDeps,
+          precomputedHumanIntent: safeObject(sharedHumanIntentContext).humanIntent || null,
         });
         const currentBotSelected = ensureArray(adjudication.selected_bot_usernames)
           .map((value) => String(value || "").trim().replace(/^@+/, "").toLowerCase())
@@ -7710,7 +7733,11 @@ async function processRunnerRouteOnce(route, runtime, mode, options = {}) {
           });
           continue;
         }
-        const requestClaim = await prepareRunnerRequestClaim(selectedRecord, adjudication.selected_bot_usernames);
+        const requestClaim = await prepareRunnerRequestClaim(
+          selectedRecord,
+          adjudication.selected_bot_usernames,
+          safeObject(sharedHumanIntentContext).humanIntent || null,
+        );
         if (!requestClaim.ok) {
           await syncRunnerRequestLedgerForProjectToServer({
             normalizedRoute,
@@ -7836,6 +7863,7 @@ async function processRunnerRouteOnce(route, runtime, mode, options = {}) {
             requestKey: String(requestClaim.requestKey || "").trim(),
             triggerDecision,
             responderAdjudication: adjudication,
+            humanIntentContext: sharedHumanIntentContext,
           },
         };
       }
@@ -7918,17 +7946,26 @@ async function processRunnerRouteOnce(route, runtime, mode, options = {}) {
         skippedRecords.push(startupLoopSkipped.skippedRecord);
         continue;
       }
+      const routingExecutionDeps = {
+        ...buildRunnerExecutionDeps(),
+        managedConversationBots,
+        resolveConversationPeerBots: resolveRunnerConversationPeers,
+      };
+      const sharedHumanIntentContext = await resolveHumanIntentContext({
+        selectedRecord,
+        normalizedRoute,
+        bot,
+        executionPlan,
+        deps: routingExecutionDeps,
+      });
       const inlineAdjudication = await resolveRunnerResponderAdjudication({
         selectedRecord,
         pendingOrdered: pending.ordered,
         normalizedRoute,
         bot,
         executionPlan,
-        deps: {
-          ...buildRunnerExecutionDeps(),
-          managedConversationBots,
-          resolveConversationPeerBots: resolveRunnerConversationPeers,
-        },
+        deps: routingExecutionDeps,
+        precomputedHumanIntent: safeObject(sharedHumanIntentContext).humanIntent || null,
       });
       const inlineCurrentBotSelected = ensureArray(inlineAdjudication.selected_bot_usernames)
         .map((value) => String(value || "").trim().replace(/^@+/, "").toLowerCase())
@@ -7950,7 +7987,11 @@ async function processRunnerRouteOnce(route, runtime, mode, options = {}) {
         continue;
       }
       const currentRouteState = safeObject(loadBotRunnerState().routes[routeKey]);
-      const requestClaim = await prepareRunnerRequestClaim(selectedRecord, inlineAdjudication.selected_bot_usernames);
+      const requestClaim = await prepareRunnerRequestClaim(
+        selectedRecord,
+        inlineAdjudication.selected_bot_usernames,
+        safeObject(sharedHumanIntentContext).humanIntent || null,
+      );
       if (!requestClaim.ok) {
         await syncRunnerRequestLedgerForProjectToServer({
           normalizedRoute,
@@ -8096,6 +8137,7 @@ async function processRunnerRouteOnce(route, runtime, mode, options = {}) {
         triggerDecision,
         responderAdjudication: inlineAdjudication,
         persistedHumanIntentRequest: claimedRequest,
+        precomputedHumanIntentContext: sharedHumanIntentContext,
         deps: {
           saveRunnerRouteState,
           startRunnerTypingHeartbeat,
@@ -10465,6 +10507,7 @@ async function runRunnerStartResolvedRoutes(routes, flags, options = {}) {
                       triggerDecision: deferredExecution.triggerDecision,
                       responderAdjudication: deferredExecution.responderAdjudication,
                       persistedHumanIntentRequest: loadRunnerRequestByKey(deferredExecution.requestKey),
+                      precomputedHumanIntentContext: safeObject(deferredExecution.humanIntentContext),
                       deps: {
                         saveRunnerRouteState,
                         startRunnerTypingHeartbeat,
@@ -14951,6 +14994,7 @@ TELEGRAM_BOT_REVIEW_TOKEN=review-token
     safeObject,
     normalizeRunnerTriggerPolicy,
     evaluateTelegramRunnerTrigger,
+    resolveRunnerResponderAdjudication,
     selectPendingArchiveComments,
     selectRunnerPendingWork,
     processRunnerSelectedRecord,

package/lib/local-ai-adapters.mjs

@@ -2067,7 +2067,7 @@ function buildConversationIntentAnalysisPrompt({
     "You are a conversation intent contract parser for a public Telegram room with managed bots.",
     "Infer the human's intended bot participation contract from the human message only.",
     "Do not infer from prior bot replies. Do not invent bots outside managed_bots.",
-    "Be conservative. If the request is ambiguous, choose single_bot and keep only the directly addressed bot as the responder.",
+    "Be conservative only when the human truly does not indicate collaboration. If the message clearly asks multiple managed bots to discuss, review, brainstorm, compare perspectives, or talk together, do not collapse it to single_bot.",
     "Also decide whether the human is asking for immediate execution/work now or only asking for information/explanation.",
     "Also classify the current message intent type.",
     "",
@@ -2092,12 +2092,13 @@ function buildConversationIntentAnalysisPrompt({
     "- intent_type=bot_role_query for asking about bot roles, bot ownership, or how managed bots are meant to collaborate.",
     "- intent_type=workspace_query for asking about the current workspace, project folder, or working directory.",
     "- intent_type=artifact_location_query for asking where a file, document, pdf, guide, or artifact is located.",
-    "- intent_type=explanation_query for explanation, clarification, or informational questions that do not require execution.",
+    "- intent_type=explanation_query for explanation, clarification, informational questions, discussion requests, review requests, brainstorming requests, or requests for bots to talk together about a topic when no concrete work execution is explicitly requested.",
     "- intent_type=ctxpack_mutation for requests to create/update project guidance, instructions, rules, policies, or other ctxpack-backed source documents now.",
     "- intent_type=workitem_mutation for requests to create/update actionable work items, backlog tasks, or task breakdowns now.",
-    "- intent_type=general_execution for other concrete work requests that should execute now.",
+    "- intent_type=general_execution only for concrete work requests that should execute now, such as creating/updating files, running tools/commands, modifying project artifacts, or producing validated deliverables.",
+    "- If the human asks bots to discuss, debate, review, brainstorm, compare opinions, or hold a conversation about a topic, default to reply_expectation=informational unless they explicitly ask for concrete execution/output now.",
     "- reply_expectation=actionable when the human is asking the bot(s) to actually do work now, produce concrete results, create/update files, delegate concrete tasks, or otherwise execute immediately.",
-    "- reply_expectation=informational when the human is only asking for explanation, status, location, clarification, or other non-execution information.",
+    "- reply_expectation=informational when the human is only asking for explanation, status, location, clarification, discussion, review, brainstorming, or other non-execution information.",
     "",
     `managed_bots=${JSON.stringify(bots)}`,
     `human_message=${JSON.stringify(String(messageText || "").trim())}`,

package/lib/runner-orchestration.mjs

@@ -973,9 +973,8 @@ function buildHumanIntentFromPersistedRunnerRequest({
   const allowedResponderSelectors = normalizeManagedSelectors(persistedRequest.conversation_allowed_responders);
   const leadBotSelector = normalizeMentionSelector(persistedRequest.conversation_lead_bot);
   const summaryBotSelector = normalizeMentionSelector(persistedRequest.conversation_summary_bot);
-  const hasContract = Boolean(
+  const hasConversationContract = Boolean(
     intentMode
-    || intentType
     || replyExpectation
     || participantSelectors.length
     || initialResponderSelectors.length
@@ -983,7 +982,13 @@ function buildHumanIntentFromPersistedRunnerRequest({
     || leadBotSelector
     || summaryBotSelector,
   );
-  if (!hasContract) {
+  const hasExecutionContract = Boolean(
+    String(persistedRequest.execution_contract_type || "").trim()
+    || persistedRequest.execution_contract_actionable === true
+    || ensureArray(persistedRequest.execution_contract_targets).length
+    || ensureArray(persistedRequest.next_expected_responders).length,
+  );
+  if (!hasConversationContract && !hasExecutionContract) {
     return null;
   }
   return {
@@ -999,7 +1004,7 @@ function buildHumanIntentFromPersistedRunnerRequest({
   };
 }
 
-async function resolveHumanIntentContext({
+export async function resolveHumanIntentContext({
   selectedRecord,
   normalizedRoute,
   bot,
@@ -3952,6 +3957,7 @@ export async function resolveRunnerResponderAdjudication({
   bot,
   executionPlan,
   deps,
+  precomputedHumanIntent = null,
 }) {
   const cacheKey = buildRunnerResponderAdjudicationCacheKey({ normalizedRoute, selectedRecord });
   if (runnerResponderAdjudicationPromises.has(cacheKey)) {
@@ -3967,6 +3973,11 @@ export async function resolveRunnerResponderAdjudication({
       bot,
       deps,
     });
+    const managedBotSelectors = new Set(
+      managedBots
+        .map((entry) => normalizeMentionSelector(entry.username))
+        .filter(Boolean),
+    );
     const triggerFacts = {
       message_kind: String(safeObject(selectedRecord?.parsedArchive).kind || "").trim(),
       chat_type: String(safeObject(selectedRecord?.parsedArchive).chatType || "").trim(),
@@ -3982,6 +3993,47 @@ 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 (!adjudicator) {
       const fallbackSelected = managedBots
         .filter((entry) => entry.trigger_eligible === true)
@@ -4104,6 +4156,7 @@ export async function processRunnerSelectedRecord({
   triggerDecision: precomputedTriggerDecision = null,
   responderAdjudication: precomputedResponderAdjudication = null,
   persistedHumanIntentRequest = null,
+  precomputedHumanIntentContext = null,
   deps,
 }) {
   const saveRunnerRouteState = requireDependency(deps, "saveRunnerRouteState");
@@ -4123,6 +4176,8 @@ export async function processRunnerSelectedRecord({
     ...safeObject(buildRunnerExecutionDeps()),
     ...safeObject(deps),
   };
+  const normalizedPrecomputedHumanIntentContext = safeObject(precomputedHumanIntentContext);
+  const normalizedPrecomputedHumanIntent = safeObject(normalizedPrecomputedHumanIntentContext.humanIntent);
   const validateWorkspaceArtifacts = typeof executionDeps.validateWorkspaceArtifacts === "function"
     ? executionDeps.validateWorkspaceArtifacts
     : null;
@@ -4167,6 +4222,7 @@ export async function processRunnerSelectedRecord({
       bot,
       executionPlan,
       deps: executionDeps,
+      precomputedHumanIntent: normalizedPrecomputedHumanIntent,
     });
   const selectedResponderSelectors = ensureArray(responderAdjudication.selected_bot_usernames)
     .map((value) => normalizeMentionSelector(value))
@@ -4196,14 +4252,16 @@ export async function processRunnerSelectedRecord({
     };
   }
 
-  const humanIntentContext = await resolveHumanIntentContext({
-    selectedRecord,
-    normalizedRoute,
-    bot,
-    executionPlan,
-    deps: executionDeps,
-    persistedRequest: persistedHumanIntentRequest,
-  });
+  const humanIntentContext = Object.keys(normalizedPrecomputedHumanIntentContext).length > 0
+    ? normalizedPrecomputedHumanIntentContext
+    : await resolveHumanIntentContext({
+      selectedRecord,
+      normalizedRoute,
+      bot,
+      executionPlan,
+      deps: executionDeps,
+      persistedRequest: persistedHumanIntentRequest,
+    });
   const precomputedIntentType = normalizeHumanIntentType(
     safeObject(safeObject(humanIntentContext).humanIntent).intentType,
   );

package/lib/selftest-runner-scenarios.mjs

@@ -118,6 +118,7 @@ export async function runSelftestRunnerScenarios(push, deps) {
   const safeObject = requireDependency(deps, "safeObject");
   const normalizeRunnerTriggerPolicy = requireDependency(deps, "normalizeRunnerTriggerPolicy");
   const evaluateTelegramRunnerTrigger = requireDependency(deps, "evaluateTelegramRunnerTrigger");
+  const resolveRunnerResponderAdjudication = requireDependency(deps, "resolveRunnerResponderAdjudication");
   const selectPendingArchiveComments = requireDependency(deps, "selectPendingArchiveComments");
   const selectRunnerPendingWork = requireDependency(deps, "selectRunnerPendingWork");
   const processRunnerSelectedRecord = requireDependency(deps, "processRunnerSelectedRecord");
@@ -2935,6 +2936,108 @@ export async function runSelftestRunnerScenarios(push, deps) {
     push("public_multi_bot_human_intent_is_computed_once_per_message", false, String(err?.message || err));
   }
 
+  try {
+    let adjudicatorCalls = 0;
+    const adjudication = await resolveRunnerResponderAdjudication({
+      selectedRecord: {
+        id: "comment-precomputed-human-intent-adjudication",
+        parsedArchive: {
+          kind: "telegram_message",
+          chatID: "-100123",
+          chatType: "supergroup",
+          senderIsBot: false,
+          body: "@RyoAI_bot @RyoAI2_bot @RyoAI3_bot discuss this project together.",
+          mentionUsernames: ["RyoAI_bot", "RyoAI2_bot", "RyoAI3_bot"],
+          messageID: 1193,
+        },
+      },
+      pendingOrdered: [],
+      normalizedRoute: normalizeRunnerRoute({
+        name: "telegram-monitor-precomputed-human-intent-adjudication",
+        project_id: selftestProjectID,
+        provider: "telegram",
+        role: "monitor",
+        role_profile: "monitor",
+        destination_id: "dest-1",
+        destination_label: "Main Room",
+        server_bot_name: "RyoAI_bot",
+        server_bot_id: "bot-lead-1",
+        trigger_policy: {
+          mentions_only: true,
+          direct_messages: true,
+          reply_to_bot_messages: true,
+        },
+        archive_policy: {
+          mirror_replies: true,
+          dedupe_inbound: true,
+          dedupe_outbound: true,
+          skip_bot_messages: true,
+        },
+        dry_run_delivery: true,
+      }),
+      bot: {
+        id: "bot-lead-1",
+        name: "RyoAI_bot",
+        username: "RyoAI_bot",
+        role: "monitor",
+        provider: "telegram",
+      },
+      executionPlan: {
+        mode: "role_profile",
+        roleProfileName: "monitor",
+        roleProfile: {
+          client: "sample",
+          model: "",
+          permissionMode: "read_only",
+          reasoningEffort: "low",
+        },
+        workspaceDir: path.join(os.tmpdir(), "metheus-runner-selftest-precomputed-human-intent-adjudication"),
+        workspaceSource: "selftest",
+        usedCommandFallback: false,
+      },
+      precomputedHumanIntent: {
+        intentMode: "delegated_single_lead",
+        intentType: "explanation_query",
+        participantSelectors: ["ryoai_bot", "ryoai2_bot", "ryoai3_bot"],
+        initialResponderSelectors: ["ryoai_bot"],
+        allowedResponderSelectors: ["ryoai_bot", "ryoai2_bot", "ryoai3_bot"],
+        leadBotSelector: "ryoai_bot",
+        summaryBotSelector: "ryoai_bot",
+        allowBotToBot: true,
+        replyExpectation: "informational",
+      },
+      deps: {
+        adjudicateRunnerRespondersWithAI: async () => {
+          adjudicatorCalls += 1;
+          return {
+            decision: "multiple_responders",
+            selected_bot_usernames: ["ryoai2_bot", "ryoai3_bot"],
+          };
+        },
+        managedConversationBots: [
+          { route: { serverBotName: "RyoAI_bot" }, bot: { username: "RyoAI_bot", name: "RyoAI_bot" } },
+          { route: { serverBotName: "RyoAI2_bot" }, bot: { username: "RyoAI2_bot", name: "RyoAI2_bot" } },
+          { route: { serverBotName: "RyoAI3_bot" }, bot: { username: "RyoAI3_bot", name: "RyoAI3_bot" } },
+        ],
+        resolveConversationPeerBots: () => [
+          { id: "bot-lead-1", name: "RyoAI_bot" },
+          { id: "bot-peer-1", name: "RyoAI2_bot" },
+          { id: "bot-peer-2", name: "RyoAI3_bot" },
+        ],
+      },
+    });
+    push(
+      "precomputed_human_intent_contract_drives_responder_selection",
+      adjudicatorCalls === 0
+        && ensureArray(adjudication.selected_bot_usernames).length === 1
+        && String(ensureArray(adjudication.selected_bot_usernames)[0] || "") === "ryoai_bot"
+        && String(adjudication.reason_code || "") === "precomputed_human_intent_contract",
+      `adjudicator_calls=${adjudicatorCalls} selected=${JSON.stringify(ensureArray(adjudication.selected_bot_usernames))} reason=${String(adjudication.reason_code || "(none)")}`,
+    );
+  } catch (err) {
+    push("precomputed_human_intent_contract_drives_responder_selection", false, String(err?.message || err));
+  }
+
   try {
     let humanIntentCalls = 0;
     const processed = await processRunnerSelectedRecord({
@@ -3074,6 +3177,142 @@ export async function runSelftestRunnerScenarios(push, deps) {
     push("public_multi_bot_persisted_human_intent_skips_reanalysis", false, String(err?.message || err));
   }
 
+  try {
+    let humanIntentCalls = 0;
+    const processed = await processRunnerSelectedRecord({
+      routeKey: "public-persisted-intent-only-key",
+      normalizedRoute: normalizeRunnerRoute({
+        name: "telegram-monitor-public-persisted-intent-only",
+        project_id: selftestProjectID,
+        provider: "telegram",
+        role: "monitor",
+        role_profile: "monitor",
+        destination_id: "dest-1",
+        destination_label: "Main Room",
+        server_bot_name: "RyoAI_bot",
+        server_bot_id: "bot-lead-1",
+        trigger_policy: {
+          mentions_only: true,
+          direct_messages: true,
+          reply_to_bot_messages: true,
+        },
+        archive_policy: {
+          mirror_replies: true,
+          dedupe_inbound: true,
+          dedupe_outbound: true,
+          skip_bot_messages: true,
+        },
+        dry_run_delivery: true,
+      }),
+      selectedRecord: {
+        id: "comment-public-persisted-intent-only",
+        createdAt: "2026-03-16T00:07:00.000Z",
+        parsedArchive: {
+          kind: "telegram_message",
+          chatID: "-100123",
+          chatType: "supergroup",
+          senderIsBot: false,
+          body: "@RyoAI_bot @RyoAI2_bot @RyoAI3_bot continue the discussion.",
+          mentionUsernames: ["RyoAI_bot", "RyoAI2_bot", "RyoAI3_bot"],
+          messageID: 1192,
+        },
+      },
+      pendingOrdered: [],
+      bot: {
+        id: "bot-lead-1",
+        name: "RyoAI_bot",
+        username: "RyoAI_bot",
+        role: "monitor",
+        provider: "telegram",
+      },
+      destination: {
+        id: "dest-1",
+        label: "Main Room",
+        provider: "telegram",
+        chatID: "-100123",
+      },
+      archiveThread: {
+        threadID: "thread-1",
+        workItemID: "work-item-1",
+      },
+      executionPlan: {
+        mode: "role_profile",
+        roleProfileName: "monitor",
+        roleProfile: {
+          client: "sample",
+          model: "",
+          permissionMode: "read_only",
+          reasoningEffort: "low",
+        },
+        workspaceDir: path.join(os.tmpdir(), "metheus-runner-selftest-persisted-human-intent-only"),
+        workspaceSource: "selftest",
+        usedCommandFallback: false,
+      },
+      runtime: {
+        baseURL: "https://example.test",
+        token: "selftest-token",
+        timeoutSeconds: 30,
+        actor: { user_id: "user-1" },
+      },
+      responderAdjudication: {
+        selected_bot_usernames: ["ryoai_bot"],
+      },
+      persistedHumanIntentRequest: {
+        request_key: "persisted-request-1192",
+        normalized_intent: "general_execution",
+      },
+      deps: {
+        saveRunnerRouteState: () => {},
+        startRunnerTypingHeartbeat: () => ({ async stop() {} }),
+        runRunnerAIExecution: async () => ({
+          skip: false,
+          reply: "bot replied",
+          replyToMessageID: 0,
+          contract: {
+            type: "direct_result",
+            actionable: false,
+          },
+        }),
+        performLocalBotDelivery: async () => ({
+          delivery: { dryRun: true, body: {} },
+          archive: {},
+        }),
+        serializeRunnerTriggerPolicy: (value) => value,
+        serializeRunnerArchivePolicy: (value) => value,
+        buildRunnerExecutionDeps: () => ({
+          analyzeHumanConversationIntentWithAI: async () => {
+            humanIntentCalls += 1;
+            return {
+              mode: "multi_bot_collab",
+              lead_bot: "ryoai_bot",
+              summary_bot: "ryoai_bot",
+              participants: ["ryoai_bot", "ryoai2_bot", "ryoai3_bot"],
+              initial_responders: ["ryoai_bot", "ryoai2_bot", "ryoai3_bot"],
+              allowed_responders: ["ryoai_bot", "ryoai2_bot", "ryoai3_bot"],
+              allow_bot_to_bot: true,
+              reply_expectation: "informational",
+              intent_type: "explanation_query",
+            };
+          },
+        }),
+        buildRunnerDeliveryDeps: () => ({}),
+        buildRunnerRuntimeDeps: () => ({}),
+        resolveConversationPeerBots: () => [
+          { id: "bot-lead-1", name: "RyoAI_bot" },
+          { id: "bot-peer-1", name: "RyoAI2_bot" },
+          { id: "bot-peer-2", name: "RyoAI3_bot" },
+        ],
+      },
+    });
+    push(
+      "public_multi_bot_persisted_intent_only_reanalyzes_human_message",
+      processed.kind === "replied" && humanIntentCalls === 1,
+      `kind=${String(processed.kind || "(none)")} human_intent_calls=${humanIntentCalls}`,
+    );
+  } catch (err) {
+    push("public_multi_bot_persisted_intent_only_reanalyzes_human_message", false, String(err?.message || err));
+  }
+
   try {
     const deliveredTexts = [];
     const deliveredConversation = [];

package/package.json

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