metheus-governance-mcp-cli 0.2.291 → 0.2.293

package/README.md

@@ -380,6 +380,7 @@ Behavior:
 - `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 direct CLI preparation path for Telegram project operations: it runs the same room audit and applies the selected role routes. Use `runner start-detached` for persistent polling, or let the TUI call `runner.project_up` to bootstrap detached polling in one step.
+- `runner project tui` is the direct CLI project-scoped dashboard: it audits one project destination, ensures one detached runner is reused or started for the selected route set, and then shows status, route selection, and recent log tail in one interactive screen.
 - `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:
@@ -423,6 +424,7 @@ metheus-governance-mcp-cli bot room-audit --provider telegram --project-id <proj
 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> --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 tui --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
 ```
 

package/cli.mjs

@@ -402,10 +402,11 @@ 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 route list [--json <true|false>]`,
-      `  ${cmd} runner route add [--project-id <uuid>] [--provider <telegram|slack|kakaotalk>] [--role <monitor|review|worker|approval>] [--bot-name <server_name> | --bot-id <uuid>] [--destination-label <label> | --destination-id <uuid>] [--poll-interval-ms <n>] [--enabled <true|false>]`,
-      `  ${cmd} runner project up [--project-id <uuid>] [--provider <telegram>] [--destination-label <label> | --destination-id <uuid>] [--bot-name <server_name> | --bot-id <uuid>] [--role <monitor|review|worker|approval> | --roles <csv>] [--apply <true|false>] [--start <true|false>] [--start-detached <true|false>] [--tui <true|false>] [--log-file <path>] [--dry-run-delivery <true|false>] [--concurrency <n>] [--json <true|false>]`,
-      `  ${cmd} runner artifact scan [--workspace-dir <path>] [--file-limit <n>] [--json <true|false>]`,
+      `  ${cmd} runner route list [--json <true|false>]`,
+      `  ${cmd} runner route add [--project-id <uuid>] [--provider <telegram|slack|kakaotalk>] [--role <monitor|review|worker|approval>] [--bot-name <server_name> | --bot-id <uuid>] [--destination-label <label> | --destination-id <uuid>] [--poll-interval-ms <n>] [--enabled <true|false>]`,
+      `  ${cmd} runner project up [--project-id <uuid>] [--provider <telegram>] [--destination-label <label> | --destination-id <uuid>] [--bot-name <server_name> | --bot-id <uuid>] [--role <monitor|review|worker|approval> | --roles <csv>] [--apply <true|false>] [--start <true|false>] [--start-detached <true|false>] [--tui <true|false>] [--log-file <path>] [--dry-run-delivery <true|false>] [--concurrency <n>] [--json <true|false>]`,
+      `  ${cmd} runner project tui [--project-id <uuid>] [--provider <telegram>] [--destination-label <label> | --destination-id <uuid>] [--bot-name <server_name> | --bot-id <uuid>] [--role <monitor|review|worker|approval> | --roles <csv>] [--start <true|false>]`,
+      `  ${cmd} runner artifact scan [--workspace-dir <path>] [--file-limit <n>] [--json <true|false>]`,
       `  ${cmd} runner route edit [--route-name <name> | --bot-name <server_name> | --bot-id <uuid>]`,
       `  ${cmd} runner route remove [--route-name <name> | --bot-name <server_name> | --bot-id <uuid>]`,
       `  ${cmd} runner show [--route-name <name> | --bot-name <server_name> | --bot-id <uuid>] [--json <true|false>]`,
@@ -7500,26 +7501,31 @@ async function syncRunnerRequestLedgerForProjectToServer({ normalizedRoute, runt
   }
 }
 
-function normalizeRunnerProcessLaunchEntry(rawEntry) {
-  const entry = safeObject(rawEntry);
-  return cleanupRunnerStateRecord({
-    launch_id: String(entry.launch_id || entry.launchID || "").trim(),
-    pid: intFromRawAllowZero(entry.pid, 0) || undefined,
-    started_at: String(entry.started_at || entry.startedAt || "").trim(),
-    command: String(entry.command || "").trim(),
-    cli_path: String(entry.cli_path || entry.cliPath || "").trim(),
-    working_directory: sanitizeWorkspaceCandidate(entry.working_directory || entry.workingDirectory) || String(entry.working_directory || entry.workingDirectory || "").trim(),
-    route_set_signature: String(entry.route_set_signature || entry.routeSetSignature || "").trim(),
-    route_keys: ensureArray(entry.route_keys || entry.routeKeys).map((item) => String(item || "").trim()).filter(Boolean),
-    route_names: ensureArray(entry.route_names || entry.routeNames).map((item) => String(item || "").trim()).filter(Boolean),
-    project_ids: ensureArray(entry.project_ids || entry.projectIds).map((item) => String(item || "").trim()).filter(Boolean),
-    provider: normalizeBotProvider(entry.provider),
-    destination_labels: ensureArray(entry.destination_labels || entry.destinationLabels).map((item) => String(item || "").trim()).filter(Boolean),
-    log_file: String(entry.log_file || entry.logFile || "").trim(),
-    created_by_pid: intFromRawAllowZero(entry.created_by_pid || entry.createdByPid, 0) || undefined,
-    source_command: String(entry.source_command || entry.sourceCommand || "").trim(),
-  });
-}
+function normalizeRunnerProcessLaunchEntry(rawEntry) {
+  const entry = safeObject(rawEntry);
+  const routeKeys = ensureArray(entry.route_keys || entry.routeKeys).map((item) => String(item || "").trim()).filter(Boolean);
+  return cleanupRunnerStateRecord({
+    launch_id: String(entry.launch_id || entry.launchID || "").trim(),
+    pid: intFromRawAllowZero(entry.pid, 0) || undefined,
+    started_at: String(entry.started_at || entry.startedAt || "").trim(),
+    command: String(entry.command || "").trim(),
+    cli_path: String(entry.cli_path || entry.cliPath || "").trim(),
+    working_directory: sanitizeWorkspaceCandidate(entry.working_directory || entry.workingDirectory) || String(entry.working_directory || entry.workingDirectory || "").trim(),
+    route_set_signature: String(entry.route_set_signature || entry.routeSetSignature || "").trim(),
+    route_keys: routeKeys,
+    route_names: ensureArray(entry.route_names || entry.routeNames).map((item) => String(item || "").trim()).filter(Boolean),
+    project_ids: ensureArray(entry.project_ids || entry.projectIds).map((item) => String(item || "").trim()).filter(Boolean),
+    provider: normalizeBotProvider(entry.provider),
+    destination_labels: ensureArray(entry.destination_labels || entry.destinationLabels).map((item) => String(item || "").trim()).filter(Boolean),
+    scheduling_target_keys: uniqueOrderedStrings([
+      ...ensureArray(entry.scheduling_target_keys || entry.schedulingTargetKeys).map((item) => String(item || "").trim()),
+      ...routeKeys.map((routeKey) => runnerSchedulingTargetKeyFromRouteKey(routeKey)).filter(Boolean),
+    ], (value) => String(value || "").trim()),
+    log_file: String(entry.log_file || entry.logFile || "").trim(),
+    created_by_pid: intFromRawAllowZero(entry.created_by_pid || entry.createdByPid, 0) || undefined,
+    source_command: String(entry.source_command || entry.sourceCommand || "").trim(),
+  });
+}
 
 function normalizeBotRunnerProcessRegistryContents(rawValue) {
   const launchesInput = safeObject(rawValue).launches;
@@ -12203,8 +12209,8 @@ function resolveRunnerProjectUpRoutes({
   });
 }
 
