metheus-governance-mcp-cli 0.2.289 → 0.2.291

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 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` 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 up` can be narrowed with `--bot-name`, `--bot-id`, `--role`, or `--roles <csv>` when you do not want every suggested role route for that room.
 - `bot remove` without flags starts a guided numbered flow: provider -> bot entry -> confirm removal.
 - Telegram stores one bot file per entry under `~/.metheus/telegram-bots/<ServerBotName>.env` with generic fields:
@@ -421,7 +421,6 @@ metheus-governance-mcp-cli bot remove --provider telegram --bot-name <server_bot
 metheus-governance-mcp-cli bot verify --provider telegram --bot-name <server_bot_name> --json true
 metheus-governance-mcp-cli bot room-audit --provider telegram --project-id <project_uuid> --destination-label <room_label> --json true
 metheus-governance-mcp-cli bot room-audit --provider telegram --project-id <project_uuid> --destination-label <room_label> --apply true --json true
-metheus-governance-mcp-cli runner project up --project-id <project_uuid> --provider telegram --destination-label <room_label>
 metheus-governance-mcp-cli runner project up --project-id <project_uuid> --provider telegram --destination-label <room_label> --start false
 metheus-governance-mcp-cli runner start-detached --project-id <project_uuid> --provider telegram --destination-label <room_label>
 metheus-governance-mcp-cli runner project up --project-id <project_uuid> --provider telegram --destination-label <room_label> --bot-name <server_bot_name> --roles monitor,review --start false
@@ -556,7 +555,7 @@ metheus-governance-mcp-cli runner start --route-name telegram-monitor --concurre
 Route management:
 - `runner route add` creates one executable route by selecting the project, provider, role, server bot, and project chat destination in order.
 - `runner route add` now auto-uses the suggested route name, `5000` ms poll interval, and `enabled=true` unless you pass explicit flags or edit the route later.
-- `runner project up` is the shortest practical route bootstrap path for Telegram: it audits one project destination, writes any missing suggested routes, and starts detached polling by default unless you explicitly pass `--start false`.
+- `runner project up` is the shortest practical direct CLI preparation path for Telegram: it audits one project destination and writes any missing suggested routes. Start persistent polling separately with `runner start-detached`, or use the TUI/local tool path that bootstraps detached polling for you.
 - 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.
