metheus-governance-mcp-cli 0.2.285 → 0.2.286

package/cli.mjs

@@ -3562,7 +3562,9 @@ function buildRunnerRequestKey({
   const intent = canonicalHumanKey
     ? "-"
     : String(normalizedIntent || "").trim().toLowerCase() || "-";
-  const resolvedConversationID = String(conversationID || parsed.conversationID || "").trim() || "-";
+  const resolvedConversationID = canonicalHumanKey
+    ? "-"
+    : String(conversationID || parsed.conversationID || "").trim() || "-";
   return [
     String(normalizedRoute?.projectID || "").trim() || "-",
     String(normalizedRoute?.provider || "").trim() || "-",
@@ -3994,10 +3996,10 @@ function runnerRequestPreferredNextExpectedResponders(entryRaw) {
   );
 }
 
-function runnerRequestPreferredAuthoritySelectedBotUsernames(entryRaw) {
-  const entry = safeObject(entryRaw);
-  const normalizedSummaryBot = normalizeTelegramMentionUsername(entry.conversation_summary_bot);
-  return uniqueOrderedStrings(
+function runnerRequestPreferredAuthoritySelectedBotUsernames(entryRaw) {
+  const entry = safeObject(entryRaw);
+  const normalizedSummaryBot = normalizeTelegramMentionUsername(entry.conversation_summary_bot);
+  return uniqueOrderedStrings(
     runnerRequestPreferredNextExpectedResponders(entry).length
       ? runnerRequestPreferredNextExpectedResponders(entry)
       : runnerRequestPreferredExecutionContractTargets(entry).length
@@ -4025,6 +4027,35 @@ function extractRunnerExplicitSelectedBotUsernamesFromParsed(parsedArchiveRaw) {
     normalizeTelegramMentionUsername,
   );
 }
+
+function runnerRequestAllowsSharedHumanClaimTakeover({
+  entryRaw,
+  currentBotUsername = "",
+  canonicalHumanMessageKey = "",
+}) {
+  const entry = safeObject(entryRaw);
+  const normalizedCurrentBotUsername = normalizeTelegramMentionUsername(currentBotUsername);
+  const normalizedCanonicalHumanMessageKey = String(canonicalHumanMessageKey || "").trim();
+  if (!normalizedCurrentBotUsername || !normalizedCanonicalHumanMessageKey) {
+    return false;
+  }
+  if (String(entry.canonical_human_message_key || "").trim() !== normalizedCanonicalHumanMessageKey) {
+    return false;
+  }
+  const pendingResponders = runnerRequestPreferredNextExpectedResponders(entry);
+  if (pendingResponders.length > 0) {
+    return pendingResponders.includes(normalizedCurrentBotUsername);
+  }
+  const directHumanResponders = uniqueOrderedStrings(
+    [
+      ...ensureArray(entry.selected_bot_usernames),
+      ...ensureArray(entry.conversation_initial_responders),
+      ...ensureArray(entry.conversation_allowed_responders),
+    ],
+    normalizeTelegramMentionUsername,
+  );
+  return directHumanResponders.includes(normalizedCurrentBotUsername);
+}
 
 function runnerRequestPreferredAIReplyPreview(entryRaw) {
   const entry = safeObject(entryRaw);
@@ -5067,8 +5098,8 @@ async function claimRunnerRequestForHumanComment({
       reason: "non_human_comment_cannot_create_request",
     };
   }
-  const currentState = loadBotRunnerState();
-  const currentRouteState = safeObject(safeObject(currentState.routes)[String(routeKey || "").trim()]);
+  const currentState = loadBotRunnerState();
+  const currentRouteState = safeObject(safeObject(currentState.routes)[String(routeKey || "").trim()]);
   const replyChainResolution = await resolveRunnerReplyChainConversationContextWithServerFallback({
     state: currentState,
     normalizedRoute,
@@ -5168,6 +5199,16 @@ async function claimRunnerRequestForHumanComment({
   const authoritativeDecisionBundle = decisionBundleValidation.ok === true
     ? safeObject(decisionBundleValidation.bundle)
     : {};
+  const normalizedAuthoritativeSourceMessageEnvelope = normalizeRunnerTelegramMessageEnvelope(
+    authoritativeSourceMessageEnvelope,
+  );
+  const currentClaimBotUsername = normalizeTelegramMentionUsername(
+    normalizedAuthoritativeSourceMessageEnvelope.source_bot_username
+      || normalizedAuthoritativeSourceMessageEnvelope.sender_username
+      || currentRouteState.last_source_bot_username
+      || currentRouteState.source_message_bot_username
+      || currentRouteState.last_speaker_bot_username,
+  );
   const authorityReplyChainContext = await buildRunnerAuthorityReplyChainContext({
     selectedRecord,
     replyChainContext,
@@ -5200,24 +5241,35 @@ async function claimRunnerRequestForHumanComment({
       requestKey,
     };
   }
-  if (
-    isActiveRunnerRequestStatus(existing.status)
-    && String(existing.claimed_by_route || "").trim()
-    && String(existing.claimed_by_route || "").trim() !== String(routeKey || "").trim()
-  ) {
-    return {
-      ok: false,
-      reason: "request_already_claimed",
-      requestKey,
-    };
-  }
-  const nowISO = new Date().toISOString();
-  const normalizedAuthoritativeSourceMessageEnvelope = normalizeRunnerTelegramMessageEnvelope(
-    authoritativeSourceMessageEnvelope,
+  if (
+    isActiveRunnerRequestStatus(existing.status)
+    && String(existing.claimed_by_route || "").trim()
+    && String(existing.claimed_by_route || "").trim() !== String(routeKey || "").trim()
+    && !runnerRequestAllowsSharedHumanClaimTakeover({
+      entryRaw: existing,
+      currentBotUsername: currentClaimBotUsername,
+      canonicalHumanMessageKey,
+    })
+  ) {
+    return {
+      ok: false,
+      reason: "request_already_claimed",
+      requestKey,
+    };
+  }
+  const nowISO = new Date().toISOString();
+  const existingSourceMessageEnvelope = normalizeRunnerTelegramMessageEnvelope(existing.source_message_envelope);
+  const preserveExistingCanonicalSourceEnvelope = Boolean(
+    canonicalHumanMessageKey
+    && String(existing.canonical_human_message_key || "").trim() === canonicalHumanMessageKey
+    && intFromRawAllowZero(existing.source_message_id, 0) === currentMessageID
+    && Object.keys(existingSourceMessageEnvelope).length > 0
   );
-  const sourceMessageEnvelope = Object.keys(normalizedAuthoritativeSourceMessageEnvelope).length
-    ? normalizedAuthoritativeSourceMessageEnvelope
-    : normalizeRunnerTelegramMessageEnvelope(existing.source_message_envelope);
+  const sourceMessageEnvelope = preserveExistingCanonicalSourceEnvelope
+    ? existingSourceMessageEnvelope
+    : Object.keys(normalizedAuthoritativeSourceMessageEnvelope).length
+      ? normalizedAuthoritativeSourceMessageEnvelope
+      : existingSourceMessageEnvelope;
   const decisionConversationParticipants = uniqueOrderedStrings(
     ensureArray(authoritativeDecisionBundle.participants),
     normalizeTelegramMentionUsername,

package/lib/runner-recovery.mjs

@@ -46,6 +46,58 @@ function uniqueOrderedStrings(values, normalizer = (value) => String(value || ""
   return output;
 }
 
+function buildRunnerRequestRecoveryAuthoritativeDecisionBundle(requestRaw) {
+  return safeObject(safeObject(requestRaw).authoritative_decision_bundle);
+}
+
+function buildRunnerRequestRecoveryPreferredExecutionContractTargets(requestRaw) {
+  const request = safeObject(requestRaw);
+  const decisionBundle = buildRunnerRequestRecoveryAuthoritativeDecisionBundle(request);
+  return uniqueOrderedStrings(
+    ensureArray(decisionBundle.execution_contract_targets).length
+      ? decisionBundle.execution_contract_targets
+      : ensureArray(request.execution_contract_targets).length
+        ? request.execution_contract_targets
+        : ensureArray(request.root_execution_contract_targets),
+    normalizeTelegramMentionUsername,
+  );
+}
+
+function buildRunnerRequestRecoveryPreferredNextExpectedResponders(requestRaw) {
+  const request = safeObject(requestRaw);
+  const decisionBundle = buildRunnerRequestRecoveryAuthoritativeDecisionBundle(request);
+  return uniqueOrderedStrings(
+    ensureArray(decisionBundle.next_expected_responders).length
+      ? decisionBundle.next_expected_responders
+      : ensureArray(request.next_expected_responders).length
+        ? request.next_expected_responders
+        : ensureArray(request.root_next_expected_responders),
+    normalizeTelegramMentionUsername,
+  );
+}
+
+function runnerRequestShouldRemainRunningDuringRecovery(requestRaw) {
+  const request = safeObject(requestRaw);
+  const decisionBundle = buildRunnerRequestRecoveryAuthoritativeDecisionBundle(request);
+  const preferredExecutionContractType = String(
+    decisionBundle.execution_contract_type
+      || request.execution_contract_type
+      || request.root_execution_contract_type
+      || "",
+  ).trim().toLowerCase();
+  const preferredExecutionContractTargets = buildRunnerRequestRecoveryPreferredExecutionContractTargets(request);
+  const preferredNextExpectedResponders = buildRunnerRequestRecoveryPreferredNextExpectedResponders(request);
+  if (decisionBundle.should_close_after_reply === true) {
+    return false;
+  }
+  if (decisionBundle.should_close_after_reply === false) {
+    return true;
+  }
+  return preferredExecutionContractType === "delegation"
+    || preferredExecutionContractTargets.length > 0
+    || preferredNextExpectedResponders.length > 0;
+}
+
 function normalizeRunnerRequestStatus(rawStatus) {
   const status = String(rawStatus || "").trim().toLowerCase();
   return [
@@ -144,25 +196,39 @@ export function buildRunnerRequestRecoveryPatchFromRouteState(currentStateRaw, r
     const requestStatus = normalizeRunnerRequestStatus(request.status);
     if (!isFinalRunnerRequestStatus(requestStatus)) {
       const routeAction = String(routeState.last_action || "").trim().toLowerCase();
+      const shouldRemainRunning = runnerRequestShouldRemainRunningDuringRecovery(request);
       if (routeAction === "replied") {
-        patch.status = "completed";
-        patch.completed_at = firstNonEmptyString([
-          request.completed_at,
-          request.updated_at,
-          new Date().toISOString(),
-        ]);
+        if (shouldRemainRunning) {
+          patch.status = "running";
+          patch.completed_at = "";
+          patch.closed_at = "";
+          patch.closed_reason = "";
+        } else {
+          patch.status = "completed";
+          patch.completed_at = firstNonEmptyString([
+            request.completed_at,
+            request.updated_at,
+            new Date().toISOString(),
+          ]);
+        }
       } else if (routeAction === "error" || routeAction === "skipped" || routeAction === "closed") {
-        patch.status = "closed";
-        patch.closed_at = firstNonEmptyString([
-          request.closed_at,
-          request.updated_at,
-          new Date().toISOString(),
-        ]);
-        patch.closed_reason = firstNonEmptyString([
-          request.closed_reason,
-          routeState.last_reason,
-          routeAction,
-        ]);
+        if (shouldRemainRunning) {
+          patch.status = "running";
+          patch.closed_at = "";
+          patch.closed_reason = "";
+        } else {
+          patch.status = "closed";
+          patch.closed_at = firstNonEmptyString([
+            request.closed_at,
+            request.updated_at,
+            new Date().toISOString(),
+          ]);
+          patch.closed_reason = firstNonEmptyString([
+            request.closed_reason,
+            routeState.last_reason,
+            routeAction,
+          ]);
+        }
       }
     }
     if (Object.keys(patch).length) {

package/lib/selftest-runner-scenarios.mjs

@@ -2334,8 +2334,238 @@ export async function runSelftestRunnerScenarios(push, deps) {
       `primary=${String(sharedHumanClaimPrimary.requestKey || "(none)")} peer=${String(sharedHumanClaimPeer.requestKey || "(none)")} peer_reason=${String(sharedHumanClaimPeer.reason || "(none)")} count=${sharedHumanRequestCount} canonical=${String(safeObject(sharedHumanRequests[0]).canonical_human_message_key || "(none)")}`,
     );
 
+    const canonicalConversationVariantBody = "@RyoAI_bot @RyoAI2_bot @RyoAI3_bot 같은 사람 메시지";
+    const canonicalConversationVariantPrimary = {
+      id: "comment-request-shared-human-conversation-1",
+      createdAt: "2026-04-01T06:10:00.000Z",
+      updatedAt: "2026-04-01T06:10:00.000Z",
+      parsedArchive: {
+        kind: "telegram_message",
+        chatID: "-100124",
+        chatType: "supergroup",
+        body: canonicalConversationVariantBody,
+        messageID: 1290,
+        senderID: "7002",
+        senderIsBot: false,
+        occurredAt: "2026-04-01T06:10:00.000Z",
+        mentionUsernames: ["ryoai_bot", "ryoai2_bot", "ryoai3_bot"],
+      },
+    };
+    const canonicalConversationVariantPeer = {
+      id: "comment-request-shared-human-conversation-2",
+      createdAt: "2026-04-01T06:10:00.000Z",
+      updatedAt: "2026-04-01T06:10:00.000Z",
+      parsedArchive: {
+        kind: "telegram_message",
+        chatID: "-100124",
+        chatType: "supergroup",
+        body: canonicalConversationVariantBody,
+        messageID: 1290,
+        senderID: "7002",
+        senderIsBot: false,
+        occurredAt: "2026-04-01T06:10:00.000Z",
+        mentionUsernames: ["ryoai_bot", "ryoai2_bot", "ryoai3_bot"],
+        conversationID: "comment-request-shared-human-conversation-1",
+      },
+    };
+    const canonicalConversationVariantPrimaryClaim = await claimRunnerRequestForHumanComment({
+      normalizedRoute: sharedHumanRouteRyoai1,
+      routeKey: sharedHumanRouteRyoai1Key,
+      selectedRecord: canonicalConversationVariantPrimary,
+      selectedBotUsernames: ["ryoai_bot", "ryoai2_bot", "ryoai3_bot"],
+      normalizedIntent: "discussion_request",
+      authoritativeSourceMessageEnvelope: {
+        chat_id: "-100124",
+        message_id: 1290,
+        sender_id: "7002",
+        sender_is_bot: false,
+        occurred_at: "2026-04-01T06:10:00.000Z",
+        body: canonicalConversationVariantBody,
+        source_origin: "local_telegram_inbound",
+        source_route_key: sharedHumanRouteRyoai1Key,
+        source_bot_username: "ryoai_bot",
+      },
+    });
+    const canonicalConversationVariantPeerClaim = await claimRunnerRequestForHumanComment({
+      normalizedRoute: sharedHumanRouteRyoai3,
+      routeKey: sharedHumanRouteRyoai3Key,
+      selectedRecord: canonicalConversationVariantPeer,
+      selectedBotUsernames: ["ryoai_bot", "ryoai2_bot", "ryoai3_bot"],
+      normalizedIntent: "discussion_request",
+      authoritativeSourceMessageEnvelope: {
+        chat_id: "-100124",
+        message_id: 1290,
+        sender_id: "7002",
+        sender_is_bot: false,
+        occurred_at: "2026-04-01T06:10:00.000Z",
+        body: canonicalConversationVariantBody,
+        source_origin: "local_telegram_inbound",
+        source_route_key: sharedHumanRouteRyoai3Key,
+        source_bot_username: "ryoai3_bot",
+      },
+    });
+    const canonicalConversationVariantState = loadBotRunnerState();
+    const canonicalConversationVariantRequests = Object.values(safeObject(canonicalConversationVariantState.requests))
+      .filter((entryRaw) => {
+        const entry = safeObject(entryRaw);
+        return String(entry.chat_id || "") === "-100124"
+          && intFromRawAllowZero(entry.source_message_id, 0) === 1290;
+      });
+    push(
+      "runner_human_opening_request_key_ignores_conversation_id_for_canonical_inbound",
+      canonicalConversationVariantPrimaryClaim.ok === true
+        && (canonicalConversationVariantPeerClaim.ok === true || String(canonicalConversationVariantPeerClaim.reason || "") === "request_already_claimed")
+        && String(canonicalConversationVariantPrimaryClaim.requestKey || "") === String(canonicalConversationVariantPeerClaim.requestKey || "")
+        && canonicalConversationVariantRequests.length === 1,
+      `primary=${String(canonicalConversationVariantPrimaryClaim.requestKey || "(none)")} peer=${String(canonicalConversationVariantPeerClaim.requestKey || "(none)")} peer_reason=${String(canonicalConversationVariantPeerClaim.reason || "(none)")} count=${canonicalConversationVariantRequests.length}`,
+    );
+
+    const sharedDirectTakeoverBody = "@RyoAI_bot @RyoAI2_bot @RyoAI3_bot 같이 답해";
+    const sharedDirectTakeoverRecordLead = {
+      id: "comment-request-shared-direct-1",
+      createdAt: "2026-04-01T06:20:00.000Z",
+      updatedAt: "2026-04-01T06:20:00.000Z",
+      parsedArchive: {
+        kind: "telegram_message",
+        chatID: "-100125",
+        chatType: "supergroup",
+        body: sharedDirectTakeoverBody,
+        messageID: 1291,
+        senderID: "7003",
+        senderIsBot: false,
+        occurredAt: "2026-04-01T06:20:00.000Z",
+        mentionUsernames: ["ryoai_bot", "ryoai2_bot", "ryoai3_bot"],
+      },
+    };
+    const sharedDirectTakeoverLeadClaim = await claimRunnerRequestForHumanComment({
+      normalizedRoute: sharedHumanRouteRyoai1,
+      routeKey: sharedHumanRouteRyoai1Key,
+      selectedRecord: sharedDirectTakeoverRecordLead,
+      selectedBotUsernames: ["ryoai_bot", "ryoai2_bot", "ryoai3_bot"],
+      normalizedIntent: "discussion_request",
+      authoritativeSourceMessageEnvelope: {
+        chat_id: "-100125",
+        message_id: 1291,
+        sender_id: "7003",
+        sender_is_bot: false,
+        occurred_at: "2026-04-01T06:20:00.000Z",
+        body: sharedDirectTakeoverBody,
+        source_origin: "local_telegram_inbound",
+        source_route_key: sharedHumanRouteRyoai1Key,
+        source_bot_username: "ryoai_bot",
+      },
+    });
+    const sharedDirectTakeoverCanonicalKey = buildArchivedInboundMessageKey({
+      chatID: "-100125",
+      messageID: 1291,
+      messageThreadID: 0,
+      kind: "telegram_message",
+      senderID: "7003",
+      senderIsBot: false,
+      occurredAt: "2026-04-01T06:20:00.000Z",
+      body: sharedDirectTakeoverBody,
+    }).replace(/^human:/, "");
+    const sharedDirectTakeoverState = loadBotRunnerState();
+    saveBotRunnerState({
+      ...sharedDirectTakeoverState,
+      requests: {
+        ...safeObject(sharedDirectTakeoverState.requests),
+        [sharedDirectTakeoverLeadClaim.requestKey]: {
+          ...safeObject(safeObject(sharedDirectTakeoverState.requests)[sharedDirectTakeoverLeadClaim.requestKey]),
+          canonical_human_message_key: sharedDirectTakeoverCanonicalKey,
+          source_message_id: 1291,
+          source_message_origin: "local_telegram_inbound",
+          source_message_route_key: sharedHumanRouteRyoai1Key,
+          source_message_bot_username: "ryoai_bot",
+          source_message_envelope: {
+            chat_id: "-100125",
+            message_id: 1291,
+            body: sharedDirectTakeoverBody,
+            source_origin: "local_telegram_inbound",
+            source_route_key: sharedHumanRouteRyoai1Key,
+            source_bot_username: "ryoai_bot",
+          },
+          selected_bot_usernames: ["ryoai_bot", "ryoai2_bot", "ryoai3_bot"],
+          conversation_initial_responders: ["ryoai_bot", "ryoai2_bot", "ryoai3_bot"],
+          conversation_allowed_responders: ["ryoai_bot", "ryoai2_bot", "ryoai3_bot"],
+          conversation_intent_mode: "multi_bot_direct",
+          execution_contract_type: "direct_result",
+          execution_contract_targets: ["ryoai_bot"],
+          next_expected_responders: ["ryoai2_bot", "ryoai3_bot"],
+          status: "running",
+          claimed_by_route: sharedHumanRouteRyoai1Key,
+          authoritative_decision_bundle: {
+            schema_version: "runner_conversation_decision.v1",
+            decision_type: "reply_outcome",
+            conversation_intent_mode: "multi_bot_direct",
+            allowed_responders: ["ryoai_bot", "ryoai2_bot", "ryoai3_bot"],
+            initial_responders: ["ryoai_bot", "ryoai2_bot", "ryoai3_bot"],
+            selected_bot_usernames: ["ryoai_bot"],
+            allow_bot_to_bot: false,
+            execution_contract_type: "direct_result",
+            execution_contract_targets: ["ryoai_bot"],
+            next_expected_responders: ["ryoai2_bot", "ryoai3_bot"],
+            should_close_after_reply: false,
+            turn_kind: "direct_reply",
+            actionable_for_current_route: true,
+            visible_handoff_required: false,
+            visible_handoff_targets: [],
+            reasoning_summary: "shared direct reply remains open for the remaining directly mentioned bots",
+          },
+        },
+      },
+    });
+    const sharedDirectTakeoverRecordPeer = {
+      id: "comment-request-shared-direct-2",
+      createdAt: "2026-04-01T06:20:00.000Z",
+      updatedAt: "2026-04-01T06:20:00.000Z",
+      parsedArchive: {
+        kind: "telegram_message",
+        chatID: "-100125",
+        chatType: "supergroup",
+        body: sharedDirectTakeoverBody,
+        messageID: 1291,
+        senderID: "7003",
+        senderIsBot: false,
+        occurredAt: "2026-04-01T06:20:00.000Z",
+        mentionUsernames: ["ryoai_bot", "ryoai2_bot", "ryoai3_bot"],
+        conversationID: "comment-request-shared-direct-1",
+      },
+    };
+    const sharedDirectTakeoverPeerClaim = await claimRunnerRequestForHumanComment({
+      normalizedRoute: sharedHumanRouteRyoai3,
+      routeKey: sharedHumanRouteRyoai3Key,
+      selectedRecord: sharedDirectTakeoverRecordPeer,
+      selectedBotUsernames: ["ryoai_bot", "ryoai2_bot", "ryoai3_bot"],
+      normalizedIntent: "discussion_request",
+      authoritativeSourceMessageEnvelope: {
+        chat_id: "-100125",
+        message_id: 1291,
+        sender_id: "7003",
+        sender_is_bot: false,
+        occurred_at: "2026-04-01T06:20:00.000Z",
+        body: sharedDirectTakeoverBody,
+        source_origin: "local_telegram_inbound",
+        source_route_key: sharedHumanRouteRyoai3Key,
+        source_bot_username: "ryoai3_bot",
+      },
+    });
+    const sharedDirectTakeoverRequest = safeObject(
+      safeObject(loadBotRunnerState().requests)[sharedDirectTakeoverLeadClaim.requestKey],
+    );
+    push(
+      "runner_shared_human_direct_reply_allows_pending_route_takeover_without_rekeying",
+      sharedDirectTakeoverLeadClaim.ok === true
+        && sharedDirectTakeoverPeerClaim.ok === true
+        && String(sharedDirectTakeoverPeerClaim.requestKey || "") === String(sharedDirectTakeoverLeadClaim.requestKey || "")
+        && String(sharedDirectTakeoverRequest.claimed_by_route || "") === sharedHumanRouteRyoai3Key
+        && String(sharedDirectTakeoverRequest.source_message_route_key || "") === sharedHumanRouteRyoai1Key
+        && String(safeObject(sharedDirectTakeoverRequest.source_message_envelope).source_route_key || "") === sharedHumanRouteRyoai1Key,
+      `lead=${String(sharedDirectTakeoverLeadClaim.requestKey || "(none)")} peer=${String(sharedDirectTakeoverPeerClaim.requestKey || "(none)")} claimed_by=${String(sharedDirectTakeoverRequest.claimed_by_route || "(none)")} source_route=${String(sharedDirectTakeoverRequest.source_message_route_key || "(none)")}`,
+    );
+
     const rootTaskRecord = {
-      id: "comment-request-root-task-1",
+      id: "comment-request-root-task-1",
       createdAt: "2026-03-22T00:05:00.000Z",
       updatedAt: "2026-03-22T00:05:00.000Z",
       parsedArchive: {
@@ -17529,10 +17759,46 @@ export async function runSelftestRunnerScenarios(push, deps) {
           && !Number(recoveredSourceEnvelope.message_id || 0),
         `origin=${String(recoveryPatch.source_message_origin || "(none)")} route=${String(recoveryPatch.source_message_route_key || "(none)")} bot=${String(recoveryPatch.source_message_bot_username || "(none)")} message=${String(recoveredSourceEnvelope.message_id || "(none)")} thread=${String(recoveryPatch.source_message_thread_id || "(none)")}`,
       );
-
-      saveBotRunnerState({
-        routes: {
-          [provenanceRouteKey]: {
+
+      const runningRecoveryPatch = buildRunnerRequestRecoveryPatchFromRouteState(
+        {
+          routes: {
+            [provenanceRouteKey]: {
+              last_source_message_id: 780,
+              last_action: "replied",
+            },
+          },
+        },
+        {
+          request_key: "request-provenance-running-recovery",
+          claimed_by_route: provenanceRouteKey,
+          chat_id: "-100123",
+          source_message_id: 780,
+          status: "running",
+          execution_contract_type: "direct_result",
+          next_expected_responders: ["ryoai2_bot"],
+          authoritative_decision_bundle: {
+            schema_version: "runner_conversation_decision.v1",
+            decision_type: "reply_outcome",
+            conversation_intent_mode: "multi_bot_direct",
+            execution_contract_type: "direct_result",
+            next_expected_responders: ["ryoai2_bot"],
+            should_close_after_reply: false,
+          },
+        },
+        provenanceRouteKey,
+      );
+      push(
+        "runner_request_recovery_keeps_running_requests_with_pending_responders",
+        String(runningRecoveryPatch.status || "") === "running"
+          && !String(runningRecoveryPatch.completed_at || "").trim()
+          && !String(runningRecoveryPatch.closed_at || "").trim(),
+        `status=${String(runningRecoveryPatch.status || "(none)")} completed_at=${String(runningRecoveryPatch.completed_at || "(none)")} closed_at=${String(runningRecoveryPatch.closed_at || "(none)")}`,
+      );
+
+      saveBotRunnerState({
+        routes: {
+          [provenanceRouteKey]: {
             active_request_key: "request-provenance-continuation",
             last_source_message_id: 779,
             recent_local_inbound_envelopes: {

package/package.json

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