metheus-governance-mcp-cli 0.2.210 → 0.2.212

package/cli.mjs

@@ -2764,6 +2764,62 @@ function sessionAllowsConversationResponder(sessionRaw, responderSelectorRaw = "
   return allowedResponders.includes(responderSelector);
 }
 
+function shouldBypassRunnerStartupLoopForContractFollowup({
+  selectedRecord,
+  bot,
+  conversationSessionFacts = null,
+}) {
+  const parsed = safeObject(selectedRecord?.parsedArchive);
+  if (String(parsed.kind || "").trim().toLowerCase() !== "bot_reply") {
+    return false;
+  }
+  const currentBotSelector = normalizeTelegramMentionUsername(bot?.username || bot?.name);
+  if (!currentBotSelector) {
+    return false;
+  }
+  const conversationID = String(parsed.conversationID || "").trim();
+  if (!conversationID) {
+    return false;
+  }
+  const executionContractType = String(parsed.executionContractType || "").trim().toLowerCase();
+  if (executionContractType !== "delegation") {
+    return false;
+  }
+  const senderBotSelector = normalizeTelegramMentionUsername(
+    parsed.botUsername
+    || parsed.botName
+    || parsed.username
+    || parsed.sender,
+  );
+  if (!senderBotSelector || senderBotSelector === currentBotSelector) {
+    return false;
+  }
+  const assignmentTargets = ensureArray(parsed.executionContractAssignments)
+    .map((item) => normalizeTelegramMentionUsername(safeObject(item).targetBot || safeObject(item).target_bot))
+    .filter(Boolean);
+  const nextResponders = ensureArray(parsed.executionContractNextResponders)
+    .map((item) => normalizeTelegramMentionUsername(item))
+    .filter(Boolean);
+  const conversationTargetBot = normalizeTelegramMentionUsername(parsed.conversationTargetBotUsername);
+  const currentBotIsExpectedResponder = assignmentTargets.includes(currentBotSelector)
+    || nextResponders.includes(currentBotSelector)
+    || conversationTargetBot === currentBotSelector;
+  if (!currentBotIsExpectedResponder) {
+    return false;
+  }
+  const sessionFacts = safeObject(conversationSessionFacts);
+  const sessionExpectedResponders = ensureArray(sessionFacts.next_expected_responders)
+    .map((item) => normalizeTelegramMentionUsername(item))
+    .filter(Boolean);
+  if (sessionExpectedResponders.length > 0 && !sessionExpectedResponders.includes(currentBotSelector)) {
+    return false;
+  }
+  if (sessionFacts.any_closed === true && sessionFacts.any_open !== true) {
+    return false;
+  }
+  return true;
+}
+
 function findRunnerRequestsForMessageID(state, normalizedRoute, selectors = {}) {
   const chatID = String(selectors.chatID || "").trim();
   const messageID = intFromRawAllowZero(selectors.messageID, 0);
@@ -3591,13 +3647,29 @@ function runnerRequestRequiresActionableContract(requestRaw) {
   const request = safeObject(requestRaw);
   const replyExpectation = String(request.conversation_reply_expectation || "").trim().toLowerCase();
   const executionContractType = String(request.execution_contract_type || "").trim().toLowerCase();
+  const intentMode = String(request.conversation_intent_mode || "").trim().toLowerCase();
+  const intentType = String(
+    request.conversation_intent_type
+    || request.intent_type
+    || request.normalized_intent
+    || "",
+  ).trim().toLowerCase();
+  const hasExecutionIntent = [
+    "general_execution",
+    "ctxpack_mutation",
+    "workitem_mutation",
+  ].includes(intentType);
   if (request.execution_contract_actionable === true) {
     return true;
   }
-  if (replyExpectation === "actionable") {
+  if (["delegation", "direct_result", "summary_request", "final_summary"].includes(executionContractType)) {
     return true;
   }
-  if (["delegation", "direct_result"].includes(executionContractType)) {
+  if (
+    intentMode === "single_bot"
+    && replyExpectation === "actionable"
+    && hasExecutionIntent
+  ) {
     return true;
   }
   return false;
@@ -7691,6 +7763,13 @@ async function maybeHandleRunnerStartupLoopCandidate({
   }
   const conversationID = String(parsed.conversationID || "").trim();
   const conversationSessionFacts = collectBotRunnerConversationSessionFacts(normalizedRoute, conversationID);
+  if (shouldBypassRunnerStartupLoopForContractFollowup({
+    selectedRecord,
+    bot,
+    conversationSessionFacts,
+  })) {
+    return null;
+  }
   const adjudication = await resolveRunnerStartupLoopAdjudication({
     selectedRecord,
     pendingOrdered,
@@ -15472,6 +15551,7 @@ TELEGRAM_BOT_REVIEW_TOKEN=review-token
     selectRunnerPendingWork,
     processRunnerSelectedRecord,
     resolveRunnerStartupLoopAdjudication,
+    shouldBypassRunnerStartupLoopForContractFollowup,
     claimRunnerRequestForHumanComment,
     markRunnerRequestLifecycle,
     resolveRunnerContinuationRequestForBotReply,

package/lib/runner-orchestration.mjs

@@ -1294,7 +1294,6 @@ export async function resolveHumanIntentContext({
       executionPlan,
       contractGuardrail: {
         require_complete_contract: true,
-        require_explicit_actionable_intent: true,
         reason: "Return a complete human intent contract for this managed-bot conversation.",
       },
     });
@@ -2584,6 +2583,11 @@ async function maybeExecuteDynamicRolePlan({
     safeObject(directHumanResponseContract).intentType
     || safeObject(safeObject(humanIntentContext).humanIntent).intentType,
   );
+  const humanIntentMode = normalizeIntentMode(
+    safeObject(directHumanResponseContract).intentMode
+    || safeObject(safeObject(humanIntentContext).humanIntent).intentMode,
+  );
+  const actionableConversationRequiresContract = safeObject(directHumanResponseContract).requiresActionableContract === true;
   const plannerContextComments = ensureArray(contextWindow).length
     ? ensureArray(contextWindow)
     : buildRunnerContextWindow(
@@ -2595,6 +2599,13 @@ async function maybeExecuteDynamicRolePlan({
   if (!assignmentTasks.length && isInformationalHumanIntentType(humanIntentType)) {
     return null;
   }
+  if (
+    !assignmentTasks.length
+    && actionableConversationRequiresContract
+    && ["delegated_single_lead", "multi_bot_collab", "multi_bot_direct"].includes(humanIntentMode)
+  ) {
+    return null;
+  }
   const executionIntentRequested = [
     "general_execution",
     "ctxpack_mutation",
@@ -5193,6 +5204,14 @@ export async function processRunnerSelectedRecord({
     }
   }
   const normalizedExecutionContractType = String(executionContract?.type || "").trim().toLowerCase();
+  const effectiveResolvedIntentType = normalizeHumanIntentType(
+    directHumanResponseContract.intentType || resolvedIntentType,
+  );
+  const effectiveResolvedIntentMode = normalizeIntentMode(
+    directHumanResponseContract.intentMode
+    || conversationContext?.intentMode
+    || safeObject(safeObject(humanIntentContext).humanIntent).intentMode,
+  );
   const shouldEnforceArtifactValidation = Boolean(
     (artifactValidationOverride && Object.keys(artifactValidationOverride).length > 0)
     || ensureArray(aiResult?.artifacts).length > 0
@@ -5202,7 +5221,8 @@ export async function processRunnerSelectedRecord({
       "general_execution",
       "ctxpack_mutation",
       "workitem_mutation",
-    ].includes(normalizeHumanIntentType(resolvedIntentType))
+    ].includes(effectiveResolvedIntentType)
+      && !["delegated_single_lead", "multi_bot_collab", "multi_bot_direct"].includes(effectiveResolvedIntentMode)
   );
   const artifactValidation = shouldEnforceArtifactValidation
     ? artifactValidationOverride && Object.keys(artifactValidationOverride).length > 0

package/lib/runner-trigger.mjs

@@ -96,12 +96,29 @@ function buildRunnerTaskName(humanIntentType, humanIntentContract = null) {
   const contract = safeObject(humanIntentContract);
   const replyExpectation = String(contract.replyExpectation || contract.reply_expectation || "").trim().toLowerCase();
   const executionContractType = String(contract.executionContractType || contract.execution_contract_type || "").trim().toLowerCase();
+  const intentMode = String(contract.intentMode || contract.intent_mode || "").trim().toLowerCase();
+  const executionIntentRequested = [
+    "general_execution",
+    "ctxpack_mutation",
+    "workitem_mutation",
+  ].includes(normalizedIntentType);
+  const collaborativeIntentMode = [
+    "delegated_single_lead",
+    "multi_bot_collab",
+    "multi_bot_direct",
+  ].includes(intentMode);
   if (normalizedIntentType === "status_query") return "answer_project_status_query";
   if (normalizedIntentType === "workspace_query") return "answer_project_workspace_query";
   if (normalizedIntentType === "bot_role_query") return "answer_project_bot_role_query";
   if (normalizedIntentType === "artifact_location_query") return "answer_project_artifact_location_query";
   if (normalizedIntentType === "small_talk") return "reply_to_project_chat_greeting";
-  if (executionContractType || replyExpectation === "actionable") {
+  if (executionContractType) {
+    return "reply_to_project_actionable_message";
+  }
+  if (collaborativeIntentMode && replyExpectation === "actionable") {
+    return "reply_to_project_chat_message";
+  }
+  if (executionIntentRequested) {
     return "reply_to_project_actionable_message";
   }
   return "reply_to_project_chat_message";

package/lib/selftest-runner-scenarios.mjs

@@ -118,16 +118,17 @@ 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");
-  const resolveRunnerStartupLoopAdjudication = requireDependency(deps, "resolveRunnerStartupLoopAdjudication");
-  const runRunnerAIExecution = requireDependency(deps, "runRunnerAIExecution");
-  const formatBotReplyArchiveComment = requireDependency(deps, "formatBotReplyArchiveComment");
-  const findArchivedBotReplyRecord = requireDependency(deps, "findArchivedBotReplyRecord");
-  const parseArchivedChatComment = requireDependency(deps, "parseArchivedChatComment");
-  const validateWorkspaceArtifacts = requireDependency(deps, "validateWorkspaceArtifacts");
+  const resolveRunnerResponderAdjudication = requireDependency(deps, "resolveRunnerResponderAdjudication");
+  const selectPendingArchiveComments = requireDependency(deps, "selectPendingArchiveComments");
+  const selectRunnerPendingWork = requireDependency(deps, "selectRunnerPendingWork");
+  const processRunnerSelectedRecord = requireDependency(deps, "processRunnerSelectedRecord");
+  const resolveRunnerStartupLoopAdjudication = requireDependency(deps, "resolveRunnerStartupLoopAdjudication");
+  const shouldBypassRunnerStartupLoopForContractFollowup = requireDependency(deps, "shouldBypassRunnerStartupLoopForContractFollowup");
+  const runRunnerAIExecution = requireDependency(deps, "runRunnerAIExecution");
+  const formatBotReplyArchiveComment = requireDependency(deps, "formatBotReplyArchiveComment");
+  const findArchivedBotReplyRecord = requireDependency(deps, "findArchivedBotReplyRecord");
+  const parseArchivedChatComment = requireDependency(deps, "parseArchivedChatComment");
+  const validateWorkspaceArtifacts = requireDependency(deps, "validateWorkspaceArtifacts");
   const buildLocalBotPrompt = requireDependency(deps, "buildLocalBotPrompt");
 
   try {
@@ -367,13 +368,53 @@ export async function runSelftestRunnerScenarios(push, deps) {
         && adjudication?.startup_facts?.repeated_same_delegation_without_new_human === true,
       `decision=${String(adjudication?.decision || "")} action=${String(adjudication?.action || "")} imported=${String(adjudication?.startup_facts?.imported_on_current_poll)} repeated_delegation=${String(adjudication?.startup_facts?.repeated_same_delegation_without_new_human)}`,
     );
-  } catch (err) {
-    push(
-      "runner_loop_adjudication_detects_repeated_same_delegation_without_new_human_input",
-      false,
-      String(err?.message || err),
-    );
-  }
+  } catch (err) {
+    push(
+      "runner_loop_adjudication_detects_repeated_same_delegation_without_new_human_input",
+      false,
+      String(err?.message || err),
+    );
+  }
+
+  try {
+    const shouldBypass = shouldBypassRunnerStartupLoopForContractFollowup({
+      selectedRecord: {
+        id: "bot-reply-4",
+        parsedArchive: {
+          kind: "bot_reply",
+          messageID: 52,
+          senderIsBot: true,
+          botUsername: "@bot-a",
+          conversationID: "conv-4",
+          executionContractType: "delegation",
+          executionContractAssignments: [
+            { targetBot: "@bot-b", task: "say hello" },
+          ],
+          executionContractNextResponders: ["@bot-b"],
+          conversationTargetBotUsername: "@bot-b",
+        },
+      },
+      bot: {
+        username: "@bot-b",
+      },
+      conversationSessionFacts: {
+        any_open: true,
+        any_closed: false,
+        next_expected_responders: ["bot-b"],
+      },
+    });
+    push(
+      "runner_startup_loop_bypasses_expected_delegation_followup_for_target_bot",
+      shouldBypass === true,
+      `should_bypass=${String(shouldBypass)}`,
+    );
+  } catch (err) {
+    push(
+      "runner_startup_loop_bypasses_expected_delegation_followup_for_target_bot",
+      false,
+      String(err?.message || err),
+    );
+  }
 
   try {
     const pendingSelection = selectPendingArchiveComments(

package/package.json

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