metheus-governance-mcp-cli 0.2.209 → 0.2.211

package/cli.mjs

@@ -3591,13 +3591,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;

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.",
           );

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",
@@ -4998,17 +5009,22 @@ export async function processRunnerSelectedRecord({
   const directHumanPeerMap = humanIntentContext?.peerMap instanceof Map
     ? humanIntentContext.peerMap
     : buildConversationPeerMap(bot, normalizedRoute, executionDeps);
-  const delegatedBotMentions = (
-    effectiveTriggerDecision.requiresDirectReply === true
-    && !conversationContext
-    && !safeObject(selectedRecord?.parsedArchive).senderIsBot
-  )
-    ? extractManagedPeerMentionSelectors(
-      String(aiResult.reply || "").trim(),
-      directHumanPeerMap,
-      currentBotSelector,
+  const delegatedBotMentions = extractManagedPeerMentionSelectors(
+    String(aiResult.reply || "").trim(),
+    directHumanPeerMap,
+    currentBotSelector,
+  );
+  const requiredDelegationTargets = uniqueOrdered(
+    (
+      delegatedBotMentions.length > 0
+        ? delegatedBotMentions
+        : requiresPeerDelegationContract
+          ? peerAllowedResponders
+          : []
     )
-    : [];
+      .map((item) => normalizeMentionSelector(item))
+      .filter(Boolean),
+  );
   if (delegatedBotMentions.length > 0) {
     allowedActionableTypes = new Set(["delegation"]);
   }
@@ -5021,7 +5037,7 @@ export async function processRunnerSelectedRecord({
     && executionContract.actionable === true
     && (!allowedActionableTypes.size || allowedActionableTypes.has(String(executionContract.type || "").trim().toLowerCase())),
   );
-  if (!requiresActionableContract && delegatedBotMentions.length > 0) {
+  if (!requiresActionableContract && requiredDelegationTargets.length > 0) {
     requiresActionableContract = true;
   }
   if (
@@ -5056,25 +5072,27 @@ export async function processRunnerSelectedRecord({
         allow_skip: false,
         must_reply: true,
         require_actionable_contract: true,
-        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(),
-        human_summary_bot: delegatedBotMentions.length > 0
-          ? String(delegatedBotMentions[0] || "").trim()
-          : String(effectiveResponseContractPayload.human_summary_bot || "").trim(),
+        human_intent_mode: String(effectiveResponseContractPayload.human_intent_mode || "").trim(),
+        human_lead_bot: String(effectiveResponseContractPayload.human_lead_bot || "").trim(),
+        human_summary_bot: String(effectiveResponseContractPayload.human_summary_bot || "").trim(),
         human_allowed_responders: ensureArray(effectiveResponseContractPayload.human_allowed_responders).length
           ? ensureArray(effectiveResponseContractPayload.human_allowed_responders)
           : uniqueOrdered([
             currentBotSelector,
-            ...(delegatedBotMentions.length > 0 ? delegatedBotMentions : peerAllowedResponders),
+            ...requiredDelegationTargets,
           ].filter(Boolean)),
-        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"]
+        allow_bot_to_bot: requiredDelegationTargets.length > 0
+          || requiresPeerDelegationContract
+          || effectiveResponseContractPayload.human_intent_mode === "delegated_single_lead",
+        allowed_contract_types: requiredDelegationTargets.length > 0 || requiresPeerDelegationContract
+          ? ["delegation"]
           : ensureArray(effectiveResponseContractPayload.allowed_contract_types).length
             ? ensureArray(effectiveResponseContractPayload.allowed_contract_types)
             : ["direct_result", "summary_request", "final_summary"],
+        required_delegation_targets: requiredDelegationTargets,
+        contract_hint: requiredDelegationTargets.length > 0
+          ? `Your previous reply mentioned ${requiredDelegationTargets.map((item) => `@${String(item || "").trim().replace(/^@+/, "")}`).join(", ")} without a delegation contract. Return contract.type=\"delegation\" with actionable=true, assignments for those exact bots, and matching next_responders.`
+          : "",
       },
     };
     effectiveResponseContractPayload = safeObject(forcedContractPayload.response_contract);
@@ -5138,7 +5156,9 @@ export async function processRunnerSelectedRecord({
   if (requiresActionableContract) {
     const validContract = hasValidActionableContract;
     if (!validContract) {
-      const reason = "reply did not produce an actionable execution contract";
+      const reason = requiredDelegationTargets.length > 0
+        ? `reply mentioned managed peer bot(s) ${requiredDelegationTargets.map((item) => `@${String(item || "").trim().replace(/^@+/, "")}`).join(", ")} without a required delegation contract`
+        : "reply did not produce an actionable execution contract";
         const directHumanExecutionFailure = effectiveTriggerDecision.requiresDirectReply === true
         && !conversationContext
         && !safeObject(selectedRecord?.parsedArchive).senderIsBot;
@@ -5184,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
@@ -5193,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

@@ -4386,10 +4386,11 @@ export async function runSelftestRunnerScenarios(push, deps) {
     push("delegated_single_lead_human_opening_creates_expandable_contract", false, String(err?.message || err));
   }
 
-  try {
-    let aiCalls = 0;
-    const deliveredConversation = [];
-    const processed = await processRunnerSelectedRecord({
+  try {
+    let aiCalls = 0;
+    const deliveredConversation = [];
+    let forcedContractPayload = null;
+    const processed = await processRunnerSelectedRecord({
       routeKey: "direct-human-delegation-contract-upgrade-key",
       normalizedRoute: normalizeRunnerRoute({
         name: "telegram-monitor-direct-human-delegation-contract-upgrade",
@@ -4464,15 +4465,16 @@ export async function runSelftestRunnerScenarios(push, deps) {
         timeoutSeconds: 30,
         actor: { user_id: "user-1" },
       },
-      deps: {
-        saveRunnerRouteState: () => {},
-        startRunnerTypingHeartbeat: () => ({ async stop() {} }),
-        runRunnerAIExecution: async ({ inputPayload }) => {
-          aiCalls += 1;
-          if (safeObject(inputPayload?.response_contract).require_actionable_contract === true) {
-            return {
-              skip: false,
-              reply: "@RyoAI3_bot briefly greet everyone in this room and state your role in one line.",
+      deps: {
+        saveRunnerRouteState: () => {},
+        startRunnerTypingHeartbeat: () => ({ async stop() {} }),
+        runRunnerAIExecution: async ({ inputPayload }) => {
+          aiCalls += 1;
+          if (safeObject(inputPayload?.response_contract).require_actionable_contract === true) {
+            forcedContractPayload = inputPayload;
+            return {
+              skip: false,
+              reply: "@RyoAI3_bot briefly greet everyone in this room and state your role in one line.",
               replyToMessageID: 0,
               contract: {
                 type: "delegation",
@@ -4530,16 +4532,17 @@ export async function runSelftestRunnerScenarios(push, deps) {
         && Array.isArray(deliveredConversation[0]?.allowedResponderSelectors)
         && deliveredConversation[0].allowedResponderSelectors.includes("ryoai3_bot")
         && String(deliveredConversation[0]?.executionContract?.type || "") === "delegation",
-      `kind=${String(processed.kind || "(none)")} ai_calls=${aiCalls} mode=${String(deliveredConversation[0]?.mode || "(none)")} contract=${String(deliveredConversation[0]?.executionContract?.type || "(none)")}`,
-    );
-  } catch (err) {
-    push("direct_human_public_delegate_reply_is_upgraded_to_actionable_contract", false, String(err?.message || err));
-  }
+      `kind=${String(processed.kind || "(none)")} ai_calls=${aiCalls} mode=${String(deliveredConversation[0]?.mode || "(none)")} contract=${String(deliveredConversation[0]?.executionContract?.type || "(none)")} required_targets=${JSON.stringify(safeObject(forcedContractPayload?.response_contract).required_delegation_targets || [])}`,
+    );
+  } catch (err) {
+    push("direct_human_public_delegate_reply_is_upgraded_to_actionable_contract", false, String(err?.message || err));
+  }
 
-  try {
-    let aiCalls = 0;
-    const deliveredConversation = [];
-    const processed = await processRunnerSelectedRecord({
+  try {
+    let aiCalls = 0;
+    const deliveredConversation = [];
+    let forcedContractPayload = null;
+    const processed = await processRunnerSelectedRecord({
       routeKey: "direct-human-public-delegate-repairs-lead-bot-key",
       normalizedRoute: normalizeRunnerRoute({
         name: "telegram-monitor-direct-human-public-delegate-repairs-lead-bot",
@@ -4686,10 +4689,11 @@ export async function runSelftestRunnerScenarios(push, deps) {
     push("direct_human_public_delegate_repairs_lead_bot_selector_for_archive_contract", false, String(err?.message || err));
   }
 
-  try {
-    let aiCalls = 0;
-    const deliveredConversation = [];
-    const processed = await processRunnerSelectedRecord({
+  try {
+    let aiCalls = 0;
+    const deliveredConversation = [];
+    let forcedContractPayload = null;
+    const processed = await processRunnerSelectedRecord({
       routeKey: "direct-human-public-delegate-fallback-uses-response-allowed-responders-key",
       normalizedRoute: normalizeRunnerRoute({
         name: "telegram-monitor-direct-human-public-delegate-fallback-uses-response-allowed-responders",
@@ -4830,10 +4834,11 @@ export async function runSelftestRunnerScenarios(push, deps) {
     push("direct_human_public_delegate_fallback_uses_response_allowed_responders", false, String(err?.message || err));
   }
 
-  try {
-    let aiCalls = 0;
-    const deliveredConversation = [];
-    const processed = await processRunnerSelectedRecord({
+  try {
+    let aiCalls = 0;
+    const deliveredConversation = [];
+    let forcedContractPayload = null;
+    const processed = await processRunnerSelectedRecord({
       routeKey: "direct-human-public-summary-fallback-contract-key",
       normalizedRoute: normalizeRunnerRoute({
         name: "telegram-monitor-direct-human-public-summary-fallback-contract",
@@ -4910,13 +4915,14 @@ export async function runSelftestRunnerScenarios(push, deps) {
       },
       deps: {
         saveRunnerRouteState: () => {},
-        startRunnerTypingHeartbeat: () => ({ async stop() {} }),
-        runRunnerAIExecution: async ({ inputPayload }) => {
-          aiCalls += 1;
-          if (safeObject(inputPayload?.response_contract).require_actionable_contract === true) {
-            return {
-              skip: false,
-              reply: "@RyoAI3_bot briefly answer now.",
+        startRunnerTypingHeartbeat: () => ({ async stop() {} }),
+        runRunnerAIExecution: async ({ inputPayload }) => {
+          aiCalls += 1;
+          if (safeObject(inputPayload?.response_contract).require_actionable_contract === true) {
+            forcedContractPayload = inputPayload;
+            return {
+              skip: false,
+              reply: "@RyoAI3_bot briefly answer now.",
               replyToMessageID: 0,
               contract: {
                 type: "summary_request",
@@ -4963,26 +4969,26 @@ export async function runSelftestRunnerScenarios(push, deps) {
         ],
       },
     });
-    push(
-      "direct_human_public_summary_request_fallback_builds_actionable_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 || "") === "summary_request",
-      `kind=${String(processed.kind || "(none)")} ai_calls=${aiCalls} lead=${String(deliveredConversation[0]?.leadBotUsername || "(none)")} contract=${String(deliveredConversation[0]?.executionContract?.type || "(none)")} reason=${String(processed.skippedRecord?.reason || "(none)")}`,
-    );
-  } catch (err) {
-    push("direct_human_public_summary_request_fallback_builds_actionable_contract", false, String(err?.message || err));
-  }
+    push(
+      "direct_human_public_peer_mention_rejects_summary_request_without_delegation",
+      processed.kind === "skipped"
+        && aiCalls >= 1
+        && deliveredConversation.length === 0
+        && ensureArray(safeObject(forcedContractPayload?.response_contract).required_delegation_targets).includes("ryoai3_bot")
+        && String(safeObject(forcedContractPayload?.response_contract).contract_hint || "").trim().length > 0
+        && String(processed.skippedRecord?.reason || "").includes("delegation contract"),
+      `kind=${String(processed.kind || "(none)")} ai_calls=${aiCalls} required_targets=${JSON.stringify(safeObject(forcedContractPayload?.response_contract).required_delegation_targets || [])} reason=${String(processed.skippedRecord?.reason || "(none)")}`,
+    );
+  } catch (err) {
+    push("direct_human_public_peer_mention_rejects_summary_request_without_delegation", false, String(err?.message || err));
+  }
 
-  try {
-    let aiCalls = 0;
-    let deliveryCalls = 0;
-    let deliveredText = "";
-    const processed = await processRunnerSelectedRecord({
+  try {
+    let aiCalls = 0;
+    let deliveryCalls = 0;
+    let deliveredText = "";
+    let forcedContractPayload = null;
+    const processed = await processRunnerSelectedRecord({
       routeKey: "delegated-single-lead-dead-end-key",
       normalizedRoute: normalizeRunnerRoute({
         name: "telegram-monitor-delegated-single-lead-dead-end",
@@ -5057,14 +5063,17 @@ export async function runSelftestRunnerScenarios(push, deps) {
         timeoutSeconds: 30,
         actor: { user_id: "user-1" },
       },
-      deps: {
-        saveRunnerRouteState: () => {},
-        startRunnerTypingHeartbeat: () => ({ async stop() {} }),
-        runRunnerAIExecution: async () => {
-          aiCalls += 1;
-          return {
-            skip: false,
-            reply: "I will analyze first and come back later.",
+      deps: {
+        saveRunnerRouteState: () => {},
+        startRunnerTypingHeartbeat: () => ({ async stop() {} }),
+        runRunnerAIExecution: async ({ inputPayload }) => {
+          aiCalls += 1;
+          if (safeObject(inputPayload?.response_contract).require_actionable_contract === true) {
+            forcedContractPayload = inputPayload;
+          }
+          return {
+            skip: false,
+            reply: "I will analyze first and come back later.",
             replyToMessageID: 0,
           };
         },
@@ -5100,16 +5109,19 @@ export async function runSelftestRunnerScenarios(push, deps) {
         ],
       },
     });
-    push(
-      "delegated_single_lead_lead_opening_requires_delegation_contract_for_peer_followup",
-      processed.kind === "skipped"
-        && aiCalls === 2
-        && !String(deliveredText || "").trim(),
-      `kind=${String(processed.kind || "(none)")} ai_calls=${aiCalls} reply=${String(deliveredText || "(none)")}`,
-    );
-  } catch (err) {
-    push("delegated_single_lead_lead_opening_requires_delegation_contract_for_peer_followup", false, String(err?.message || err));
-  }
+    push(
+      "delegated_single_lead_lead_opening_requires_delegation_contract_for_peer_followup",
+      processed.kind === "skipped"
+        && aiCalls === 2
+        && !String(deliveredText || "").trim()
+        && ensureArray(safeObject(forcedContractPayload?.response_contract).required_delegation_targets).includes("ryoai2_bot")
+        && ensureArray(safeObject(forcedContractPayload?.response_contract).required_delegation_targets).includes("ryoai3_bot")
+        && String(safeObject(forcedContractPayload?.response_contract).contract_hint || "").trim().length > 0,
+      `kind=${String(processed.kind || "(none)")} ai_calls=${aiCalls} reply=${String(deliveredText || "(none)")} required_targets=${JSON.stringify(safeObject(forcedContractPayload?.response_contract).required_delegation_targets || [])} hint=${String(safeObject(forcedContractPayload?.response_contract).contract_hint || "(none)")}`,
+    );
+  } catch (err) {
+    push("delegated_single_lead_lead_opening_requires_delegation_contract_for_peer_followup", false, String(err?.message || err));
+  }
 
   try {
     let aiCalls = 0;
@@ -9966,14 +9978,51 @@ export async function runSelftestRunnerScenarios(push, deps) {
         && !prompt.includes("Archived Note"),
       `kind=${String(processed.kind || "(none)")} ai_calls=${aiCalls} contexts=${projectContexts.map((item) => item.title).join(",") || "(none)"} prompt_has_active_context=${String(prompt.includes("Active project context"))}`,
     );
-  } catch (err) {
-    push("active_project_context_is_injected_into_runner_prompt", false, String(err?.message || err));
-  }
-
-  try {
-    const createCalls = [];
-    let lastSavedState = null;
-    const workspaceDir = fs.mkdtempSync(path.join(os.tmpdir(), "metheus-runner-selftest-context-suggest-"));
+  } catch (err) {
+    push("active_project_context_is_injected_into_runner_prompt", false, String(err?.message || err));
+  }
+
+  try {
+    const prompt = buildLocalBotPrompt({
+      bot: {
+        name: "RyoAI_bot",
+        username: "RyoAI_bot",
+        role: "monitor",
+      },
+      trigger: {
+        body: "@RyoAI_bot ask @RyoAI2_bot to greet in one line",
+      },
+      response_contract: {
+        is_current_bot_candidate: true,
+        require_actionable_contract: true,
+        allowed_contract_types: ["delegation"],
+        required_delegation_targets: ["ryoai2_bot"],
+        contract_hint: "Previous reply mentioned @ryoai2_bot without a delegation contract.",
+      },
+      destination: {
+        label: "Main Room",
+        chat_id: "-100123",
+      },
+      project: {
+        id: selftestProjectID,
+      },
+    }, { terse: true });
+    push(
+      "local_bot_prompt_requires_contract_for_peer_mentions",
+      prompt.includes("Without a matching contract, mentioned bots will not act.")
+        && prompt.includes("@ryoai2_bot")
+        && prompt.includes("contract.type=\"delegation\"")
+        && prompt.includes("Previous reply mentioned @ryoai2_bot without a delegation contract."),
+      prompt,
+    );
+  } catch (err) {
+    push("local_bot_prompt_requires_contract_for_peer_mentions", false, String(err?.message || err));
+  }
+
+  try {
+    const createCalls = [];
+    let lastSavedState = null;
+    const workspaceDir = fs.mkdtempSync(path.join(os.tmpdir(), "metheus-runner-selftest-context-suggest-"));
     const processed = await processRunnerSelectedRecord({
       routeKey: "context-suggest-human-rule-key",
       normalizedRoute: normalizeRunnerRoute({

package/package.json

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