metheus-governance-mcp-cli 0.2.228 → 0.2.230

package/lib/gateway-transport.mjs

@@ -1,6 +1,48 @@
 import http from "node:http";
 import https from "node:https";
 
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function isTransientGatewayTransportError(err) {
+  const code = String(err?.code || "").trim().toUpperCase();
+  const text = String(err?.message || err || "").toLowerCase();
+  if ([
+    "ECONNRESET",
+    "EPIPE",
+    "ETIMEDOUT",
+    "ECONNABORTED",
+    "EAI_AGAIN",
+  ].includes(code)) {
+    return true;
+  }
+  return [
+    "timeout",
+    "socket hang up",
+    "bad record mac",
+    "decryption failed",
+    "tls_get_more_records",
+  ].some((item) => text.includes(item));
+}
+
+async function withTransientGatewayRetry(operation) {
+  const maxAttempts = 3;
+  let lastError = null;
+  for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+    try {
+      return await Promise.resolve(operation(attempt));
+    } catch (err) {
+      lastError = err;
+      if (attempt >= maxAttempts || !isTransientGatewayTransportError(err)) {
+        throw err;
+      }
+      await sleep(250 * attempt);
+    }
+  }
+  throw lastError || new Error("gateway transport failed");
+}
+
 function safeObject(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) return {};
   return value;
