metheus-governance-mcp-cli 0.2.111 → 0.2.113

package/README.md

@@ -305,7 +305,7 @@ For direct Telegram adds, the CLI derives the local file name from the matched s
 
 For direct Telegram edits, prefer `--bot-name` or `--bot-id` because server bot identity is the source of truth. Use `--bot-key` only when you intentionally need the legacy local selector. If one server bot name expands to multiple roles such as `approval / worker / review / monitor`, prefer the guided `bot edit` flow so you can keep the current grouped settings, edit one role only, or walk every role in sequence instead of forcing one entry-level AI override.
 
-For runner commands, you can still use `--route-name` directly, but normal operator workflows can also use `--bot-name` or `--bot-id` when those identify one enabled route uniquely. Use `runner list` first if you are not sure which route belongs to which server bot.
+For runner commands, routes are the executable unit. Use `--route-name` as the primary selector. `--bot-name` and `--bot-id` are convenience route aliases only when they identify one enabled route uniquely. Use `runner list` first if you are not sure which route belongs to which server bot, and use `runner show` to inspect the resolved route, server identity, workspace mapping, and execution profile together.
 
 Current support status:
 
@@ -388,6 +388,7 @@ Commands:
 
 ```bash
 metheus-governance-mcp-cli runner list
+metheus-governance-mcp-cli runner show --route-name telegram-monitor
 metheus-governance-mcp-cli runner once --route-name telegram-monitor
 metheus-governance-mcp-cli runner start --route-name telegram-monitor
 ```
@@ -399,9 +400,16 @@ metheus-governance-mcp-cli runner once --route-name telegram-monitor --dry-run-d
 metheus-governance-mcp-cli runner start --route-name telegram-monitor
 ```
 
+What `runner list` means:
+- `server_bot_name` may come from `route.server_bot_name` or be resolved from the Telegram bot env file by `server_bot_id`
+- `server_bot_name_source=route_config` means the route file already stores the name directly
+- `server_bot_name_source=telegram_env_lookup` means the CLI resolved the name from the local Telegram bot file
+- `route_alias_by_server_bot_name` is a convenience selector, not a separate execution target
+
 Debug/selection overrides:
 
 ```bash
+metheus-governance-mcp-cli runner show --bot-name <server_bot_name>
 metheus-governance-mcp-cli runner once --project-id <project_uuid> --provider telegram --role monitor
 metheus-governance-mcp-cli runner start --project-id <project_uuid> --provider telegram --role monitor --poll-interval-ms 5000
 metheus-governance-mcp-cli runner once --project-id <project_uuid> --provider telegram --role monitor --role-profile review

package/cli.mjs

