metheus-governance-mcp-cli 0.2.295 → 0.2.296

package/lib/runner-orchestration-entrypoints.mjs

@@ -383,6 +383,19 @@ function buildRunnerRequestFollowupSyntheticRecord(requestRaw, currentBotSelecto
       .map((value) => normalizeMentionSelector(value))
       .filter(Boolean),
   ));
+  const normalizedExecutionContractType = String(
+    request.execution_contract_type || request.normalized_execution_contract_type || "",
+  ).trim().toLowerCase() || "direct_result";
+  const normalizedSummaryBotSelector = normalizeMentionSelector(request.conversation_summary_bot);
+  const executionContract = {
+    type: normalizedExecutionContractType,
+    actionable: request.execution_contract_actionable === true,
+    assignments: executionTargets.map((targetBot) => ({
+      target_bot: targetBot,
+    })),
+    ...(normalizedSummaryBotSelector ? { summary_bot: normalizedSummaryBotSelector } : {}),
+    ...(nextResponders.length > 0 ? { next_responders: nextResponders } : {}),
+  };
   const replyOccurredAtMs = Date.parse(occurredAt);
   const maxPendingAgeMs = intFromRawAllowZero(safeObject(pendingSelectionOptions).maxPendingAgeMs, 0);
   const staleAfterAt = maxPendingAgeMs > 0 && Number.isFinite(replyOccurredAtMs)