@@ -569,7 +568,6 @@ Route management:
 Recommended operational path:
 
 ```bash
-metheus-governance-mcp-cli runner project up --project-id <project_uuid> --provider telegram --destination-label <room_label>
 metheus-governance-mcp-cli runner project up --project-id <project_uuid> --provider telegram --destination-label <room_label> --start false
 metheus-governance-mcp-cli runner start-detached --project-id <project_uuid> --provider telegram --destination-label <room_label>
 metheus-governance-mcp-cli runner project up --project-id <project_uuid> --provider telegram --destination-label <room_label> --bot-name <server_bot_name> --roles monitor,review --start false

package/cli.mjs

@@ -12306,7 +12306,7 @@ function resolveRunnerProjectUpExecutionPolicy(flags = {}) {
     ? boolFromRaw(startDetachedRaw, true)
     : (explicitDetachedAliasRequested
       ? boolFromRaw(flags.detached, false)
-      : !explicitStartRequested);
+      : false);
   const shouldStartRunner = startRequested || startDetachedRequested;
   return {
     applyRequested,
@@ -12323,6 +12323,61 @@ function buildRunnerStartDetachedCommand(flags = {}) {
   })].join(" ");
 }
 
+function sleepSyncMilliseconds(durationMs) {
+  const numericDurationMs = Math.max(0, intFromRaw(durationMs, 0) || 0);
+  if (numericDurationMs <= 0) return;
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, numericDurationMs);
+}
+
+function buildDetachedRunnerBootstrapLogPaths(logFilePath = "") {
+  const normalizedLogFilePath = String(logFilePath || "").trim();
+  if (!normalizedLogFilePath) {
+    return { stdoutPath: "", stderrPath: "" };
+  }
+  const parsed = path.parse(normalizedLogFilePath);
+  const baseName = parsed.name || "runner-start";
+  return {
+    stdoutPath: path.join(parsed.dir, `${baseName}.bootstrap.out.log`),
+    stderrPath: path.join(parsed.dir, `${baseName}.bootstrap.err.log`),
+  };
+}
+
+function ensureDetachedRunnerBootstrapped(childPID, logFilePath = "", bootstrapLogPaths = {}) {
+  const normalizedLogFilePath = String(logFilePath || "").trim();
+  const normalizedBootstrapStdoutPath = String(safeObject(bootstrapLogPaths).stdoutPath || "").trim();
+  const normalizedBootstrapStderrPath = String(safeObject(bootstrapLogPaths).stderrPath || "").trim();
+  const deadlineMs = Date.now() + 5000;
+  while (Date.now() < deadlineMs) {
+    if (!isProcessAlive(childPID)) {
+      if (normalizedBootstrapStderrPath && fs.existsSync(normalizedBootstrapStderrPath)) {
+        throw new Error(`detached runner exited during bootstrap; inspect ${normalizedBootstrapStderrPath}`);
+      }
+      if (normalizedBootstrapStdoutPath && fs.existsSync(normalizedBootstrapStdoutPath)) {
+        throw new Error(`detached runner exited during bootstrap; inspect ${normalizedBootstrapStdoutPath}`);
+      }
+      if (normalizedLogFilePath && fs.existsSync(normalizedLogFilePath)) {
+        throw new Error(`detached runner exited during bootstrap; inspect ${normalizedLogFilePath}`);
+      }
+      throw new Error("detached runner exited during bootstrap before the polling loop became stable");
+    }
+    if (normalizedLogFilePath && fs.existsSync(normalizedLogFilePath)) {
+      try {
+        if (fs.statSync(normalizedLogFilePath).size > 0) {
+          return;
+        }
+      } catch {}
+    }
+    sleepSyncMilliseconds(250);
+  }
+  if (normalizedBootstrapStderrPath && fs.existsSync(normalizedBootstrapStderrPath)) {
+    throw new Error(`detached runner stayed alive but did not create the runner log; inspect ${normalizedBootstrapStderrPath}`);
+  }
+  if (normalizedBootstrapStdoutPath && fs.existsSync(normalizedBootstrapStdoutPath)) {
+    throw new Error(`detached runner stayed alive but did not create the runner log; inspect ${normalizedBootstrapStdoutPath}`);
+  }
+  throw new Error("detached runner stayed alive but did not create the runner log during bootstrap");
+}
+
 function buildRunnerProjectUpNextSteps({
   applyRequested,
   shouldStartRunner,
@@ -12354,7 +12409,7 @@ 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");
+      ui.setFlow("RUNNER PROJECT UP", "Audit one project destination, create missing runner routes, and optionally start polling when explicitly requested");
     }
     const provider = String(flags.provider || "").trim()
       ? normalizeBotProvider(flags.provider)
@@ -12452,7 +12507,7 @@ async function buildRunnerProjectUpResult(flags = {}) {
       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_requested: startRequested,
       start_detached_requested: startDetachedRequested,
       next_steps: [],
       applied_routes: ensureArray(applyResult.appliedRoutes).map((item) => safeObject(item)),
@@ -12782,16 +12837,16 @@ async function waitForRunnerPIDFile(pidFilePath, timeoutMs = 8000) {
   throw new Error(`detached runner launch did not publish a child process id: ${pidFilePath}`);
 }
 
-function buildRunnerDetachedLaunchRecord(childPID, routes, flags, sourceCommand, logFilePath = "") {
-  const normalizedRoutes = ensureArray(routes).map((route) => normalizeRunnerRoute(route));
-  const cliPath = fileURLToPath(import.meta.url);
-  return normalizeRunnerProcessLaunchEntry({
-    launch_id: `${Date.now()}-${childPID}`,
-    pid: childPID,
-    started_at: new Date().toISOString(),
-    command: [process.execPath, cliPath, "--no-update", "runner", "start", ...serializeCLIFlags(flags, { omit: ["json", "start", "start-detached", "detached"] })].join(" "),
-    cli_path: cliPath,
-    working_directory: path.dirname(cliPath),
+function buildRunnerDetachedLaunchRecord(childPID, routes, flags, sourceCommand, logFilePath = "") {
+  const normalizedRoutes = ensureArray(routes).map((route) => normalizeRunnerRoute(route));
+  const cliPath = fileURLToPath(import.meta.url);
+  return normalizeRunnerProcessLaunchEntry({
+    launch_id: `${Date.now()}-${childPID}`,
+    pid: childPID,
+    started_at: new Date().toISOString(),
+    command: [process.execPath, cliPath, "runner", "start", "--no-update", ...serializeCLIFlags(flags, { omit: ["json", "start", "start-detached", "detached"] })].join(" "),
+    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)),
@@ -12813,47 +12868,45 @@ function findExistingDetachedRunnerLaunch(registry, routes) {
   }) || null;
 }
 
-async function launchDetachedRunnerProcess(flags, routes, sourceCommand) {
-  const cliPath = fileURLToPath(import.meta.url);
-  const detachedLogFilePath = resolveRunnerLogFilePath(flags["log-file"], routes, sourceCommand);
-  const startFlags = {
-    ...safeObject(flags),
-    ...(detachedLogFilePath ? { "log-file": detachedLogFilePath } : {}),
-  };
-  const startArgs = [cliPath, "--no-update", "runner", "start", ...serializeCLIFlags(startFlags, {
-    omit: ["json", "start", "start-detached", "detached"],
-  })];
-  if (process.platform === "win32") {
-    const script = [
-      `$wd = ${powershellSingleQuote(path.dirname(cliPath))}`,
-      `$node = ${powershellSingleQuote(process.execPath)}`,
-      `$args = @(${startArgs.map((item) => powershellSingleQuote(item)).join(", ")})`,
-      "$p = Start-Process -FilePath $node -WorkingDirectory $wd -ArgumentList $args -WindowStyle Normal -PassThru",
-      "Write-Output $p.Id",
-    ].join("; ");
-    const launched = spawnSync("powershell.exe", [
-      "-NoLogo",
-      "-NoProfile",
-      "-ExecutionPolicy",
-      "Bypass",
-      "-Command",
-      script,
-    ], {
-      encoding: "utf8",
-      windowsHide: true,
-    });
-    if (launched.error) {
-      throw launched.error;
-    }
-    if (launched.status !== 0) {
-      throw new Error(String(launched.stderr || launched.stdout || "failed to launch detached runner").trim());
-    }
-    const childPID = intFromRawAllowZero(String(launched.stdout || "").trim().split(/\r?\n/).pop(), 0);
-    if (childPID <= 0) {
-      throw new Error("detached runner launch did not return a child process id");
-    }
-    return buildRunnerDetachedLaunchRecord(childPID, routes, startFlags, sourceCommand, detachedLogFilePath);
-  }
+async function launchDetachedRunnerProcess(flags, routes, sourceCommand) {
+  const cliPath = fileURLToPath(import.meta.url);
+  const detachedLogFilePath = resolveRunnerLogFilePath(flags["log-file"], routes, sourceCommand);
+  const bootstrapLogPaths = buildDetachedRunnerBootstrapLogPaths(detachedLogFilePath);
+  const startFlags = {
+    ...safeObject(flags),
+    tui: boolFromRaw(flags.tui, false),
+    ...(detachedLogFilePath ? { "log-file": detachedLogFilePath } : {}),
+  };
+  const startArgs = [cliPath, "runner", "start", "--no-update", ...serializeCLIFlags(startFlags, {
+    omit: ["json", "start", "start-detached", "detached"],
+  })];
+  if (process.platform === "win32") {
+    const stdoutFd = bootstrapLogPaths.stdoutPath ? fs.openSync(bootstrapLogPaths.stdoutPath, "a") : "ignore";
+    const stderrFd = bootstrapLogPaths.stderrPath ? fs.openSync(bootstrapLogPaths.stderrPath, "a") : "ignore";
+    let child = null;
+    try {
+      child = spawn(process.execPath, startArgs, {
+        cwd: path.dirname(cliPath),
+        detached: true,
+        stdio: ["ignore", stdoutFd, stderrFd],
+        windowsHide: true,
+      });
+      if (!child.pid) {
+        throw new Error("detached runner launch did not return a child process id");
+      }
+      child.unref();
+    } finally {
+      if (typeof stdoutFd === "number") {
+        try { fs.closeSync(stdoutFd); } catch {}
+      }
+      if (typeof stderrFd === "number") {
+        try { fs.closeSync(stderrFd); } catch {}
+      }
+    }
+    const childPID = intFromRawAllowZero(child?.pid, 0);
+    ensureDetachedRunnerBootstrapped(childPID, detachedLogFilePath, bootstrapLogPaths);
+    return buildRunnerDetachedLaunchRecord(childPID, routes, startFlags, sourceCommand, detachedLogFilePath);
+  }
   const launchTempDir = fs.mkdtempSync(path.join(os.tmpdir(), "metheus-runner-launch-"));
   const scriptPath = path.join(launchTempDir, "start-runner.sh");
   const pidFilePath = path.join(launchTempDir, "runner.pid");
@@ -12877,13 +12930,14 @@ async function launchDetachedRunnerProcess(flags, routes, sourceCommand) {
       });
       if (launched.error) {
         throw launched.error;
-      }
-      if (launched.status !== 0) {
-        throw new Error(String(launched.stderr || launched.stdout || "failed to launch detached runner in Terminal.app").trim());
-      }
-      const childPID = await waitForRunnerPIDFile(pidFilePath);
-      return buildRunnerDetachedLaunchRecord(childPID, routes, startFlags, sourceCommand, detachedLogFilePath);
-    }
+      }
+      if (launched.status !== 0) {
+        throw new Error(String(launched.stderr || launched.stdout || "failed to launch detached runner in Terminal.app").trim());
+      }
+      const childPID = await waitForRunnerPIDFile(pidFilePath);
+      ensureDetachedRunnerBootstrapped(childPID, detachedLogFilePath, bootstrapLogPaths);
+      return buildRunnerDetachedLaunchRecord(childPID, routes, startFlags, sourceCommand, detachedLogFilePath);
+    }
     const terminalLauncher = resolveLinuxDetachedTerminalLauncher(scriptPath);
     if (!terminalLauncher) {
       throw new Error("no supported Linux terminal emulator was found (tried x-terminal-emulator, gnome-terminal, konsole, mate-terminal, tilix, alacritty, xterm). Install one of those terminals so runner.start_detached can open an independent window");
@@ -12894,12 +12948,13 @@ async function launchDetachedRunnerProcess(flags, routes, sourceCommand) {
       stdio: "ignore",
     });
     child.unref();
-    if (!child.pid) {
-      throw new Error("detached terminal launcher did not return a process id");
-    }
-    const runnerPID = await waitForRunnerPIDFile(pidFilePath);
-    return buildRunnerDetachedLaunchRecord(runnerPID, routes, startFlags, sourceCommand, detachedLogFilePath);
-  } finally {
+    if (!child.pid) {
+      throw new Error("detached terminal launcher did not return a process id");
+    }
+    const runnerPID = await waitForRunnerPIDFile(pidFilePath);
+    ensureDetachedRunnerBootstrapped(runnerPID, detachedLogFilePath, bootstrapLogPaths);
+    return buildRunnerDetachedLaunchRecord(runnerPID, routes, startFlags, sourceCommand, detachedLogFilePath);
+  } finally {
     try {
       fs.rmSync(launchTempDir, { recursive: true, force: true });
     } catch {}
@@ -19230,25 +19285,28 @@ TELEGRAM_BOT_REVIEW_TOKEN=review-token
     }
   }
 
-  try {
-    const detachedArgs = serializeCLIFlags({
-      "project-id": selftestProjectID,
-      provider: "telegram",
-      "destination-id": "dest-1",
-      "start-detached": "true",
-      detached: "true",
-      start: "true",
-    }, {
-      omit: ["start", "start-detached", "detached"],
+  try {
+    const detachedArgs = serializeCLIFlags({
+      "project-id": selftestProjectID,
+      provider: "telegram",
+      "destination-id": "dest-1",
+      tui: "false",
+      "start-detached": "true",
+      detached: "true",
+      start: "true",
+    }, {
+      omit: ["start", "start-detached", "detached"],
     });
-    push(
-      "detached_runner_cli_args_strip_control_flags",
-      detachedArgs.includes("--project-id")
-        && detachedArgs.includes(selftestProjectID)
-        && !detachedArgs.includes("--start")
-        && !detachedArgs.includes("--start-detached")
-        && !detachedArgs.includes("--detached"),
-      detachedArgs.join(" "),
+    push(
+      "detached_runner_cli_args_strip_control_flags",
+      detachedArgs.includes("--project-id")
+        && detachedArgs.includes(selftestProjectID)
+        && detachedArgs.includes("--tui")
+        && detachedArgs.includes("false")
+        && !detachedArgs.includes("--start")
+        && !detachedArgs.includes("--start-detached")
+        && !detachedArgs.includes("--detached"),
+      detachedArgs.join(" "),
     );
   } catch (err) {
     push("detached_runner_cli_args_strip_control_flags", false, String(err?.message || err));
@@ -19272,43 +19330,45 @@ TELEGRAM_BOT_REVIEW_TOKEN=review-token
     push("runner_default_log_file_path_uses_runner_logs_directory", false, String(err?.message || err));
   }
 
-  try {
-    const detachedLaunch = buildRunnerDetachedLaunchRecord(
-      4321,
-      [{ name: "telegram-monitor-selftest", projectID: selftestProjectID, provider: "telegram", destinationLabel: "Selftest Room" }],
-      {},
-      "runner start-detached",
-      "C:\\logs\\runner-selftest.jsonl",
-    );
-    push(
-      "detached_runner_launch_record_persists_log_file",
-      String(detachedLaunch.log_file || "").trim() === "C:\\logs\\runner-selftest.jsonl",
-      `log_file=${String(detachedLaunch.log_file || "").trim() || "(none)"}`,
-    );
-  } catch (err) {
-    push("detached_runner_launch_record_persists_log_file", false, String(err?.message || err));
-  }
+  try {
+    const detachedLaunch = buildRunnerDetachedLaunchRecord(
+      4321,
+      [{ name: "telegram-monitor-selftest", projectID: selftestProjectID, provider: "telegram", destinationLabel: "Selftest Room" }],
+      { tui: false },
+      "runner start-detached",
+      "C:\\logs\\runner-selftest.jsonl",
+    );
+    push(
+      "detached_runner_launch_record_persists_log_file",
+      String(detachedLaunch.log_file || "").trim() === "C:\\logs\\runner-selftest.jsonl"
+        && String(detachedLaunch.command || "").includes(" runner start --no-update ")
+        && String(detachedLaunch.command || "").includes("--tui false"),
+      `log_file=${String(detachedLaunch.log_file || "").trim() || "(none)"} command=${String(detachedLaunch.command || "").trim() || "(none)"}`,
+    );
+  } 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-"));
     const scriptPath = path.join(detachedRunnerPosixTempDir, "start-runner.sh");
     const pidFilePath = path.join(detachedRunnerPosixTempDir, "runner.pid");
-    buildRunnerDetachedPosixLaunchScript({
-      scriptPath,
-      pidFilePath,
-      workingDirectory: detachedRunnerPosixTempDir,
-      nodePath: "/usr/local/bin/node",
-      startArgs: ["/tmp/cli.mjs", "--no-update", "runner", "start", "--project-id", selftestProjectID],
-    });
+    buildRunnerDetachedPosixLaunchScript({
+      scriptPath,
+      pidFilePath,
+      workingDirectory: detachedRunnerPosixTempDir,
+      nodePath: "/usr/local/bin/node",
+      startArgs: ["/tmp/cli.mjs", "runner", "start", "--no-update", "--project-id", selftestProjectID],
+    });
     const scriptText = fs.readFileSync(scriptPath, "utf8");
-    push(
-      "detached_runner_posix_launch_script_serializes_runner_command",
-      scriptText.includes(`echo $$ > ${posixSingleQuote(pidFilePath)}`)
-        && scriptText.includes(`cd ${posixSingleQuote(detachedRunnerPosixTempDir)} || exit 1`)
-        && scriptText.includes(`exec ${posixSingleQuote("/usr/local/bin/node")} ${posixSingleQuote("/tmp/cli.mjs")} ${posixSingleQuote("--no-update")} ${posixSingleQuote("runner")} ${posixSingleQuote("start")}`),
-      scriptText.replace(/\r?\n/g, " | "),
-    );
+    push(
+      "detached_runner_posix_launch_script_serializes_runner_command",
+      scriptText.includes(`echo $$ > ${posixSingleQuote(pidFilePath)}`)
+        && scriptText.includes(`cd ${posixSingleQuote(detachedRunnerPosixTempDir)} || exit 1`)
+        && scriptText.includes(`exec ${posixSingleQuote("/usr/local/bin/node")} ${posixSingleQuote("/tmp/cli.mjs")} ${posixSingleQuote("runner")} ${posixSingleQuote("start")} ${posixSingleQuote("--no-update")}`),
+      scriptText.replace(/\r?\n/g, " | "),
+    );
   } catch (err) {
     push("detached_runner_posix_launch_script_serializes_runner_command", false, String(err?.message || err));
   } finally {
@@ -19334,15 +19394,15 @@ TELEGRAM_BOT_REVIEW_TOKEN=review-token
   try {
     const projectUpPolicy = resolveRunnerProjectUpExecutionPolicy({});
     push(
-      "runner_project_up_default_policy_prefers_detached_start",
+      "runner_project_up_default_policy_keeps_prepare_only_for_direct_cli",
       projectUpPolicy.applyRequested === true
         && projectUpPolicy.startRequested === false
-        && projectUpPolicy.startDetachedRequested === true
-        && projectUpPolicy.shouldStartRunner === true,
+        && projectUpPolicy.startDetachedRequested === false
+        && projectUpPolicy.shouldStartRunner === false,
       `apply=${projectUpPolicy.applyRequested} start=${projectUpPolicy.startRequested} detached=${projectUpPolicy.startDetachedRequested} shouldStart=${projectUpPolicy.shouldStartRunner}`,
     );
   } catch (err) {
-    push("runner_project_up_default_policy_prefers_detached_start", false, String(err?.message || err));
+    push("runner_project_up_default_policy_keeps_prepare_only_for_direct_cli", false, String(err?.message || err));
   }
 
   try {

package/package.json

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