metheus-governance-mcp-cli 0.2.208 → 0.2.210

package/cli.mjs

@@ -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) {
@@ -3339,8 +3340,6 @@ async function claimRunnerRequestForHumanComment({
   ).trim();
   const preferredNormalizedIntent = String(
     normalizedSharedHumanIntent.intentType
-      || sharedConversationSource.normalized_intent
-      || referencedRequest.normalized_intent
       || resolvedNormalizedIntent
       || "",
   ).trim().toLowerCase();
@@ -3381,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 || "",
@@ -3450,7 +3469,7 @@ async function claimRunnerRequestForHumanComment({
             : [],
       normalizeTelegramMentionUsername,
     ),
-    normalized_intent: preferredNormalizedIntent,
+    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,
@@ -3501,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) {
@@ -3512,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()
   );
 }
@@ -3824,7 +3926,7 @@ async function ensureRunnerRootWorkItemForRequest({
       requestKey: key,
     };
   }
-  if (!isActionableRunnerRequestIntent(existing.normalized_intent)) {
+  if (!runnerRequestRequiresActionableContract(existing)) {
     return {
       ok: true,
       requestKey: key,
@@ -4216,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]),
@@ -4333,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";
@@ -4364,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
@@ -4386,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(
@@ -4401,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(),
@@ -4842,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

@@ -1896,6 +1896,17 @@ export function buildLocalBotPrompt(payload, { terse = true } = {}) {
       responseContract.require_actionable_contract === true && Array.isArray(responseContract.allowed_contract_types) && responseContract.allowed_contract_types.length > 0
         ? `Allowed execution contract types for this reply: ${responseContract.allowed_contract_types.join(", ")}.`
         : "",
+      "If you mention any other managed bot @username anywhere in the reply, you must include a contract for that mention.",
+      "Do not mention another managed bot unless the contract explicitly names that bot in assignments or next_responders.",
+      "Without a matching contract, mentioned bots will not act.",
+      "When delegating to another managed bot, use contract.type=\"delegation\" with actionable=true, assignments, and next_responders.",
+      "Delegation contract example: {\"type\":\"delegation\",\"actionable\":true,\"assignments\":[{\"target_bot\":\"ryoai2_bot\",\"task\":\"briefly greet in one line\"}],\"next_responders\":[\"ryoai2_bot\"]}.",
+      ensureArray(responseContract.required_delegation_targets).length > 0
+        ? `This reply must delegate to these exact managed bots now: ${ensureArray(responseContract.required_delegation_targets).map((item) => `@${String(item || "").trim().replace(/^@+/, "")}`).join(", ")}.`
+        : "",
+      String(responseContract.contract_hint || "").trim()
+        ? `Contract requirement hint: ${String(responseContract.contract_hint || "").trim()}`
+        : "",
       "",
     );
   }
@@ -2042,6 +2053,7 @@ export function buildLocalBotPrompt(payload, { terse = true } = {}) {
           lines.push(
             "As the lead bot, your first public reply must be immediately actionable.",
             "If you are delegating, include contract.type=\"delegation\" with concrete assignments for the exact bots you are tasking now.",
+            "If you mention any allowed responder in the reply text, the contract must name that responder in assignments or next_responders.",
             "If you are completing the work yourself now, include contract.type=\"direct_result\".",
             "Do not say you will come back later, wait, or plan first without producing an actionable contract in this same reply.",
           );
@@ -2085,7 +2097,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 {
@@ -2129,6 +2143,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())}`,
@@ -2471,6 +2494,7 @@ export function analyzeHumanConversationIntentWithAI({
   messageText,
   managedBots,
   workspaceDir,
+  contractGuardrail = null,
   client = "",
   model = "",
   env = process.env,
@@ -2498,6 +2522,7 @@ export function analyzeHumanConversationIntentWithAI({
     promptText: buildConversationIntentAnalysisPrompt({
       messageText,
       managedBots: bots,
+      contractGuardrail,
     }),
     workspaceDir,
     model: parserModel,