@@ -412,27 +425,33 @@ function buildRunnerRequestFollowupSyntheticRecord(requestRaw, currentBotSelecto
       senderIsBot: true,
       username: senderSelector,
       botUsername: senderSelector,
-      mentionUsernames: ensureArray(replyEnvelope.mention_usernames),
+      mentionUsernames: uniqueOrdered([
+        ...ensureArray(replyEnvelope.mention_usernames)
+          .map((value) => normalizeMentionSelector(value))
+          .filter(Boolean),
+        ...nextResponders,
+      ]),
       occurredAt,
       body: String(replyEnvelope.body || "").trim(),
       conversationID: String(request.conversation_id || "").trim(),
-      conversationMode: String(request.conversation_intent_mode || "").trim(),
+      conversationMode: "public_multi_bot",
       conversationStage: "bot_reply",
+      conversationIntentMode: String(request.conversation_intent_mode || "").trim(),
       conversationAllowBotToBot: request.conversation_allow_bot_to_bot === true,
       conversationLeadBotUsername: normalizeMentionSelector(request.conversation_lead_bot),
-      conversationSummaryBotUsername: normalizeMentionSelector(request.conversation_summary_bot),
+      conversationSummaryBotUsername: normalizedSummaryBotSelector,
       conversationTargetBotUsername: nextResponders.length === 1 ? nextResponders[0] : "",
       conversationParticipants: participants,
       conversationInitialResponders: initialResponders,
       conversationAllowedResponders: allowedResponders,
       conversationReplyExpectation: String(request.conversation_reply_expectation || "").trim().toLowerCase(),
-      executionContractType: String(
-        request.execution_contract_type || request.normalized_execution_contract_type || "",
-      ).trim().toLowerCase(),
+      executionContract,
+      executionContractType: normalizedExecutionContractType,
       executionContractActionable: request.execution_contract_actionable === true,
       executionContractAssignments: executionTargets.map((targetBot) => ({
         targetBot,
       })),
+      executionContractSummaryBot: normalizedSummaryBotSelector,
       executionContractNextResponders: nextResponders,
       sourceOrigin: "request_followup_replay",
       sourceRouteKey: String(request.claimed_by_route || "").trim(),

package/lib/selftest-runner-scenarios.mjs

@@ -22236,7 +22236,10 @@ export async function runSelftestRunnerScenarios(push, deps) {
         && ensureArray(safeObject(pendingWork.pending).pending).length === 1
         && String(safeObject(ensureArray(pendingWork.requestFollowupPending)[0]).id || "").startsWith("request-followup:request-followup-1:498:ryoai_bot")
         && safeObject(safeObject(ensureArray(pendingWork.requestFollowupPending)[0]).parsedArchive).kind === "bot_reply"
-        && ensureArray(safeObject(safeObject(ensureArray(pendingWork.requestFollowupPending)[0]).parsedArchive).executionContractNextResponders).includes("ryoai_bot"),
+        && String(safeObject(safeObject(ensureArray(pendingWork.requestFollowupPending)[0]).parsedArchive).conversationMode || "") === "public_multi_bot"
+        && String(safeObject(safeObject(ensureArray(pendingWork.requestFollowupPending)[0]).parsedArchive).conversationIntentMode || "") === "multi_bot_direct"
+        && ensureArray(safeObject(safeObject(ensureArray(pendingWork.requestFollowupPending)[0]).parsedArchive).executionContractNextResponders).includes("ryoai_bot")
+        && ensureArray(safeObject(safeObject(safeObject(ensureArray(pendingWork.requestFollowupPending)[0]).parsedArchive).executionContract).next_responders).includes("ryoai_bot"),
       `replay=${ensureArray(pendingWork.requestFollowupPending).map((item) => String(safeObject(item).id || "")).join(",") || "(none)"} pending=${ensureArray(safeObject(pendingWork.pending).pending).map((item) => String(safeObject(item).id || "")).join(",") || "(none)"}`,
     );
   } catch (err) {
@@ -22310,6 +22313,174 @@ export async function runSelftestRunnerScenarios(push, deps) {
     push("runner_entrypoint_does_not_replay_request_followup_after_route_cursor", false, String(err?.message || err));
   }
 
+  try {
+    const pendingWork = selectRunnerPendingWorkEntrypoint({
+      comments: [],
+      importOutcome: {
+        importedCommentIDs: [],
+        importedComments: [],
+        currentPollLocalInboundReceipts: [],
+      },
+      refreshedState: {
+        last_processed_comment_id: "comment-before-followup-3",
+        last_processed_created_at: "2026-04-06T00:12:00.000Z",
+      },
+      mode: "continue",
+      parseArchivedChatComment,
+      deps: {
+        normalizeArchiveCommentRecord: (record) => ({
+          id: String(record?.id || "").trim(),
+          body: String(record?.body || "").trim(),
+          createdAt: String(record?.created_at || record?.createdAt || record?.updated_at || record?.updatedAt || "").trim(),
+          updatedAt: String(record?.updated_at || record?.updatedAt || "").trim(),
+          parsedArchive: safeObject(record?.parsedArchive),
+        }),
+        applyPendingAgeSelection: (selection) => selection,
+      },
+      pendingSelectionOptions: {},
+      followupRequests: [
+        {
+          request_key: "request-followup-3",
+          status: "running",
+          project_id: selftestProjectID,
+          provider: "telegram",
+          chat_id: "-100126",
+          conversation_id: "conversation-followup-3",
+          conversation_intent_mode: "multi_bot_direct",
+          conversation_allow_bot_to_bot: true,
+          conversation_participants: ["ryoai2_bot", "ryoai3_bot"],
+          conversation_initial_responders: ["ryoai2_bot", "ryoai3_bot"],
+          conversation_allowed_responders: ["ryoai2_bot", "ryoai3_bot"],
+          execution_contract_type: "direct_result",
+          execution_contract_actionable: true,
+          execution_contract_targets: ["ryoai2_bot", "ryoai3_bot"],
+          next_expected_responders: ["ryoai3_bot"],
+          updated_at: "2026-04-06T00:12:00.000Z",
+          last_reply_message_envelope: {
+            chat_id: "-100126",
+            message_id: 515,
+            reply_to_message_id: 514,
+            body: "안녕하세요, RyoAI2_bot입니다.",
+            sender: "@RyoAI2_bot",
+            sender_username: "ryoai2_bot",
+            sender_is_bot: true,
+            occurred_at: "2026-04-06T00:12:00.000Z",
+            canonical_human_message_key: "shared-human-key-515",
+          },
+        },
+      ],
+      currentBotSelector: "ryoai3_bot",
+    });
+    let aiCalls = 0;
+    const deliveredConversation = [];
+    const processed = await processRunnerSelectedRecord({
+      routeKey: "runner-followup-public-multi-bot-peer-key",
+      normalizedRoute: normalizeRunnerRoute({
+        name: "telegram-monitor-runner-followup-public-multi-bot-peer",
+        project_id: selftestProjectID,
+        provider: "telegram",
+        role: "monitor",
+        role_profile: "monitor",
+        destination_id: "dest-1",
+        destination_label: "Main Room",
+        server_bot_name: "RyoAI3_bot",
+        server_bot_id: "bot-peer-2",
+        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: ensureArray(pendingWork.requestFollowupPending)[0],
+      pendingOrdered: ensureArray(pendingWork.pending?.pending),
+      bot: {
+        id: "bot-peer-2",
+        name: "RyoAI3_bot",
+        username: "RyoAI3_bot",
+        role: "monitor",
+        provider: "telegram",
+      },
+      destination: {
+        id: "dest-1",
+        label: "Main Room",
+        provider: "telegram",
+        chatID: "-100126",
+      },
+      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-followup-public-multi-bot-peer"),
+        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: "안녕하세요, RyoAI3_bot입니다.",
+          };
+        },
+        performLocalBotDelivery: async ({ archiveConversation, archiveConversationContext, archiveExecutionContract }) => {
+          deliveredConversation.push(buildSelftestArchiveConversation({
+            archiveConversation,
+            archiveConversationContext,
+            archiveExecutionContract,
+          }));
+          return {
+            delivery: { dryRun: true, body: {} },
+            archive: {},
+          };
+        },
+        serializeRunnerTriggerPolicy: (value) => value,
+        serializeRunnerArchivePolicy: (value) => value,
+        buildRunnerExecutionDeps: () => ({}),
+        buildRunnerDeliveryDeps: () => ({}),
+        buildRunnerRuntimeDeps: () => ({}),
+        resolveConversationPeerBots: () => [
+          { id: "bot-peer-1", name: "RyoAI2_bot" },
+          { id: "bot-peer-2", name: "RyoAI3_bot" },
+        ],
+      },
+    });
+    push(
+      "runner_request_followup_public_multi_bot_continuation_is_authorized",
+      processed.kind === "replied"
+        && aiCalls === 1
+        && String(deliveredConversation[0]?.mode || "") === "public_multi_bot"
+        && String(deliveredConversation[0]?.intentMode || "") === "multi_bot_direct"
+        && ensureArray(deliveredConversation[0]?.allowedResponderSelectors).includes("ryoai3_bot"),
+      `kind=${String(processed.kind || "(none)")} ai_calls=${aiCalls} mode=${String(deliveredConversation[0]?.mode || "(none)")} intent=${String(deliveredConversation[0]?.intentMode || "(none)")} reason=${String(processed.skippedRecord?.reason || "(none)")}`,
+    );
+  } catch (err) {
+    push("runner_request_followup_public_multi_bot_continuation_is_authorized", false, String(err?.message || err));
+  }
+
   try {
     const deliveryContext = await prepareLocalBotDeliveryContext({
       siteBaseURL: "https://example.test",

package/package.json

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