metheus-governance-mcp-cli 0.2.285 → 0.2.287

package/README.md

@@ -379,7 +379,7 @@ Behavior:
 - `bot room-audit` now suggests executable runner routes for the managed server+local intersection. Room visibility is still reported, but a bot no longer has to appear in the admin list before route automation can prepare it.
 - `bot room-audit` defaults to `monitor` only unless you pass `--role` or `--roles`.
 - `bot room-audit --apply true` writes missing suggested routes into `~/.metheus/bot-runner.json` and disables overlapping enabled routes in the same project/provider/destination/bot scope that are outside the selected role set.
-- `runner project up` is the one-command path for Telegram project operations: it runs the same room audit, applies the selected role routes, and can immediately start polling for that project destination.
+- `runner project up` is the route preparation path for Telegram project operations: it runs the same room audit, applies the selected role routes, and starts polling only when you explicitly pass `--start true` or `--start-detached true`.
 - `runner project up` can be narrowed with `--bot-name`, `--bot-id`, `--role`, or `--roles <csv>` when you do not want every suggested role route for that room.
 - `bot remove` without flags starts a guided numbered flow: provider -> bot entry -> confirm removal.
 - Telegram stores one bot file per entry under `~/.metheus/telegram-bots/<ServerBotName>.env` with generic fields:
@@ -421,7 +421,8 @@ metheus-governance-mcp-cli bot remove --provider telegram --bot-name <server_bot
 metheus-governance-mcp-cli bot verify --provider telegram --bot-name <server_bot_name> --json true
 metheus-governance-mcp-cli bot room-audit --provider telegram --project-id <project_uuid> --destination-label <room_label> --json true
 metheus-governance-mcp-cli bot room-audit --provider telegram --project-id <project_uuid> --destination-label <room_label> --apply true --json true
-metheus-governance-mcp-cli runner project up --project-id <project_uuid> --provider telegram --destination-label <room_label>
+metheus-governance-mcp-cli runner project up --project-id <project_uuid> --provider telegram --destination-label <room_label> --start false
+metheus-governance-mcp-cli runner start-detached --project-id <project_uuid> --provider telegram --destination-label <room_label>
 metheus-governance-mcp-cli runner project up --project-id <project_uuid> --provider telegram --destination-label <room_label> --bot-name <server_bot_name> --roles monitor,review --start false
 ```
 
@@ -540,7 +541,8 @@ Commands:
 
 ```bash
 metheus-governance-mcp-cli runner list
-metheus-governance-mcp-cli runner project up --project-id <project_uuid> --provider telegram --destination-label <room_label>
+metheus-governance-mcp-cli runner project up --project-id <project_uuid> --provider telegram --destination-label <room_label> --start false
+metheus-governance-mcp-cli runner start-detached --project-id <project_uuid> --provider telegram --destination-label <room_label>
 metheus-governance-mcp-cli runner route add
 metheus-governance-mcp-cli runner route edit --route-name telegram-monitor
 metheus-governance-mcp-cli runner route remove --route-name telegram-monitor
@@ -553,7 +555,7 @@ metheus-governance-mcp-cli runner start --route-name telegram-monitor --concurre
 Route management:
 - `runner route add` creates one executable route by selecting the project, provider, role, server bot, and project chat destination in order.
 - `runner route add` now auto-uses the suggested route name, `5000` ms poll interval, and `enabled=true` unless you pass explicit flags or edit the route later.
-- `runner project up` is the shortest practical route bootstrap path for Telegram: it audits one project destination, writes any missing suggested routes, then starts polling for that same destination unless you pass `--start false`.
+- `runner project up` is the shortest practical route bootstrap path for Telegram: it audits one project destination, writes any missing suggested routes, and prepares that destination for later launch. It starts polling only when you explicitly pass `--start true` or `--start-detached true`.
 - if room visibility probe fails but one or more enabled routes already exist for that project destination, `runner project up` now treats the probe failure as a warning and can still start those existing routes.
 - `runner project up --dry-run-delivery true` lets the started runner validate route execution without sending a real provider message.
 - In public Telegram bot conversations, the stored route role is treated as a hint only. Live room context, the current human request, and recent bot replies take priority over the stored route role hint when the local AI client decides how to answer.
