metheus-governance-mcp-cli 0.2.201 → 0.2.202

package/cli.mjs

@@ -6319,6 +6319,7 @@ function stableTextModulo(rawValue, modulo = 1) {
   return hash % normalizedModulo;
 }
 
+/* Dead small_talk helper kept only as commented legacy code after lookup-only migration.
 function buildRunnerSmallTalkReply({ route, executionPlan } = {}) {
   const normalizedRoute = safeObject(route);
   const roleProfileName = normalizeRunnerRoleProfileName(
@@ -6355,6 +6356,7 @@ function buildRunnerSmallTalkReply({ route, executionPlan } = {}) {
   const templatePool = roleSpecificReplies[roleProfileName] || roleSpecificReplies.monitor;
   return templatePool[stableTextModulo(`${displayName}:${roleProfileName}`, templatePool.length)];
 }
+*/
 
 function buildInformationalMiniExecutionOverride({ route, executionPlan } = {}) {
   const safeRoute = safeObject(route);
@@ -6616,11 +6618,11 @@ async function resolveInformationalQueryReply({
         user_message: messageText,
         bot_name: firstNonEmptyString([route?.botName, route?.serverBotName, route?.server_bot_name, route?.name]),
         bot_role: String(route?.role || route?.roleProfile || "").trim(),
-        proposed_summary: buildRunnerSmallTalkReply({ route, executionPlan }),
       },
       execution_override: executionOverride,
     };
   }
