metheus-governance-mcp-cli 0.2.221 → 0.2.223

package/cli.mjs

@@ -11085,8 +11085,10 @@ async function runRunnerStartResolvedRoutes(routes, flags, options = {}) {
               route_name: normalizedRoute.name,
               logical_signature: runnerRouteLogicalSignature(normalizedRoute),
             });
+            let cycleOutcome = "polling";
             try {
               const result = await processRunnerRouteOnce(normalizedRoute, runtime, "start", { deferExecution: true });
+              cycleOutcome = String(result?.outcome || "").trim().toLowerCase() || "idle";
               const deferredExecution = safeObject(result.deferred_execution);
               if (deferredExecution.routeKey) {
                 tui?.reportExecutionStage({
@@ -11392,6 +11394,7 @@ async function runRunnerStartResolvedRoutes(routes, flags, options = {}) {
                   ...result,
                   deferred_execution: undefined,
                 };
+                cycleOutcome = String(acceptedResult?.outcome || "accepted").trim().toLowerCase() || "accepted";
                 runnerLogger?.append("route_result", {
                   route_key: String(acceptedResult?.route_key || routeKey).trim(),
                   route_name: String(acceptedResult?.route_name || normalizedRoute.name || "").trim(),
@@ -11430,6 +11433,7 @@ async function runRunnerStartResolvedRoutes(routes, flags, options = {}) {
               const errorText = String(err?.message || err);
               const fatalArchiveBootstrapError = errorText.includes("Archive thread is missing")
                 && errorText.includes("write access is denied");
+              cycleOutcome = fatalArchiveBootstrapError ? "blocked" : "error";
               saveRunnerRouteState(routeKey, {
                 ...safeObject(loadBotRunnerState().routes[routeKey]),
                 last_error: errorText,
@@ -11453,8 +11457,25 @@ async function runRunnerStartResolvedRoutes(routes, flags, options = {}) {
                 printRunnerResult("start", result, jsonMode);
               }
             } finally {
-              const routeState = safeObject(loadBotRunnerState().routes[routeKey]);
-              const activeExecutionState = resolveRunnerActiveExecutionState(routeState);
+              let routeState = safeObject(loadBotRunnerState().routes[routeKey]);
+              let activeExecutionState = resolveRunnerActiveExecutionState(routeState);
+              const shouldClearStaleRouteError = !activeExecutionState.active
+                && [
+                  "idle",
+                  "primed",
+                  "skipped",
+                  "replied",
+                  "dry_run",
+                  "delivery_failed_after_generation",
+                ].includes(cycleOutcome);
+              if (shouldClearStaleRouteError && (String(routeState.last_error || "").trim() || String(routeState.active_comment_id || "").trim())) {
+                saveRunnerRouteState(routeKey, {
+                  ...emptyRunnerActiveExecutionPatch(),
+                  last_error: "",
+                });
+                routeState = safeObject(loadBotRunnerState().routes[routeKey]);
+                activeExecutionState = resolveRunnerActiveExecutionState(routeState);
+              }
               tui?.setRouteState(routeKey, {
                 intent_type: String(routeState.last_intent_type || "").trim(),
                 source_message_id: intFromRawAllowZero(routeState.last_source_message_id, 0),

package/lib/local-ai-adapters.mjs

@@ -1939,6 +1939,18 @@ export function buildLocalBotPrompt(payload, { terse = true } = {}) {
           && 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."
@@ -2117,6 +2129,15 @@ export function buildLocalBotPrompt(payload, { terse = true } = {}) {
         if (selfIsLeadBot) {
           lines.push(
             "As the lead bot, your first public reply must be immediately actionable.",
+            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\".",

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

@@ -10156,6 +10156,54 @@ export async function runSelftestRunnerScenarios(push, deps) {
     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.221",
+  "version": "0.2.223",
   "description": "Metheus Governance MCP CLI (setup + stdio proxy)",
   "type": "module",
   "files": [