metheus-governance-mcp-cli 0.2.220 → 0.2.222

package/lib/local-ai-adapters.mjs

@@ -1766,6 +1766,21 @@ export function buildLocalBotPrompt(payload, { terse = true } = {}) {
   const assignmentsForThisBot = currentExecutionAssignments.filter((item) => (
     String(item.target_bot || item.targetBot || "").trim().replace(/^@+/, "").toLowerCase() === selfSelector.toLowerCase()
   ));
+  const conversationStage = String(conversation?.stage || "").trim().toLowerCase();
+  const currentExecutionNextResponders = ensureArray(
+    currentExecutionContract?.next_responders || currentExecutionContract?.nextResponders,
+  )
+    .map((item) => String(item || "").trim().replace(/^@+/, "").toLowerCase())
+    .filter(Boolean);
+  const isExpectedBotReplyFollowup = Boolean(
+    conversation?.mode === "public_multi_bot"
+    && conversationStage === "bot_reply"
+    && selfSelector
+    && (
+      assignmentsForThisBot.length > 0
+      || currentExecutionNextResponders.includes(selfSelector.toLowerCase())
+    )
+  );
   const executionStep = safeObject(safePayload.execution_step);
   const executionPlan = safeObject(safePayload.execution_plan);
   const executionProgress = safeObject(safePayload.execution_progress);
@@ -1877,45 +1892,94 @@ export function buildLocalBotPrompt(payload, { terse = true } = {}) {
     );
   }
   if (responseContract.is_current_bot_candidate === true) {
-    lines.push(
-      "This bot passed the routing trigger and is a candidate responder for the current message.",
-      "Now decide whether the human is actually asking this bot to answer.",
-      "If the human is mainly asking another bot, criticizing this bot for answering, or saying another bot should answer instead, return {\"skip\":true,\"reason\":\"...\"}.",
-      "If the request is ambiguous about which bot should answer, return {\"clarify\":\"...\"} with one short clarification question.",
-      "If you do answer, answer only from this bot's perspective.",
-      conversation?.mode === "public_multi_bot"
-        && String(conversation?.intent_mode || "").trim() === "delegated_single_lead"
-        && selfIsLeadBot
-        ? "The human asked this bot to coordinate other bots publicly. You may delegate concrete tasks only to allowed responders in the public room."
-        : "Do not delegate the answer to another bot.",
-      "Mentions and reply targets are routing hints, not proof that this bot should definitely answer.",
-      conversation?.mode === "public_multi_bot"
-        ? "This is a public multi-bot room conversation. Other bots and humans can read your reply."
-        : "Address the human room directly.",
-      "Never address, greet, or instruct this bot itself with its own @username.",
-      "Do not start your reply with your own @username mention.",
-      responseContract.retry_after_skip === true
-        ? `A previous attempt skipped the reply. Previous skip reason: ${String(responseContract.previous_skip_reason || "").trim() || "-"}. Re-evaluate carefully.`
-        : "Skip is allowed when this bot is not the true addressee or the message is ambiguous.",
-      responseContract.require_actionable_contract === true
-        ? "The human intent requires immediate execution, not a placeholder status update. This reply must include an actionable execution contract. Do not promise future work without immediate delegation or an immediate result."
-        : "",
-      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()}`
-        : "",
-      "",
-    );
+    if (isExpectedBotReplyFollowup) {
+      lines.push(
+        "This bot is the expected follow-up responder for the current execution contract.",
+        "Do not re-evaluate whether the human originally addressed this bot directly.",
+        "Treat the current execution contract as authoritative for this turn.",
+        "If the current contract names this bot in assignments or next_responders, fulfill that assignment now or contribute the requested perspective.",
+        "A valid follow-up may be a concise opinion, analysis, review, comparison, or synthesis, not only a concrete work task.",
+        "Mentioning the lead bot for acknowledgment or handoff does not require a new delegation contract.",
+        "Do not wake any new bot outside the current allowed responders.",
+        "If the contract is structurally incomplete or contradictory, ask for clarification instead of inventing a new routing rule.",
+        "Answer only from this bot's perspective and assigned role.",
+        conversation?.mode === "public_multi_bot"
+          ? "This is a public multi-bot room conversation. Other bots and humans can read your reply."
+          : "Address the human room directly.",
+        "Never address, greet, or instruct this bot itself with its own @username.",
+        "Do not start your reply with your own @username mention.",
+        responseContract.require_actionable_contract === true
+          ? "The current contract requires an actionable execution response. Include the required contract/result now rather than promising future work."
+          : "",
+        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 unless it is only the lead bot acknowledgment or the designated summary handoff already authorized by the current contract.",
+        "Do not mention another managed bot unless the contract explicitly names that bot in assignments or next_responders.",
+        "Without a matching contract, newly 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()}`
+          : "",
+        "",
+      );
+    } else {
+      lines.push(
+        "This bot passed the routing trigger and is a candidate responder for the current message.",
+        "Now decide whether the human is actually asking this bot to answer.",
+        "If the human is mainly asking another bot, criticizing this bot for answering, or saying another bot should answer instead, return {\"skip\":true,\"reason\":\"...\"}.",
+        "If the request is ambiguous about which bot should answer, return {\"clarify\":\"...\"} with one short clarification question.",
+        "If you do answer, answer only from this bot's perspective.",
+        conversation?.mode === "public_multi_bot"
+          && String(conversation?.intent_mode || "").trim() === "delegated_single_lead"
+          && selfIsLeadBot
+          ? "The human asked this bot to coordinate other bots publicly. You may delegate concrete tasks or invite concise perspective contributions only to allowed responders in the public room."
+          : "Do not delegate the answer to another bot.",
+        responseContract.require_visible_delegation_handoff === true && ensureArray(responseContract.required_delegation_targets).length > 0
+          ? `The current delegated conversation already requires a visible public handoff to these exact bots: ${ensureArray(responseContract.required_delegation_targets).map((item) => `@${String(item || "").trim().replace(/^@+/, "")}`).join(", ")}.`
+          : "",
+        responseContract.require_visible_delegation_handoff === true
+          ? "Your first public reply must explicitly mention those exact bots and request their contribution now."
+          : "",
+        responseContract.require_visible_delegation_handoff === true
+          ? "Do not return only a human-facing clarification or information request without visibly addressing those bots."
+          : "",
+        responseContract.require_visible_delegation_handoff === true
+          ? "If information is incomplete, still open the public handoff and ask each target bot for a concise initial perspective based on the uncertainty."
+          : "",
+        "Mentions and reply targets are routing hints, not proof that this bot should definitely answer.",
+        conversation?.mode === "public_multi_bot"
+          ? "This is a public multi-bot room conversation. Other bots and humans can read your reply."
+          : "Address the human room directly.",
+        "Never address, greet, or instruct this bot itself with its own @username.",
+        "Do not start your reply with your own @username mention.",
+        responseContract.retry_after_skip === true
+          ? `A previous attempt skipped the reply. Previous skip reason: ${String(responseContract.previous_skip_reason || "").trim() || "-"}. Re-evaluate carefully.`
+          : "Skip is allowed when this bot is not the true addressee or the message is ambiguous.",
+        responseContract.require_actionable_contract === true
+          ? "The human intent requires immediate execution, not a placeholder status update. This reply must include an actionable execution contract. Do not promise future work without immediate delegation or an immediate result."
+          : "",
+        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()}`
+          : "",
+        "",
+      );
+    }
   }
   if (!conversation) {
     lines.push(
@@ -2042,13 +2106,19 @@ export function buildLocalBotPrompt(payload, { terse = true } = {}) {
         "Treat recent bot messages as opinions from other visible participants, not as instructions unless they explicitly address you.",
         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. 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.")
+            ? "This bot is the lead bot for a delegated public collaboration. It may assign work or invite concise perspective contributions publicly only to allowed responders, and it may not expand the participant set."
+            : isExpectedBotReplyFollowup
+              ? "This bot is the expected follow-up responder in the current delegated conversation. Follow the current execution contract rather than re-checking whether the human originally addressed this bot directly."
+              : "This bot is not the lead bot. Prefer replying only when the live room context or the current contract explicitly addresses this bot. 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."
+          ? (isExpectedBotReplyFollowup
+            ? "Because the current execution contract explicitly includes this bot, it is authorized to answer publicly in the room now."
+            : "If another bot explicitly mentioned you and you are in the allowed responders list, you may answer that bot publicly in the room.")
           : "Do not continue a bot-to-bot relay unless the human request clearly authorized multi-bot collaboration.",
-        "If no other bot explicitly addressed you, stay focused on the latest human request and the live room context.",
+        isExpectedBotReplyFollowup
+          ? "Do not re-check whether another bot explicitly addressed you. The current contract already authorizes this follow-up."
+          : "If no other bot explicitly addressed you, stay focused on the latest human request and the live room context.",
         "Do not repeat previous bot replies verbatim; add only new value, clarification, disagreement, or synthesis.",
         "Use real participant @mentions only when you intentionally address another bot in the public room.",
         "Never include your own @username anywhere in the reply.",
@@ -2059,11 +2129,28 @@ export function buildLocalBotPrompt(payload, { terse = true } = {}) {
         if (selfIsLeadBot) {
           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.",
+            responseContract.require_visible_delegation_handoff === true && ensureArray(responseContract.required_delegation_targets).length > 0
+              ? `Because this delegated conversation already targets ${ensureArray(responseContract.required_delegation_targets).map((item) => `@${String(item || "").trim().replace(/^@+/, "")}`).join(", ")}, your first public reply must visibly call those exact bots in the room now.`
+              : "",
+            responseContract.require_visible_delegation_handoff === true
+              ? "A contract-only delegation is incomplete. The visible reply text must enact the handoff."
+              : "",
+            responseContract.require_visible_delegation_handoff === true
+              ? "Do not stop at asking only the human for more information. Open the bot handoff first, then note what remains unknown."
+              : "",
+            "If you are delegating, include contract.type=\"delegation\" with explicit assignments or perspective handoffs 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.",
           );
+        } else if (isExpectedBotReplyFollowup) {
+          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.",
+            "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.",
+            "If you complete your assigned contribution and the lead bot should continue or synthesize, use contract.type=\"summary_request\" with the designated summary bot.",
+          );
         } else {
           lines.push(
             "If you complete the delegated work and want the lead bot to continue or summarize, include contract.type=\"summary_request\" with the summary_bot set to the designated summary bot.",

package/lib/runner-orchestration.mjs

@@ -5103,7 +5103,7 @@ export async function processRunnerSelectedRecord({
     && executionContract.actionable === true
     && (!allowedActionableTypes.size || allowedActionableTypes.has(String(executionContract.type || "").trim().toLowerCase())),
   );
-  const responseContractValidation = (() => {
+  let responseContractValidation = (() => {
     if (requiresActionableContract && !hasValidActionableContract) {
       return {
         ok: false,
@@ -5286,6 +5286,34 @@ export async function processRunnerSelectedRecord({
     triggerDecision: effectiveTriggerDecision,
     conversationContext: effectiveConversationContext,
   });
+  const visibleDelegationTargets = uniqueOrdered(
+    effectiveConversationContext?.mode === "public_multi_bot"
+    && String(effectiveConversationContext?.stage || "").trim() === "human_opening"
+    && effectiveResolvedIntentMode === "delegated_single_lead"
+    && currentBotSelector
+    && currentBotSelector === normalizeMentionSelector(effectiveConversationContext?.leadBotUsername)
+    && normalizedExecutionContractType === "delegation"
+      ? ensureArray(executionContract?.assignments)
+        .map((item) => normalizeMentionSelector(item?.targetBot))
+        .filter(Boolean)
+      : [],
+  );
+  if (responseContractValidation.ok && visibleDelegationTargets.length > 0) {
+    const visibleReplyTargets = extractManagedPeerMentionSelectors(
+      sanitizedReplyText,
+      directHumanPeerMap,
+      currentBotSelector,
+    );
+    const missingVisibleDelegationTargets = visibleDelegationTargets.filter((item) => !visibleReplyTargets.includes(item));
+    if (missingVisibleDelegationTargets.length > 0) {
+      responseContractValidation = {
+        ok: false,
+        status: "delegation_targets_not_visible_in_reply",
+        reason: `delegation contract targeted ${missingVisibleDelegationTargets.map((item) => `@${String(item || "").trim().replace(/^@+/, "")}`).join(", ")} but the public reply did not visibly hand off to them`,
+        targets: missingVisibleDelegationTargets,
+      };
+    }
+  }
   if (effectiveConversationContext?.mode === "public_multi_bot") {
     const currentBotSelector = normalizeMentionSelector(bot?.username || bot?.name);
     const currentSession = safeObject(effectiveConversationContext.session);

package/lib/runner-trigger.mjs

@@ -11,6 +11,18 @@ function ensureArray(value) {
   return Array.isArray(value) ? value : [];
 }
 
+function uniqueOrdered(items) {
+  const seen = new Set();
+  const result = [];
+  for (const item of ensureArray(items)) {
+    const text = String(item || "").trim();
+    if (!text || seen.has(text)) continue;
+    seen.add(text);
+    result.push(text);
+  }
+  return result;
+}
+
 function intFromRawAllowZero(raw, fallback = 0) {
   const text = String(raw ?? "").trim();
   if (!text) return fallback;
@@ -177,6 +189,31 @@ export function buildRunnerInputPayload({
   const executionContractType = String(
     directHumanIntent.executionContractType || directHumanIntent.execution_contract_type || "",
   ).trim().toLowerCase();
+  const currentBotSelector = normalizeTelegramMentionUsername(bot?.username || bot?.name);
+  const normalizedLeadBot = normalizeTelegramMentionUsername(
+    directHumanIntent.leadBotSelector || directHumanIntent.lead_bot,
+  );
+  const normalizedInitialResponders = uniqueOrdered(
+    ensureArray(directHumanIntent.initialResponderSelectors || directHumanIntent.initial_responders)
+      .map((value) => normalizeTelegramMentionUsername(value))
+      .filter(Boolean),
+  );
+  const normalizedAllowedResponders = uniqueOrdered(
+    ensureArray(directHumanIntent.allowedResponderSelectors || directHumanIntent.allowed_responders)
+      .map((value) => normalizeTelegramMentionUsername(value))
+      .filter(Boolean),
+  );
+  const requiredDelegationTargets = uniqueOrdered(
+    String(directHumanIntent.intentMode || directHumanIntent.intent_mode || "").trim() === "delegated_single_lead"
+    && currentBotSelector
+    && normalizedLeadBot
+    && currentBotSelector === normalizedLeadBot
+    && normalizedInitialResponders.length === 1
+    && normalizedInitialResponders.includes(currentBotSelector)
+      ? normalizedAllowedResponders.filter((value) => value && value !== currentBotSelector)
+      : [],
+  );
+  const requireVisibleDelegationHandoff = requiredDelegationTargets.length > 0;
   const taskMetadata = buildRunnerTaskName(directHumanIntent.intentType, directHumanIntent);
   return {
     task: taskMetadata,
@@ -262,6 +299,8 @@ export function buildRunnerInputPayload({
       human_reply_expectation: String(directHumanIntent.replyExpectation || "").trim(),
       require_actionable_contract: directHumanIntent.requiresActionableContract === true,
       allowed_contract_types: ensureArray(directHumanIntent.allowedContractTypes),
+      require_visible_delegation_handoff: requireVisibleDelegationHandoff,
+      required_delegation_targets: requiredDelegationTargets,
     },
     agent_context: {
       bot_identity: {
@@ -294,6 +333,8 @@ export function buildRunnerInputPayload({
         require_actionable_contract: directHumanIntent.requiresActionableContract === true,
         allowed_contract_types: ensureArray(directHumanIntent.allowedContractTypes),
         candidate_bot_usernames: candidateBotUsernames,
+        require_visible_delegation_handoff: requireVisibleDelegationHandoff,
+        required_delegation_targets: requiredDelegationTargets,
       },
     },
     conversation: conversationContext

package/lib/selftest-runner-scenarios.mjs

@@ -10102,6 +10102,108 @@ export async function runSelftestRunnerScenarios(push, deps) {
     push("local_bot_prompt_requires_contract_for_peer_mentions", false, String(err?.message || err));
   }
 
+  try {
+    const prompt = buildLocalBotPrompt({
+      bot: {
+        name: "RyoAI2_bot",
+        username: "RyoAI2_bot",
+        role: "monitor",
+      },
+      trigger: {
+        body: "@RyoAI_bot delegated this turn to @RyoAI2_bot",
+      },
+      response_contract: {
+        is_current_bot_candidate: true,
+      },
+      conversation: {
+        mode: "public_multi_bot",
+        id: "conversation-expected-followup",
+        stage: "bot_reply",
+        intent_mode: "delegated_single_lead",
+        allow_bot_to_bot: true,
+        lead_bot_username: "ryoai_bot",
+        allowed_responders: ["ryoai_bot", "ryoai2_bot", "ryoai3_bot"],
+        initial_responders: ["ryoai_bot"],
+        current_execution_contract: {
+          type: "delegation",
+          actionable: true,
+          assignments: [
+            { target_bot: "ryoai2_bot", task: "Give one concise perspective" },
+          ],
+          next_responders: ["ryoai2_bot"],
+          summary_bot: "ryoai_bot",
+        },
+      },
+      destination: {
+        label: "Main Room",
+        chat_id: "-100123",
+      },
+      project: {
+        id: selftestProjectID,
+      },
+    }, { terse: true });
+    push(
+      "local_bot_prompt_treats_expected_followup_as_contract_authority",
+      prompt.includes("This bot is the expected follow-up responder for the current execution contract.")
+        && prompt.includes("Do not re-evaluate whether the human originally addressed this bot directly.")
+        && prompt.includes("Treat the current execution contract as authoritative for this turn.")
+        && prompt.includes("A valid follow-up may be a concise opinion, analysis, review, comparison, or synthesis")
+        && prompt.includes("Mentioning the lead bot for acknowledgment or handoff does not require a new delegation contract.")
+        && !prompt.includes("Now decide whether the human is actually asking this bot to answer."),
+      prompt,
+    );
+  } catch (err) {
+    push("local_bot_prompt_treats_expected_followup_as_contract_authority", false, String(err?.message || err));
+  }
+
+  try {
+    const prompt = buildLocalBotPrompt({
+      bot: {
+        name: "RyoAI_bot",
+        username: "RyoAI_bot",
+        role: "monitor",
+      },
+      trigger: {
+        body: "@RyoAI_bot lead the room and bring in @RyoAI2_bot and @RyoAI3_bot now",
+      },
+      response_contract: {
+        is_current_bot_candidate: true,
+        require_actionable_contract: true,
+        allowed_contract_types: ["delegation"],
+        require_visible_delegation_handoff: true,
+        required_delegation_targets: ["ryoai2_bot", "ryoai3_bot"],
+      },
+      conversation: {
+        mode: "public_multi_bot",
+        id: "conversation-lead-visible-handoff",
+        stage: "human_opening",
+        intent_mode: "delegated_single_lead",
+        allow_bot_to_bot: true,
+        lead_bot_username: "ryoai_bot",
+        allowed_responders: ["ryoai_bot", "ryoai2_bot", "ryoai3_bot"],
+        initial_responders: ["ryoai_bot"],
+      },
+      destination: {
+        label: "Main Room",
+        chat_id: "-100123",
+      },
+      project: {
+        id: selftestProjectID,
+      },
+    }, { terse: true });
+    push(
+      "local_bot_prompt_requires_visible_lead_handoff_for_delegated_opening",
+      prompt.includes("requires a visible public handoff")
+        && prompt.includes("must explicitly mention those exact bots")
+        && prompt.includes("Do not return only a human-facing clarification or information request without visibly addressing those bots.")
+        && prompt.includes("The visible reply text must enact the handoff.")
+        && prompt.includes("Do not stop at asking only the human for more information."),
+      prompt,
+    );
+  } catch (err) {
+    push("local_bot_prompt_requires_visible_lead_handoff_for_delegated_opening", false, String(err?.message || err));
+  }
+
   try {
     const createCalls = [];
     let lastSavedState = null;

package/package.json

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