metheus-governance-mcp-cli 0.2.209 → 0.2.210

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

@@ -4998,17 +4998,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 +5026,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 +5061,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 +5145,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;

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.210",
   "description": "Metheus Governance MCP CLI (setup + stdio proxy)",
   "type": "module",
   "files": [