metheus-governance-mcp-cli 0.2.207 → 0.2.208

package/cli.mjs

@@ -2623,7 +2623,7 @@ function inferRunnerRequestClaimIntent(selectedRecord) {
   if (looksLikeRunnerClaimQuestion(rawText) && normalizedText.split(/\s+/).filter(Boolean).length <= 8) {
     return "status_query";
   }
-  return "general_execution";
+  return "";
 }
 
 function resolveRunnerRequestClaimIntent({
@@ -2647,6 +2647,16 @@ function buildSyntheticReplyChainConversationID(normalizedRoute, chatID, anchorM
   return `reply_chain:${provider}:${normalizedChatID}:${normalizedAnchorMessageID}`;
 }
 
+function buildSyntheticHumanOpeningConversationID(normalizedRoute, chatID, messageID) {
+  const provider = String(normalizedRoute?.provider || "").trim() || "unknown";
+  const normalizedChatID = String(chatID || "").trim() || "-";
+  const normalizedMessageID = intFromRawAllowZero(messageID, 0);
+  if (normalizedMessageID <= 0) {
+    return "";
+  }
+  return `human_opening:${provider}:${normalizedChatID}:${normalizedMessageID}`;
+}
+
 function findRunnerRequestsForScope(state, normalizedRoute, selectors = {}) {
   const requests = normalizeBotRunnerRequests(state?.requests);
   const projectID = String(normalizedRoute?.projectID || "").trim();
@@ -3259,13 +3269,17 @@ async function claimRunnerRequestForHumanComment({
     normalizedIntent,
     selectedRecord,
   });
-  const requestKey = buildRunnerRequestKey({
+  let stateForClaim = safeObject(replyChainResolution.state);
+  const normalizedSharedHumanIntent = safeObject(sharedHumanIntent);
+  const provisionalNormalizedIntent = String(
+    normalizedSharedHumanIntent.intentType || resolvedNormalizedIntent || "",
+  ).trim().toLowerCase();
+  const provisionalRequestKey = buildRunnerRequestKey({
     normalizedRoute,
     selectedRecord,
     selectedBotUsernames,
-    normalizedIntent: resolvedNormalizedIntent,
+    normalizedIntent: provisionalNormalizedIntent,
   });
-  let stateForClaim = safeObject(replyChainResolution.state);
   const baseConversationID = String(
     parsed.conversationID
     || replyChainContext.conversationID
@@ -3285,9 +3299,6 @@ async function claimRunnerRequestForHumanComment({
       requests: backfilled.requests,
     };
   }
-  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(
@@ -3295,7 +3306,7 @@ async function claimRunnerRequestForHumanComment({
         chatID: String(parsed.chatID || parsed.chatId || "").trim(),
         messageID: currentMessageID,
       }),
-      requestKey,
+      provisionalRequestKey,
     )
     : {};
   if (
@@ -3309,14 +3320,38 @@ async function claimRunnerRequestForHumanComment({
       runtime,
       chatID: String(parsed.chatID || parsed.chatId || "").trim(),
       messageID: currentMessageID,
-      excludeRequestKey: requestKey,
+      excludeRequestKey: provisionalRequestKey,
     }));
   }
   const resolvedConversationID = String(
     baseConversationID
     || sharedConversationSource.conversation_id
+    || (
+      Object.keys(normalizedSharedHumanIntent).length > 0
+        ? buildSyntheticHumanOpeningConversationID(
+          normalizedRoute,
+          String(parsed.chatID || parsed.chatId || "").trim(),
+          currentMessageID,
+        )
+        : ""
+    )
     || "",
   ).trim();
+  const preferredNormalizedIntent = String(
+    normalizedSharedHumanIntent.intentType
+      || sharedConversationSource.normalized_intent
+      || referencedRequest.normalized_intent
+      || resolvedNormalizedIntent
+      || "",
+  ).trim().toLowerCase();
+  const requestKey = buildRunnerRequestKey({
+    normalizedRoute,
+    selectedRecord,
+    selectedBotUsernames,
+    normalizedIntent: preferredNormalizedIntent,
+  });
+  const requests = normalizeBotRunnerRequests(stateForClaim.requests);
+  const existing = safeObject(requests[requestKey]);
   if (isFinalRunnerRequestStatus(existing.status)) {
     return {
       ok: false,
@@ -3412,10 +3447,10 @@ async function claimRunnerRequestForHumanComment({
           ? sharedConversationSource.next_expected_responders
           : ensureArray(referencedRequest.next_expected_responders).length
             ? referencedRequest.next_expected_responders
-            : normalizedSharedHumanIntent.initialResponderSelectors,
+            : [],
       normalizeTelegramMentionUsername,
     ),
-    normalized_intent: resolvedNormalizedIntent,
+    normalized_intent: preferredNormalizedIntent,
     status: "claimed",
     claimed_by_route: String(routeKey || "").trim(),
     claimed_at: firstNonEmptyString([existing.claimed_at, nowISO]) || nowISO,

package/lib/local-ai-adapters.mjs

@@ -949,7 +949,7 @@ function normalizeExecutionContract(rawContract) {
     || contract.target_summary_bot
     || "",
   ).trim().replace(/^@+/, "").toLowerCase();
-  const nextResponders = uniqueOrdered(
+  const explicitNextResponders = uniqueOrdered(
     ensureArray(contract.next_responders || contract.nextResponders || contract.responders)
       .map((item) => String(item || "").trim().replace(/^@+/, "").toLowerCase())
       .filter(Boolean),
@@ -962,6 +962,13 @@ function normalizeExecutionContract(rawContract) {
   ].includes(type)
     ? type
     : "";
+  const nextResponders = explicitNextResponders.length > 0
+    ? explicitNextResponders
+    : normalizedType === "delegation"
+      ? uniqueOrdered(assignments.map((item) => String(item.target_bot || item.targetBot || "").trim().replace(/^@+/, "").toLowerCase()).filter(Boolean))
+      : normalizedType === "summary_request" && summaryBot
+        ? [summaryBot]
+        : [];
   const actionable = contract.actionable === true
     || (normalizedType === "delegation" && assignments.length > 0)
     || (normalizedType === "summary_request" && Boolean(summaryBot))

package/lib/runner-delivery.mjs

@@ -101,11 +101,18 @@ function normalizeExecutionContractForArchive(rawContract) {
     })
     .filter(Boolean);
   const summaryBot = normalizeMentionUsername(contract.summary_bot || contract.summaryBot || "");
-  const nextResponders = Array.from(new Set(
+  const explicitNextResponders = Array.from(new Set(
     ensureArray(contract.next_responders || contract.nextResponders || contract.responders)
       .map((item) => normalizeMentionUsername(item))
       .filter(Boolean),
   ));
+  const nextResponders = explicitNextResponders.length > 0
+    ? explicitNextResponders
+    : type === "delegation"
+      ? Array.from(new Set(assignments.map((item) => normalizeMentionUsername(item.target_bot)).filter(Boolean)))
+      : type === "summary_request" && summaryBot
+        ? [summaryBot]
+        : [];
   const actionable = contract.actionable === true;
   if (!type && !assignments.length && !summaryBot && !nextResponders.length && !actionable) {
     return null;

package/lib/runner-orchestration.mjs

@@ -1109,14 +1109,26 @@ function buildHumanIntentFromPersistedRunnerRequest({
       .filter((item) => item && (managedSelectors.size === 0 || managedSelectors.has(item))),
   );
   const intentMode = String(persistedRequest.conversation_intent_mode || "").trim();
-  const intentType = normalizeHumanIntentType(
+  const persistedReplyExpectation = normalizeReplyExpectation(
+    persistedRequest.conversation_reply_expectation,
+    "",
+  );
+  const persistedExecutionActionable = persistedRequest.execution_contract_actionable === true;
+  const persistedNormalizedIntent = normalizeHumanIntentType(
     persistedRequest.normalized_intent || persistedRequest.intent_type,
     "",
   );
-  const replyExpectation = normalizeReplyExpectation(
-    persistedRequest.conversation_reply_expectation,
+  const intentType = normalizeHumanIntentType(
+    (
+      persistedNormalizedIntent === "general_execution"
+      && persistedReplyExpectation !== "actionable"
+      && !persistedExecutionActionable
+    )
+      ? ""
+      : persistedNormalizedIntent,
     "",
   );
+  const replyExpectation = persistedReplyExpectation;
   const participantSelectors = normalizeManagedSelectors(persistedRequest.conversation_participants);
   const initialResponderSelectors = normalizeManagedSelectors(persistedRequest.conversation_initial_responders);
   const allowedResponderSelectors = normalizeManagedSelectors(persistedRequest.conversation_allowed_responders);
@@ -1261,7 +1273,7 @@ function buildDirectHumanResponseContract({
     }
   }
   const requiresActionableContract = (
-    (replyExpectation === "actionable" || intentMode === "delegated_single_lead")
+    replyExpectation === "actionable"
     && Boolean(currentBotSelector)
     && initialResponderSelectors.includes(currentBotSelector)
   );
@@ -3307,11 +3319,18 @@ function normalizeConversationExecutionContract(
     || contract.summary_bot
     || conversationContext?.summaryBotUsername,
   );
-  const nextResponders = uniqueOrdered(
-    ensureArray(contract.nextResponders || contract.next_responders || contract.responders)
-      .map((item) => normalizeMentionSelector(item))
-      .filter((item) => !allowedResponderSet.size || allowedResponderSet.has(item)),
-  );
+  const explicitNextResponders = uniqueOrdered(
+    ensureArray(contract.nextResponders || contract.next_responders || contract.responders)
+      .map((item) => normalizeMentionSelector(item))
+      .filter((item) => !allowedResponderSet.size || allowedResponderSet.has(item)),
+  );
+  const nextResponders = explicitNextResponders.length > 0
+    ? explicitNextResponders
+    : normalizedType === "delegation"
+      ? uniqueOrdered(assignments.map((item) => normalizeMentionSelector(item.targetBot)).filter(Boolean))
+      : normalizedType === "summary_request" && summaryBot
+        ? [summaryBot]
+        : [];
   const actionable = contract.actionable === true
     || (normalizedType === "delegation" && assignments.length > 0)
     || (normalizedType === "summary_request" && Boolean(summaryBot || nextResponders.length))
@@ -3386,11 +3405,18 @@ function normalizeResponseExecutionContract(rawContract, responseContract, { cur
     contract.summaryBot
     || contract.summary_bot,
   );
-  const nextResponders = uniqueOrdered(
+  const explicitNextResponders = uniqueOrdered(
     ensureArray(contract.nextResponders || contract.next_responders || contract.responders)
       .map((item) => normalizeMentionSelector(item))
       .filter(Boolean),
   );
+  const nextResponders = explicitNextResponders.length > 0
+    ? explicitNextResponders
+    : normalizedType === "delegation"
+      ? uniqueOrdered(assignments.map((item) => normalizeMentionSelector(item.targetBot)).filter(Boolean))
+      : normalizedType === "summary_request" && summaryBot
+        ? [summaryBot]
+        : [];
   const actionable = contract.actionable === true
     || (normalizedType === "delegation" && assignments.length > 0)
     || (normalizedType === "summary_request" && Boolean(summaryBot || nextResponders.length))
@@ -3411,7 +3437,7 @@ function normalizeResponseExecutionContract(rawContract, responseContract, { cur
   };
 }
 
-function buildImplicitSummaryRequestContract(conversationContext, currentBotSelector) {
+function buildImplicitSummaryRequestContract(conversationContext, currentBotSelector) {
   if (String(conversationContext?.mode || "").trim() !== "public_multi_bot") {
     return null;
   }
@@ -3426,15 +3452,45 @@ function buildImplicitSummaryRequestContract(conversationContext, currentBotSele
   if (!summaryBotSelector || !currentSelector || summaryBotSelector === currentSelector) {
     return null;
   }
-  return {
-    type: "summary_request",
-    actionable: true,
-    assignments: [],
-    summaryBot: summaryBotSelector,
-    nextResponders: [summaryBotSelector],
-    implicit: true,
-  };
-}
+  return {
+    type: "summary_request",
+    actionable: true,
+    assignments: [],
+    summaryBot: summaryBotSelector,
+    nextResponders: [summaryBotSelector],
+    implicit: true,
+  };
+}
+
+function collectExecutionContractNextResponders(executionContract) {
+  const contract = safeObject(executionContract);
+  const normalizedType = String(
+    contract.type
+    || contract.contract_type
+    || contract.contractType
+    || "",
+  ).trim().toLowerCase();
+  const explicitNextResponders = uniqueOrdered(
+    ensureArray(contract.nextResponders || contract.next_responders || contract.responders)
+      .map((item) => normalizeMentionSelector(item))
+      .filter(Boolean),
+  );
+  if (explicitNextResponders.length > 0) {
+    return explicitNextResponders;
+  }
+  if (normalizedType === "delegation") {
+    return uniqueOrdered(
+      ensureArray(contract.assignments)
+        .map((item) => normalizeMentionSelector(safeObject(item).targetBot || safeObject(item).target_bot))
+        .filter(Boolean),
+    );
+  }
+  const summaryBot = normalizeMentionSelector(contract.summaryBot || contract.summary_bot);
+  if (normalizedType === "summary_request" && summaryBot) {
+    return [summaryBot];
+  }
+  return [];
+}
 
 function conversationSessionIsExpired(session, policy, nowMs = Date.now()) {
   const expiresAtMs = parseISOStringMs(safeObject(session).expires_at);
@@ -4866,6 +4922,24 @@ export async function processRunnerSelectedRecord({
       .filter(Boolean),
   );
   let requiresActionableContract = safeObject(aiPayload.response_contract).require_actionable_contract === true;
+  const normalizedConversationInitialResponders = uniqueOrdered(
+    ensureArray(conversationContext?.initialResponderSelectors)
+      .map((item) => normalizeMentionSelector(item))
+      .filter(Boolean),
+  );
+  const normalizedConversationAllowedResponders = uniqueOrdered(
+    ensureArray(conversationContext?.allowedResponderSelectors)
+      .map((item) => normalizeMentionSelector(item))
+      .filter(Boolean),
+  );
+  const peerAllowedResponders = normalizedConversationAllowedResponders.filter((item) => item && item !== currentBotSelector);
+  const requiresPeerDelegationContract = conversationContext?.mode === "public_multi_bot"
+    && String(conversationContext?.stage || "").trim() === "human_opening"
+    && conversationContext?.allowBotToBot === true
+    && Boolean(currentBotSelector)
+    && normalizedConversationInitialResponders.length === 1
+    && normalizedConversationInitialResponders.includes(currentBotSelector)
+    && peerAllowedResponders.length > 0;
   const directHumanPeerMap = humanIntentContext?.peerMap instanceof Map
     ? humanIntentContext.peerMap
     : buildConversationPeerMap(bot, normalizedRoute, executionDeps);
@@ -4883,6 +4957,10 @@ export async function processRunnerSelectedRecord({
   if (delegatedBotMentions.length > 0) {
     allowedActionableTypes = new Set(["delegation"]);
   }
+  if (requiresPeerDelegationContract) {
+    allowedActionableTypes = new Set(["delegation"]);
+    requiresActionableContract = true;
+  }
   let hasValidActionableContract = Boolean(
     executionContract
     && executionContract.actionable === true
@@ -4923,7 +5001,7 @@ export async function processRunnerSelectedRecord({
         allow_skip: false,
         must_reply: true,
         require_actionable_contract: true,
-        human_intent_mode: effectiveResponseContractPayload.human_intent_mode || (delegatedBotMentions.length > 0 ? "delegated_single_lead" : ""),
+        human_intent_mode: effectiveResponseContractPayload.human_intent_mode || ((delegatedBotMentions.length > 0 || requiresPeerDelegationContract) ? "delegated_single_lead" : ""),
         human_lead_bot: delegatedBotMentions.length > 0
           ? currentBotSelector
           : String(effectiveResponseContractPayload.human_lead_bot || "").trim(),
@@ -4934,10 +5012,10 @@ export async function processRunnerSelectedRecord({
           ? ensureArray(effectiveResponseContractPayload.human_allowed_responders)
           : uniqueOrdered([
             currentBotSelector,
-            ...delegatedBotMentions,
+            ...(delegatedBotMentions.length > 0 ? delegatedBotMentions : peerAllowedResponders),
           ].filter(Boolean)),
-        allow_bot_to_bot: delegatedBotMentions.length > 0 || effectiveResponseContractPayload.human_intent_mode === "delegated_single_lead",
-        allowed_contract_types: delegatedBotMentions.length > 0
+        allow_bot_to_bot: delegatedBotMentions.length > 0 || requiresPeerDelegationContract || effectiveResponseContractPayload.human_intent_mode === "delegated_single_lead",
+        allowed_contract_types: delegatedBotMentions.length > 0 || requiresPeerDelegationContract
           ? ["delegation", "summary_request", "final_summary"]
           : ensureArray(effectiveResponseContractPayload.allowed_contract_types).length
             ? ensureArray(effectiveResponseContractPayload.allowed_contract_types)
@@ -5256,10 +5334,7 @@ export async function processRunnerSelectedRecord({
           last_execution_contract_type: String(executionContract?.type || "").trim(),
           last_execution_contract_actionable: executionContract?.actionable === true,
           last_execution_contract_targets: ensureArray(executionContract?.assignments).map((item) => normalizeMentionSelector(item.targetBot)).filter(Boolean),
-          next_expected_responders: uniqueOrdered([
-            ...ensureArray(executionContract?.nextResponders).map((item) => normalizeMentionSelector(item)).filter(Boolean),
-            normalizeMentionSelector(executionContract?.summaryBot),
-          ]),
+          next_expected_responders: collectExecutionContractNextResponders(executionContract),
           last_speaker_bot_username: currentBotSelector,
           speaker_counts: speakerCounts,
           last_sender_bot_username: String(effectiveConversationContext?.senderBotUsername || "").trim(),
@@ -5355,10 +5430,7 @@ export async function processRunnerSelectedRecord({
       execution_contract_type: String(executionContract?.type || "").trim(),
       execution_contract_actionable: executionContract?.actionable === true,
       execution_contract_targets: ensureArray(executionContract?.assignments).map((item) => normalizeMentionSelector(item.targetBot)).filter(Boolean),
-      next_expected_responders: uniqueOrdered([
-        ...ensureArray(executionContract?.nextResponders).map((item) => normalizeMentionSelector(item)).filter(Boolean),
-        normalizeMentionSelector(executionContract?.summaryBot),
-      ]),
+      next_expected_responders: collectExecutionContractNextResponders(executionContract),
       artifact_validation: String(artifactValidation.status || "").trim() || "none",
       artifact_paths: summarizeValidatedArtifactPaths(artifactValidation),
       ctxpack_version_id: String(safeObject(aiResult?.ctxpackUpdate).version_id || "").trim(),

package/lib/selftest-runner-scenarios.mjs

@@ -1569,9 +1569,9 @@ export async function runSelftestRunnerScenarios(push, deps) {
     });
     const inferredExecutionRequest = safeObject(safeObject(loadBotRunnerState().requests)[inferredExecutionClaim.requestKey]);
     push(
-      "runner_request_claim_defaults_actionable_messages_to_general_execution",
+      "runner_request_claim_leaves_unclassified_messages_unresolved",
       inferredExecutionClaim.ok === true
-        && String(inferredExecutionRequest.normalized_intent || "") === "general_execution",
+        && String(inferredExecutionRequest.normalized_intent || "") === "",
       `intent=${String(inferredExecutionRequest.normalized_intent || "(none)")} request=${String(inferredExecutionClaim.requestKey || "(none)")}`,
     );
 
@@ -4785,7 +4785,7 @@ export async function runSelftestRunnerScenarios(push, deps) {
     push(
       "direct_human_public_delegate_fallback_uses_response_allowed_responders",
       processed.kind === "replied"
-        && aiCalls === 1
+        && aiCalls === 2
         && String(deliveredConversation[0]?.mode || "") === "public_multi_bot"
         && Array.isArray(deliveredConversation[0]?.allowedResponderSelectors)
         && deliveredConversation[0].allowedResponderSelectors.includes("ryoai3_bot")
@@ -5064,14 +5064,14 @@ export async function runSelftestRunnerScenarios(push, deps) {
       },
     });
     push(
-      "delegated_single_lead_lead_opening_requires_actionable_contract",
+      "delegated_single_lead_lead_opening_requires_delegation_contract_for_peer_followup",
       processed.kind === "skipped"
         && aiCalls === 2
-        && /actionable execution contract/i.test(String(processed.skippedRecord?.reason || "")),
-      `kind=${String(processed.kind || "(none)")} ai_calls=${aiCalls} reason=${String(processed.skippedRecord?.reason || "(none)")}`,
+        && !String(deliveredText || "").trim(),
+      `kind=${String(processed.kind || "(none)")} ai_calls=${aiCalls} reply=${String(deliveredText || "(none)")}`,
     );
   } catch (err) {
-    push("delegated_single_lead_lead_opening_requires_actionable_contract", false, String(err?.message || err));
+    push("delegated_single_lead_lead_opening_requires_delegation_contract_for_peer_followup", false, String(err?.message || err));
   }
 
   try {

package/package.json

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