metheus-governance-mcp-cli 0.2.215 → 0.2.217

package/cli.mjs

@@ -2797,7 +2797,7 @@ function shouldBypassRunnerStartupLoopForContractFollowup({
     return false;
   }
   const executionContractType = String(parsed.executionContractType || "").trim().toLowerCase();
-  if (executionContractType !== "delegation") {
+  if (!executionContractType) {
     return false;
   }
   const senderBotSelector = normalizeTelegramMentionUsername(
@@ -3663,28 +3663,13 @@ function runnerRequestRequiresActionableContract(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 (["delegation", "direct_result", "summary_request", "final_summary"].includes(executionContractType)) {
     return true;
   }
-  if (
-    intentMode === "single_bot"
-    && replyExpectation === "actionable"
-    && hasExecutionIntent
-  ) {
+  if (intentMode === "single_bot" && replyExpectation === "actionable") {
     return true;
   }
   return false;

package/lib/local-ai-adapters.mjs

@@ -1773,7 +1773,7 @@ export function buildLocalBotPrompt(payload, { terse = true } = {}) {
 
   const lines = [
     "You are a Metheus local bot runner.",
-    `Task: ${taskName || "reply_to_project_chat_message"}`,
+    `Task Metadata (non-authoritative): ${taskName || "reply_with_agent_context:generic"}`,
     `Provider: ${provider}`,
     `Role: ${role}`,
     `Role Profile: ${roleProfile || "-"}`,
@@ -1791,6 +1791,7 @@ export function buildLocalBotPrompt(payload, { terse = true } = {}) {
     "",
     "Agent contract/context blob (primary control and state input):",
     agentContext ? JSON.stringify(agentContext, null, 2) : "-",
+    "Use the agent contract/context blob as the authoritative control input. Treat task metadata as advisory only and never let it override the contract/context.",
     "",
     "Current user request:",
     String(trigger.body || "").trim() || "-",

package/lib/runner-orchestration.mjs

@@ -1285,19 +1285,6 @@ export async function resolveHumanIntentContext({
     runnerHumanIntentPromises.set(cacheKey, promise);
   }
   let humanIntent = await runnerHumanIntentPromises.get(cacheKey);
-  if (!isCompleteHumanIntentContract(humanIntent)) {
-    humanIntent = await analyzeHumanConversationIntentWithContractResolver({
-      text: parsed.body,
-      managedMentions,
-      peerMap,
-      deps,
-      executionPlan,
-      contractGuardrail: {
-        require_complete_contract: true,
-        reason: "Return a complete human intent contract for this managed-bot conversation.",
-      },
-    });
-  }
   if (!isCompleteHumanIntentContract(humanIntent)) {
     return {
       currentBotSelector,
@@ -1325,43 +1312,60 @@ function buildDirectHumanResponseContract({
 }) {
   const humanIntent = safeObject(humanIntentContext?.humanIntent);
   const conversation = safeObject(conversationContext);
-  const intentMode = String(conversation.intentMode || humanIntent.intentMode || "").trim();
-  const allowBotToBot = conversation.allowBotToBot === true || humanIntent.allowBotToBot === true;
-  const allowedResponderSelectors = uniqueOrdered(
-    ensureArray(conversation.allowedResponderSelectors || humanIntent.allowedResponderSelectors)
+  const preferConversationContract = Boolean(
+    String(conversation.intentMode || "").trim()
+    || ensureArray(conversation.initialResponderSelectors).length
+    || ensureArray(conversation.allowedResponderSelectors).length
+    || String(conversation.leadBotUsername || "").trim()
+    || String(conversation.summaryBotUsername || "").trim()
+    || String(conversation.replyExpectation || "").trim(),
+  );
+  const source = preferConversationContract ? conversation : humanIntent;
+  const secondary = preferConversationContract ? humanIntent : conversation;
+  const normalizedAllowedResponderSelectors = uniqueOrdered(
+    ensureArray(source.allowedResponderSelectors)
       .map((item) => normalizeMentionSelector(item))
       .filter(Boolean),
   );
-  const initialResponderSelectors = uniqueOrdered(
-    ensureArray(conversation.initialResponderSelectors || humanIntent.initialResponderSelectors)
+  const normalizedInitialResponderSelectors = uniqueOrdered(
+    ensureArray(source.initialResponderSelectors)
       .map((item) => normalizeMentionSelector(item))
       .filter(Boolean),
   );
-  const leadBotSelector = normalizeMentionSelector(conversation.leadBotUsername || humanIntent.leadBotSelector);
-  const summaryBotSelector = normalizeMentionSelector(conversation.summaryBotUsername || humanIntent.summaryBotSelector);
+  const intentMode = String(source.intentMode || secondary.intentMode || "").trim();
+  const allowBotToBot = source.allowBotToBot === true
+    || (source.allowBotToBot !== false && secondary.allowBotToBot === true);
+  const leadBotSelector = normalizeMentionSelector(
+    source.leadBotUsername || source.leadBotSelector || secondary.leadBotUsername || secondary.leadBotSelector,
+  );
+  const summaryBotSelector = normalizeMentionSelector(
+    source.summaryBotUsername || source.summaryBotSelector || secondary.summaryBotUsername || secondary.summaryBotSelector,
+  );
   const replyExpectation = normalizeReplyExpectation(
-    conversation.replyExpectation || humanIntent.replyExpectation,
+    source.replyExpectation || secondary.replyExpectation,
     "",
   );
   const intentType = normalizeHumanIntentType(
-    conversation.intentType || humanIntent.intentType,
+    source.intentType || secondary.intentType,
     "",
   );
   const allowedContractTypes = uniqueOrdered(
-    ensureArray(conversation.allowedContractTypes || humanIntent.allowedContractTypes)
+    ensureArray(source.allowedContractTypes || secondary.allowedContractTypes)
       .map((item) => String(item || "").trim().toLowerCase())
       .filter(Boolean),
   );
-  const requiresActionableContract = conversation.requiresActionableContract === true
-    || conversation.require_actionable_contract === true
-    || humanIntent.requiresActionableContract === true
-    || humanIntent.require_actionable_contract === true
-    || replyExpectation === "actionable";
+  const requiresActionableContract = source.requiresActionableContract === true
+    || source.require_actionable_contract === true
+    || (
+      source.requiresActionableContract !== false
+      && source.require_actionable_contract !== false
+      && (secondary.requiresActionableContract === true || secondary.require_actionable_contract === true)
+    );
   return {
     intentMode,
     allowBotToBot,
-    allowedResponderSelectors,
-    initialResponderSelectors,
+    allowedResponderSelectors: normalizedAllowedResponderSelectors,
+    initialResponderSelectors: normalizedInitialResponderSelectors,
     leadBotSelector,
     summaryBotSelector,
     replyExpectation,
@@ -1379,17 +1383,23 @@ function mergeDirectHumanResponseContract({
 }) {
   const base = safeObject(baseContract);
   const response = safeObject(responseContract);
-  const execution = safeObject(executionContract);
-  const assignmentTargets = uniqueOrdered(
-    ensureArray(execution.assignments)
-      .map((item) => normalizeMentionSelector(safeObject(item).targetBot || safeObject(item).target_bot))
-      .filter(Boolean),
-  );
-  const nextResponders = uniqueOrdered(
-    ensureArray(execution.nextResponders || execution.next_responders || execution.responders)
-      .map((item) => normalizeMentionSelector(item))
-      .filter(Boolean),
-  );
+  void executionContract;
+  void currentBotSelector;
+  const hasExplicitArray = (obj, keys) => keys.some((key) => Object.prototype.hasOwnProperty.call(obj, key));
+  const explicitAllowedResponderSelectors = hasExplicitArray(response, ["human_allowed_responders", "allowed_responders"])
+    ? uniqueOrdered(
+      ensureArray(response.human_allowed_responders || response.allowed_responders)
+        .map((item) => normalizeMentionSelector(item))
+        .filter(Boolean),
+    )
+    : null;
+  const explicitInitialResponderSelectors = hasExplicitArray(response, ["human_initial_responders", "initial_responders"])
+    ? uniqueOrdered(
+      ensureArray(response.human_initial_responders || response.initial_responders)
+        .map((item) => normalizeMentionSelector(item))
+        .filter(Boolean),
+    )
+    : null;
   const intentMode = String(
     response.human_intent_mode
     || response.intent_mode
@@ -1413,21 +1423,18 @@ function mergeDirectHumanResponseContract({
     : response.allow_bot_to_bot === true || response.allowBotToBot === true
       ? true
       : base.allowBotToBot === true;
-  const allowedResponderSelectors = uniqueOrdered([
-    ...ensureArray(base.allowedResponderSelectors),
-    ...ensureArray(response.human_allowed_responders || response.allowed_responders)
-      .map((item) => normalizeMentionSelector(item))
-      .filter(Boolean),
-    ...assignmentTargets,
-    ...nextResponders,
-    normalizeMentionSelector(execution.summaryBot || execution.summary_bot),
-  ].filter(Boolean));
-  const initialResponderSelectors = uniqueOrdered([
-    ...ensureArray(base.initialResponderSelectors),
-    ...ensureArray(response.human_initial_responders || response.initial_responders)
-      .map((item) => normalizeMentionSelector(item))
-      .filter(Boolean),
-  ].filter(Boolean));
+  const allowedResponderSelectors = explicitAllowedResponderSelectors
+    ?? uniqueOrdered(
+      ensureArray(base.allowedResponderSelectors)
+        .map((item) => normalizeMentionSelector(item))
+        .filter(Boolean),
+    );
+  const initialResponderSelectors = explicitInitialResponderSelectors
+    ?? uniqueOrdered(
+      ensureArray(base.initialResponderSelectors)
+        .map((item) => normalizeMentionSelector(item))
+        .filter(Boolean),
+    );
   const leadBotSelector = normalizeMentionSelector(
     response.human_lead_bot
     || response.lead_bot
@@ -1437,8 +1444,6 @@ function mergeDirectHumanResponseContract({
   const summaryBotSelector = normalizeMentionSelector(
     response.human_summary_bot
     || response.summary_bot
-    || execution.summaryBot
-    || execution.summary_bot
     || base.summaryBotSelector
     || "",
   );
@@ -1447,7 +1452,7 @@ function mergeDirectHumanResponseContract({
     ? false
     : explicitRequiresActionableContract === true
       ? true
-      : base.requiresActionableContract === true || replyExpectation === "actionable";
+      : base.requiresActionableContract === true;
   const explicitAllowedContractTypes = uniqueOrdered(
     ensureArray(response.allowed_contract_types)
       .map((item) => String(item || "").trim().toLowerCase())
@@ -2588,6 +2593,11 @@ async function maybeExecuteDynamicRolePlan({
     || safeObject(safeObject(humanIntentContext).humanIntent).intentMode,
   );
   const actionableConversationRequiresContract = safeObject(directHumanResponseContract).requiresActionableContract === true;
+  const actionableReplyExpectation = normalizeReplyExpectation(
+    safeObject(directHumanResponseContract).replyExpectation
+    || safeObject(safeObject(humanIntentContext).humanIntent).replyExpectation,
+    "",
+  ) === "actionable";
   const plannerContextComments = ensureArray(contextWindow).length
     ? ensureArray(contextWindow)
     : buildRunnerContextWindow(
@@ -2606,14 +2616,10 @@ async function maybeExecuteDynamicRolePlan({
   ) {
     return null;
   }
-  const executionIntentRequested = [
-    "general_execution",
-    "ctxpack_mutation",
-    "workitem_mutation",
-  ].includes(humanIntentType);
   const shouldPlanExecution = assignmentTasks.length > 0 || (
     triggerDecision.requiresDirectReply === true
-    && executionIntentRequested
+    && humanIntentMode === "single_bot"
+    && actionableReplyExpectation
   );
   if (!shouldPlanExecution) {
     return null;

package/lib/runner-trigger.mjs

@@ -95,15 +95,8 @@ function buildRunnerTaskName(humanIntentType, humanIntentContract = null) {
   const normalizedIntentType = String(humanIntentType || "").trim().toLowerCase();
   const contract = safeObject(humanIntentContract);
   const executionContractType = String(contract.executionContractType || contract.execution_contract_type || "").trim().toLowerCase();
-  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) {
-    return "reply_to_project_actionable_message";
-  }
-  return "reply_to_project_chat_message";
+  const legacyHint = executionContractType || normalizedIntentType || "generic";
+  return `reply_with_agent_context:${legacyHint}`;
 }
 
 export function evaluateTelegramRunnerTrigger(record, route, bot) {
@@ -184,8 +177,14 @@ export function buildRunnerInputPayload({
   const executionContractType = String(
     directHumanIntent.executionContractType || directHumanIntent.execution_contract_type || "",
   ).trim().toLowerCase();
+  const taskMetadata = buildRunnerTaskName(directHumanIntent.intentType, directHumanIntent);
   return {
-    task: buildRunnerTaskName(directHumanIntent.intentType, directHumanIntent),
+    task: taskMetadata,
+    task_metadata: {
+      legacy_task_hint: taskMetadata,
+      intent_type: String(directHumanIntent.intentType || "").trim(),
+      execution_contract_type: executionContractType,
+    },
     project_id: String(route?.projectID || "").trim(),
     provider: String(route?.provider || "").trim(),
     role: String(bot?.role || route?.role || "").trim(),

package/lib/selftest-runner-scenarios.mjs

@@ -4565,20 +4565,20 @@ export async function runSelftestRunnerScenarios(push, deps) {
       },
     });
     push(
-      "direct_human_public_delegate_reply_is_upgraded_to_actionable_contract",
+      "direct_human_public_delegate_reply_records_missing_contract_without_fabrication",
       processed.kind === "replied"
         && aiCalls === 1
         && String(deliveredConversation[0]?.mode || "") === "public_multi_bot"
         && String(deliveredConversation[0]?.leadBotUsername || "") === "ryoai_bot"
         && Array.isArray(deliveredConversation[0]?.allowedResponderSelectors)
         && deliveredConversation[0].allowedResponderSelectors.includes("ryoai3_bot")
-        && String(deliveredConversation[0]?.executionContract?.type || "") === "delegation"
-        && String(processed.result?.response_contract_validation_status || "") === "valid"
+        && !String(deliveredConversation[0]?.executionContract?.type || "").trim()
+        && String(processed.result?.response_contract_validation_status || "") === "missing_required_contract"
         && ensureArray(processed.result?.response_contract_validation_targets).includes("ryoai3_bot"),
       `kind=${String(processed.kind || "(none)")} ai_calls=${aiCalls} mode=${String(deliveredConversation[0]?.mode || "(none)")} contract=${String(deliveredConversation[0]?.executionContract?.type || "(none)")} validation=${String(processed.result?.response_contract_validation_status || "(none)")} targets=${JSON.stringify(processed.result?.response_contract_validation_targets || [])}`,
     );
   } catch (err) {
-    push("direct_human_public_delegate_reply_is_upgraded_to_actionable_contract", false, String(err?.message || err));
+    push("direct_human_public_delegate_reply_records_missing_contract_without_fabrication", false, String(err?.message || err));
   }
 
   try {
@@ -4718,20 +4718,20 @@ export async function runSelftestRunnerScenarios(push, deps) {
       },
     });
     push(
-      "direct_human_public_delegate_repairs_lead_bot_selector_for_archive_contract",
+      "direct_human_public_delegate_preserves_lead_context_while_recording_missing_contract",
       processed.kind === "replied"
         && aiCalls === 1
         && String(deliveredConversation[0]?.mode || "") === "public_multi_bot"
         && String(deliveredConversation[0]?.leadBotUsername || "") === "ryoai_bot"
         && Array.isArray(deliveredConversation[0]?.allowedResponderSelectors)
         && deliveredConversation[0].allowedResponderSelectors.includes("ryoai3_bot")
-        && String(deliveredConversation[0]?.executionContract?.type || "") === "delegation"
-        && String(processed.result?.response_contract_validation_status || "") === "valid",
+        && !String(deliveredConversation[0]?.executionContract?.type || "").trim()
+        && String(processed.result?.response_contract_validation_status || "") === "missing_required_contract",
       `kind=${String(processed.kind || "(none)")} ai_calls=${aiCalls} lead=${String(deliveredConversation[0]?.leadBotUsername || "(none)")} mode=${String(deliveredConversation[0]?.mode || "(none)")} validation=${String(processed.result?.response_contract_validation_status || "(none)")}`,
     );
-  } catch (err) {
-    push("direct_human_public_delegate_repairs_lead_bot_selector_for_archive_contract", false, String(err?.message || err));
-  }
+  } catch (err) {
+    push("direct_human_public_delegate_preserves_lead_context_while_recording_missing_contract", false, String(err?.message || err));
+  }
 
   try {
     let aiCalls = 0;
@@ -4865,19 +4865,19 @@ export async function runSelftestRunnerScenarios(push, deps) {
       },
     });
     push(
-      "direct_human_public_delegate_fallback_uses_response_allowed_responders",
+      "direct_human_public_delegate_records_allowed_responders_without_fabricated_contract",
       processed.kind === "replied"
         && aiCalls === 1
         && String(deliveredConversation[0]?.mode || "") === "public_multi_bot"
         && Array.isArray(deliveredConversation[0]?.allowedResponderSelectors)
         && deliveredConversation[0].allowedResponderSelectors.includes("ryoai3_bot")
-        && String(deliveredConversation[0]?.executionContract?.type || "") === "delegation"
-        && String(processed.result?.response_contract_validation_status || "") === "valid",
+        && !String(deliveredConversation[0]?.executionContract?.type || "").trim()
+        && String(processed.result?.response_contract_validation_status || "") === "missing_required_contract",
       `kind=${String(processed.kind || "(none)")} ai_calls=${aiCalls} mode=${String(deliveredConversation[0]?.mode || "(none)")} allowed=${JSON.stringify(deliveredConversation[0]?.allowedResponderSelectors || [])} contract=${String(deliveredConversation[0]?.executionContract?.type || "(none)")} validation=${String(processed.result?.response_contract_validation_status || "(none)")}`,
     );
-  } catch (err) {
-    push("direct_human_public_delegate_fallback_uses_response_allowed_responders", false, String(err?.message || err));
-  }
+  } catch (err) {
+    push("direct_human_public_delegate_records_allowed_responders_without_fabricated_contract", false, String(err?.message || err));
+  }
 
   try {
     let aiCalls = 0;

package/package.json

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