metheus-governance-mcp-cli 0.2.207 → 0.2.209

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({
@@ -2634,7 +2634,8 @@ function resolveRunnerRequestClaimIntent({
   if (explicitIntent) {
     return explicitIntent;
   }
-  return inferRunnerRequestClaimIntent(selectedRecord);
+  const inferredIntent = inferRunnerRequestClaimIntent(selectedRecord);
+  return inferredIntent === "status_query" ? inferredIntent : "";
 }
 
 function buildSyntheticReplyChainConversationID(normalizedRoute, chatID, anchorMessageID) {
@@ -2647,6 +2648,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 +3270,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 +3300,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 +3307,7 @@ async function claimRunnerRequestForHumanComment({
         chatID: String(parsed.chatID || parsed.chatId || "").trim(),
         messageID: currentMessageID,
       }),
-      requestKey,
+      provisionalRequestKey,
     )
     : {};
   if (
@@ -3309,14 +3321,36 @@ 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
+      || 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,
@@ -3346,50 +3380,70 @@ 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 || normalizedSharedHumanIntent.intentMode || "",
+      normalizedSharedHumanIntent.intentMode
+        || existing.conversation_intent_mode
+        || sharedConversationSource.conversation_intent_mode
+        || referencedRequest.conversation_intent_mode
+        || "",
     ).trim().toLowerCase(),
     conversation_lead_bot: normalizeTelegramMentionUsername(
-      existing.conversation_lead_bot || sharedConversationSource.conversation_lead_bot || referencedRequest.conversation_lead_bot || normalizedSharedHumanIntent.leadBotSelector,
+      normalizedSharedHumanIntent.leadBotSelector
+        || existing.conversation_lead_bot
+        || sharedConversationSource.conversation_lead_bot
+        || referencedRequest.conversation_lead_bot,
     ),
     conversation_summary_bot: normalizeTelegramMentionUsername(
-      existing.conversation_summary_bot || sharedConversationSource.conversation_summary_bot || referencedRequest.conversation_summary_bot || normalizedSharedHumanIntent.summaryBotSelector,
+      normalizedSharedHumanIntent.summaryBotSelector
+        || existing.conversation_summary_bot
+        || sharedConversationSource.conversation_summary_bot
+        || referencedRequest.conversation_summary_bot,
     ),
     conversation_participants: uniqueOrderedStrings(
-      ensureArray(existing.conversation_participants).length
-        ? existing.conversation_participants
-        : ensureArray(sharedConversationSource.conversation_participants).length
-          ? sharedConversationSource.conversation_participants
-          : ensureArray(referencedRequest.conversation_participants).length
-            ? referencedRequest.conversation_participants
-            : normalizedSharedHumanIntent.participantSelectors,
+      ensureArray(normalizedSharedHumanIntent.participantSelectors).length
+        ? normalizedSharedHumanIntent.participantSelectors
+        : ensureArray(existing.conversation_participants).length
+          ? existing.conversation_participants
+          : ensureArray(sharedConversationSource.conversation_participants).length
+            ? sharedConversationSource.conversation_participants
+            : ensureArray(referencedRequest.conversation_participants).length
+              ? referencedRequest.conversation_participants
+              : [],
       normalizeTelegramMentionUsername,
     ),
     conversation_initial_responders: uniqueOrderedStrings(
-      ensureArray(existing.conversation_initial_responders).length
-        ? existing.conversation_initial_responders
-        : ensureArray(sharedConversationSource.conversation_initial_responders).length
-          ? sharedConversationSource.conversation_initial_responders
-          : ensureArray(referencedRequest.conversation_initial_responders).length
-            ? referencedRequest.conversation_initial_responders
-            : normalizedSharedHumanIntent.initialResponderSelectors,
+      ensureArray(normalizedSharedHumanIntent.initialResponderSelectors).length
+        ? normalizedSharedHumanIntent.initialResponderSelectors
+        : ensureArray(existing.conversation_initial_responders).length
+          ? existing.conversation_initial_responders
+          : ensureArray(sharedConversationSource.conversation_initial_responders).length
+            ? sharedConversationSource.conversation_initial_responders
+            : ensureArray(referencedRequest.conversation_initial_responders).length
+              ? referencedRequest.conversation_initial_responders
+              : [],
       normalizeTelegramMentionUsername,
     ),
     conversation_allowed_responders: uniqueOrderedStrings(
-      ensureArray(existing.conversation_allowed_responders).length
-        ? existing.conversation_allowed_responders
-        : ensureArray(sharedConversationSource.conversation_allowed_responders).length
-          ? sharedConversationSource.conversation_allowed_responders
-          : ensureArray(referencedRequest.conversation_allowed_responders).length
-            ? referencedRequest.conversation_allowed_responders
-            : normalizedSharedHumanIntent.allowedResponderSelectors,
+      ensureArray(normalizedSharedHumanIntent.allowedResponderSelectors).length
+        ? normalizedSharedHumanIntent.allowedResponderSelectors
+        : ensureArray(existing.conversation_allowed_responders).length
+          ? existing.conversation_allowed_responders
+          : ensureArray(sharedConversationSource.conversation_allowed_responders).length
+            ? sharedConversationSource.conversation_allowed_responders
+            : ensureArray(referencedRequest.conversation_allowed_responders).length
+              ? referencedRequest.conversation_allowed_responders
+              : [],
       normalizeTelegramMentionUsername,
     ),
-    conversation_allow_bot_to_bot: existing.conversation_allow_bot_to_bot === true
+    conversation_allow_bot_to_bot: normalizedSharedHumanIntent.allowBotToBot === true
+      || existing.conversation_allow_bot_to_bot === true
       || sharedConversationSource.conversation_allow_bot_to_bot === true
-      || referencedRequest.conversation_allow_bot_to_bot === true
-      || normalizedSharedHumanIntent.allowBotToBot === true,
+      || referencedRequest.conversation_allow_bot_to_bot === true,
     conversation_reply_expectation: String(
-      existing.conversation_reply_expectation || sharedConversationSource.conversation_reply_expectation || referencedRequest.conversation_reply_expectation || normalizedSharedHumanIntent.replyExpectation || "",
+      normalizedSharedHumanIntent.replyExpectation
+        || existing.conversation_reply_expectation
+        || sharedConversationSource.conversation_reply_expectation
+        || referencedRequest.conversation_reply_expectation
+        || "",
     ).trim().toLowerCase(),
     execution_contract_type: String(
       existing.execution_contract_type || sharedConversationSource.execution_contract_type || referencedRequest.execution_contract_type || "",
@@ -3412,10 +3466,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: String(preferredNormalizedIntent || existing.normalized_intent || "").trim().toLowerCase(),
     status: "claimed",
     claimed_by_route: String(routeKey || "").trim(),
     claimed_at: firstNonEmptyString([existing.claimed_at, nowISO]) || nowISO,
@@ -3466,6 +3520,89 @@ function isActionableRunnerRequestIntent(rawIntent) {
   return Boolean(normalizedIntent) && !isInformationalRunnerRequestIntent(normalizedIntent);
 }
 
+function runnerRequestHasConversationContract(requestRaw) {
+  const request = safeObject(requestRaw);
+  return Boolean(
+    String(request.conversation_id || "").trim()
+    || String(request.conversation_intent_mode || "").trim()
+    || String(request.conversation_reply_expectation || "").trim()
+    || ensureArray(request.conversation_participants).length
+    || ensureArray(request.conversation_initial_responders).length
+    || ensureArray(request.conversation_allowed_responders).length
+  );
+}
+
+function runnerRequestHasCompleteConversationContract(requestRaw) {
+  const request = safeObject(requestRaw);
+  const intentMode = String(request.conversation_intent_mode || "").trim().toLowerCase();
+  const conversationID = String(request.conversation_id || "").trim();
+  const replyExpectation = String(request.conversation_reply_expectation || "").trim().toLowerCase();
+  const participants = ensureArray(request.conversation_participants);
+  const initialResponders = ensureArray(request.conversation_initial_responders);
+  const allowedResponders = ensureArray(request.conversation_allowed_responders);
+  if (!runnerRequestHasConversationContract(request)) {
+    return false;
+  }
+  if (!conversationID || !intentMode || !replyExpectation) {
+    return false;
+  }
+  if (intentMode === "single_bot") {
+    return allowedResponders.length > 0 || participants.length > 0;
+  }
+  return participants.length > 0 && initialResponders.length > 0 && allowedResponders.length > 0;
+}
+
+function runnerRequestHasExecutionContract(requestRaw) {
+  const request = safeObject(requestRaw);
+  return Boolean(
+    String(request.execution_contract_type || "").trim()
+    || request.execution_contract_actionable === true
+    || ensureArray(request.execution_contract_targets).length
+    || ensureArray(request.next_expected_responders).length
+  );
+}
+
+function runnerRequestHasCompleteExecutionContract(requestRaw) {
+  const request = safeObject(requestRaw);
+  const executionContractType = String(request.execution_contract_type || "").trim().toLowerCase();
+  const executionTargets = ensureArray(request.execution_contract_targets);
+  const nextExpectedResponders = ensureArray(request.next_expected_responders);
+  if (!runnerRequestHasExecutionContract(request)) {
+    return false;
+  }
+  if (!executionContractType) {
+    return false;
+  }
+  if (executionContractType === "delegation") {
+    return executionTargets.length > 0 || nextExpectedResponders.length > 0;
+  }
+  if (executionContractType === "summary_request") {
+    return nextExpectedResponders.length > 0 || executionTargets.length > 0;
+  }
+  return true;
+}
+
+function runnerRequestHasContractSignals(requestRaw) {
+  const request = safeObject(requestRaw);
+  return runnerRequestHasConversationContract(request) || runnerRequestHasExecutionContract(request);
+}
+
+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();
+  if (request.execution_contract_actionable === true) {
+    return true;
+  }
+  if (replyExpectation === "actionable") {
+    return true;
+  }
+  if (["delegation", "direct_result"].includes(executionContractType)) {
+    return true;
+  }
+  return false;
+}
+
 function loadRunnerRequestByKey(requestKey) {
   const key = String(requestKey || "").trim();
   if (!key) {
@@ -3477,7 +3614,7 @@ function loadRunnerRequestByKey(requestKey) {
 function actionableRunnerRequestMissingRootWorkItem(requestRaw) {
   const request = safeObject(requestRaw);
   return (
-    isActionableRunnerRequestIntent(request.normalized_intent)
+    runnerRequestRequiresActionableContract(request)
     && !String(request.root_work_item_id || "").trim()
   );
 }
@@ -3789,7 +3926,7 @@ async function ensureRunnerRootWorkItemForRequest({
       requestKey: key,
     };
   }
-  if (!isActionableRunnerRequestIntent(existing.normalized_intent)) {
+  if (!runnerRequestRequiresActionableContract(existing)) {
     return {
       ok: true,
       requestKey: key,
@@ -4181,7 +4318,7 @@ function resolveRunnerContinuationRequestForBotReply({
           execution_contract_actionable: session.last_execution_contract_actionable === true,
           execution_contract_targets: ensureArray(session.last_execution_contract_targets),
           next_expected_responders: ensureArray(session.next_expected_responders),
-          normalized_intent: String(safeObject(sessionMatch.routeState).last_intent_type || "").trim().toLowerCase(),
+          normalized_intent: String(fallbackRequest.normalized_intent || "").trim().toLowerCase(),
           status: "running",
           claimed_by_route: String(sessionMatch.routeKey || "").trim(),
           claimed_at: firstNonEmptyString([session.started_at, nowISO]),
@@ -4298,6 +4435,26 @@ function markRunnerRequestLifecycle({
     normalizeTelegramMentionUsername,
   ).filter((selector) => selector && selector !== normalizedCurrentBotSelector);
   const shouldRemainRunningAfterReply = continuationSelectors.length > 0;
+  const nextConversationIntentMode = String(
+    conversationIntentMode
+    || existing.conversation_intent_mode
+    || "",
+  ).trim().toLowerCase();
+  const nextExecutionContractType = String(
+    executionContractType
+    || existing.execution_contract_type
+    || "",
+  ).trim().toLowerCase();
+  const nextNormalizedIntent = (() => {
+    const explicitIntent = String(normalizedIntent || "").trim().toLowerCase();
+    if (explicitIntent) {
+      return explicitIntent;
+    }
+    if (nextConversationIntentMode && !nextExecutionContractType) {
+      return "";
+    }
+    return String(existing.normalized_intent || "").trim().toLowerCase();
+  })();
   const normalizedOutcome = String(outcome || "").trim().toLowerCase();
   const nextStatus = (() => {
     if (normalizedOutcome === "claimed") return "claimed";
@@ -4329,11 +4486,7 @@ function markRunnerRequestLifecycle({
       ensureArray(allowedResponders).length ? allowedResponders : existing.conversation_allowed_responders,
       normalizeTelegramMentionUsername,
     ),
-    conversation_intent_mode: String(
-      conversationIntentMode
-      || existing.conversation_intent_mode
-      || "",
-    ).trim().toLowerCase(),
+    conversation_intent_mode: nextConversationIntentMode,
     conversation_lead_bot: normalizeTelegramMentionUsername(
       conversationLeadBot
       || existing.conversation_lead_bot
@@ -4351,11 +4504,7 @@ function markRunnerRequestLifecycle({
       || existing.conversation_reply_expectation
       || "",
     ).trim().toLowerCase(),
-    execution_contract_type: String(
-      executionContractType
-      || existing.execution_contract_type
-      || "",
-    ).trim().toLowerCase(),
+    execution_contract_type: nextExecutionContractType,
     execution_contract_actionable: executionContractActionable === true
       || existing.execution_contract_actionable === true,
     execution_contract_targets: uniqueOrderedStrings(
@@ -4366,7 +4515,7 @@ function markRunnerRequestLifecycle({
       ensureArray(nextExpectedResponders).length ? nextExpectedResponders : existing.next_expected_responders,
       normalizeTelegramMentionUsername,
     ),
-    normalized_intent: String(normalizedIntent || existing.normalized_intent || "").trim().toLowerCase(),
+    normalized_intent: nextNormalizedIntent,
     status: nextStatus,
     started_at: firstNonEmptyString([existing.started_at, nowISO]),
     completed_at: nextStatus === "completed" ? nowISO : String(existing.completed_at || "").trim(),
@@ -4807,7 +4956,7 @@ async function syncRunnerRequestLedgerForProjectToServer({ normalizedRoute, runt
         })[String(request.request_key || "").trim()]
         : request;
       if (
-        isActionableRunnerRequestIntent(recoveredRequest.normalized_intent)
+        runnerRequestRequiresActionableContract(recoveredRequest)
         && !String(recoveredRequest.root_work_item_id || "").trim()
       ) {
         continue;

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))
@@ -2078,7 +2085,9 @@ export function serializeLocalAIResult(result) {
 function buildConversationIntentAnalysisPrompt({
   messageText,
   managedBots,
+  contractGuardrail = null,
 }) {
+  const guardrail = safeObject(contractGuardrail);
   const bots = ensureArray(managedBots).map((item) => {
     const bot = safeObject(item);
     return {
@@ -2122,6 +2131,15 @@ function buildConversationIntentAnalysisPrompt({
     "- 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, discussion, review, brainstorming, or other non-execution information.",
+    guardrail.require_complete_contract === true
+      ? "- Contract guardrail: do not leave intent_type, reply_expectation, participants, initial_responders, or allowed_responders empty when the message clearly addresses managed bots."
+      : "",
+    guardrail.require_explicit_actionable_intent === true
+      ? "- Contract guardrail: if reply_expectation=actionable, intent_type must be exactly one of ctxpack_mutation, workitem_mutation, or general_execution."
+      : "",
+    String(guardrail.reason || "").trim()
+      ? `- Contract guardrail reason: ${String(guardrail.reason || "").trim()}`
+      : "",
     "",
     `managed_bots=${JSON.stringify(bots)}`,
     `human_message=${JSON.stringify(String(messageText || "").trim())}`,
@@ -2464,6 +2482,7 @@ export function analyzeHumanConversationIntentWithAI({
   messageText,
   managedBots,
   workspaceDir,
+  contractGuardrail = null,
   client = "",
   model = "",
   env = process.env,
@@ -2491,6 +2510,7 @@ export function analyzeHumanConversationIntentWithAI({
     promptText: buildConversationIntentAnalysisPrompt({
       messageText,
       managedBots: bots,
+      contractGuardrail,
     }),
     workspaceDir,
     model: parserModel,

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;