metheus-governance-mcp-cli 0.2.278 → 0.2.279

package/lib/runner-orchestration-selected-record-contract-context.mjs

@@ -9,6 +9,14 @@ function ensureArray(value) {
   return Array.isArray(value) ? value : [];
 }
 
+function intFromRawAllowZero(raw, fallback = 0) {
+  if (raw === null || raw === undefined || raw === "") {
+    return fallback;
+  }
+  const parsed = Number.parseInt(String(raw).trim(), 10);
+  return Number.isFinite(parsed) ? parsed : fallback;
+}
+
 function uniqueOrdered(values) {
   const seen = new Set();
   const ordered = [];
@@ -21,6 +29,104 @@ function uniqueOrdered(values) {
   return ordered;
 }
 
+function normalizeSelectorList(values, normalizeMentionSelector) {
+  return uniqueOrdered(
+    ensureArray(values)
+      .map((item) => normalizeMentionSelector(item))
+      .filter(Boolean),
+  );
+}
+
+function buildImplicitPublicMultiBotExecutionContract({
+  conversationContext = null,
+  executionContract = null,
+  currentBotSelector = "",
+  normalizeMentionSelector,
+}) {
+  const context = safeObject(conversationContext);
+  const normalizedCurrentBotSelector = normalizeMentionSelector(currentBotSelector);
+  if (
+    String(context.mode || "").trim() !== "public_multi_bot"
+    || String(context.intentMode || "").trim() !== "multi_bot_collab"
+    || context.allowBotToBot !== true
+    || !normalizedCurrentBotSelector
+  ) {
+    return safeObject(executionContract);
+  }
+  const normalizedAllowedResponders = normalizeSelectorList(
+    context.allowedResponderSelectors,
+    normalizeMentionSelector,
+  );
+  if (
+    normalizedAllowedResponders.length < 2
+    || !normalizedAllowedResponders.includes(normalizedCurrentBotSelector)
+  ) {
+    return safeObject(executionContract);
+  }
+
+  const explicitContract = safeObject(executionContract);
+  const explicitAssignments = normalizeSelectorList(
+    ensureArray(explicitContract.assignments).map((item) => (
+      safeObject(item).targetBot || safeObject(item).target_bot
+    )),
+    normalizeMentionSelector,
+  ).filter((item) => item !== normalizedCurrentBotSelector);
+  const explicitNextResponders = normalizeSelectorList(
+    explicitContract.nextResponders || explicitContract.next_responders || explicitContract.responders,
+    normalizeMentionSelector,
+  ).filter((item) => item !== normalizedCurrentBotSelector);
+  const explicitSummaryBot = normalizeMentionSelector(
+    explicitContract.summaryBot || explicitContract.summary_bot || context.summaryBotUsername,
+  );
+  const explicitType = String(explicitContract.type || "").trim().toLowerCase();
+  const hasExplicitFollowup = explicitAssignments.length > 0
+    || explicitNextResponders.length > 0
+    || (explicitType === "summary_request" && explicitSummaryBot && explicitSummaryBot !== normalizedCurrentBotSelector);
+  if (hasExplicitFollowup) {
+    return explicitContract;
+  }
+
+  const sessionSpeakerCounts = safeObject(safeObject(context.session).speaker_counts);
+  const projectedSpeakerCounts = {
+    ...sessionSpeakerCounts,
+    [normalizedCurrentBotSelector]: intFromRawAllowZero(sessionSpeakerCounts[normalizedCurrentBotSelector], 0) + 1,
+  };
+  const remainingPeerResponders = normalizedAllowedResponders.filter((selector) => (
+    selector
+    && selector !== normalizedCurrentBotSelector
+    && intFromRawAllowZero(projectedSpeakerCounts[selector], 0) <= 0
+  ));
+  if (remainingPeerResponders.length > 0) {
+    return {
+      type: "delegation",
+      actionable: true,
+      assignments: remainingPeerResponders.map((targetBot) => ({ targetBot })),
+      summaryBot: explicitSummaryBot,
+      nextResponders: remainingPeerResponders,
+      implicitFollowup: true,
+    };
+  }
+
+  const stage = String(context.stage || "").trim().toLowerCase();
+  if (
+    stage === "bot_reply"
+    && explicitSummaryBot
+    && explicitSummaryBot !== normalizedCurrentBotSelector
+    && normalizedAllowedResponders.includes(explicitSummaryBot)
+  ) {
+    return {
+      type: "summary_request",
+      actionable: true,
+      assignments: [],
+      summaryBot: explicitSummaryBot,
+      nextResponders: [explicitSummaryBot],
+      implicitFollowup: true,
+    };
+  }
+
+  return explicitContract;
+}
+
 export async function prepareRunnerSelectedRecordContractContext({
   selectedRecord,
   routeState,
@@ -64,7 +170,7 @@ export async function prepareRunnerSelectedRecordContractContext({
   }
 
   const effectiveResponseContractPayload = safeObject(aiPayload?.response_contract);
-  const executionContract = conversationContext?.mode === "public_multi_bot"
+  const normalizedExecutionContract = conversationContext?.mode === "public_multi_bot"
     ? normalizeConversationExecutionContract(
         aiResult?.contract,
         {
@@ -78,6 +184,12 @@ export async function prepareRunnerSelectedRecordContractContext({
         effectiveResponseContractPayload,
         { currentBotSelector },
       );
+  const executionContract = buildImplicitPublicMultiBotExecutionContract({
+    conversationContext,
+    executionContract: normalizedExecutionContract,
+    currentBotSelector,
+    normalizeMentionSelector,
+  });
   let allowedActionableTypes = new Set(
     ensureArray(effectiveResponseContractPayload.allowed_contract_types)
       .map((item) => String(item || "").trim().toLowerCase())
@@ -99,7 +211,6 @@ export async function prepareRunnerSelectedRecordContractContext({
     && String(conversationContext?.stage || "").trim() === "human_opening"
     && conversationContext?.allowBotToBot === true
     && Boolean(currentBotSelector)
-    && normalizedConversationInitialResponders.length === 1
     && normalizedConversationInitialResponders.includes(currentBotSelector)
     && peerAllowedResponders.length > 0;
   const directHumanPeerMap = humanIntentContext?.peerMap instanceof Map

package/lib/selftest-runner-scenarios.mjs

@@ -2951,6 +2951,50 @@ export async function runSelftestRunnerScenarios(push, deps) {
       `status=${String(continuedRequest?.status || "(none)")}`,
     );
 
+    saveBotRunnerState({
+      routes: {
+        [requestRouteKey]: {},
+      },
+      sharedInboxes: {},
+      excludedComments: {},
+      requests: {
+        "request-key-2c": {
+          request_key: "request-key-2c",
+          project_id: selftestProjectID,
+          provider: "telegram",
+          chat_id: "-100123",
+          source_message_id: 721,
+          conversation_id: "conv-request-2c",
+          status: "running",
+          claimed_by_route: requestRouteKey,
+        },
+      },
+      consumedComments: {},
+    });
+    const continuedByNextExpected = markRunnerRequestLifecycle({
+      normalizedRoute: requestRoute,
+      requestKey: "request-key-2c",
+      selectedRecord: {
+        id: "comment-request-finish-2c",
+        parsedArchive: {
+          kind: "bot_reply",
+          chatID: "-100123",
+          messageID: 722,
+          conversationID: "conv-request-2c",
+        },
+      },
+      routeKey: requestRouteKey,
+      outcome: "replied",
+      currentBotSelector: "@RyoAI_bot",
+      executionContractTargets: [],
+      nextExpectedResponders: ["@RyoAI2_bot", "@RyoAI3_bot"],
+    });
+    push(
+      "runner_request_lifecycle_reply_remains_running_with_next_expected_responders",
+      String(continuedByNextExpected?.status || "") === "running",
+      `status=${String(continuedByNextExpected?.status || "(none)")}`,
+    );
+
     saveBotRunnerState({
       routes: {
         [requestRouteKey]: {},
@@ -5450,16 +5494,162 @@ export async function runSelftestRunnerScenarios(push, deps) {
         && String(deliveredConversation[0]?.summaryBotUsername || "") === "ryoai_bot",
       `kind=${String(processed.kind || "(none)")} intent=${String(deliveredConversation[0]?.intentMode || "(none)")} summary=${String(deliveredConversation[0]?.summaryBotUsername || "(none)")}`,
     );
-  } catch (err) {
-    push("intent_fallback_uses_repeated_managed_mention_for_summary_target", false, String(err?.message || err));
-  }
-
-  try {
-    const deliveredConversation = [];
-    const processed = await processRunnerSelectedRecord({
-      routeKey: "delegated-single-lead-human-open-key",
-      normalizedRoute: normalizeRunnerRoute({
-        name: "telegram-monitor-delegated-single-lead-open",
+  } catch (err) {
+    push("intent_fallback_uses_repeated_managed_mention_for_summary_target", false, String(err?.message || err));
+  }
+
+  try {
+    let aiCalls = 0;
+    const deliveredConversation = [];
+    const processed = await processRunnerSelectedRecord({
+      routeKey: "multi-bot-collab-human-opening-synthesizes-next-turn-contract-key",
+      normalizedRoute: normalizeRunnerRoute({
+        name: "telegram-monitor-multi-bot-collab-human-opening-synthesizes-next-turn-contract",
+        project_id: selftestProjectID,
+        provider: "telegram",
+        role: "monitor",
+        role_profile: "monitor",
+        destination_id: "dest-1",
+        destination_label: "Main Room",
+        server_bot_name: "RyoAI_bot",
+        server_bot_id: "bot-lead-1",
+        trigger_policy: {
+          mentions_only: true,
+          direct_messages: true,
+          reply_to_bot_messages: true,
+        },
+        archive_policy: {
+          mirror_replies: true,
+          dedupe_inbound: true,
+          dedupe_outbound: true,
+          skip_bot_messages: true,
+        },
+        dry_run_delivery: true,
+      }),
+      selectedRecord: {
+        id: "comment-multi-bot-collab-human-opening",
+        body: "@RyoAI_bot @RyoAI2_bot @RyoAI3_bot 같이 논의해줘.",
+        threadID: "thread-1",
+        createdAt: "2026-03-17T00:00:00.000Z",
+        updatedAt: "2026-03-17T00:00:00.000Z",
+        parsedArchive: {
+          kind: "telegram_message",
+          body: "@RyoAI_bot @RyoAI2_bot @RyoAI3_bot 같이 논의해줘.",
+          sender: "User",
+          senderName: "User",
+          senderIsBot: false,
+          username: "user1",
+          chatType: "supergroup",
+          mentionUsernames: ["ryoai_bot", "ryoai2_bot", "ryoai3_bot"],
+          messageID: 1901,
+          chatID: "-100123",
+        },
+      },
+      routeState: {},
+      pendingOrdered: [],
+      bot: {
+        id: "bot-lead-1",
+        name: "RyoAI_bot",
+        username: "RyoAI_bot",
+      },
+      destination: {
+        id: "dest-1",
+        label: "Main Room",
+        provider: "telegram",
+        chatID: "-100123",
+      },
+      archiveThread: {
+        threadID: "thread-1",
+        workItemID: "work-item-1",
+      },
+      executionPlan: {
+        mode: "role_profile",
+        roleProfileName: "monitor",
+        roleProfile: {
+          client: "sample",
+          model: "",
+          permissionMode: "read_only",
+          reasoningEffort: "low",
+        },
+        workspaceDir: path.join(os.tmpdir(), "metheus-runner-selftest-multi-bot-collab-kickoff"),
+        workspaceSource: "selftest",
+        usedCommandFallback: false,
+      },
+      runtime: {
+        baseURL: "https://example.test",
+        token: "selftest-token",
+        timeoutSeconds: 30,
+        actor: { user_id: "user-1" },
+      },
+      deps: {
+        saveRunnerRouteState: () => {},
+        startRunnerTypingHeartbeat: () => ({ async stop() {} }),
+        runRunnerAIExecution: async () => {
+          aiCalls += 1;
+          return {
+            skip: false,
+            reply: "좋아요. 먼저 제 관점을 짧게 정리하고, 다른 봇 의견도 이어서 받겠습니다.",
+            replyToMessageID: 0,
+          };
+        },
+        performLocalBotDelivery: async ({ archiveConversation, archiveConversationContext, archiveExecutionContract }) => {
+          deliveredConversation.push(buildSelftestArchiveConversation({
+            archiveConversation,
+            archiveConversationContext,
+            archiveExecutionContract,
+          }));
+          return {
+            delivery: { dryRun: true, body: {} },
+            archive: {},
+          };
+        },
+        serializeRunnerTriggerPolicy: (value) => value,
+        serializeRunnerArchivePolicy: (value) => value,
+        buildRunnerExecutionDeps: () => ({
+          analyzeHumanConversationIntentWithAI: async () => ({
+            mode: "multi_bot_collab",
+            intent_type: "explanation_query",
+            lead_bot: "ryoai_bot",
+            participants: ["ryoai_bot", "ryoai2_bot", "ryoai3_bot"],
+            initial_responders: ["ryoai_bot", "ryoai2_bot", "ryoai3_bot"],
+            allowed_responders: ["ryoai_bot", "ryoai2_bot", "ryoai3_bot"],
+            summary_bot: "ryoai_bot",
+            allow_bot_to_bot: true,
+            reply_expectation: "informational",
+          }),
+        }),
+        buildRunnerDeliveryDeps: () => ({}),
+        buildRunnerRuntimeDeps: () => ({}),
+        resolveConversationPeerBots: () => [
+          { id: "bot-lead-1", name: "RyoAI_bot" },
+          { id: "bot-peer-1", name: "RyoAI2_bot" },
+          { id: "bot-peer-2", name: "RyoAI3_bot" },
+        ],
+      },
+    });
+    push(
+      "multi_bot_collab_human_opening_synthesizes_shared_next_turn_contract",
+      processed.kind === "replied"
+        && aiCalls === 1
+        && String(deliveredConversation[0]?.mode || "") === "public_multi_bot"
+        && String(deliveredConversation[0]?.executionContract?.type || "") === "delegation"
+        && ensureArray(deliveredConversation[0]?.executionContract?.nextResponders).includes("ryoai2_bot")
+        && ensureArray(deliveredConversation[0]?.executionContract?.nextResponders).includes("ryoai3_bot")
+        && ensureArray(processed.result?.next_expected_responders).includes("ryoai2_bot")
+        && ensureArray(processed.result?.next_expected_responders).includes("ryoai3_bot")
+        && String(processed.result?.response_contract_validation_status || "") === "valid",
+      `kind=${String(processed.kind || "(none)")} ai_calls=${aiCalls} contract=${String(deliveredConversation[0]?.executionContract?.type || "(none)")} next=${JSON.stringify(processed.result?.next_expected_responders || [])} validation=${String(processed.result?.response_contract_validation_status || "(none)")}`,
+    );
+  } catch (err) {
+    push("multi_bot_collab_human_opening_synthesizes_shared_next_turn_contract", false, String(err?.message || err));
+  }
+
+  try {
+    const deliveredConversation = [];
+    const processed = await processRunnerSelectedRecord({
+      routeKey: "delegated-single-lead-human-open-key",
+      normalizedRoute: normalizeRunnerRoute({
+        name: "telegram-monitor-delegated-single-lead-open",
         project_id: selftestProjectID,
         provider: "telegram",
         role: "monitor",

package/package.json

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