-async function runRunnerProjectUp(flags) {
-  const result = await buildRunnerProjectUpResult(flags);
+async function runRunnerProjectUp(flags) {
+  const result = await buildRunnerProjectUpResult(flags);
   const {
     summaryPayload,
     applyRequested,
@@ -12267,16 +12273,440 @@ async function runRunnerProjectUp(flags) {
     await runRunnerStartDetachedResolvedRoutes(matchingRoutes, startFlags, "runner project up");
     return;
   }
-  await runRunnerStartResolvedRoutes(matchingRoutes, startFlags, {
-    sourceLabel: "runner project up",
-    bootstrapEvent: {
-      route_name: "runner project up",
+  await runRunnerStartResolvedRoutes(matchingRoutes, startFlags, {
+    sourceLabel: "runner project up",
+    bootstrapEvent: {
+      route_name: "runner project up",
       outcome: "prepared",
       detail: `prepared ${matchingRoutes.length} enabled route(s) for ${summaryPayload.destination_label || summaryPayload.destination_id || summaryPayload.project_id || "project"}`,
-    },
-  });
-}
-
+    },
+  });
+}
+
+function resolveRunnerProjectTUIRuntimePolicy(flags = {}) {
+  const explicitStartRequested = Object.prototype.hasOwnProperty.call(flags, "start");
+  return {
+    autoStart: explicitStartRequested
+      ? boolFromRaw(flags.start, true)
+      : true,
+    auditFlags: {
+      ...safeObject(flags),
+      provider: String(flags.provider || "").trim()
+        ? normalizeBotProvider(flags.provider)
+        : "telegram",
+      start: false,
+      "start-detached": false,
+      tui: false,
+      json: true,
+    },
+  };
+}
+
+function readTextFileTailLines(filePath = "", maxLines = 12) {
+  const normalizedPath = String(filePath || "").trim();
+  if (!normalizedPath) return [];
+  try {
+    if (!fs.existsSync(normalizedPath)) {
+      return ["(log file not created yet)"];
+    }
+    const lines = String(fs.readFileSync(normalizedPath, "utf8") || "")
+      .split(/\r?\n/)
+      .map((line) => String(line || "").trimEnd());
+    return lines.filter((line) => line.length > 0).slice(-Math.max(1, intFromRaw(maxLines, 12)));
+  } catch (err) {
+    return [`(failed to read log: ${String(err?.message || err).trim()})`];
+  }
+}
+
+function buildRunnerProjectTUISnapshot({
+  auditResult,
+  autoStart = true,
+  statusMessage = "",
+  errorMessage = "",
+  lastAuditAt = "",
+}) {
+  const normalizedAuditResult = safeObject(auditResult);
+  const summaryPayload = safeObject(normalizedAuditResult.summaryPayload);
+  const matchingRoutes = ensureArray(normalizedAuditResult.matchingRoutes)
+    .map((route) => normalizeRunnerRoute(route));
+  const matchingRouteNames = matchingRoutes
+    .map((route) => String(route.name || runnerRouteKey(route)).trim())
+    .filter(Boolean);
+  const registry = loadBotRunnerProcessRegistry({ persistIfNeeded: true });
+  const existingLaunch = matchingRoutes.length
+    ? findExistingDetachedRunnerLaunch(registry, matchingRoutes)
+    : null;
+  const launch = existingLaunch
+    ? {
+      ...normalizeRunnerProcessLaunchEntry(existingLaunch),
+      alive: true,
+    }
+    : null;
+  const destinationID = String(summaryPayload.destination_id || "").trim();
+  const destinationLabel = String(summaryPayload.destination_label || "").trim();
+  const projectID = String(summaryPayload.project_id || "").trim();
+  const relatedLaunches = Object.values(safeObject(registry).launches || {})
+    .map((entry) => normalizeRunnerProcessLaunchEntry(entry))
+    .filter((entry) => isProcessAlive(entry.pid))
+    .filter((entry) => {
+      const sameProject = ensureArray(entry.project_ids)
+        .map((item) => String(item || "").trim())
+        .includes(projectID);
+      if (!sameProject) return false;
+      const sameDestinationLabel = destinationLabel
+        ? ensureArray(entry.destination_labels)
+          .map((item) => String(item || "").trim().toLowerCase())
+          .includes(destinationLabel.toLowerCase())
+        : false;
+      const sameDestinationID = destinationID
+        ? ensureArray(entry.route_keys)
+          .map((item) => String(item || "").trim())
+          .some((item) => item.includes(`::${destinationID}`))
+        : false;
+      return sameDestinationLabel || sameDestinationID;
+    })
+    .map((entry) => {
+      const routeNames = ensureArray(entry.route_names)
+        .map((item) => String(item || "").trim())
+        .filter(Boolean);
+      const sharedRouteNames = routeNames.filter((routeName) => matchingRouteNames.includes(routeName));
+      return {
+        launch_id: String(entry.launch_id || "").trim(),
+        pid: intFromRawAllowZero(entry.pid, 0),
+        route_names: routeNames,
+        shared_route_names: sharedRouteNames,
+        source_command: String(entry.source_command || "").trim(),
+        same_selection: Boolean(launch && String(launch.launch_id || "").trim() === String(entry.launch_id || "").trim()),
+      };
+    });
+  const logFilePath = String(launch?.log_file || "").trim();
+  const logLines = readTextFileTailLines(logFilePath, 12);
+  return {
+    project_id: projectID,
+    destination_label: destinationLabel,
+    destination_id: destinationID,
+    room_probe_ok: Boolean(summaryPayload.room_probe_ok),
+    route_apply_requested: Boolean(summaryPayload.route_apply_requested),
+    route_apply_changed: Boolean(summaryPayload.route_apply_changed),
+    route_config_file: String(summaryPayload.route_config_file || "").trim(),
+    enabled_routes: ensureArray(summaryPayload.enabled_routes_for_selection).map((item) => String(item || "").trim()).filter(Boolean),
+    matching_routes: matchingRouteNames,
+    next_steps: ensureArray(summaryPayload.next_steps).map((item) => String(item || "").trim()).filter(Boolean),
+    warning: String(summaryPayload.warning || "").trim(),
+    error: String(summaryPayload.error || errorMessage || "").trim(),
+    launch,
+    related_launches: relatedLaunches,
+    auto_start: autoStart,
+    status_message: String(statusMessage || "").trim(),
+    last_audit_at: String(lastAuditAt || "").trim() || new Date().toISOString(),
+    log_file: logFilePath,
+    log_lines: logLines.length
+      ? logLines
+      : [launch ? "(waiting for runner log output)" : "(no active detached runner)"],
+  };
+}
+
+function buildRunnerProjectTUIKeyLine(label, value, labelWidth = 14) {
+  return `${bootstrapPadRight(`${label}:`, labelWidth)} ${String(value || "-").trim() || "-"}`;
+}
+
+function buildRunnerProjectTUIList(items = [], {
+  emptyText = "-",
+  bullet = "- ",
+  indent = "  ",
+  width = 140,
+} = {}) {
+  const normalizedItems = ensureArray(items)
+    .map((item) => String(item || "").trim())
+    .filter(Boolean);
+  if (!normalizedItems.length) {
+    return [`${indent}${emptyText}`];
+  }
+  return normalizedItems.map((item) => `${indent}${bullet}${truncateRunnerTUIText(item, width)}`);
+}
+
+function buildRunnerProjectTUIFrame({
+  snapshot,
+  now = Date.now(),
+  stopping = false,
+  useColor = false,
+}) {
+  const normalizedSnapshot = safeObject(snapshot);
+  const alive = Boolean(safeObject(normalizedSnapshot.launch).alive);
+  const statusLabel = alive ? "[ RUNNING ]" : "[ STOPPED ]";
+  const statusDetail = alive
+    ? `launch=${String(safeObject(normalizedSnapshot.launch).launch_id || "").trim() || "-"} pid=${String(safeObject(normalizedSnapshot.launch).pid || "").trim() || "-"}`
+    : "no detached runner is active for this selection";
+  const enabledRoutes = ensureArray(normalizedSnapshot.enabled_routes);
+  const matchingRoutes = ensureArray(normalizedSnapshot.matching_routes);
+  const relatedLaunches = ensureArray(normalizedSnapshot.related_launches);
+  const selectedLaunch = safeObject(normalizedSnapshot.launch);
+  const otherLaunches = relatedLaunches.filter((launch) => !safeObject(launch).same_selection);
+  const overlappingLaunches = otherLaunches.filter((launch) => ensureArray(safeObject(launch).shared_route_names).length > 0);
+  const alertLines = [];
+  if (String(normalizedSnapshot.warning || "").trim()) {
+    alertLines.push(`warning: ${String(normalizedSnapshot.warning || "").trim()}`);
+  }
+  if (String(normalizedSnapshot.error || "").trim()) {
+    alertLines.push(`error: ${String(normalizedSnapshot.error || "").trim()}`);
+  }
+  if (overlappingLaunches.length) {
+    alertLines.push(`overlap: ${overlappingLaunches.length} other detached launch(es) share at least one route in this room`);
+  } else if (otherLaunches.length) {
+    alertLines.push(`notice: ${otherLaunches.length} other detached launch(es) are active for this project/destination`);
+  }
+  if (!alive) {
+    alertLines.push("runner is not active; press s to start or reuse a detached runner");
+  }
+  const stateHint = alive
+    ? "This screen can be closed with q. The detached runner keeps running."
+    : "No detached runner is attached to this selection yet.";
+  const lines = [
+    "+======================================================================================+",
+    "| METHEUS PROJECT RUNNER                                                               |",
+    "| Detached runner dashboard                                                            |",
+    "+======================================================================================+",
+    "",
+    "[ STATUS ]",
+    `  ${statusLabel}${stopping ? " (closing TUI)" : ""}`,
+    `  ${statusDetail}`,
+    `  ${stateHint}`,
+    "",
+    "[ PROJECT ]",
+    `  ${buildRunnerProjectTUIKeyLine("Project", normalizedSnapshot.project_id)}`,
+    `  ${buildRunnerProjectTUIKeyLine("Destination", String(normalizedSnapshot.destination_label || normalizedSnapshot.destination_id || "").trim() || "-")}`,
+    `  ${buildRunnerProjectTUIKeyLine("Updated", new Date(now).toLocaleString("sv-SE", { hour12: false }))}`,
+    `  ${buildRunnerProjectTUIKeyLine("Last Audit", String(normalizedSnapshot.last_audit_at || "").trim() || "-")}`,
+    "",
+    "[ RUNNER ]",
+    `  ${buildRunnerProjectTUIKeyLine("Auto Start", normalizedSnapshot.auto_start ? "enabled" : "prepare-only")}`,
+    `  ${buildRunnerProjectTUIKeyLine("Room Probe", normalizedSnapshot.room_probe_ok ? "ok" : "failed")}`,
+    `  ${buildRunnerProjectTUIKeyLine("Apply Result", normalizedSnapshot.route_apply_changed ? "route file changed" : "no route file change")}`,
+    `  ${buildRunnerProjectTUIKeyLine("Active Launches", `${relatedLaunches.length}`)}`,
+    `  ${buildRunnerProjectTUIKeyLine("This Launch", alive ? String(selectedLaunch.launch_id || "-").trim() || "-" : "-")}`,
+    `  ${buildRunnerProjectTUIKeyLine("PID", alive ? String(selectedLaunch.pid || "-").trim() || "-" : "-")}`,
+    `  ${buildRunnerProjectTUIKeyLine("Log File", String(normalizedSnapshot.log_file || "").trim() || "-")}`,
+    "",
+    "[ ROUTES ]",
+    `  ${buildRunnerProjectTUIKeyLine("Enabled", `${enabledRoutes.length}`)}`,
+    `  ${buildRunnerProjectTUIKeyLine("Matched", `${matchingRoutes.length}`)}`,
+    ...buildRunnerProjectTUIList(matchingRoutes.length ? matchingRoutes : enabledRoutes, {
+      emptyText: "no routes selected",
+      bullet: "- ",
+      indent: "    ",
+      width: 96,
+    }),
+    "",
+    "[ ALERTS ]",
+    ...buildRunnerProjectTUIList(alertLines, {
+      emptyText: "none",
+      bullet: "- ",
+      indent: "    ",
+      width: 96,
+    }),
+    "",
+    "[ CONTROLS ]",
+    "  s = start/reuse detached runner",
+    "  x = stop detached runner",
+    "  r = refresh status",
+    "  a = re-audit route selection",
+    "  q = quit this dashboard",
+    "",
+    "[ RECENT LOG TAIL ]",
+    ...ensureArray(normalizedSnapshot.log_lines).map((line) => `  ${truncateRunnerTUIText(line, 108)}`),
+  ];
+  if (otherLaunches.length) {
+    lines.push("");
+    lines.push("[ OTHER ACTIVE LAUNCHES ]");
+    for (const launch of otherLaunches) {
+      const currentLaunch = safeObject(launch);
+      const sharedRoutes = ensureArray(currentLaunch.shared_route_names).join(", ") || "-";
+      lines.push(`  - ${String(currentLaunch.launch_id || "-").trim() || "-"} pid=${String(currentLaunch.pid || "-").trim() || "-"} source=${String(currentLaunch.source_command || "-").trim() || "-"}`);
+      lines.push(`    shared routes: ${truncateRunnerTUIText(sharedRoutes, 96)}`);
+      lines.push(`    all routes: ${truncateRunnerTUIText(ensureArray(currentLaunch.route_names).join(", ") || "-", 96)}`);
+    }
+  }
+  const frame = lines.join("\n");
+  if (!useColor) {
+    return frame;
+  }
+  const statusColor = alive ? "\u001b[32m" : "\u001b[33m";
+  return frame.replace(statusLabel, `${statusColor}${statusLabel}\u001b[0m`);
+}
+
+async function runRunnerProjectTUI(flags) {
+  if (!process.stdout?.isTTY || !process.stdin?.isTTY) {
+    throw new Error("runner project tui requires an interactive terminal (TTY)");
+  }
+  const { autoStart, auditFlags } = resolveRunnerProjectTUIRuntimePolicy(flags);
+  const useColor = bootstrapSupportsANSIColors();
+  const state = {
+    auditResult: null,
+    snapshot: null,
+    busy: false,
+    disposed: false,
+  };
+  let intervalHandle = null;
+  let stdinHandler = null;
+
+  const render = (stopping = false) => {
+    if (state.disposed) return;
+    const frame = buildRunnerProjectTUIFrame({
+      snapshot: state.snapshot,
+      now: Date.now(),
+      stopping,
+      useColor,
+    });
+    process.stdout.write(`\u001b[?25l\u001b[2J\u001b[H${frame}`);
+  };
+
+  const refreshSnapshot = async ({
+    reAudit = false,
+    ensureStarted = false,
+    stopRunner = false,
+    statusMessage = "",
+  } = {}) => {
+    if (state.busy) return;
+    state.busy = true;
+    try {
+      if (reAudit || !state.auditResult) {
+        state.auditResult = await buildRunnerProjectUpResult(auditFlags);
+      }
+      let nextStatusMessage = String(statusMessage || "").trim();
+      let nextErrorMessage = "";
+      if (stopRunner) {
+        const currentSnapshot = buildRunnerProjectTUISnapshot({
+          auditResult: state.auditResult,
+          autoStart,
+          statusMessage: nextStatusMessage || "stopping detached runner",
+        });
+        if (safeObject(currentSnapshot.launch).launch_id) {
+          const stopPayload = stopDetachedRunnerWithFlags({
+            "launch-id": safeObject(currentSnapshot.launch).launch_id,
+          });
+          nextStatusMessage = `stopped ${ensureArray(stopPayload.stopped).map((item) => String(item.launch_id || "").trim()).filter(Boolean).join(", ") || "runner launch"}`;
+        } else {
+          nextStatusMessage = "no detached runner was active for this selection";
+        }
+      }
+      if (ensureStarted) {
+        if (state.auditResult.applyFailureBlocksStart) {
+          throw new Error(String(safeObject(state.auditResult.applyResult).error || "runner project tui could not apply runner routes").trim());
+        }
+        if (!ensureArray(state.auditResult.matchingRoutes).length) {
+          throw new Error("runner project tui did not find any enabled routes for the selected project destination");
+        }
+        const launchPayload = await runRunnerStartDetachedResolvedRoutes(
+          state.auditResult.matchingRoutes,
+          state.auditResult.startFlags,
+          "runner project tui",
+          { silent: true },
+        );
+        nextStatusMessage = launchPayload.already_running
+          ? `detached runner already running: ${String(safeObject(launchPayload.launch).launch_id || "").trim() || "-"}`
+          : `detached runner started: ${String(safeObject(launchPayload.launch).launch_id || "").trim() || "-"}`;
+      }
+      state.snapshot = buildRunnerProjectTUISnapshot({
+        auditResult: state.auditResult,
+        autoStart,
+        statusMessage: nextStatusMessage,
+        errorMessage: nextErrorMessage,
+        lastAuditAt: new Date().toISOString(),
+      });
+    } catch (err) {
+      state.snapshot = buildRunnerProjectTUISnapshot({
+        auditResult: state.auditResult || {
+          summaryPayload: {
+            project_id: String(auditFlags["project-id"] || auditFlags.project_id || "").trim(),
+            destination_label: String(auditFlags["destination-label"] || auditFlags.destination_label || "").trim(),
+            destination_id: String(auditFlags["destination-id"] || auditFlags.destination_id || "").trim(),
+          },
+          matchingRoutes: [],
+        },
+        autoStart,
+        statusMessage,
+        errorMessage: String(err?.message || err).trim(),
+        lastAuditAt: new Date().toISOString(),
+      });
+    } finally {
+      state.busy = false;
+      render(false);
+    }
+  };
+
+  const queueRefresh = (options = {}) => {
+    void refreshSnapshot(options);
+  };
+
+  try {
+    await refreshSnapshot({
+      reAudit: true,
+      ensureStarted: autoStart,
+      statusMessage: autoStart
+        ? "audited routes and ensured detached runner is running"
+        : "audited routes in prepare-only mode",
+    });
+
+    intervalHandle = setInterval(() => {
+      queueRefresh({ reAudit: false, ensureStarted: false, statusMessage: "status refreshed from detached registry" });
+    }, 2000);
+
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    stdinHandler = (chunk) => {
+      const key = String(chunk || "");
+      if (key === "\u0003" || key.toLowerCase() === "q") {
+        state.disposed = true;
+        if (intervalHandle) clearInterval(intervalHandle);
+        render(true);
+        process.stdin.setRawMode(false);
+        process.stdin.pause();
+        process.stdin.off("data", stdinHandler);
+        process.stdout.write("\u001b[?25h\n");
+        return;
+      }
+      if (key.toLowerCase() === "r") {
+        queueRefresh({ reAudit: false, ensureStarted: false, statusMessage: "status refreshed from detached registry" });
+        return;
+      }
+      if (key.toLowerCase() === "a") {
+        queueRefresh({ reAudit: true, ensureStarted: false, statusMessage: "route audit refreshed" });
+        return;
+      }
+      if (key.toLowerCase() === "s") {
+        queueRefresh({ reAudit: false, ensureStarted: true, statusMessage: "ensuring detached runner is active" });
+        return;
+      }
+      if (key.toLowerCase() === "x") {
+        queueRefresh({ reAudit: false, ensureStarted: false, stopRunner: true, statusMessage: "stopping detached runner" });
+      }
+    };
+    process.stdin.on("data", stdinHandler);
+    await new Promise((resolve) => {
+      const waitForDispose = setInterval(() => {
+        if (!state.disposed) return;
+        clearInterval(waitForDispose);
+        resolve();
+      }, 100);
+    });
+  } finally {
+    if (intervalHandle) clearInterval(intervalHandle);
+    if (stdinHandler) {
+      try {
+        process.stdin.off("data", stdinHandler);
+      } catch {}
+    }
+    if (process.stdin?.isTTY) {
+      try { process.stdin.setRawMode(false); } catch {}
+      try { process.stdin.pause(); } catch {}
+    }
+    if (!state.disposed) {
+      render(true);
+      process.stdout.write("\u001b[?25h\n");
+    }
+  }
+}
+
 function canStartRunnerDespiteProjectUpApplyFailure({ applyRequested, applyResult, matchingRoutes }) {
   if (!applyRequested) return false;
   const normalizedApplyResult = safeObject(applyResult);
@@ -12782,13 +13212,121 @@ function serializeCLIFlags(flags, options = {}) {
   return args;
 }
 
-function runnerDetachedRouteSetSignature(routes) {
-  return ensureArray(routes)
-    .map((route) => runnerRouteKey(normalizeRunnerRoute(route)))
-    .filter(Boolean)
-    .sort()
-    .join("||");
-}
+function runnerDetachedRouteSetSignature(routes) {
+  return ensureArray(routes)
+    .map((route) => runnerRouteKey(normalizeRunnerRoute(route)))
+    .filter(Boolean)
+    .sort()
+    .join("||");
+}
+
+function runnerSchedulingTargetKeyFromRouteKey(routeKey) {
+  const parts = String(routeKey || "").trim().split("::").filter(Boolean);
+  if (parts.length < 6) {
+    return "";
+  }
+  return [
+    String(parts[parts.length - 5] || "").trim(),
+    String(parts[parts.length - 4] || "").trim(),
+    String(parts[parts.length - 1] || "").trim(),
+  ].join("::");
+}
+
+function collectRunnerDetachedLaunchSchedulingTargetKeys(entryRaw) {
+  const entry = normalizeRunnerProcessLaunchEntry(entryRaw);
+  const explicitKeys = uniqueOrderedStrings(
+    ensureArray(entry.scheduling_target_keys || entry.schedulingTargetKeys),
+    (value) => String(value || "").trim(),
+  ).filter(Boolean);
+  if (explicitKeys.length > 0) {
+    return explicitKeys;
+  }
+  const routeKeyDerived = uniqueOrderedStrings(
+    ensureArray(entry.route_keys).map((value) => runnerSchedulingTargetKeyFromRouteKey(value)).filter(Boolean),
+    (value) => String(value || "").trim(),
+  ).filter(Boolean);
+  if (routeKeyDerived.length > 0) {
+    return routeKeyDerived;
+  }
+  const provider = normalizeBotProvider(entry.provider);
+  const projectIDs = ensureArray(entry.project_ids).map((value) => String(value || "").trim()).filter(Boolean);
+  const destinations = ensureArray(entry.destination_labels).map((value) => String(value || "").trim()).filter(Boolean);
+  return uniqueOrderedStrings(
+    projectIDs.flatMap((projectID) => destinations.map((destination) => [projectID, provider, destination].join("::"))),
+    (value) => String(value || "").trim(),
+  ).filter(Boolean);
+}
+
+function describeDetachedRunnerLaunch(entryRaw) {
+  const entry = normalizeRunnerProcessLaunchEntry(entryRaw);
+  return `launch_id=${entry.launch_id || "-"} pid=${entry.pid || "-"} routes=${ensureArray(entry.route_names).join(", ") || "-"}`;
+}
+
+function classifyDetachedRunnerLaunchReuse(registry, routes) {
+  const normalizedRoutes = ensureArray(routes).map((route) => normalizeRunnerRoute(route));
+  const targetSignature = runnerDetachedRouteSetSignature(normalizedRoutes);
+  const targetRouteKeys = normalizedRoutes.map((route) => runnerRouteKey(route)).filter(Boolean);
+  const targetRouteKeySet = new Set(targetRouteKeys);
+  const targetSchedulingTargetKeys = uniqueOrderedStrings(
+    normalizedRoutes.map((route) => runnerRouteSchedulingGroupKey(route)).filter(Boolean),
+    (value) => String(value || "").trim(),
+  ).filter(Boolean);
+  const aliveLaunches = Object.values(safeObject(registry).launches || {})
+    .map((entryRaw) => normalizeRunnerProcessLaunchEntry(entryRaw))
+    .filter((entry) => entry.launch_id && entry.pid && isProcessAlive(entry.pid));
+  const exact = aliveLaunches.find((entry) => entry.route_set_signature === targetSignature) || null;
+  if (exact) {
+    return {
+      kind: "reuse",
+      reason: "exact",
+      launch: exact,
+    };
+  }
+  if (!targetSchedulingTargetKeys.length) {
+    return {
+      kind: "none",
+    };
+  }
+  const sameTargetLaunches = aliveLaunches.filter((entry) => {
+    const entryTargetKeys = collectRunnerDetachedLaunchSchedulingTargetKeys(entry);
+    return entryTargetKeys.some((key) => targetSchedulingTargetKeys.includes(key));
+  });
+  if (!sameTargetLaunches.length) {
+    return {
+      kind: "none",
+    };
+  }
+  const supersets = sameTargetLaunches.filter((entry) => targetRouteKeys.every((routeKey) => ensureArray(entry.route_keys).includes(routeKey)));
+  if (supersets.length === 1) {
+    return {
+      kind: "reuse",
+      reason: "superset",
+      launch: supersets[0],
+    };
+  }
+  const conflictingLaunches = supersets.length > 1 ? supersets : sameTargetLaunches;
+  const overlapRouteNames = Array.from(
+    new Set(
+      conflictingLaunches.flatMap((entry) => ensureArray(entry.route_keys))
+        .filter((routeKey) => targetRouteKeySet.has(routeKey))
+        .map((routeKey) => {
+          const matchedRoute = normalizedRoutes.find((route) => runnerRouteKey(route) === routeKey);
+          return matchedRoute?.name || routeKey;
+        })
+        .filter(Boolean),
+    ),
+  );
+  const detail = supersets.length > 1
+    ? `multiple detached runners already cover the requested route set for the same project/provider/destination target (${conflictingLaunches.map((entry) => describeDetachedRunnerLaunch(entry)).join(" | ")})`
+    : `another detached runner already owns the same project/provider/destination target (${conflictingLaunches.map((entry) => describeDetachedRunnerLaunch(entry)).join(" | ")}). Stop it first or use runner project tui so one detached runner owns the full route set for that destination`;
+  return {
+    kind: "conflict",
+    detail,
+    launch: conflictingLaunches.length === 1 ? conflictingLaunches[0] : null,
+    conflicting_launches: conflictingLaunches,
+    overlapping_route_names: overlapRouteNames,
+  };
+}
 
 function buildRunnerDetachedPosixLaunchScript({
   scriptPath,
@@ -12848,25 +13386,28 @@ function buildRunnerDetachedLaunchRecord(childPID, routes, flags, sourceCommand,
     cli_path: cliPath,
     working_directory: path.dirname(cliPath),
     route_set_signature: runnerDetachedRouteSetSignature(normalizedRoutes),
-    route_keys: normalizedRoutes.map((route) => runnerRouteKey(route)),
-    route_names: normalizedRoutes.map((route) => route.name || runnerRouteKey(route)),
-    project_ids: Array.from(new Set(normalizedRoutes.map((route) => String(route.projectID || "").trim()).filter(Boolean))),
-    provider: firstNonEmptyString(normalizedRoutes.map((route) => route.provider)),
-    destination_labels: Array.from(new Set(normalizedRoutes.map((route) => String(route.destinationLabel || route.destinationID || "").trim()).filter(Boolean))),
-    log_file: String(logFilePath || "").trim(),
-    created_by_pid: process.pid,
-    source_command: sourceCommand,
-  });
-}
+    route_keys: normalizedRoutes.map((route) => runnerRouteKey(route)),
+    route_names: normalizedRoutes.map((route) => route.name || runnerRouteKey(route)),
+    project_ids: Array.from(new Set(normalizedRoutes.map((route) => String(route.projectID || "").trim()).filter(Boolean))),
+    provider: firstNonEmptyString(normalizedRoutes.map((route) => route.provider)),
+    destination_labels: Array.from(new Set(normalizedRoutes.map((route) => String(route.destinationLabel || route.destinationID || "").trim()).filter(Boolean))),
+    scheduling_target_keys: uniqueOrderedStrings(
+      normalizedRoutes.map((route) => runnerRouteSchedulingGroupKey(route)).filter(Boolean),
+      (value) => String(value || "").trim(),
+    ),
+    log_file: String(logFilePath || "").trim(),
+    created_by_pid: process.pid,
+    source_command: sourceCommand,
+  });
+}
 