@@ -566,8 +568,10 @@ Route management:
 Recommended operational path:
 
 ```bash
-metheus-governance-mcp-cli runner project up --project-id <project_uuid> --provider telegram --destination-label <room_label>
+metheus-governance-mcp-cli runner project up --project-id <project_uuid> --provider telegram --destination-label <room_label> --start false
+metheus-governance-mcp-cli runner start-detached --project-id <project_uuid> --provider telegram --destination-label <room_label>
 metheus-governance-mcp-cli runner project up --project-id <project_uuid> --provider telegram --destination-label <room_label> --bot-name <server_bot_name> --roles monitor,review --start false
+metheus-governance-mcp-cli runner start-detached --project-id <project_uuid> --provider telegram --destination-label <room_label> --bot-name <server_bot_name> --role monitor
 ```
 
 If you want the older step-by-step path instead:

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,
@@ -12206,11 +12258,11 @@ async function runRunnerProjectUp(flags) {
   if (!matchingRoutes.length) {
     throw new Error("runner project up did not find any enabled routes for the selected project destination");
   }
-  if (!boolFromRaw(flags.json, false)) {
-    process.stdout.write(
-      `${startDetachedRequested ? "Starting detached runner" : "Starting runner"} for project ${summaryPayload.project_id} destination ${summaryPayload.destination_label || summaryPayload.destination_id} using ${matchingRoutes.length} enabled route(s).\n`,
-    );
-  }
+  if (!boolFromRaw(flags.json, false)) {
+    process.stdout.write(
+      `${startDetachedRequested ? "Starting detached runner" : "Starting foreground runner (stops when this session ends)"} for project ${summaryPayload.project_id} destination ${summaryPayload.destination_label || summaryPayload.destination_id} using ${matchingRoutes.length} enabled route(s).\n`,
+    );
+  }
   if (startDetachedRequested) {
     await runRunnerStartDetachedResolvedRoutes(matchingRoutes, startFlags, "runner project up");
     return;
@@ -12225,39 +12277,89 @@ async function runRunnerProjectUp(flags) {
   });
 }
 
