metheus-governance-mcp-cli 0.2.286 → 0.2.288

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 one-command direct CLI path for Telegram project operations: it runs the same room audit, applies the selected role routes, and starts detached polling by default unless you explicitly pass `--start false`.
 - `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:
@@ -422,6 +422,8 @@ metheus-governance-mcp-cli bot verify --provider telegram --bot-name <server_bot
 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 +542,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 +556,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 starts detached polling by default unless you explicitly pass `--start false`.
 - 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.
@@ -567,7 +570,10 @@ 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

@@ -12258,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;
@@ -12277,39 +12277,94 @@ 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 explicitStartDetachedRequested = Object.prototype.hasOwnProperty.call(flags, "start-detached");
+  const explicitDetachedAliasRequested = Object.prototype.hasOwnProperty.call(flags, "detached");
+  const explicitStartRequested = Object.prototype.hasOwnProperty.call(flags, "start");
+  const startRequested = Object.prototype.hasOwnProperty.call(flags, "start")
+    ? boolFromRaw(flags.start, true)
+    : false;
+  const startDetachedRequested = explicitStartDetachedRequested
+    ? boolFromRaw(flags["start-detached"], true)
+    : (explicitDetachedAliasRequested
+      ? boolFromRaw(flags.detached, false)
+      : !explicitStartRequested);
+  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 start detached polling by default unless --start false is passed");
+    }
+    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();
@@ -12392,30 +12447,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,
@@ -16907,12 +16967,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:
@@ -19267,12 +19327,64 @@ 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_prefers_detached_start",
+      projectUpPolicy.applyRequested === true
+        && projectUpPolicy.startRequested === false
+        && projectUpPolicy.startDetachedRequested === true
+        && projectUpPolicy.shouldStartRunner === true,
+      `apply=${projectUpPolicy.applyRequested} start=${projectUpPolicy.startRequested} detached=${projectUpPolicy.startDetachedRequested} shouldStart=${projectUpPolicy.shouldStartRunner}`,
+    );
+  } catch (err) {
+    push("runner_project_up_default_policy_prefers_detached_start", false, String(err?.message || err));
+  }
+
+  try {
+    const projectUpPolicy = resolveRunnerProjectUpExecutionPolicy({ start: false });
+    push(
+      "runner_project_up_explicit_start_false_keeps_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_explicit_start_false_keeps_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/package.json

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