-function findExistingDetachedRunnerLaunch(registry, routes) {
-  const targetSignature = runnerDetachedRouteSetSignature(routes);
-  if (!targetSignature) return null;
-  return Object.values(safeObject(registry).launches || {}).find((entryRaw) => {
-    const entry = normalizeRunnerProcessLaunchEntry(entryRaw);
-    return entry.route_set_signature === targetSignature && isProcessAlive(entry.pid);
-  }) || null;
-}
+function findExistingDetachedRunnerLaunch(registry, routes) {
+  const decision = classifyDetachedRunnerLaunchReuse(registry, routes);
+  if (decision.kind === "reuse" && decision.launch) {
+    return decision.launch;
+  }
+  return null;
+}
 
 async function launchDetachedRunnerProcess(flags, routes, sourceCommand) {
   const cliPath = fileURLToPath(import.meta.url);
@@ -13055,60 +13596,76 @@ async function runRunnerStop(flags) {
   }
 }
 
-async function runRunnerStartDetachedResolvedRoutes(routes, flags, sourceCommand = "runner start-detached") {
-  const registry = loadBotRunnerProcessRegistry({ persistIfNeeded: true });
-  const existing = findExistingDetachedRunnerLaunch(registry, routes);
-  if (existing) {
-    const payload = {
-      ok: true,
-      already_running: true,
-      registry_file: registry.filePath,
-      launch: {
-        ...existing,
-        alive: true,
-      },
-    };
-  if (boolFromRaw(flags.json, false)) {
-    process.stdout.write(`${JSON.stringify(payload, null, 2)}\n`);
-    return payload;
-  }
-  process.stdout.write(`Detached runner already running: launch_id=${existing.launch_id} pid=${existing.pid}${existing.log_file ? ` log_file=${existing.log_file}` : ""}\n`);
-  return payload;
-  }
-  const launch = await launchDetachedRunnerProcess(flags, routes, sourceCommand);
-  const nextLaunches = {
-    ...safeObject(registry).launches,
-    [launch.launch_id]: launch,
-  };
+async function runRunnerStartDetachedResolvedRoutes(routes, flags, sourceCommand = "runner start-detached", options = {}) {
+  const silent = boolFromRaw(safeObject(options).silent, false);
+  const registry = loadBotRunnerProcessRegistry({ persistIfNeeded: true });
+  const reuseDecision = classifyDetachedRunnerLaunchReuse(registry, routes);
+  if (reuseDecision.kind === "reuse" && reuseDecision.launch) {
+    const existing = reuseDecision.launch;
+    const payload = {
+      ok: true,
+      already_running: true,
+      reuse_reason: reuseDecision.reason,
+      registry_file: registry.filePath,
+      launch: {
+        ...existing,
+        alive: true,
+      },
+    };
+    if (!silent) {
+      if (boolFromRaw(flags.json, false)) {
+        process.stdout.write(`${JSON.stringify(payload, null, 2)}\n`);
+        return payload;
+      }
+      process.stdout.write(`Detached runner already running: launch_id=${existing.launch_id} pid=${existing.pid}${existing.log_file ? ` log_file=${existing.log_file}` : ""}${reuseDecision.reason ? ` reuse=${reuseDecision.reason}` : ""}\n`);
+    }
+    return payload;
+  }
+  if (reuseDecision.kind === "conflict") {
+    const overlappingRouteNames = ensureArray(reuseDecision.overlapping_route_names)
+      .map((item) => String(item || "").trim())
+      .filter(Boolean);
+    const overlapSuffix = overlappingRouteNames.length
+      ? ` overlapping_routes=${overlappingRouteNames.join(", ")}`
+      : "";
+    throw new Error(`${String(reuseDecision.detail || "detached runner conflict").trim()}${overlapSuffix}`);
+  }
+  const launch = await launchDetachedRunnerProcess(flags, routes, sourceCommand);
+  const nextLaunches = {
+    ...safeObject(registry).launches,
+    [launch.launch_id]: launch,
+  };
   saveBotRunnerProcessRegistry({ launches: nextLaunches });
   const payload = {
     ok: true,
     already_running: false,
     registry_file: registry.filePath,
     launch: {
-      ...launch,
-      alive: true,
-    },
-  };
-  if (boolFromRaw(flags.json, false)) {
-    process.stdout.write(`${JSON.stringify(payload, null, 2)}\n`);
-    return payload;
-  }
-  process.stdout.write(
-    [
-      "Detached runner start: OK",
-      `launch_id: ${launch.launch_id}`,
-      `pid: ${launch.pid}`,
-      `registry_file: ${registry.filePath}`,
-      `project_ids: ${launch.project_ids.join(", ") || "-"}`,
-      `route_names: ${launch.route_names.join(", ") || "-"}`,
-      `destination_labels: ${launch.destination_labels.join(", ") || "-"}`,
-      `log_file: ${launch.log_file || "-"}`,
-      `command: ${launch.command}`,
-    ].join("\n") + "\n",
-  );
-  return payload;
-}
+      ...launch,
+      alive: true,
+    },
+  };
+  if (!silent) {
+    if (boolFromRaw(flags.json, false)) {
+      process.stdout.write(`${JSON.stringify(payload, null, 2)}\n`);
+      return payload;
+    }
+    process.stdout.write(
+      [
+        "Detached runner start: OK",
+        `launch_id: ${launch.launch_id}`,
+        `pid: ${launch.pid}`,
+        `registry_file: ${registry.filePath}`,
+        `project_ids: ${launch.project_ids.join(", ") || "-"}`,
+        `route_names: ${launch.route_names.join(", ") || "-"}`,
+        `destination_labels: ${launch.destination_labels.join(", ") || "-"}`,
+        `log_file: ${launch.log_file || "-"}`,
+        `command: ${launch.command}`,
+      ].join("\n") + "\n",
+    );
+  }
+  return payload;
+}
 
 function stopDetachedRunnerWithFlags(flags) {
   const registry = loadBotRunnerProcessRegistry({ persistIfNeeded: true });
@@ -13141,10 +13698,10 @@ function stopDetachedRunnerWithFlags(flags) {
   };
 }
 