+  /* Dead legacy direct small_talk branch kept commented for reference.
   if (false && normalizedIntentType === "small_talk") {
     return {
       handled: true,
@@ -6628,6 +6630,7 @@ async function resolveInformationalQueryReply({
       source: "small_talk",
     };
   }
+  */
   if (normalizedIntentType === "workspace_query") {
     const workspace = resolveProjectWorkspaceBindingSummary(route?.projectID, executionPlan?.workspaceDir || route?.workspaceDir || "");
     const workspaceDir = String(workspace.workspace_dir || "").trim();
@@ -6641,7 +6644,6 @@ async function resolveInformationalQueryReply({
       source: "project.workspace",
       lookup: {
         ...workspace,
-        proposed_summary: reply,
       },
       execution_override: executionOverride,
     };
@@ -6660,7 +6662,6 @@ async function resolveInformationalQueryReply({
       source: "project.bot_roles",
       lookup: {
         ...payload,
-        proposed_summary: buildProjectBotRolesText(payload),
       },
       execution_override: executionOverride,
     };
@@ -6730,7 +6731,6 @@ async function resolveInformationalQueryReply({
       source: "project.file.locate",
       lookup: {
         ...payload,
-        proposed_summary: buildProjectFileLocateText(payload),
       },
       execution_override: executionOverride,
     };
@@ -14394,21 +14394,6 @@ async function runSelftest(flags = {}) {
     String(parsedEnv.SLACK_BOT_TOKEN || "") === "xoxb-test",
     `token=${String(parsedEnv.SLACK_BOT_TOKEN || "(missing)")}`,
   );
-  const monitorGreeting = buildRunnerSmallTalkReply({
-    route: { botName: "RyoAI_bot", roleProfile: "monitor" },
-    executionPlan: { roleProfileName: "monitor" },
-  });
-  const reviewGreeting = buildRunnerSmallTalkReply({
-    route: { botName: "RyoAI2_bot", roleProfile: "review" },
-    executionPlan: { roleProfileName: "review" },
-  });
-  push(
-    "small_talk_reply_varies_by_bot_and_role",
-    monitorGreeting.includes("RyoAI_bot")
-      && reviewGreeting.includes("RyoAI2_bot")
-      && monitorGreeting !== reviewGreeting,
-    `monitor=${monitorGreeting} review=${reviewGreeting}`,
-  );
   const informationalMiniReply = await resolveInformationalQueryReply({
     intentType: "small_talk",
     route: { botName: "RyoAI_bot", role: "monitor", roleProfile: "monitor" },
@@ -14441,6 +14426,7 @@ async function runSelftest(flags = {}) {
     safeObject(informationalMiniReply).handled === true
       && String(safeObject(informationalMiniReply).response_mode || "") === "lookup_only"
       && String(safeObject(informationalMiniReply).reply || "") === ""
+      && !Object.prototype.hasOwnProperty.call(safeObject(safeObject(informationalMiniReply).lookup), "proposed_summary")
       && String(safeObject(safeObject(informationalMiniReply).execution_override).role_profile?.client || "") === "gpt"
       && String(safeObject(safeObject(informationalMiniReply).execution_override).role_profile?.model || "") === String(expectedInformationalModel || "")
       && String(safeObject(safeObject(informationalMiniReply).execution_override).role_profile?.permissionMode || "") === "read_only"

package/lib/local-ai-adapters.mjs

@@ -1786,9 +1786,6 @@ export function buildLocalBotPrompt(payload, { terse = true } = {}) {
     if (queryLookupResponseMode) {
       lines.push(`- Response mode: ${queryLookupResponseMode}`);
     }
-    if (String(queryLookup.proposed_reply || "").trim()) {
-      lines.push(`- Proposed factual reply: ${String(queryLookup.proposed_reply || "").trim()}`);
-    }
     if (queryLookupFacts != null) {
       lines.push("Structured lookup facts:");
       lines.push(JSON.stringify(queryLookupFacts, null, 2));
@@ -1994,7 +1991,7 @@ export function buildLocalBotPrompt(payload, { terse = true } = {}) {
         String(conversation.intent_mode || "").trim() === "delegated_single_lead"
           ? (selfIsLeadBot
             ? "This bot is the lead bot for a delegated public collaboration. It may assign work publicly only to allowed responders, and it may not expand the participant set."
-            : "This bot is not the lead bot. Respond only when the lead bot or the human explicitly addresses this bot, and do not start peer-to-peer chains.")
+            : "This bot is not the lead bot. Prefer replying when the human, the lead bot, or another managed bot explicitly addresses this bot in the live room context. Do not expand the participant set beyond the allowed responders.")
           : "Use the human conversation contract as the source of truth for who may reply.",
         conversation.allow_bot_to_bot === true
           ? "If another bot explicitly mentioned you and you are in the allowed responders list, you may answer that bot publicly in the room."

package/lib/runner-orchestration.mjs

@@ -3331,15 +3331,6 @@ async function resolvePublicConversationContext({
     },
     { currentBotSelector: senderBotSelector, excludeCurrentTargetAssignments: false },
   );
-  const assignmentTargets = uniqueOrdered(
-    ensureArray(executionContract?.assignments)
-      .map((item) => normalizeMentionSelector(item.targetBot))
-      .filter(Boolean),
-  );
-  const contractNextResponders = uniqueOrdered([
-    ...ensureArray(executionContract?.nextResponders).map((item) => normalizeMentionSelector(item)).filter(Boolean),
-    normalizeMentionSelector(executionContract?.summaryBot),
-  ]);
   if (!hasActiveRequest && String(session.status || "").trim() === "closed") {
     return {
       mode: "public_multi_bot",
@@ -3496,130 +3487,15 @@ async function resolvePublicConversationContext({
       session,
     };
   }
-  if (!executionContract || executionContract.actionable !== true) {
-    return {
-      mode: "public_multi_bot",
-      id: String(parsed.conversationID || "").trim(),
-      stage: "ignored_non_actionable_bot_reply",
-      skip: true,
-      reason: "bot reply did not include an actionable execution contract",
-      intentMode,
-      allowBotToBot,
-      participants: buildConversationParticipantViews(participants, peerMap),
-      participantSelectors: participants,
-      allowedResponders: buildConversationParticipantViews(normalizedAllowedResponders, peerMap),
-      allowedResponderSelectors: normalizedAllowedResponders,
-      summaryBotUsername: summaryBotSelector,
-      executionContract,
-      policy,
-      session,
-    };
-  }
-  if (intentMode === "delegated_single_lead" && normalizedLeadBotSelector) {
-    const senderIsLeadBot = senderBotSelector === normalizedLeadBotSelector;
-    const currentIsLeadBot = currentBotSelector === normalizedLeadBotSelector;
-    if (senderIsLeadBot) {
-      if (currentIsLeadBot) {
-        return {
-          mode: "public_multi_bot",
-          id: String(parsed.conversationID || "").trim(),
-          stage: "ignored_lead_waits_for_peer",
-          skip: true,
-          reason: "delegated single-lead conversation waits for a peer bot after the lead bot issues public instructions",
-          intentMode,
-          allowBotToBot,
-          participants: buildConversationParticipantViews(participants, peerMap),
-          participantSelectors: participants,
-          allowedResponders: buildConversationParticipantViews(normalizedAllowedResponders, peerMap),
-          allowedResponderSelectors: normalizedAllowedResponders,
-          summaryBotUsername: summaryBotSelector,
-          policy,
-          session,
-        };
-      }
-      if (executionContract.type !== "delegation" || !assignmentTargets.includes(currentBotSelector)) {
-        return {
-          mode: "public_multi_bot",
-          id: String(parsed.conversationID || "").trim(),
-          stage: "ignored_unaddressed_peer",
-          skip: true,
-          reason: "lead bot reply did not include an actionable assignment for this peer bot",
-          intentMode,
-          allowBotToBot,
-          participants: buildConversationParticipantViews(participants, peerMap),
-          participantSelectors: participants,
-          allowedResponders: buildConversationParticipantViews(normalizedAllowedResponders, peerMap),
-          allowedResponderSelectors: normalizedAllowedResponders,
-          summaryBotUsername: summaryBotSelector,
-          executionContract,
-          policy,
-          session,
-        };
-      }
-    } else if (currentIsLeadBot) {
-      if (!contractNextResponders.includes(currentBotSelector)) {
-        return {
-          mode: "public_multi_bot",
-          id: String(parsed.conversationID || "").trim(),
-          stage: "ignored_peer_without_lead_call",
-          skip: true,
-          reason: "peer reply did not request follow-up from the lead or summary bot",
-          intentMode,
-          allowBotToBot,
-          participants: buildConversationParticipantViews(participants, peerMap),
-          participantSelectors: participants,
-          allowedResponders: buildConversationParticipantViews(normalizedAllowedResponders, peerMap),
-          allowedResponderSelectors: normalizedAllowedResponders,
-          summaryBotUsername: summaryBotSelector,
-          executionContract,
-          policy,
-          session,
-        };
-      }
-    } else {
-      return {
-        mode: "public_multi_bot",
-        id: String(parsed.conversationID || "").trim(),
-        stage: "ignored_peer_to_peer_chain",
-        skip: true,
-        reason: "delegated single-lead conversation routes peer replies back to the lead bot only",
-        intentMode,
-        allowBotToBot,
-        participants: buildConversationParticipantViews(participants, peerMap),
-        participantSelectors: participants,
-        allowedResponders: buildConversationParticipantViews(normalizedAllowedResponders, peerMap),
-        allowedResponderSelectors: normalizedAllowedResponders,
-        summaryBotUsername: summaryBotSelector,
-        executionContract,
-        policy,
-        session,
-      };
-    }
-  }
-  const currentBotIsContractTarget = assignmentTargets.includes(currentBotSelector) || contractNextResponders.includes(currentBotSelector);
-  if (!currentBotIsContractTarget) {
-    return {
-      mode: "public_multi_bot",
-      id: String(parsed.conversationID || "").trim(),
-      stage: "ignored_unassigned_bot_reply",
-      skip: true,
-      reason: "execution contract did not target this bot",
-      intentMode,
-      allowBotToBot,
-      participants: buildConversationParticipantViews(participants, peerMap),
-      participantSelectors: participants,
-      allowedResponders: buildConversationParticipantViews(normalizedAllowedResponders, peerMap),
-      allowedResponderSelectors: normalizedAllowedResponders,
-      summaryBotUsername: summaryBotSelector,
-      executionContract,
-      policy,
-      session,
-    };
-  }
-  return {
-    mode: "public_multi_bot",
-    id: String(parsed.conversationID || "").trim(),
-    stage: "bot_reply",
+  // For public multi-bot bot replies, let the client AI decide whether the
+  // latest room message is a real delegation/follow-up. The runtime keeps only
+  // structural guards here (participant membership, allowed responders,
+  // self-reply, closed/expired sessions). Semantic contract interpretation is
+  // intentionally deferred to the AI layer.
+  return {
+    mode: "public_multi_bot",
+    id: String(parsed.conversationID || "").trim(),
+    stage: "bot_reply",
     intentMode,
     allowBotToBot,
     participants: buildConversationParticipantViews(participants, peerMap),

package/lib/runner-trigger.mjs

@@ -296,7 +296,6 @@ export function buildRunnerInputPayload({
           handled: true,
           source: String(safeDirectQueryReply.source || "").trim(),
           response_mode: String(safeDirectQueryReply.response_mode || "").trim(),
-          proposed_reply: String(safeDirectQueryReply.reply || "").trim(),
           facts: Object.prototype.hasOwnProperty.call(safeDirectQueryReply, "lookup")
             ? directQueryReply.lookup
             : null,

package/lib/selftest-runner-scenarios.mjs

@@ -8233,14 +8233,14 @@ export async function runSelftestRunnerScenarios(push, deps) {
       },
     });
     push(
-      "delegated_single_lead_blocks_peer_to_peer_chain",
-      processed.kind === "skipped"
-        && aiCalls === 0
-        && /lead bot only|lead bot/i.test(String(processed.skippedRecord?.reason || "")),
-      `kind=${String(processed.kind || "(none)")} ai_calls=${aiCalls} reason=${String(processed.skippedRecord?.reason || "(none)")}`,
+      "delegated_single_lead_peer_to_peer_reply_reaches_ai_decision",
+      processed.kind === "replied"
+        && aiCalls === 1
+        && String(processed.result?.execution_contract_type || "") === "summary_request",
+      `kind=${String(processed.kind || "(none)")} ai_calls=${aiCalls} contract=${String(processed.result?.execution_contract_type || "(none)")} reason=${String(processed.skippedRecord?.reason || "(none)")}`,
     );
   } catch (err) {
-    push("delegated_single_lead_blocks_peer_to_peer_chain", false, String(err?.message || err));
+    push("delegated_single_lead_peer_to_peer_reply_reaches_ai_decision", false, String(err?.message || err));
   }
 
   try {

package/package.json

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