@@ -255,8 +255,9 @@ function printUsage() {
       `  ${cmd} selftest [--json <true|false>]`,
       `  ${cmd} local-bot-bridge [--client <gpt|claude|gemini|sample>] [--cwd <path>] [--model <name>] [--permission-mode <read_only|workspace_write|danger_full_access>] [--reasoning-effort <low|medium|high>]`,
       `  ${cmd} runner list [--json <true|false>]`,
-      `  ${cmd} runner once [--route-name <name> | --bot-name <server_name> | --bot-id <uuid>] [--project-id <uuid>] [--provider <telegram|slack|kakaotalk>] [--role <monitor|review|worker|approval>] [--role-profile <name>] [--mentions-only <true|false>] [--reply-to-bot-messages <true|false>] [--direct-messages <true|false>] [--ignore-edited-messages <true|false>] [--dry-run-delivery <true|false>] [--context-comments <n>] [--archive-replies <true|false>]`,
-      `  ${cmd} runner start [--route-name <name> | --bot-name <server_name> | --bot-id <uuid>] [--project-id <uuid>] [--provider <telegram|slack|kakaotalk>] [--role <monitor|review|worker|approval>] [--role-profile <name>] [--mentions-only <true|false>] [--reply-to-bot-messages <true|false>] [--direct-messages <true|false>] [--ignore-edited-messages <true|false>] [--dry-run-delivery <true|false>] [--poll-interval-ms <n>] [--context-comments <n>] [--archive-replies <true|false>]`,
+      `  ${cmd} runner show [--route-name <name> | --bot-name <server_name> | --bot-id <uuid>] [--json <true|false>]`,
+      `  ${cmd} runner once [--route-name <name> | --bot-name <server_name when one enabled route matches> | --bot-id <uuid when one enabled route matches>] [--project-id <uuid>] [--provider <telegram|slack|kakaotalk>] [--role <monitor|review|worker|approval>] [--role-profile <name>] [--mentions-only <true|false>] [--reply-to-bot-messages <true|false>] [--direct-messages <true|false>] [--ignore-edited-messages <true|false>] [--dry-run-delivery <true|false>] [--context-comments <n>] [--archive-replies <true|false>]`,
+      `  ${cmd} runner start [--route-name <name> | --bot-name <server_name when one enabled route matches> | --bot-id <uuid when one enabled route matches>] [--project-id <uuid>] [--provider <telegram|slack|kakaotalk>] [--role <monitor|review|worker|approval>] [--role-profile <name>] [--mentions-only <true|false>] [--reply-to-bot-messages <true|false>] [--direct-messages <true|false>] [--ignore-edited-messages <true|false>] [--dry-run-delivery <true|false>] [--poll-interval-ms <n>] [--context-comments <n>] [--archive-replies <true|false>]`,
       `  ${cmd} ctxpack pull [--project-id <uuid>] [--base-url <url>] [--workspace-dir <path|auto>] [--paths <csv>] [--timeout-seconds <n>]`,
       `  ${cmd} auth status`,
       `  ${cmd} auth login [--base-url <url>] [--flow <auto|device|callback|manual>] [--keycloak-url <url>] [--realm <name>] [--client-id <id>] [--open-browser <true|false>] [--callback-port <n>] [--timeout-seconds <n>] [--manual <true|false>]`,
@@ -1269,10 +1270,21 @@ function normalizeBotRunnerConfigContents(parsed, filePath) {
     if (!binding.name || (!binding.botID && !binding.botName)) continue;
     if (!binding.roleProfile && !binding.client && !binding.model && !binding.permissionMode && !binding.reasoningEffort) continue;
     botBindings[binding.name] = binding;
-    const rawClient = String(safeObject(rawBinding).client || "").trim().toLowerCase();
+    const rawBindingObject = safeObject(rawBinding);
+    const rawClient = String(rawBindingObject.client || "").trim().toLowerCase();
     if (rawClient === "codex") {
       migrated = true;
     }
+    if (
+      (!Object.prototype.hasOwnProperty.call(rawBindingObject, "server_bot_id")
+        && !Object.prototype.hasOwnProperty.call(rawBindingObject, "serverBotID")
+        && (Object.prototype.hasOwnProperty.call(rawBindingObject, "bot_id") || Object.prototype.hasOwnProperty.call(rawBindingObject, "botId")))
+      || (!Object.prototype.hasOwnProperty.call(rawBindingObject, "server_bot_name")
+        && !Object.prototype.hasOwnProperty.call(rawBindingObject, "serverBotName")
+        && (Object.prototype.hasOwnProperty.call(rawBindingObject, "bot_name") || Object.prototype.hasOwnProperty.call(rawBindingObject, "botName")))
+    ) {
+      migrated = true;
+    }
   }
 
   const projectMappings = {};
@@ -1289,6 +1301,16 @@ function normalizeBotRunnerConfigContents(parsed, filePath) {
     const routeSource = safeObject(rawRoute);
     const route = normalizeRunnerRoute(routeSource);
     routes.push(route);
+    if (
+      (!Object.prototype.hasOwnProperty.call(routeSource, "server_bot_id")
+        && !Object.prototype.hasOwnProperty.call(routeSource, "serverBotID")
+        && (Object.prototype.hasOwnProperty.call(routeSource, "bot_id") || Object.prototype.hasOwnProperty.call(routeSource, "botID")))
+      || (!Object.prototype.hasOwnProperty.call(routeSource, "server_bot_name")
+        && !Object.prototype.hasOwnProperty.call(routeSource, "serverBotName")
+        && (Object.prototype.hasOwnProperty.call(routeSource, "bot_name") || Object.prototype.hasOwnProperty.call(routeSource, "botName")))
+    ) {
+      migrated = true;
+    }
     if (!Object.prototype.hasOwnProperty.call(routeSource, "trigger_policy") && !Object.prototype.hasOwnProperty.call(routeSource, "triggerPolicy")) {
       migrated = true;
     }
@@ -1797,8 +1819,27 @@ function matchesRunnerRouteText(candidate, expected) {
   return String(candidate || "").trim().toLowerCase() === expectedText.toLowerCase();
 }
 
-function configuredRunnerRouteMatchesInlineSelection(route, inlineRoute, flags) {
+function resolveConfiguredRunnerRouteServerBotName(route, telegramEntries = []) {
   const candidate = normalizeRunnerRoute(route);
+  if (candidate.botName) {
+    return candidate.botName;
+  }
+  if (candidate.provider !== "telegram") {
+    return "";
+  }
+  const matchedTelegramEntry = ensureArray(telegramEntries).find((entry) => {
+    const current = safeObject(entry);
+    return (
+      (candidate.botID && current.serverBotID && current.serverBotID === candidate.botID)
+      || (candidate.botName && current.serverBotName && current.serverBotName === candidate.botName)
+    );
+  });
+  return String(matchedTelegramEntry?.serverBotName || "").trim();
+}
+
+function configuredRunnerRouteMatchesInlineSelection(route, inlineRoute, flags, options = {}) {
+  const candidate = normalizeRunnerRoute(route);
+  const candidateBotName = resolveConfiguredRunnerRouteServerBotName(candidate, options.telegramEntries);
   if (hasRunnerFlag(flags, "route-name") && !matchesRunnerRouteText(candidate.name, flags["route-name"])) {
     return false;
   }
@@ -1817,7 +1858,7 @@ function configuredRunnerRouteMatchesInlineSelection(route, inlineRoute, flags)
   if (inlineRoute.botID && candidate.botID !== inlineRoute.botID) {
     return false;
   }
-  if (inlineRoute.botName && !matchesRunnerRouteText(candidate.botName, inlineRoute.botName)) {
+  if (inlineRoute.botName && !matchesRunnerRouteText(candidateBotName, inlineRoute.botName)) {
     return false;
   }
   if (inlineRoute.destinationID && candidate.destinationID !== inlineRoute.destinationID) {
@@ -2014,9 +2055,10 @@ function resolveRunnerRoutes(flags, mode) {
     .map((rawRoute) => normalizeRunnerRoute(rawRoute))
     .filter((route) => route.enabled)
     .filter((route) => !routeNameFilter || String(route.name || "").trim().toLowerCase() === routeNameFilter);
+  const telegramEntries = selectionRequested ? ensureArray(readTelegramEnvState().entries) : [];
 
   if (selectionRequested) {
-    const matchedRoutes = configuredRoutes.filter((route) => configuredRunnerRouteMatchesInlineSelection(route, inlineRoute, flags));
+    const matchedRoutes = configuredRoutes.filter((route) => configuredRunnerRouteMatchesInlineSelection(route, inlineRoute, flags, { telegramEntries }));
     if (matchedRoutes.length === 1) {
       return [applyRunnerRouteFlagOverrides(matchedRoutes[0], flags)];
     }
@@ -2591,10 +2633,14 @@ function buildRunnerRouteListRows() {
         );
       })
       : null;
+    const botNameSource = route.botName
+      ? "route_config"
+      : matchedTelegramEntry?.serverBotName
+        ? "telegram_env_lookup"
+        : "unresolved";
     const resolvedBotName = firstNonEmptyString([
       route.botName,
       matchedTelegramEntry?.serverBotName,
-      matchedTelegramEntry?.key,
       "-",
     ]);
     return {
@@ -2604,6 +2650,7 @@ function buildRunnerRouteListRows() {
       provider: route.provider || "-",
       projectID: route.projectID || "-",
       botName: resolvedBotName,
+      botNameSource,
       botID: route.botID || "-",
       role: route.role || "-",
       roleProfile: route.roleProfile || "-",
@@ -2621,6 +2668,7 @@ async function runRunnerList(flags) {
     return;
   }
   process.stdout.write("Runner routes\n");
+  process.stdout.write("  note: routes are the executable unit. --bot-name and --bot-id are convenience selectors that resolve one enabled route when the match is unique.\n");
   if (!rows.length) {
     process.stdout.write("  none configured\n");
     return;
@@ -2633,18 +2681,141 @@ async function runRunnerList(flags) {
         `    provider: ${row.provider}`,
         `    project_id: ${row.projectID}`,
         `    server_bot_name: ${row.botName}`,
+        `    server_bot_name_source: ${row.botNameSource}`,
         `    server_bot_id: ${row.botID}`,
         `    role: ${row.role}`,
         `    role_profile: ${row.roleProfile}`,
         `    destination_label: ${row.destinationLabel}`,
         `    poll_interval_ms: ${row.pollIntervalMs}`,
         `    run_once: ${CLI_NAME} runner once --route-name ${row.name}`,
-        row.botName ? `    run_once_by_server_bot_name: ${CLI_NAME} runner once --bot-name "${row.botName}"` : "",
+        row.botName && row.botNameSource !== "unresolved"
+          ? `    route_alias_by_server_bot_name: ${CLI_NAME} runner once --bot-name "${row.botName}"`
+          : "",
       ].join("\n") + "\n",
     );
   });
 }
 
+function resolveRunnerShowSelection(flags) {
+  const routes = resolveRunnerRoutes(flags, "once");
+  if (!routes.length) {
+    throw new Error("no runner route matched the provided filters");
+  }
+  if (routes.length > 1) {
+    const names = routes.map((route) => normalizeRunnerRoute(route).name || runnerRouteKey(route)).join(", ");
+    throw new Error(`Multiple enabled runner routes matched. Narrow with --route-name, --bot-name, or --bot-id. Matches: ${names}`);
+  }
+  return normalizeRunnerRoute(routes[0]);
+}
+
+function findRunnerTelegramEntryForRoute(route, telegramEntries) {
+  const normalizedRoute = normalizeRunnerRoute(route);
+  if (normalizedRoute.provider !== "telegram") return null;
+  return ensureArray(telegramEntries).find((entry) => {
+    const current = safeObject(entry);
+    return (
+      (normalizedRoute.botID && current.serverBotID && current.serverBotID === normalizedRoute.botID)
+      || (normalizedRoute.botName && current.serverBotName && current.serverBotName === normalizedRoute.botName)
+    );
+  }) || null;
+}
+
+function buildRunnerShowPayload(route, flags = {}) {
+  const normalizedRoute = normalizeRunnerRoute(route);
+  const runnerConfig = loadBotRunnerConfig({ persistIfNeeded: true });
+  const diagnostics = collectRunnerRouteDiagnostics(normalizedRoute, runnerConfig);
+  const telegramState = readTelegramEnvState();
+  const telegramEntries = ensureArray(telegramState.entries);
+  const matchedTelegramEntry = findRunnerTelegramEntryForRoute(normalizedRoute, telegramEntries);
+  const botNameSource = normalizedRoute.botName
+    ? "route_config"
+    : matchedTelegramEntry?.serverBotName
+      ? "telegram_env_lookup"
+      : "unresolved";
+  const resolvedServerBotName = firstNonEmptyString([
+    normalizedRoute.botName,
+    matchedTelegramEntry?.serverBotName,
+    "-",
+  ]);
+  const envConfig = normalizedRoute.provider
+    ? loadProviderEnvConfig(normalizedRoute.provider, {
+      botID: normalizedRoute.botID,
+      botName: resolvedServerBotName !== "-" ? resolvedServerBotName : "",
+      route: normalizedRoute,
+    })
+    : null;
+  return {
+    ok: diagnostics.errors.length === 0,
+    route_name: normalizedRoute.name || runnerRouteKey(normalizedRoute),
+    route_key: runnerRouteKey(normalizedRoute),
+    route_config_file: runnerConfig.filePath,
+    route_config: serializeRunnerRoute(normalizedRoute),
+    resolved_server_identity: {
+      server_bot_name: resolvedServerBotName,
+      server_bot_name_source: botNameSource,
+      server_bot_id: normalizedRoute.botID || "-",
+      telegram_entry_file: String(envConfig?.entryFilePath || "").trim() || "-",
+    },
+    workspace_mapping: {
+      workspace_dir: diagnostics.workspaceDir || "-",
+      workspace_source: diagnostics.workspaceSource || "-",
+    },
+    execution_profile: {
+      route_role: normalizedRoute.role || "-",
+      role_profile_name: diagnostics.roleProfileName || "-",
+      client: String(diagnostics.roleProfile?.client || "").trim() || "-",
+      model: String(diagnostics.roleProfile?.model || "").trim() || "-",
+      permission_mode: String(diagnostics.roleProfile?.permissionMode || "").trim() || "-",
+      reasoning_effort: String(diagnostics.roleProfile?.reasoningEffort || "").trim() || "-",
+    },
+    route_selection_note: "Routes are the executable unit. --bot-name and --bot-id are convenience selectors that resolve one enabled route when the match is unique.",
+    warnings: diagnostics.warnings,
+    errors: diagnostics.errors,
+  };
+}
+
+async function runRunnerShow(flags) {
+  const route = resolveRunnerShowSelection(flags);
+  const payload = buildRunnerShowPayload(route, flags);
+  if (boolFromRaw(flags.json, false)) {
+    process.stdout.write(`${JSON.stringify(payload, null, 2)}\n`);
+    return;
+  }
+  process.stdout.write("Runner route details\n");
+  process.stdout.write("  note: routes are the executable unit. --bot-name and --bot-id are convenience selectors that resolve one enabled route when the match is unique.\n");
+  process.stdout.write(
+    [
+      `  route_name: ${payload.route_name}`,
+      `  route_key: ${payload.route_key}`,
+      `  route_config_file: ${payload.route_config_file}`,
+      "  route_config:",
+      `    provider: ${payload.route_config.provider || "-"}`,
+      `    project_id: ${payload.route_config.project_id || "-"}`,
+      `    role: ${payload.route_config.role || "-"}`,
+      `    role_profile: ${payload.route_config.role_profile || "-"}`,
+      `    destination_label: ${payload.route_config.destination_label || "-"}`,
+      `    poll_interval_ms: ${payload.route_config.poll_interval_ms || 0}`,
+      "  resolved_server_identity:",
+      `    server_bot_name: ${payload.resolved_server_identity.server_bot_name}`,
+      `    server_bot_name_source: ${payload.resolved_server_identity.server_bot_name_source}`,
+      `    server_bot_id: ${payload.resolved_server_identity.server_bot_id}`,
+      `    telegram_entry_file: ${payload.resolved_server_identity.telegram_entry_file}`,
+      "  workspace_mapping:",
+      `    workspace_dir: ${payload.workspace_mapping.workspace_dir}`,
+      `    workspace_source: ${payload.workspace_mapping.workspace_source}`,
+      "  execution_profile:",
+      `    route_role: ${payload.execution_profile.route_role}`,
+      `    role_profile_name: ${payload.execution_profile.role_profile_name}`,
+      `    client: ${payload.execution_profile.client}`,
+      `    model: ${payload.execution_profile.model}`,
+      `    permission_mode: ${payload.execution_profile.permission_mode}`,
+      `    reasoning_effort: ${payload.execution_profile.reasoning_effort}`,
+      payload.warnings.length ? `  warnings: ${payload.warnings.join("; ")}` : "  warnings: -",
+      payload.errors.length ? `  errors: ${payload.errors.join("; ")}` : "  errors: -",
+    ].join("\n") + "\n",
+  );
+}
+
 async function runRunnerStart(flags) {
   const jsonMode = boolFromRaw(flags.json, false);
   const routes = resolveRunnerRoutes(flags, "start");
@@ -2709,6 +2880,10 @@ async function runRunner(argv) {
     await runRunnerList(flags);
     return;
   }
+  if (subcommand === "show") {
+    await runRunnerShow(flags);
+    return;
+  }
   if (subcommand === "once") {
     await runRunnerOnce(flags);
     return;
@@ -3938,6 +4113,7 @@ function buildBotCommandDeps() {
     normalizeBotProvider,
     normalizeTelegramBotEnvKey,
     normalizeTelegramBotUsername,
+    normalizeRunnerRoute,
     normalizeRunnerRoleProfileName,
     normalizeLocalAIClientName,
     normalizeLocalAIPermissionMode,

package/lib/bot-commands.mjs

@@ -1254,6 +1254,7 @@ function summarizeTelegramRouteLinks(parsedEnv, entry, serverBinding, deps) {
   const selectedEntry = safeObject(entry);
   const binding = safeObject(serverBinding);
   const config = safeObject(requireDependency(deps, "loadBotRunnerConfig")({ persistIfNeeded: true }));
+  const normalizeRunnerRoute = requireDependency(deps, "normalizeRunnerRoute");
   const routes = ensureArray(config.routes);
   const entryKey = String(selectedEntry.key || "").trim();
   const defaultBotKey = String(safeObject(parsedEnv).TELEGRAM_DEFAULT_BOT_KEY || "").trim();
@@ -1267,12 +1268,12 @@ function summarizeTelegramRouteLinks(parsedEnv, entry, serverBinding, deps) {
   );
   const linkedRoutes = [];
   routes.forEach((rawRoute, index) => {
-    const route = safeObject(rawRoute);
+    const route = normalizeRunnerRoute(rawRoute);
     if (route.enabled === false) return;
     if (String(route.provider || "").trim().toLowerCase() !== "telegram") return;
     const routeName = String(route.name || route.route_name || `telegram-route-${index + 1}`).trim();
-    const routeBotID = String(route.bot_id || route.botID || "").trim();
-    const routeBotName = normalizeServerBotIdentityText(route.bot_name || route.botName || "");
+    const routeBotID = String(route.server_bot_id || route.serverBotID || route.bot_id || route.botID || "").trim();
+    const routeBotName = normalizeServerBotIdentityText(route.server_bot_name || route.serverBotName || route.bot_name || route.botName || "");
     const routeRole = String(route.role_profile || route.roleProfile || route.role || "").trim();
     let matchedBy = "";
     if (serverBotID && routeBotID === serverBotID) {

package/lib/selftest-bot-commands.mjs

@@ -565,7 +565,7 @@ export async function runSelftestBotCommands(push, deps) {
         enabled: true,
         project_id: "03c586a2-006d-4051-83b4-f353a5813176",
         provider: "telegram",
-        bot_id: mock.bots[0].id,
+        server_bot_id: mock.bots[0].id,
         role_profile: "monitor",
       },
       {

package/lib/selftest-runner-scenarios.mjs

@@ -415,7 +415,26 @@ export async function runSelftestRunnerScenarios(push, deps) {
     originalResolveUserProfile = process.env.USERPROFILE;
     const resolveHome = path.join(runnerRouteResolveTempRoot, "home");
     const resolveMetheusDir = path.join(resolveHome, ".metheus");
+    const resolveTelegramDir = path.join(resolveMetheusDir, "telegram-bots");
     fs.mkdirSync(resolveMetheusDir, { recursive: true });
+    fs.mkdirSync(resolveTelegramDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(resolveTelegramDir, "global.env"),
+      "TELEGRAM_DEFAULT_BOT_KEY=serverprotocolmonitorbot\n",
+      "utf8",
+    );
+    fs.writeFileSync(
+      path.join(resolveTelegramDir, "ServerProtocolMonitorBot.env"),
+      [
+        "TELEGRAM_BOT_SERVER_BOT_ID=22222222-2222-2222-2222-222222222222",
+        "TELEGRAM_BOT_SERVER_NAME=ServerProtocolMonitorBot",
+        "TELEGRAM_BOT_SERVER_ROLES=monitor",
+        "TELEGRAM_BOT_SERVER_ROLE_IDS=monitor:22222222-2222-2222-2222-222222222222",
+        "TELEGRAM_BOT_TOKEN=test-token",
+        "",
+      ].join("\n"),
+      "utf8",
+    );
     fs.writeFileSync(
       path.join(resolveMetheusDir, "bot-runner.json"),
       `${JSON.stringify({
@@ -435,9 +454,21 @@ export async function runSelftestRunnerScenarios(push, deps) {
             provider: "telegram",
             role: "monitor",
             role_profile: "monitor",
-            bot_name: "ServerProtocolMonitorBot",
+            bot_id: "22222222-2222-2222-2222-222222222222",
             destination_label: "AI incubating CHAT ROOM",
             archive_work_item_id: "304ce77a-7032-421c-aeda-bc54daf088dd",
+            trigger_policy: {
+              mentions_only: true,
+              direct_messages: true,
+              reply_to_bot_messages: true,
+              ignore_edited_messages: true,
+            },
+            archive_policy: {
+              mirror_replies: true,
+              dedupe_inbound: true,
+              dedupe_outbound: true,
+              skip_bot_messages: true,
+            },
           },
         ],
       }, null, 2)}\n`,
@@ -457,14 +488,18 @@ export async function runSelftestRunnerScenarios(push, deps) {
       "once",
     );
     const resolvedRunnerRoute = normalizeRunnerRoute(resolvedRunnerRoutes[0]);
+    const persistedRunnerConfig = JSON.parse(fs.readFileSync(path.join(resolveMetheusDir, "bot-runner.json"), "utf8"));
+    const persistedRoute = Array.isArray(persistedRunnerConfig.routes) ? persistedRunnerConfig.routes[0] || {} : {};
     push(
       "bot_runner_inline_filters_reuse_configured_route",
       resolvedRunnerRoutes.length === 1
         && resolvedRunnerRoute.name === "telegram-monitor"
         && resolvedRunnerRoute.destinationLabel === "AI incubating CHAT ROOM"
         && resolvedRunnerRoute.dryRunDelivery === true
-        && runnerRouteKey(resolvedRunnerRoute) === "telegram-monitor::11111111-1111-1111-1111-111111111111::telegram::monitor::ServerProtocolMonitorBot::AI incubating CHAT ROOM",
-      `name=${resolvedRunnerRoute.name || "(none)"} destination=${resolvedRunnerRoute.destinationLabel || "(none)"} key=${runnerRouteKey(resolvedRunnerRoute)}`,
+        && runnerRouteKey(resolvedRunnerRoute) === "telegram-monitor::11111111-1111-1111-1111-111111111111::telegram::monitor::22222222-2222-2222-2222-222222222222::AI incubating CHAT ROOM"
+        && String(persistedRoute.server_bot_id || "") === "22222222-2222-2222-2222-222222222222"
+        && !Object.prototype.hasOwnProperty.call(persistedRoute, "bot_id"),
+      `name=${resolvedRunnerRoute.name || "(none)"} destination=${resolvedRunnerRoute.destinationLabel || "(none)"} key=${runnerRouteKey(resolvedRunnerRoute)} persisted=${JSON.stringify(persistedRoute)}`,
     );
   } catch (err) {
     push("bot_runner_inline_filters_reuse_configured_route", false, String(err?.message || err));

package/package.json

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