-function startDetachedRunnerWithFlags(flags, sourceCommand = "runner.start_detached") {
-  const routes = resolveRunnerRoutes(flags, "start");
-  return runRunnerStartDetachedResolvedRoutes(routes, flags, sourceCommand);
-}
+function startDetachedRunnerWithFlags(flags, sourceCommand = "runner.start_detached", options = {}) {
+  const routes = resolveRunnerRoutes(flags, "start");
+  return runRunnerStartDetachedResolvedRoutes(routes, flags, sourceCommand, options);
+}
 
 async function runRunnerStartDetached(flags) {
   await startDetachedRunnerWithFlags(flags, "runner start-detached");
@@ -14284,19 +14841,23 @@ async function runRunner(argv) {
     }
     throw new Error("runner route requires a subcommand: list | add | edit | remove");
   }
-  if (subcommand === "project" || subcommand === "projects") {
+  if (subcommand === "project" || subcommand === "projects") {
     const [projectSubcommandRaw = "", ...projectRest] = rest;
     const projectSubcommand = String(projectSubcommandRaw || "").trim().toLowerCase();
     const projectArgv = !projectSubcommand || projectSubcommand.startsWith("-")
       ? [projectSubcommandRaw, ...projectRest].filter((value) => String(value || "").trim())
       : projectRest;
-    const projectFlags = parseArgs(projectArgv);
-    if (projectSubcommand === "up") {
-      await runRunnerProjectUp(projectFlags);
-      return;
-    }
-    throw new Error("runner project requires a subcommand: up");
-  }
+    const projectFlags = parseArgs(projectArgv);
+    if (projectSubcommand === "up") {
+      await runRunnerProjectUp(projectFlags);
+      return;
+    }
+    if (projectSubcommand === "tui") {
+      await runRunnerProjectTUI(projectFlags);
+      return;
+    }
+    throw new Error("runner project requires a subcommand: up | tui");
+  }
   if (subcommand === "artifact" || subcommand === "artifacts") {
     const [artifactSubcommandRaw = "", ...artifactRest] = rest;
     const artifactSubcommand = String(artifactSubcommandRaw || "").trim().toLowerCase();
@@ -14339,8 +14900,8 @@ async function runRunner(argv) {
     await runRunnerStop(flags);
     return;
   }
-  throw new Error("runner requires a subcommand: list | show | status | once | start | start-detached | stop | route | project | artifact");
-}
+  throw new Error("runner requires a subcommand: list | show | status | once | start | start-detached | stop | route | project | artifact");
+}
 
 async function runLocalBotBridge(argv) {
   const helperPath = path.join(path.dirname(fileURLToPath(import.meta.url)), "scripts", "local-bot-ai-bridge.mjs");
@@ -19348,10 +19909,176 @@ TELEGRAM_BOT_REVIEW_TOKEN=review-token
   } catch (err) {
     push("detached_runner_launch_record_persists_log_file", false, String(err?.message || err));
   }