-function canStartRunnerDespiteProjectUpApplyFailure({ applyRequested, applyResult, matchingRoutes }) {
-  if (!applyRequested) return false;
-  const normalizedApplyResult = safeObject(applyResult);
-  if (normalizedApplyResult.ok !== false) return false;
+function canStartRunnerDespiteProjectUpApplyFailure({ applyRequested, applyResult, matchingRoutes }) {
+  if (!applyRequested) return false;
+  const normalizedApplyResult = safeObject(applyResult);
+  if (normalizedApplyResult.ok !== false) return false;
   const errorText = String(normalizedApplyResult.error || "").trim();
   if (errorText !== "route apply skipped because the Telegram room visibility probe failed") {
     return false;
   }
-  return ensureArray(matchingRoutes).length > 0;
-}
-
-async function buildRunnerProjectUpResult(flags = {}) {
-  const ui = createPrompter();
-  try {
-    if (shouldRenderPromptChrome(flags)) {
-      ui.setFlow("RUNNER PROJECT UP", "Audit one project destination, create missing runner routes, and optionally start polling");
-    }
-    const provider = String(flags.provider || "").trim()
-      ? normalizeBotProvider(flags.provider)
-      : "telegram";
-    if (provider !== "telegram") {
-      throw new Error("runner project up currently supports only --provider telegram");
-    }
-    const applyRequested = Object.prototype.hasOwnProperty.call(flags, "apply")
-      ? boolFromRaw(flags.apply, true)
-      : true;
-    const startDetachedRequested = Object.prototype.hasOwnProperty.call(flags, "start-detached")
-      ? boolFromRaw(flags["start-detached"], true)
-      : boolFromRaw(flags.detached, false);
-    const startRequested = Object.prototype.hasOwnProperty.call(flags, "start")
-      ? boolFromRaw(flags.start, true)
-      : true;
-    const shouldStartRunner = startRequested || startDetachedRequested;
+  return ensureArray(matchingRoutes).length > 0;
+}
+
+function resolveRunnerProjectUpExecutionPolicy(flags = {}) {
+  const applyRequested = Object.prototype.hasOwnProperty.call(flags, "apply")
+    ? boolFromRaw(flags.apply, true)
+    : true;
+  const startDetachedRequested = Object.prototype.hasOwnProperty.call(flags, "start-detached")
+    ? boolFromRaw(flags["start-detached"], true)
+    : boolFromRaw(flags.detached, false);
+  const startRequested = Object.prototype.hasOwnProperty.call(flags, "start")
+    ? boolFromRaw(flags.start, true)
+    : false;
+  const shouldStartRunner = startRequested || startDetachedRequested;
+  return {
+    applyRequested,
+    startDetachedRequested,
+    startRequested,
+    shouldStartRunner,
+    foregroundStartRequested: startRequested && !startDetachedRequested,
+  };
+}
+
+function buildRunnerStartDetachedCommand(flags = {}) {
+  return [CLI_NAME, "runner", "start-detached", ...serializeCLIFlags(flags, {
+    omit: ["json", "start", "start-detached", "detached"],
+  })].join(" ");
+}
+
+function buildRunnerProjectUpNextSteps({
+  applyRequested,
+  shouldStartRunner,
+  projectID,
+  provider,
+  destinationID,
+  matchingRoutes,
+  startFlags,
+}) {
+  const nextSteps = [];
+  const routeNames = ensureArray(matchingRoutes).map((route) => normalizeRunnerRoute(route).name).filter(Boolean);
+  if (!applyRequested) {
+    nextSteps.push(`${CLI_NAME} runner project up --project-id ${projectID} --provider ${provider} --destination-id ${destinationID} --apply true --start false`);
+  }
+  if (!shouldStartRunner) {
+    if (routeNames.length > 0) {
+      nextSteps.push(`${CLI_NAME} runner show --route-name ${routeNames[0]}`);
+      nextSteps.push(buildRunnerStartDetachedCommand(startFlags));
+    } else if (applyRequested) {
+      nextSteps.push(`${CLI_NAME} runner project up --project-id ${projectID} --provider ${provider} --destination-id ${destinationID} --apply true --start false`);
+    }
+    return nextSteps;
+  }
+  nextSteps.push(`${CLI_NAME} runner show --route-name ${routeNames[0] || "<route_name>"}`);
+  return nextSteps;
+}
+
+async function buildRunnerProjectUpResult(flags = {}) {
+  const ui = createPrompter();
+  try {
+    if (shouldRenderPromptChrome(flags)) {
+      ui.setFlow("RUNNER PROJECT UP", "Audit one project destination, create missing runner routes, and optionally start polling when explicitly requested");
+    }
+    const provider = String(flags.provider || "").trim()
+      ? normalizeBotProvider(flags.provider)
+      : "telegram";
+    if (provider !== "telegram") {
+      throw new Error("runner project up currently supports only --provider telegram");
+    }
+    const {
+      applyRequested,
+      startDetachedRequested,
+      startRequested,
+      shouldStartRunner,
+      foregroundStartRequested,
+    } = resolveRunnerProjectUpExecutionPolicy(flags);
     const roleFilter = parseRunnerProjectUpRoles(flags);
     const botNameFilter = String(flags["bot-name"] || "").trim();
     const botIDFilter = String(flags["bot-id"] || "").trim();
@@ -12340,30 +12442,35 @@ async function buildRunnerProjectUpResult(flags = {}) {
       route_apply_requested: applyRequested,
       route_apply_changed: Boolean(applyResult.changed),
       route_config_file: String(applyResult.filePath || auditPayload.routeSuggestionConfigFilePath || "-").trim() || "-",
-      enabled_routes_for_selection: matchingRoutes.map((route) => normalizeRunnerRoute(route).name).filter(Boolean),
-      start_requested: shouldStartRunner,
-      start_detached_requested: startDetachedRequested,
-      next_steps: [],
-      applied_routes: ensureArray(applyResult.appliedRoutes).map((item) => safeObject(item)),
-      disabled_routes: ensureArray(applyResult.disabledRoutes).map((item) => safeObject(item)),
-    };
-    if (!applyRequested) {
-      summaryPayload.next_steps.push(`${CLI_NAME} runner project up --project-id ${summaryPayload.project_id} --provider ${provider} --destination-id ${summaryPayload.destination_id} --apply true --start false`);
-    } else if (!shouldStartRunner) {
-      summaryPayload.next_steps.push(`${CLI_NAME} runner project up --project-id ${summaryPayload.project_id} --provider ${provider} --destination-id ${summaryPayload.destination_id}`);
-    } else {
-      summaryPayload.next_steps.push(`${CLI_NAME} runner show --route-name ${summaryPayload.enabled_routes_for_selection[0] || "<route_name>"}`);
-    }
-    if (applyRequested && applyResult.ok === false && applyResult.error) {
-      if (applyFailureWarningOnly) {
-        summaryPayload.warning = String(applyResult.error || "").trim();
-      } else {
-        summaryPayload.error = String(applyResult.error || "").trim();
-      }
-    }
-    return {
-      summaryPayload,
-      applyRequested,
+      enabled_routes_for_selection: matchingRoutes.map((route) => normalizeRunnerRoute(route).name).filter(Boolean),
+      start_requested: shouldStartRunner,
+      start_detached_requested: startDetachedRequested,
+      next_steps: [],
+      applied_routes: ensureArray(applyResult.appliedRoutes).map((item) => safeObject(item)),
+      disabled_routes: ensureArray(applyResult.disabledRoutes).map((item) => safeObject(item)),
+    };
+    summaryPayload.next_steps.push(...buildRunnerProjectUpNextSteps({
+      applyRequested,
+      shouldStartRunner,
+      projectID: summaryPayload.project_id,
+      provider,
+      destinationID: summaryPayload.destination_id,
+      matchingRoutes,
+      startFlags,
+    }));
+    if (applyRequested && applyResult.ok === false && applyResult.error) {
+      if (applyFailureWarningOnly) {
+        summaryPayload.warning = String(applyResult.error || "").trim();
+      } else {
+        summaryPayload.error = String(applyResult.error || "").trim();
+      }
+    }
+    if (foregroundStartRequested && !summaryPayload.warning && !summaryPayload.error) {
+      summaryPayload.warning = "foreground runner start was explicitly requested; the runner stops when this terminal session ends. Use runner start-detached for persistent polling.";
+    }
+    return {
+      summaryPayload,
+      applyRequested,
       applyResult,
       shouldStartRunner,
       startDetachedRequested,
@@ -16855,12 +16962,12 @@ function buildLocalToolSpecs() {
         "Delete one project context item permanently.",
       inputSchema: buildProjectContextGetInputSchema(),
     },
-    {
-      name: "runner.project_up",
-      description:
-        "Audit one project destination, create missing runner routes, and optionally start polling. Use this before runner.start_detached when the route is not ready yet.",
-      inputSchema: buildRunnerProjectUpInputSchema(),
-    },
+    {
+      name: "runner.project_up",
+      description:
+        "Audit one project destination, create missing runner routes, and optionally start polling only when explicitly requested. Use this before runner.start_detached when the route is not ready yet.",
+      inputSchema: buildRunnerProjectUpInputSchema(),
+    },
     {
       name: "runner.show",
       description:
@@ -19215,12 +19322,50 @@ TELEGRAM_BOT_REVIEW_TOKEN=review-token
     push("detached_runner_linux_launcher_selects_supported_terminal", false, String(err?.message || err));
   }
 
-  try {
-    push(
-      "runner_project_up_probe_failure_allows_existing_route_start",
-      canStartRunnerDespiteProjectUpApplyFailure({
-        applyRequested: true,
-        applyResult: { ok: false, error: "route apply skipped because the Telegram room visibility probe failed" },
+  try {
+    const projectUpPolicy = resolveRunnerProjectUpExecutionPolicy({});
+    push(
+      "runner_project_up_default_policy_is_prepare_only",
+      projectUpPolicy.applyRequested === true
+        && projectUpPolicy.startRequested === false
+        && projectUpPolicy.startDetachedRequested === false
+        && projectUpPolicy.shouldStartRunner === false,
+      `apply=${projectUpPolicy.applyRequested} start=${projectUpPolicy.startRequested} detached=${projectUpPolicy.startDetachedRequested} shouldStart=${projectUpPolicy.shouldStartRunner}`,
+    );
+  } catch (err) {
+    push("runner_project_up_default_policy_is_prepare_only", false, String(err?.message || err));
+  }
+
+  try {
+    const nextSteps = buildRunnerProjectUpNextSteps({
+      applyRequested: true,
+      shouldStartRunner: false,
+      projectID: selftestProjectID,
+      provider: "telegram",
+      destinationID: "dest-1",
+      matchingRoutes: [{ name: "telegram-monitor-selftest", enabled: true }],
+      startFlags: {
+        "project-id": selftestProjectID,
+        provider: "telegram",
+        "destination-id": "dest-1",
+      },
+    });
+    push(
+      "runner_project_up_next_steps_prefer_start_detached",
+      nextSteps.includes(`${CLI_NAME} runner show --route-name telegram-monitor-selftest`)
+        && nextSteps.includes(`${CLI_NAME} runner start-detached --project-id ${selftestProjectID} --provider telegram --destination-id dest-1`),
+      nextSteps.join(" | "),
+    );
+  } catch (err) {
+    push("runner_project_up_next_steps_prefer_start_detached", false, String(err?.message || err));
+  }
+
+  try {
+    push(
+      "runner_project_up_probe_failure_allows_existing_route_start",
+      canStartRunnerDespiteProjectUpApplyFailure({
+        applyRequested: true,
+        applyResult: { ok: false, error: "route apply skipped because the Telegram room visibility probe failed" },
         matchingRoutes: [{ name: "telegram-monitor-selftest" }],
       }) === true,
       "existing_routes=1 probe_failure=warning_only",

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.287",
   "description": "Metheus Governance MCP CLI (setup + stdio proxy)",
   "type": "module",
   "files": [