@@ -32,7 +74,7 @@ export function parseToolEnvelopeFromRPCResult(resultObj, deps) {
 }
 
 export async function postJSON(urlText, timeoutSeconds, token, payload) {
-  return new Promise((resolve, reject) => {
+  return withTransientGatewayRetry(() => new Promise((resolve, reject) => {
     const url = new URL(urlText);
     const body = Buffer.from(JSON.stringify(payload));
     const transport = url.protocol === "http:" ? http : https;
@@ -74,11 +116,11 @@ export async function postJSON(urlText, timeoutSeconds, token, payload) {
     req.on("error", reject);
     req.write(body);
     req.end();
-  });
+  }));
 }
 
 export function getJSONWithAuthHeaders(urlText, timeoutSeconds, token, extraHeaders = {}) {
-  return new Promise((resolve, reject) => {
+  return withTransientGatewayRetry(() => new Promise((resolve, reject) => {
     const url = new URL(urlText);
     const transport = url.protocol === "http:" ? http : https;
     const req = transport.request(
@@ -121,7 +163,7 @@ export function getJSONWithAuthHeaders(urlText, timeoutSeconds, token, extraHead
     });
     req.on("error", reject);
     req.end();
-  });
+  }));
 }
 
 export function getJSONWithAuth(urlText, timeoutSeconds, token) {

package/lib/local-ai-adapters.mjs

@@ -2158,8 +2158,11 @@ export function buildLocalBotPrompt(payload, { terse = true } = {}) {
           lines.push(
             "As an expected follow-up responder, contribute the assigned perspective or delegated result now.",
             "A valid follow-up may be a concise opinion, analysis, review, comparison, synthesis, or direct delegated result.",
+            "Do not ask the human to restate the project goal, current status, or blockers before contributing your assigned perspective.",
+            "Use the current room context and execution contract first. If context is limited, state your assumptions explicitly and still provide the best concise contribution you can now.",
             "Mentioning the lead bot for acknowledgment or handoff does not require a new delegation contract.",
             "Do not wake any third bot. Only the lead bot may delegate new public work in this conversation.",
+            "Do not create a new delegation contract unless the current contract explicitly authorizes this bot to hand work onward.",
             "If any other expected responder besides this bot still remains in the current execution contract, do not emit contract.type=\"summary_request\" yet.",
             "Only the final remaining contributor may hand control back to the designated summary bot with contract.type=\"summary_request\".",
           );

package/lib/runner-orchestration.mjs

@@ -5411,36 +5411,9 @@ export async function processRunnerSelectedRecord({
       },
     };
   }
-  if (
-    conversationContext?.mode === "public_multi_bot"
-    && String(conversationContext.intentMode || "").trim() === "delegated_single_lead"
-    && currentBotSelector
-    && currentBotSelector !== normalizeMentionSelector(conversationContext.leadBotUsername)
-    && executionContract?.type === "delegation"
-  ) {
-    const reason = "only the delegated lead bot may issue new public assignments";
-    saveRunnerRouteState(
-      routeKey,
-      buildRunnerRouteStateFromComment(selectedRecord, {
-        last_action: "conversation_skipped",
-        last_reason: reason,
-        last_conversation_id: String(conversationContext?.id || "").trim(),
-        last_conversation_stage: String(conversationContext?.stage || "").trim(),
-        ...intentStatePatch,
-      }),
-    );
-    return {
-      kind: "skipped",
-      skippedRecord: {
-        id: selectedRecord.id,
-        reason,
-        messageID: intFromRawAllowZero(selectedRecord?.parsedArchive?.messageID, 0),
-      },
-    };
-  }
   const replyToMessageID = aiResult.replyToMessageID > 0
-    ? aiResult.replyToMessageID
-    : intFromRawAllowZero(selectedRecord.parsedArchive?.messageID, 0);
+    ? aiResult.replyToMessageID
+    : intFromRawAllowZero(selectedRecord.parsedArchive?.messageID, 0);
   const sanitizedReplyText = sanitizeForcedDirectReplyText({
     replyText: aiResult.reply,
     bot,
@@ -5476,6 +5449,80 @@ export async function processRunnerSelectedRecord({
       };
     }
   }
+  if (
+    responseContractValidation.ok
+    && effectiveConversationContext?.mode === "public_multi_bot"
+    && String(effectiveConversationContext.intentMode || "").trim() === "delegated_single_lead"
+    && currentBotSelector
+    && currentBotSelector !== normalizeMentionSelector(effectiveConversationContext.leadBotUsername)
+    && normalizedExecutionContractType === "delegation"
+  ) {
+    const unauthorizedDelegationTargets = uniqueOrdered([
+      ...ensureArray(executionContract?.assignments)
+        .map((item) => normalizeMentionSelector(item?.targetBot))
+        .filter(Boolean),
+      ...collectExecutionContractNextResponders(executionContract)
+        .map((item) => normalizeMentionSelector(item))
+        .filter(Boolean),
+    ]).filter((item) => item && item !== currentBotSelector);
+    if (unauthorizedDelegationTargets.length > 0) {
+      responseContractValidation = {
+        ok: false,
+        status: "non_lead_public_assignment",
+        reason: "only the delegated lead bot may issue new public assignments",
+        targets: unauthorizedDelegationTargets,
+      };
+    }
+  }
+  if (!responseContractValidation.ok && String(responseContractValidation.status || "").trim() === "non_lead_public_assignment") {
+    const reason = String(responseContractValidation.reason || "").trim()
+      || "response contract validation failed";
+    saveRunnerRouteState(
+      routeKey,
+      buildRunnerRouteStateFromComment(selectedRecord, {
+        last_action: "conversation_skipped",
+        last_reason: reason,
+        last_conversation_id: String(effectiveConversationContext?.id || "").trim(),
+        last_conversation_stage: String(effectiveConversationContext?.stage || "").trim(),
+        last_contract_validation_status: String(responseContractValidation.status || "").trim(),
+        last_contract_validation_reason: reason,
+        last_contract_validation_targets: ensureArray(responseContractValidation.targets),
+        ...intentStatePatch,
+      }),
+    );
+    return {
+      kind: "skipped",
+      skippedRecord: {
+        id: selectedRecord.id,
+        reason,
+        messageID: intFromRawAllowZero(selectedRecord?.parsedArchive?.messageID, 0),
+      },
+      result: {
+        route_key: routeKey,
+        route_name: normalizedRoute.name,
+        outcome: "contract_validation_failed",
+        detail: reason,
+        thread_id: archiveThread.threadID,
+        comment_id: selectedRecord.id,
+        trigger_kind: String(effectiveTriggerDecision.trigger || "").trim(),
+        conversation_id: String(effectiveConversationContext?.id || "").trim(),
+        conversation_stage: String(effectiveConversationContext?.stage || "").trim(),
+        conversation_intent_mode: String(effectiveConversationContext?.intentMode || "").trim(),
+        conversation_lead_bot: String(effectiveConversationContext?.leadBotUsername || "").trim(),
+        conversation_summary_bot: String(effectiveConversationContext?.summaryBotUsername || "").trim(),
+        execution_contract_type: String(executionContract?.type || "").trim(),
+        execution_contract_actionable: executionContract?.actionable === true,
+        execution_contract_targets: ensureArray(executionContract?.assignments).map((item) => normalizeMentionSelector(item.targetBot)).filter(Boolean),
+        next_expected_responders: collectExecutionContractNextResponders(executionContract),
+        response_contract_validation_status: String(responseContractValidation.status || "").trim(),
+        response_contract_validation_reason: reason,
+        response_contract_validation_targets: ensureArray(responseContractValidation.targets),
+        assignment_validation_status: String(assignmentExecutionValidation.status || "").trim(),
+        assignment_validation_reason: String(assignmentExecutionValidation.reason || "").trim(),
+        assignment_validation_modes: ensureArray(assignmentExecutionValidation.assignmentModes),
+      },
+    };
+  }
   if (effectiveConversationContext?.mode === "public_multi_bot") {
     const currentBotSelector = normalizeMentionSelector(bot?.username || bot?.name);
     const currentSession = safeObject(effectiveConversationContext.session);

package/lib/selftest-runner-scenarios.mjs

@@ -9505,12 +9505,291 @@ export async function runSelftestRunnerScenarios(push, deps) {
         && !processed.skippedRecord,
       `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_peer_to_peer_reply_reaches_ai_decision", false, String(err?.message || err));
-  }
-
-  try {
-    const workspaceDir = fs.mkdtempSync(path.join(os.tmpdir(), "metheus-runner-selftest-artifacts-ok-"));
+  } catch (err) {
+    push("delegated_single_lead_peer_to_peer_reply_reaches_ai_decision", false, String(err?.message || err));
+  }
+
+  try {
+    let aiCalls = 0;
+    const processed = await processRunnerSelectedRecord({
+      routeKey: "delegated-single-lead-non-lead-summary-request-allowed-key",
+      normalizedRoute: normalizeRunnerRoute({
+        name: "telegram-monitor-delegated-single-lead-non-lead-summary-request-allowed",
+        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: {
+        id: "comment-delegated-single-lead-non-lead-summary-request-allowed",
+        createdAt: "2026-03-16T00:02:21.000Z",
+        parsedArchive: {
+          kind: "bot_reply",
+          conversationID: "comment-delegated-single-lead-open",
+          conversationMode: "public_multi_bot",
+          conversationStage: "bot_reply",
+          conversationIntentMode: "delegated_single_lead",
+          conversationAllowBotToBot: true,
+          conversationLeadBotUsername: "ryoai_bot",
+          conversationParticipants: ["ryoai_bot", "ryoai2_bot", "ryoai3_bot"],
+          conversationInitialResponders: ["ryoai_bot"],
+          conversationAllowedResponders: ["ryoai_bot", "ryoai2_bot", "ryoai3_bot"],
+          conversationSummaryBotUsername: "ryoai_bot",
+          botUsername: "RyoAI_bot",
+          botName: "RyoAI_bot",
+          sender: "RyoAI_bot",
+          body: "@RyoAI3_bot Review the biggest implementation risk.",
+          mentionUsernames: ["ryoai3_bot"],
+          executionContract: {
+            type: "delegation",
+            actionable: true,
+            assignments: [
+              { target_bot: "ryoai3_bot", task: "Review the biggest implementation risk.", mode: "conversation_contribution" },
+            ],
+            summary_bot: "ryoai_bot",
+            next_responders: ["ryoai3_bot"],
+          },
+        },
+      },
+      pendingOrdered: [],
+      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: "-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-non-lead-summary-request-allowed"),
+        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: "현재 가장 큰 구현 리스크는 요구사항 경계가 아직 불명확하다는 점입니다. @RyoAI_bot 방향 정리를 부탁드립니다.",
+            contract: {
+              type: "summary_request",
+              actionable: true,
+              assignments: [],
+              summary_bot: "ryoai_bot",
+              next_responders: ["ryoai_bot"],
+            },
+          };
+        },
+        performLocalBotDelivery: async () => ({
+          delivery: { dryRun: true, body: {} },
+          archive: {},
+        }),
+        serializeRunnerTriggerPolicy: (value) => value,
+        serializeRunnerArchivePolicy: (value) => value,
+        buildRunnerExecutionDeps: () => ({}),
+        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(
+      "delegated_single_lead_non_lead_summary_request_allowed",
+      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_non_lead_summary_request_allowed", false, String(err?.message || err));
+  }
+
+  try {
+    let aiCalls = 0;
+    const processed = await processRunnerSelectedRecord({
+      routeKey: "delegated-single-lead-non-lead-new-assignment-blocked-key",
+      normalizedRoute: normalizeRunnerRoute({
+        name: "telegram-monitor-delegated-single-lead-non-lead-new-assignment-blocked",
+        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: {
+        id: "comment-delegated-single-lead-non-lead-new-assignment-blocked",
+        createdAt: "2026-03-16T00:02:22.000Z",
+        parsedArchive: {
+          kind: "bot_reply",
+          conversationID: "comment-delegated-single-lead-open",
+          conversationMode: "public_multi_bot",
+          conversationStage: "bot_reply",
+          conversationIntentMode: "delegated_single_lead",
+          conversationAllowBotToBot: true,
+          conversationLeadBotUsername: "ryoai_bot",
+          conversationParticipants: ["ryoai_bot", "ryoai2_bot", "ryoai3_bot"],
+          conversationInitialResponders: ["ryoai_bot"],
+          conversationAllowedResponders: ["ryoai_bot", "ryoai2_bot", "ryoai3_bot"],
+          conversationSummaryBotUsername: "ryoai_bot",
+          botUsername: "RyoAI_bot",
+          botName: "RyoAI_bot",
+          sender: "RyoAI_bot",
+          body: "@RyoAI3_bot Review the biggest implementation risk.",
+          mentionUsernames: ["ryoai3_bot"],
+          executionContract: {
+            type: "delegation",
+            actionable: true,
+            assignments: [
+              { target_bot: "ryoai3_bot", task: "Review the biggest implementation risk.", mode: "conversation_contribution" },
+            ],
+            summary_bot: "ryoai_bot",
+            next_responders: ["ryoai3_bot"],
+          },
+        },
+      },
+      pendingOrdered: [],
+      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: "-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-non-lead-new-assignment-blocked"),
+        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: "@RyoAI2_bot 추가 검토를 해주세요.",
+            contract: {
+              type: "delegation",
+              actionable: true,
+              assignments: [
+                { target_bot: "ryoai2_bot", task: "추가 검토를 해주세요.", mode: "conversation_contribution" },
+              ],
+              next_responders: ["ryoai2_bot"],
+            },
+          };
+        },
+        performLocalBotDelivery: async () => ({
+          delivery: { dryRun: true, body: {} },
+          archive: {},
+        }),
+        serializeRunnerTriggerPolicy: (value) => value,
+        serializeRunnerArchivePolicy: (value) => value,
+        buildRunnerExecutionDeps: () => ({}),
+        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(
+      "delegated_single_lead_non_lead_new_assignment_blocked",
+      processed.kind === "skipped"
+        && aiCalls === 1
+        && String(processed.result?.response_contract_validation_status || "") === "non_lead_public_assignment",
+      `kind=${String(processed.kind || "(none)")} ai_calls=${aiCalls} validation=${String(processed.result?.response_contract_validation_status || "(none)")} reason=${String(processed.skippedRecord?.reason || "(none)")}`,
+    );
+  } catch (err) {
+    push("delegated_single_lead_non_lead_new_assignment_blocked", false, String(err?.message || err));
+  }
+
+  try {
+    const workspaceDir = fs.mkdtempSync(path.join(os.tmpdir(), "metheus-runner-selftest-artifacts-ok-"));
     const artifactPath = path.join(workspaceDir, "docs", "plan.md");
     fs.mkdirSync(path.dirname(artifactPath), { recursive: true });
     fs.writeFileSync(artifactPath, "# plan\n", "utf8");

package/package.json

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