metheus-governance-mcp-cli 0.2.276 → 0.2.277

package/cli.mjs

@@ -5770,7 +5770,21 @@ async function finalizePreparedRunnerSelectedRecordExecutionContext({
     };
   }
   if (mode === "continuation_finalize") {
-    const requestClaim = normalizePreparedRunnerRequestClaim(requestPreparation.requestClaim);
+    const requestClaim = normalizePreparedRunnerRequestClaim(resolveRunnerContinuationRequestForBotReplyImpl({
+      normalizedRoute,
+      routeKey,
+      selectedRecord,
+      persist: true,
+      deps: buildRunnerRecoveryDeps(),
+    }));
+    if (!requestClaim.ok) {
+      return finalizeRunnerRequestClaimFailureRecorderState({
+        normalizedRoute,
+        runtime,
+        requestClaim,
+        syncRunnerRequestLedgerForProjectToServer,
+      });
+    }
     const finalizedRequest = await finalizePreparedRunnerRequestForExecution({
       normalizedRoute,
       routeKey,

package/lib/runner-orchestration-adjudication.mjs

@@ -16,6 +16,10 @@ function ensureArray(value) {
   return Array.isArray(value) ? value : [];
 }
 
+function normalizeMentionSelector(rawValue) {
+  return String(rawValue || "").trim().replace(/^@+/, "").toLowerCase();
+}
+
 function intFromRawAllowZero(raw, fallback = 0) {
   if (raw === null || raw === undefined || raw === "") {
     return fallback;
@@ -48,6 +52,45 @@ function buildRunnerContinuationContractTriggerDecision(triggerDecision) {
   };
 }
 
+function isRunnerBotReplyContinuationAuthorizedForCurrentBot({
+  selectedRecord,
+  persistedRequest = null,
+  currentBotSelector = "",
+}) {
+  const normalizedCurrentBotSelector = normalizeMentionSelector(currentBotSelector);
+  if (!normalizedCurrentBotSelector) {
+    return false;
+  }
+  const parsed = safeObject(selectedRecord?.parsedArchive);
+  const normalizedSenderSelectors = ensureArray([
+    parsed.botUsername,
+    parsed.senderUsername,
+    parsed.sender,
+  ])
+    .map((value) => normalizeMentionSelector(value))
+    .filter(Boolean);
+  if (normalizedSenderSelectors.includes(normalizedCurrentBotSelector)) {
+    return false;
+  }
+  const explicitReplyTargets = ensureArray([
+    ...(Array.isArray(parsed.mentionUsernames) ? parsed.mentionUsernames : []),
+    parsed.replyToBotUsername,
+    parsed.targetBotUsername,
+    parsed.assignBotUsername,
+    parsed.nextResponderBotUsername,
+  ])
+    .map((value) => normalizeMentionSelector(value))
+    .filter(Boolean);
+  if (explicitReplyTargets.includes(normalizedCurrentBotSelector)) {
+    return true;
+  }
+  const request = safeObject(persistedRequest);
+  const nextExpectedResponders = ensureArray(request.next_expected_responders)
+    .map((value) => normalizeMentionSelector(value))
+    .filter(Boolean);
+  return nextExpectedResponders.includes(normalizedCurrentBotSelector);
+}
+
 export async function resolveRunnerPrecomputedResponderAdjudication({
   selectedRecord,
   pendingOrdered,
@@ -189,6 +232,11 @@ export async function resolveRunnerPrecomputedBotReplyAuthorityContext({
     persistedRequest: resolveRunnerContinuationLinkedRequest(normalizedRequestClaim),
     triggerDecision,
   });
+  const continuationAuthorizedForCurrentBot = isRunnerBotReplyContinuationAuthorizedForCurrentBot({
+    selectedRecord,
+    persistedRequest: resolveRunnerContinuationLinkedRequest(normalizedRequestClaim),
+    currentBotSelector,
+  });
   const currentBotSelected = ensureArray(continuationAdjudication?.selected_bot_usernames)
     .map((value) => String(value || "").trim().replace(/^@+/, "").toLowerCase())
     .includes(currentBotSelector);
@@ -204,6 +252,18 @@ export async function resolveRunnerPrecomputedBotReplyAuthorityContext({
       sharedHumanIntentContext: null,
     };
   }
+  if (!continuationAuthorizedForCurrentBot) {
+    return {
+      shouldSkip: true,
+      requestless: false,
+      skipAction: "adjudication_skipped",
+      skipReason: "bot_reply_not_explicitly_handed_off",
+      skipTrigger: "request_contract",
+      skipRecordPatch: {},
+      adjudication: continuationAdjudication,
+      sharedHumanIntentContext: null,
+    };
+  }
   return {
     shouldSkip: false,
     requestless: false,

package/lib/runner-recovery.mjs

@@ -431,6 +431,7 @@ export function peekRunnerContinuationRequestForBotReply({
 export function recoverRunnerContinuationRequestForBotReply({
   normalizedRoute,
   continuationPreview,
+  persist = true,
   deps = {},
 }) {
   const upsertRunnerRequest = requireDependency(deps, "upsertRunnerRequest");
@@ -506,6 +507,18 @@ export function recoverRunnerContinuationRequestForBotReply({
         || "",
       ).trim().toLowerCase(),
     };
+  if (persist !== true) {
+    return {
+      ok: true,
+      linkedRequestKey: fallbackRequestKey,
+      linkedRequest: seedRequest,
+      currentState,
+      conversationID: String(preview.conversationID || "").trim(),
+      commentKind: String(preview.commentKind || "").trim().toLowerCase(),
+      linkResolutionKind: "recovered_request_link",
+      linkRecovered: true,
+    };
+  }
   const seededRequest = upsertRunnerRequest(currentState, fallbackRequestKey, seedRequest);
   currentState.requests = seededRequest.requests;
   saveBotRunnerState({
@@ -531,6 +544,7 @@ export function resolveRunnerContinuationRequestForBotReply({
   normalizedRoute,
   routeKey,
   selectedRecord,
+  persist = true,
   deps = {},
 }) {
   const upsertRunnerConsumedComment = requireDependency(deps, "upsertRunnerConsumedComment");
@@ -547,12 +561,16 @@ export function resolveRunnerContinuationRequestForBotReply({
     continuation = recoverRunnerContinuationRequestForBotReply({
       normalizedRoute,
       continuationPreview: continuation,
+      persist,
       deps,
     });
   }
   if (!continuation.ok) {
     return continuation;
   }
+  if (persist !== true) {
+    return continuation;
+  }
   const {
     currentState,
     linkedRequest,
@@ -609,6 +627,7 @@ export function prepareRunnerBotReplyContinuationContext({
       normalizedRoute,
       routeKey,
       selectedRecord,
+      persist: false,
       deps,
     })
     : continuationPreview;

package/lib/selftest-runner-scenarios.mjs

@@ -16340,11 +16340,82 @@ export async function runSelftestRunnerScenarios(push, deps) {
           && !Object.prototype.hasOwnProperty.call(continuation, "request"),
         `linked_key=${String(continuation.linkedRequestKey || "(none)")} has_request=${String(Object.prototype.hasOwnProperty.call(continuation, "request"))}`,
       );
-    } finally {
-      process.env.HOME = previousHome;
-      process.env.USERPROFILE = previousUserProfile;
-      try {
-        fs.rmSync(provenanceTempRoot, { recursive: true, force: true });
+      saveBotRunnerState({
+        routes: {
+          [provenanceRouteKey]: {
+            conversation_sessions: {
+              "conversation-provenance-seed": {
+                status: "open",
+                started_at: "2026-03-27T00:00:00.000Z",
+                participants: ["ryoai_bot"],
+                initial_responders: ["ryoai_bot"],
+                allowed_responders: ["ryoai_bot"],
+                intent_mode: "single_bot",
+                allow_bot_to_bot: false,
+              },
+            },
+            recent_local_inbound_receipts: {
+              "-100123:779": {
+                chat_id: "-100123",
+                message_id: 779,
+                receipt_origin: "local_telegram_inbound",
+                receipt_route_key: provenanceRouteKey,
+                receipt_bot_username: "ryoai_bot",
+                source_origin: "local_telegram_inbound",
+                source_route_key: provenanceRouteKey,
+                source_bot_username: "ryoai_bot",
+                body: "hello provenance",
+                message_thread_id: 43,
+              },
+            },
+            last_followup_source_message_envelope: {
+              message_id: 779,
+              message_thread_id: 43,
+              body: "hello provenance",
+              source_origin: "local_telegram_inbound",
+              source_route_key: provenanceRouteKey,
+              source_bot_username: "ryoai_bot",
+            },
+          },
+        },
+        sharedInboxes: {},
+        excludedComments: {},
+        requests: {},
+        consumedComments: {},
+      });
+      const stateBeforePreviewOnlyContinuation = loadBotRunnerState();
+      const previewOnlyRecoveryContext = prepareRunnerSelectedRecordRecoveryContext({
+        normalizedRoute: provenanceRoute,
+        routeKey: provenanceRouteKey,
+        selectedRecord: {
+          id: "bot-reply-preview-only-seed",
+          parsedArchive: {
+            kind: "bot_reply",
+            chatID: "-100123",
+            messageID: 881,
+            senderIsBot: true,
+            conversationID: "conversation-provenance-seed",
+            botUsername: "@ryoai_bot",
+          },
+        },
+      });
+      const stateAfterPreviewOnlyContinuation = loadBotRunnerState();
+      const previewRequestsBefore = Object.keys(normalizeBotRunnerRequests(stateBeforePreviewOnlyContinuation.requests)).length;
+      const previewRequestsAfter = Object.keys(normalizeBotRunnerRequests(stateAfterPreviewOnlyContinuation.requests)).length;
+      const previewConsumedBefore = Object.keys(safeObject(stateBeforePreviewOnlyContinuation.consumedComments || stateBeforePreviewOnlyContinuation.consumed_comments)).length;
+      const previewConsumedAfter = Object.keys(safeObject(stateAfterPreviewOnlyContinuation.consumedComments || stateAfterPreviewOnlyContinuation.consumed_comments)).length;
+      push(
+        "runner_continuation_preview_does_not_write_request_or_consumed_state",
+        safeObject(previewOnlyRecoveryContext.botReplyContinuationContext).continuationLinkRecoverable === true
+          && previewRequestsBefore === previewRequestsAfter
+          && previewConsumedBefore === previewConsumedAfter,
+        `recoverable=${String(safeObject(previewOnlyRecoveryContext.botReplyContinuationContext).continuationLinkRecoverable)} requests=${String(previewRequestsBefore)}->${String(previewRequestsAfter)} consumed=${String(previewConsumedBefore)}->${String(previewConsumedAfter)}`,
+      );
+    } finally {
+      process.env.HOME = previousHome;
+      process.env.USERPROFILE = previousUserProfile;
+      try {
+        fs.rmSync(provenanceTempRoot, { recursive: true, force: true });
       } catch {}
     }
   } catch (err) {
@@ -17447,6 +17518,7 @@ export async function runSelftestRunnerScenarios(push, deps) {
                 linkedRequest: {
                   request_key: "req-1",
                   selected_bot_usernames: ["alpha_bot"],
+                  next_expected_responders: ["alpha_bot"],
                 },
               },
             },
@@ -17493,6 +17565,7 @@ export async function runSelftestRunnerScenarios(push, deps) {
             linkedRequest: {
               request_key: "req-1",
               selected_bot_usernames: ["alpha_bot"],
+              next_expected_responders: ["alpha_bot"],
             },
           },
         },
@@ -17529,6 +17602,69 @@ export async function runSelftestRunnerScenarios(push, deps) {
     push("runner_selected_record_execution_context_promotes_continuation_only_after_recovery", false, String(err?.message || err));
   }
 
+  try {
+    const preparation = await resolveRunnerPrecomputedSelectedRecordExecutionContext({
+      selectedRecord: {
+        id: "comment-continuation-no-explicit-handoff",
+        parsedArchive: {
+          kind: "bot_reply",
+          chatID: "-100123",
+          chatType: "supergroup",
+          messageID: 3504,
+          body: "foreign bot follow up",
+          sender: "other bot",
+          senderIsBot: true,
+          botUsername: "@other_bot",
+          mentionUsernames: [],
+        },
+      },
+      recoveryContext: {
+        selectedRecordKind: "bot_reply",
+        botReplyContinuationContext: {
+          continuationLinkRecoverable: true,
+          continuationLinkResolution: {
+            ok: true,
+            linkedRequestKey: "req-no-explicit-handoff",
+            linkedRequest: {
+              request_key: "req-no-explicit-handoff",
+              selected_bot_usernames: ["alpha_bot"],
+              next_expected_responders: [],
+            },
+          },
+        },
+      },
+      normalizedRoute: {
+        provider: "telegram",
+        triggerPolicy: {
+          replyToBotMessages: true,
+        },
+      },
+      routeKey: "telegram-monitor-alpha::project::telegram::monitor::dest::actor",
+      routeState: {},
+      fallbackRouteState: {},
+      bot: {
+        username: "alpha_bot",
+        name: "alpha_bot",
+      },
+      executionPlan: {},
+      pendingOrdered: [],
+      currentBotSelector: "alpha_bot",
+      routingExecutionDeps: {
+        managedConversationBots: [],
+      },
+    });
+    push(
+      "runner_selected_record_execution_context_requires_explicit_handoff_for_bot_reply_continuation",
+      preparation.kind === "skip"
+        && String(preparation?.skipAction || "") === "adjudication_skipped"
+        && String(preparation?.skipReason || "") === "bot_reply_not_explicitly_handed_off"
+        && String(preparation?.skipTrigger || "") === "request_contract",
+      `kind=${String(preparation?.kind || "(none)")} action=${String(preparation?.skipAction || "(none)")} reason=${String(preparation?.skipReason || "(none)")} trigger=${String(preparation?.skipTrigger || "(none)")}`,
+    );
+  } catch (err) {
+    push("runner_selected_record_execution_context_requires_explicit_handoff_for_bot_reply_continuation", false, String(err?.message || err));
+  }
+
   try {
     const preparation = await resolveRunnerPrecomputedSelectedRecordExecutionContext({
       selectedRecord: {

package/package.json

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