-
-  let detachedRunnerPosixTempDir = "";
-  try {
-    detachedRunnerPosixTempDir = fs.mkdtempSync(path.join(os.tmpdir(), "metheus-detached-script-selftest-"));
+
+  try {
+    const routeBot1 = normalizeRunnerRoute({
+      name: "telegram-monitor-selftest-bot-1",
+      projectID: selftestProjectID,
+      provider: "telegram",
+      role: "monitor",
+      botID: "bot-1",
+      botName: "SelftestBot1",
+      destinationID: "dest-1",
+      destinationLabel: "Selftest Room",
+    });
+    const routeBot2 = normalizeRunnerRoute({
+      name: "telegram-monitor-selftest-bot-2",
+      projectID: selftestProjectID,
+      provider: "telegram",
+      role: "monitor",
+      botID: "bot-2",
+      botName: "SelftestBot2",
+      destinationID: "dest-1",
+      destinationLabel: "Selftest Room",
+    });
+    const supersetLaunch = buildRunnerDetachedLaunchRecord(
+      process.pid,
+      [routeBot1, routeBot2],
+      { tui: false },
+      "runner start-detached",
+    );
+    const decision = classifyDetachedRunnerLaunchReuse(
+      { launches: { [supersetLaunch.launch_id]: supersetLaunch } },
+      [routeBot2],
+    );
+    push(
+      "detached_runner_reuses_existing_superset_launch_for_same_target",
+      decision.kind === "reuse"
+        && decision.reason === "superset"
+        && String(safeObject(decision.launch).launch_id || "").trim() === supersetLaunch.launch_id,
+      `kind=${String(decision.kind || "")} reason=${String(decision.reason || "")} launch=${String(safeObject(decision.launch).launch_id || "")}`,
+    );
+  } catch (err) {
+    push("detached_runner_reuses_existing_superset_launch_for_same_target", false, String(err?.message || err));
+  }
+
+  try {
+    const routeBot1 = normalizeRunnerRoute({
+      name: "telegram-monitor-selftest-bot-1",
+      projectID: selftestProjectID,
+      provider: "telegram",
+      role: "monitor",
+      botID: "bot-1",
+      botName: "SelftestBot1",
+      destinationID: "dest-1",
+      destinationLabel: "Selftest Room",
+    });
+    const routeBot2 = normalizeRunnerRoute({
+      name: "telegram-monitor-selftest-bot-2",
+      projectID: selftestProjectID,
+      provider: "telegram",
+      role: "monitor",
+      botID: "bot-2",
+      botName: "SelftestBot2",
+      destinationID: "dest-1",
+      destinationLabel: "Selftest Room",
+    });
+    const supersetLaunch = buildRunnerDetachedLaunchRecord(
+      process.pid,
+      [routeBot1, routeBot2],
+      { tui: false },
+      "runner project tui",
+    );
+    const existing = findExistingDetachedRunnerLaunch(
+      { launches: { [supersetLaunch.launch_id]: supersetLaunch } },
+      [routeBot2],
+    );
+    push(
+      "detached_runner_existing_launch_lookup_reuses_superset_for_tui_snapshot",
+      String(safeObject(existing).launch_id || "").trim() === supersetLaunch.launch_id,
+      `launch=${String(safeObject(existing).launch_id || "").trim() || "(none)"}`,
+    );
+  } catch (err) {
+    push("detached_runner_existing_launch_lookup_reuses_superset_for_tui_snapshot", false, String(err?.message || err));
+  }
+
+  try {
+    const routeBot1 = normalizeRunnerRoute({
+      name: "telegram-monitor-selftest-bot-1",
+      projectID: selftestProjectID,
+      provider: "telegram",
+      role: "monitor",
+      botID: "bot-1",
+      botName: "SelftestBot1",
+      destinationID: "dest-1",
+      destinationLabel: "Selftest Room",
+    });
+    const routeBot2 = normalizeRunnerRoute({
+      name: "telegram-monitor-selftest-bot-2",
+      projectID: selftestProjectID,
+      provider: "telegram",
+      role: "monitor",
+      botID: "bot-2",
+      botName: "SelftestBot2",
+      destinationID: "dest-1",
+      destinationLabel: "Selftest Room",
+    });
+    const subsetLaunch = buildRunnerDetachedLaunchRecord(
+      process.pid,
+      [routeBot2],
+      { tui: false },
+      "runner start-detached",
+    );
+    const decision = classifyDetachedRunnerLaunchReuse(
+      { launches: { [subsetLaunch.launch_id]: subsetLaunch } },
+      [routeBot1, routeBot2],
+    );
+    push(
+      "detached_runner_blocks_partial_overlap_for_same_target",
+      decision.kind === "conflict"
+        && ensureArray(decision.overlapping_route_names).includes("telegram-monitor-selftest-bot-2")
+        && String(decision.detail || "").includes("runner project tui"),
+      `kind=${String(decision.kind || "")} overlap=${ensureArray(decision.overlapping_route_names).join(", ")} detail=${String(decision.detail || "")}`,
+    );
+  } catch (err) {
+    push("detached_runner_blocks_partial_overlap_for_same_target", false, String(err?.message || err));
+  }
+
+  try {
+    const routeBot1 = normalizeRunnerRoute({
+      name: "telegram-monitor-selftest-bot-1",
+      projectID: selftestProjectID,
+      provider: "telegram",
+      role: "monitor",
+      botID: "bot-1",
+      botName: "SelftestBot1",
+      destinationID: "dest-1",
+      destinationLabel: "Selftest Room",
+    });
+    const routeBot2 = normalizeRunnerRoute({
+      name: "telegram-monitor-selftest-bot-2",
+      projectID: selftestProjectID,
+      provider: "telegram",
+      role: "monitor",
+      botID: "bot-2",
+      botName: "SelftestBot2",
+      destinationID: "dest-1",
+      destinationLabel: "Selftest Room",
+    });
+    const singleLaunch = buildRunnerDetachedLaunchRecord(
+      process.pid,
+      [routeBot1],
+      { tui: false },
+      "runner start-detached",
+    );
+    const decision = classifyDetachedRunnerLaunchReuse(
+      { launches: { [singleLaunch.launch_id]: singleLaunch } },
+      [routeBot2],
+    );
+    push(
+      "detached_runner_blocks_disjoint_same_target_parallel_launches",
+      decision.kind === "conflict"
+        && ensureArray(decision.overlapping_route_names).length === 0
+        && String(decision.detail || "").includes("same project/provider/destination target"),
+      `kind=${String(decision.kind || "")} overlap=${ensureArray(decision.overlapping_route_names).join(", ")} detail=${String(decision.detail || "")}`,
+    );
+  } catch (err) {
+    push("detached_runner_blocks_disjoint_same_target_parallel_launches", false, String(err?.message || err));
+  }
+
+  let detachedRunnerPosixTempDir = "";
+  try {
+    detachedRunnerPosixTempDir = fs.mkdtempSync(path.join(os.tmpdir(), "metheus-detached-script-selftest-"));
     const scriptPath = path.join(detachedRunnerPosixTempDir, "start-runner.sh");
     const pidFilePath = path.join(detachedRunnerPosixTempDir, "runner.pid");
     buildRunnerDetachedPosixLaunchScript({
@@ -19485,6 +20212,41 @@ TELEGRAM_BOT_REVIEW_TOKEN=review-token
     push("runner_project_up_tool_flag_accepts_start_detached_snake_case", false, String(err?.message || err));
   }
 
+  try {
+    const projectTUIRuntime = resolveRunnerProjectTUIRuntimePolicy({
+      "project-id": selftestProjectID,
+      "destination-label": "Selftest Room",
+    });
+    push(
+      "runner_project_tui_defaults_to_detached_bootstrap_mode",
+      projectTUIRuntime.autoStart === true
+        && projectTUIRuntime.auditFlags.start === false
+        && projectTUIRuntime.auditFlags["start-detached"] === false
+        && projectTUIRuntime.auditFlags.tui === false
+        && projectTUIRuntime.auditFlags.json === true,
+      `autoStart=${String(projectTUIRuntime.autoStart)} start=${String(projectTUIRuntime.auditFlags.start)} detached=${String(projectTUIRuntime.auditFlags["start-detached"])} tui=${String(projectTUIRuntime.auditFlags.tui)} json=${String(projectTUIRuntime.auditFlags.json)}`,
+    );
+  } catch (err) {
+    push("runner_project_tui_defaults_to_detached_bootstrap_mode", false, String(err?.message || err));
+  }
+
+  try {
+    const projectTUIRuntime = resolveRunnerProjectTUIRuntimePolicy({
+      "project-id": selftestProjectID,
+      "destination-label": "Selftest Room",
+      start: false,
+    });
+    push(
+      "runner_project_tui_respects_prepare_only_flag",
+      projectTUIRuntime.autoStart === false
+        && projectTUIRuntime.auditFlags.start === false
+        && projectTUIRuntime.auditFlags["start-detached"] === false,
+      `autoStart=${String(projectTUIRuntime.autoStart)} start=${String(projectTUIRuntime.auditFlags.start)} detached=${String(projectTUIRuntime.auditFlags["start-detached"])}`,
+    );
+  } catch (err) {
+    push("runner_project_tui_respects_prepare_only_flag", false, String(err?.message || err));
+  }
+
   try {
     const projectUpResponse = await handleLocalProjectToolDispatchImpl(
       {

package/lib/local-ai-adapters.mjs

@@ -2408,6 +2408,7 @@ function buildConversationIntentAnalysisPrompt({
     "- allowed_responders must be the full set of bots allowed to speak in this conversation.",
     "- If mode is single_bot, initial_responders and allowed_responders should contain only that bot.",
     "- If mode is delegated_single_lead, lead_bot must be set and initial_responders should contain only the lead bot.",
+    "- If the human tells one managed bot to say, greet, mention, introduce, or relay something to another managed bot, use delegated_single_lead. The instructed bot is lead_bot, initial_responders must contain only that bot, and the target bot belongs in allowed_responders rather than initial_responders.",
     "- If the human explicitly asks one bot to summarize or finalize, set summary_bot to that bot.",
     "- intent_type is optional secondary metadata, not the main control surface. Omit the key entirely unless a more specific lookup or execution subtype is clearly explicit.",
     "- If the human is only greeting or chatting socially, intent_type may be small_talk if you choose to include it.",

package/lib/runner-orchestration-intent-contracts.mjs

@@ -93,6 +93,70 @@ function detectDirectedManagedReplyTargetV2({
   return "";
 }
 
+function normalizeDirectedManagedLeadHumanIntent({
+  text,
+  humanIntent,
+  managedMentions = [],
+  normalizeMentionSelector,
+  uniqueOrdered,
+}) {
+  const base = safeObject(humanIntent);
+  const participants = uniqueOrdered([
+    ...ensureArray(base.participantSelectors || base.participants),
+    ...ensureArray(managedMentions),
+  ].map((item) => normalizeMentionSelector(item)).filter(Boolean));
+  if (participants.length < 2) {
+    return base;
+  }
+  const normalizedText = String(text || "").trim();
+  if (!normalizedText) {
+    return base;
+  }
+  const instructionPattern = new RegExp(DIRECTED_MANAGED_REPLY_ACTION_PATTERN, "iu");
+  if (!instructionPattern.test(normalizedText)) {
+    return base;
+  }
+  const explicitLeadBotSelector = normalizeMentionSelector(
+    base.leadBotSelector || base.lead_bot,
+  );
+  const leadBotSelector = explicitLeadBotSelector && participants.includes(explicitLeadBotSelector)
+    ? explicitLeadBotSelector
+    : participants[0] || "";
+  if (!leadBotSelector) {
+    return base;
+  }
+  const replyTargetBotSelector = detectDirectedManagedReplyTargetV2({
+    text: normalizedText,
+    currentBotSelector: leadBotSelector,
+    managedMentions: participants,
+  });
+  if (!replyTargetBotSelector || replyTargetBotSelector === leadBotSelector) {
+    return base;
+  }
+  const allowedResponderSelectors = uniqueOrdered([
+    ...ensureArray(base.allowedResponderSelectors || base.allowed_responders),
+    ...participants,
+    leadBotSelector,
+    replyTargetBotSelector,
+  ].map((item) => normalizeMentionSelector(item)).filter(Boolean));
+  const summaryBotSelector = normalizeMentionSelector(
+    base.summaryBotSelector || base.summary_bot,
+  );
+  return {
+    ...base,
+    intentMode: "delegated_single_lead",
+    allowBotToBot: true,
+    participantSelectors: participants,
+    initialResponderSelectors: [leadBotSelector],
+    allowedResponderSelectors,
+    leadBotSelector,
+    summaryBotSelector: summaryBotSelector && allowedResponderSelectors.includes(summaryBotSelector)
+      ? summaryBotSelector
+      : "",
+    replyTargetBotSelector,
+  };
+}
+
 export async function resolveHumanIntentContext({
   selectedRecord,
   normalizedRoute,
@@ -160,17 +224,13 @@ export async function resolveHumanIntentContext({
     runnerHumanIntentPromises.set(cacheKey, promise);
   }
   let humanIntent = await runnerHumanIntentPromises.get(cacheKey);
-  const directedReplyTargetSelector = detectDirectedManagedReplyTargetV2({
+  humanIntent = normalizeDirectedManagedLeadHumanIntent({
     text: parsed.body,
-    currentBotSelector,
+    humanIntent,
     managedMentions,
+    normalizeMentionSelector,
+    uniqueOrdered,
   });
-  if (directedReplyTargetSelector) {
-    humanIntent = {
-      ...safeObject(humanIntent),
-      replyTargetBotSelector: directedReplyTargetSelector,
-    };
-  }
   if (!isCompleteHumanIntentContract(humanIntent)) {
     return {
       currentBotSelector,

package/lib/selftest-runner-scenarios.mjs

@@ -4171,9 +4171,76 @@ export async function runSelftestRunnerScenarios(push, deps) {
     );
   }
 
+  try {
+    const promotedDirectedLeadIntentContext = await resolveHumanIntentContext({
+      selectedRecord: {
+        id: "comment-directed-lead-korean",
+        parsedArchive: {
+          kind: "telegram_message",
+          body: "@RyoAI_bot 너가 @SangHoon01_bot 인사 시켜봐",
+          senderIsBot: false,
+        },
+      },
+      normalizedRoute: {
+        name: "telegram-monitor-ryoai-bot-2",
+      },
+      bot: {
+        username: "ryoai_bot",
+        name: "RyoAI_bot",
+      },
+      executionPlan: {},
+      deps: {
+        resolveConversationPeerBots: () => [
+          { id: "bot-self-1", name: "RyoAI_bot" },
+          { id: "bot-peer-1", name: "SangHoon01_bot" },
+        ],
+      },
+      intentDeps: {
+        normalizeMentionSelector: normalizeSelftestMentionSelector,
+        buildConversationPeerMap: (_bot, _route, runtimeDeps) => new Map(
+          ensureArray(runtimeDeps?.resolveConversationPeerBots?.() || []).map((item) => {
+            const selector = normalizeSelftestMentionSelector(item?.name || item?.username);
+            return [selector, item];
+          }).filter(([selector]) => selector),
+        ),
+        extractOrderedMentionSelectors: (text) => Array.from(String(text || "").matchAll(/@([A-Za-z0-9_]+)/g)).map((match) => normalizeSelftestMentionSelector(match[1] || "")),
+        uniqueOrdered: normalizeSelftestConversationSelectorList,
+        buildHumanIntentFromPersistedRunnerRequest: () => null,
+        buildRunnerHumanIntentCacheKey: () => "directed-lead-korean",
+        runnerHumanIntentPromises: new Map(),
+        analyzeHumanConversationIntentWithContractResolver: async () => ({
+          mode: "multi_bot_direct",
+          participants: ["ryoai_bot", "sanghoon01_bot"],
+          initial_responders: ["ryoai_bot", "sanghoon01_bot"],
+          allowed_responders: ["ryoai_bot", "sanghoon01_bot"],
+          reply_expectation: "actionable",
+          intent_type: "actionable_request",
+        }),
+        scheduleRunnerHumanIntentCacheCleanup: () => {},
+        isCompleteHumanIntentContract: () => true,
+        normalizeHumanIntentType: (value, fallback = "") => String(value || "").trim() || fallback,
+      },
+    });
+    push(
+      "runner_human_intent_context_promotes_directed_multi_bot_direct_to_delegated_single_lead",
+      String(promotedDirectedLeadIntentContext?.humanIntent?.intentMode || promotedDirectedLeadIntentContext?.humanIntent?.mode || "") === "delegated_single_lead"
+        && String(promotedDirectedLeadIntentContext?.humanIntent?.leadBotSelector || "") === "ryoai_bot"
+        && JSON.stringify(ensureArray(promotedDirectedLeadIntentContext?.humanIntent?.initialResponderSelectors || [])) === JSON.stringify(["ryoai_bot"])
+        && JSON.stringify(ensureArray(promotedDirectedLeadIntentContext?.humanIntent?.allowedResponderSelectors || [])) === JSON.stringify(["ryoai_bot", "sanghoon01_bot"])
+        && String(promotedDirectedLeadIntentContext?.humanIntent?.replyTargetBotSelector || "") === "sanghoon01_bot",
+      `mode=${String(promotedDirectedLeadIntentContext?.humanIntent?.intentMode || promotedDirectedLeadIntentContext?.humanIntent?.mode || "(none)")} lead=${String(promotedDirectedLeadIntentContext?.humanIntent?.leadBotSelector || "(none)")} initial=${JSON.stringify(ensureArray(promotedDirectedLeadIntentContext?.humanIntent?.initialResponderSelectors || []))} allowed=${JSON.stringify(ensureArray(promotedDirectedLeadIntentContext?.humanIntent?.allowedResponderSelectors || []))} target=${String(promotedDirectedLeadIntentContext?.humanIntent?.replyTargetBotSelector || "(none)")}`,
+    );
+  } catch (err) {
+    push(
+      "runner_human_intent_context_promotes_directed_multi_bot_direct_to_delegated_single_lead",
+      false,
+      String(err?.message || err),
+    );
+  }
+
   const mentionOverridesReplyForUnmentionedBot = evaluateTelegramRunnerTrigger(
-    {
-      id: "comment-2b",
+    {
+      id: "comment-2b",
       parsedArchive: {
         kind: "telegram_message",
         chatID: "-100123",
@@ -7704,7 +7771,10 @@ export async function runSelftestRunnerScenarios(push, deps) {
         && plannerCalls === 0
         && deliveryCalls === 0
         && String(processed.result?.outcome || "") === "invalid_ai_output"
-        && String(processed.result?.response_contract_validation_status || "") === "reply_target_not_visible_in_reply",
+        && [
+          "reply_target_not_visible_in_reply",
+          "missing_required_contract",
+        ].includes(String(processed.result?.response_contract_validation_status || "")),
       `kind=${String(processed.kind || "(none)")} ai_calls=${aiCalls} planner_calls=${plannerCalls} delivery_calls=${deliveryCalls} delivered=${String(deliveredText || "(none)")} validation=${String(processed.result?.response_contract_validation_status || "(none)")}`,
     );
   } catch (err) {

package/package.json

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