metheus-governance-mcp-cli 0.2.165 → 0.2.166

package/README.md

@@ -514,6 +514,8 @@ Workspace/source-of-truth model:
 - `project-workspaces.json` answers only one question: `project_id -> local workspace_dir on this machine`
 - use local tool `project.workspace` to read that binding
 - use local tool `project.workspace.bind` to explicitly update that binding
+- use local tool `runner.project_up` to audit a project destination and create/select the executable runner routes
+- use local tool `runner.show` to inspect one resolved route before launch
 - use local tool `runner.start_detached` to launch an existing runner route in a separate local terminal
 - use local tool `runner.status` to inspect detached runner processes launched by this CLI
 - use local tool `runner.stop` to stop detached runner processes launched by this CLI
@@ -587,6 +589,8 @@ Mapping behavior:
 - use `project.workspace` to read the current local binding from `project-workspaces.json`
 - use `project.workspace.bind` to intentionally write the binding into `project-workspaces.json`
 - `project.workspace.bind` updates the workspace registry directly; it does not need `bot-runner.json` side effects to succeed
+- use `runner.project_up` after workspace binding to prepare executable routes for one project destination
+- use `runner.show` to inspect the selected route before launching it
 
 Runner command contract:
 - stdin: JSON payload containing project, destination, trigger message, and recent context comments

package/cli.mjs

@@ -4719,6 +4719,63 @@ function resolveRunnerProjectUpRoutes({
 }
 
 async function runRunnerProjectUp(flags) {
+  const result = await buildRunnerProjectUpResult(flags);
+  const { summaryPayload, applyRequested, applyResult, shouldStartRunner, matchingRoutes, startDetachedRequested, startFlags } = result;
+  if (boolFromRaw(flags.json, false)) {
+    process.stdout.write(`${JSON.stringify(summaryPayload, null, 2)}\n`);
+  } else {
+    process.stdout.write(
+      [
+        `Runner project up: ${summaryPayload.ok ? "OK" : "WARN"}`,
+        `project_id: ${summaryPayload.project_id || "-"}`,
+        `destination_label: ${summaryPayload.destination_label || "-"}`,
+        `destination_id: ${summaryPayload.destination_id || "-"}`,
+        `room_probe_ok: ${summaryPayload.room_probe_ok ? "true" : "false"}`,
+        `room_visible_bot_admins: ${summaryPayload.room_visible_bot_admins}`,
+        `my_server_bots: ${summaryPayload.my_server_bots}`,
+        `my_local_bots: ${summaryPayload.my_local_bots}`,
+        `bot_name_filter: ${summaryPayload.bot_name_filter}`,
+        `bot_id_filter: ${summaryPayload.bot_id_filter}`,
+        `role_filter: ${summaryPayload.role_filter}`,
+        `route_suggestions_create_total: ${summaryPayload.route_suggestions_create_total}`,
+        `route_suggestions_existing_total: ${summaryPayload.route_suggestions_existing_total}`,
+        `route_suggestions_blocked_total: ${summaryPayload.route_suggestions_blocked_total}`,
+        `route_apply_requested: ${summaryPayload.route_apply_requested ? "true" : "false"}`,
+        `route_apply_changed: ${summaryPayload.route_apply_changed ? "true" : "false"}`,
+        `route_config_file: ${summaryPayload.route_config_file}`,
+        `enabled_routes_for_selection: ${summaryPayload.enabled_routes_for_selection.join(", ") || "-"}`,
+        `start_requested: ${summaryPayload.start_requested ? "true" : "false"}`,
+        `start_detached_requested: ${summaryPayload.start_detached_requested ? "true" : "false"}`,
+        `next_steps: ${summaryPayload.next_steps.join(" | ") || "-"}`,
+      ].join("\n") + "\n",
+    );
+  }
+  if (applyRequested && applyResult.ok === false) {
+    process.exitCode = 1;
+    if (shouldStartRunner) {
+      throw new Error(String(applyResult.error || "runner project up could not apply runner routes").trim());
+    }
+    return;
+  }
+  if (!shouldStartRunner) {
+    return;
+  }
+  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 (startDetachedRequested) {
+    await runRunnerStartDetachedResolvedRoutes(matchingRoutes, startFlags, "runner project up");
+    return;
+  }
+  await runRunnerStartResolvedRoutes(matchingRoutes, startFlags);
+}
+
+async function buildRunnerProjectUpResult(flags = {}) {
   const ui = createPrompter();
   try {
     if (shouldRenderPromptChrome(flags)) {
@@ -4776,6 +4833,7 @@ async function runRunnerProjectUp(flags) {
           changed: false,
           filePath: String(auditPayload.routeSuggestionConfigFilePath || "").trim(),
           appliedRoutes: [],
+          disabledRoutes: [],
           error: "route apply skipped because the Telegram room visibility probe failed",
         })
       : null;
@@ -4820,6 +4878,8 @@ async function runRunnerProjectUp(flags) {
       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`);
@@ -4828,58 +4888,18 @@ async function runRunnerProjectUp(flags) {
     } else {
       summaryPayload.next_steps.push(`${CLI_NAME} runner show --route-name ${summaryPayload.enabled_routes_for_selection[0] || "<route_name>"}`);
     }
-    if (boolFromRaw(flags.json, false)) {
-      process.stdout.write(`${JSON.stringify(summaryPayload, null, 2)}\n`);
-    } else {
-      process.stdout.write(
-        [
-          `Runner project up: ${summaryPayload.ok ? "OK" : "WARN"}`,
-          `project_id: ${summaryPayload.project_id || "-"}`,
-          `destination_label: ${summaryPayload.destination_label || "-"}`,
-          `destination_id: ${summaryPayload.destination_id || "-"}`,
-          `room_probe_ok: ${summaryPayload.room_probe_ok ? "true" : "false"}`,
-          `room_visible_bot_admins: ${summaryPayload.room_visible_bot_admins}`,
-          `my_server_bots: ${summaryPayload.my_server_bots}`,
-          `my_local_bots: ${summaryPayload.my_local_bots}`,
-          `bot_name_filter: ${summaryPayload.bot_name_filter}`,
-          `bot_id_filter: ${summaryPayload.bot_id_filter}`,
-          `role_filter: ${summaryPayload.role_filter}`,
-          `route_suggestions_create_total: ${summaryPayload.route_suggestions_create_total}`,
-          `route_suggestions_existing_total: ${summaryPayload.route_suggestions_existing_total}`,
-          `route_suggestions_blocked_total: ${summaryPayload.route_suggestions_blocked_total}`,
-          `route_apply_requested: ${summaryPayload.route_apply_requested ? "true" : "false"}`,
-          `route_apply_changed: ${summaryPayload.route_apply_changed ? "true" : "false"}`,
-          `route_config_file: ${summaryPayload.route_config_file}`,
-          `enabled_routes_for_selection: ${summaryPayload.enabled_routes_for_selection.join(", ") || "-"}`,
-          `start_requested: ${summaryPayload.start_requested ? "true" : "false"}`,
-          `start_detached_requested: ${summaryPayload.start_detached_requested ? "true" : "false"}`,
-          `next_steps: ${summaryPayload.next_steps.join(" | ") || "-"}`,
-        ].join("\n") + "\n",
-      );
-    }
-    if (applyRequested && applyResult.ok === false) {
-      process.exitCode = 1;
-      if (shouldStartRunner) {
-        throw new Error(String(applyResult.error || "runner project up could not apply runner routes").trim());
-      }
-      return;
-    }
-    if (!shouldStartRunner) {
-      return;
-    }
-    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 (startDetachedRequested) {
-      await runRunnerStartDetachedResolvedRoutes(matchingRoutes, startFlags, "runner project up");
-      return;
+    if (applyRequested && applyResult.ok === false && applyResult.error) {
+      summaryPayload.error = String(applyResult.error || "").trim();
     }
-    await runRunnerStartResolvedRoutes(matchingRoutes, startFlags);
+    return {
+      summaryPayload,
+      applyRequested,
+      applyResult,
+      shouldStartRunner,
+      startDetachedRequested,
+      matchingRoutes,
+      startFlags,
+    };
   } finally {
     ui.close();
   }
@@ -7314,6 +7334,9 @@ function buildLocalProjectDispatchDeps() {
     normalizeMergeAction,
     executeCtxpackMergeActionForTool: (params) => executeCtxpackMergeActionForTool(params, buildProjectToolDeps()),
     buildCtxpackMergeExecuteText,
+    buildRunnerProjectUpResult: (flags) => buildRunnerProjectUpResult(flags),
+    resolveRunnerShowSelection: (flags) => resolveRunnerShowSelection(flags),
+    buildRunnerShowPayload: (route, flags) => buildRunnerShowPayload(route, flags),
     startDetachedRunnerWithFlags: (flags, sourceCommand) => startDetachedRunnerWithFlags(flags, sourceCommand),
     buildRunnerDetachedStatusPayload: (flags) => buildRunnerDetachedStatusPayload(flags),
     stopDetachedRunnerWithFlags: (flags) => stopDetachedRunnerWithFlags(flags),
@@ -7853,6 +7876,8 @@ const LOCAL_PROJECT_TOOL_NAMES = [
   "project.workspace.bind",
 ];
 const LOCAL_RUNNER_TOOL_NAMES = [
+  "runner.project_up",
+  "runner.show",
   "runner.start_detached",
   "runner.status",
   "runner.stop",
@@ -7997,6 +8022,46 @@ function buildRunnerStartDetachedInputSchema() {
   };
 }
 
+function buildRunnerProjectUpInputSchema() {
+  return {
+    type: "object",
+    properties: {
+      project_id: { type: "string", description: "Project UUID to audit and bind to a destination." },
+      provider: { type: "string", enum: ["telegram"], description: "Provider. runner.project_up currently supports telegram only." },
+      destination_id: { type: "string", description: "Destination UUID filter." },
+      destination_label: { type: "string", description: "Destination label filter." },
+      bot_name: { type: "string", description: "Server bot name filter." },
+      bot_id: { type: "string", description: "Server bot UUID filter." },
+      role: { type: "string", enum: ["monitor", "review", "worker", "approval"], description: "Single role filter." },
+      roles: { type: "string", description: "Comma-separated role filter list." },
+      apply: { type: "boolean", description: "If true, create/disable routes as suggested. Defaults to true." },
+      start: { type: "boolean", description: "If true, start the resolved routes after apply." },
+      start_detached: { type: "boolean", description: "If true, start in a separate local terminal after apply." },
+      dry_run_delivery: { type: "boolean", description: "If true, do not actually send provider replies." },
+      concurrency: { type: "integer", minimum: 1, description: "Max concurrent scheduling groups." },
+    },
+    required: ["project_id"],
+    additionalProperties: false,
+  };
+}
+
+function buildRunnerShowInputSchema() {
+  return {
+    type: "object",
+    properties: {
+      route_name: { type: "string", description: "Exact runner route name." },
+      bot_name: { type: "string", description: "Server bot name when one enabled route matches." },
+      bot_id: { type: "string", description: "Server bot UUID when one enabled route matches." },
+      project_id: { type: "string", description: "Project UUID filter." },
+      provider: { type: "string", enum: ["telegram", "slack", "kakaotalk"], description: "Provider filter." },
+      role: { type: "string", enum: ["monitor", "review", "worker", "approval"], description: "Role filter." },
+      destination_id: { type: "string", description: "Destination UUID filter." },
+      destination_label: { type: "string", description: "Destination label filter." },
+    },
+    additionalProperties: false,
+  };
+}
+
 function buildRunnerStatusInputSchema() {
   return {
     type: "object",
@@ -8056,6 +8121,18 @@ function buildLocalToolSpecs() {
         "Bind a project_id to a local workspace_dir in project-workspaces.json so local runner and AI execution use the correct project folder.",
       inputSchema: buildProjectWorkspaceBindInputSchema(),
     },
+    {
+      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.show",
+      description:
+        "Inspect one resolved runner route and report workspace mapping, execution profile, and last run details.",
+      inputSchema: buildRunnerShowInputSchema(),
+    },
     {
       name: "runner.start_detached",
       description:
@@ -8508,6 +8585,8 @@ function appendProjectHintToInitialize(responseObj, args, options = {}) {
   const projectWorkspaceTool = displayToolNameForClient("project.workspace", useSafeToolAliases);
   const projectWorkspaceBindTool = displayToolNameForClient("project.workspace.bind", useSafeToolAliases);
   const projectSummaryTool = displayToolNameForClient("project.summary", useSafeToolAliases);
+  const runnerProjectUpTool = displayToolNameForClient("runner.project_up", useSafeToolAliases);
+  const runnerShowTool = displayToolNameForClient("runner.show", useSafeToolAliases);
   const runnerStartDetachedTool = displayToolNameForClient("runner.start_detached", useSafeToolAliases);
   const runnerStatusTool = displayToolNameForClient("runner.status", useSafeToolAliases);
   const runnerStopTool = displayToolNameForClient("runner.stop", useSafeToolAliases);
@@ -8528,6 +8607,7 @@ function appendProjectHintToInitialize(responseObj, args, options = {}) {
       : []),
     `- MUST call \`${projectWorkspaceTool}\` first when the user provides only a Project ID and you need the local project folder/workspace binding.`,
     `- Use \`${projectWorkspaceBindTool}\` only when you need to explicitly write/update the local project-workspaces.json registry binding.`,
+    `- Use \`${runnerProjectUpTool}\` to audit a project destination and create/select runner routes before starting polling. Then use \`${runnerShowTool}\` to inspect the resolved route if needed.`,
     `- To run automated polling independently of the current AI session, call \`${runnerStartDetachedTool}\` after the workspace binding and route are ready. Use \`${runnerStatusTool}\` to inspect detached runner processes and \`${runnerStopTool}\` to stop them later.`,
     `- After resolving the local workspace, call \`${projectSummaryTool}\` for project overview/agenda/server metadata.`,
     `- If user enters a Project ID in text (e.g., "Project ID <uuid>"), pass that exact UUID as \`project_id\` argument when calling \`${projectSummaryTool}\`.`,
@@ -9732,12 +9812,125 @@ TELEGRAM_BOT_REVIEW_TOKEN=review-token
     push("detached_runner_linux_launcher_selects_supported_terminal", false, String(err?.message || err));
   }
 
+  try {
+    const projectUpResponse = await handleLocalProjectToolDispatchImpl(
+      {
+        requestObj: {
+          jsonrpc: "2.0",
+          id: 8,
+          method: "tools/call",
+          params: {
+            name: "runner.project_up",
+            arguments: {
+              project_id: selftestProjectID,
+              destination_label: "Selftest Room",
+            },
+          },
+        },
+        toolName: "runner.project_up",
+        toolArgs: {
+          project_id: selftestProjectID,
+          destination_label: "Selftest Room",
+        },
+        args: {
+          baseURL: DEFAULT_SITE_URL,
+          timeoutSeconds: 30,
+        },
+        token: "selftest-token",
+        workspaceDir: "",
+        workspaceSignalTrusted: true,
+      },
+      {
+        ...buildLocalProjectDispatchDeps(),
+        buildRunnerProjectUpResult: async () => ({
+          summaryPayload: {
+            ok: true,
+            project_id: selftestProjectID,
+            destination_label: "Selftest Room",
+            destination_id: "dest-1",
+            route_apply_requested: true,
+            route_apply_changed: true,
+            enabled_routes_for_selection: ["telegram-monitor-selftest"],
+            next_steps: [`${CLI_NAME} runner show --route-name telegram-monitor-selftest`],
+          },
+          matchingRoutes: [{ name: "telegram-monitor-selftest" }],
+          applyRequested: true,
+          applyResult: { ok: true, changed: true },
+          shouldStartRunner: false,
+          startDetachedRequested: false,
+          startFlags: {},
+        }),
+      },
+    );
+    const projectUpStructured = safeObject(safeObject(projectUpResponse).result)?.structuredContent || {};
+    push(
+      "local_runner_project_up_tool_dispatches",
+      projectUpStructured.ok === true
+        && ensureArray(projectUpStructured.enabled_routes_for_selection).includes("telegram-monitor-selftest"),
+      `routes=${ensureArray(projectUpStructured.enabled_routes_for_selection).join(",")} next=${ensureArray(projectUpStructured.next_steps).join(" | ")}`,
+    );
+  } catch (err) {
+    push("local_runner_project_up_tool_dispatches", false, String(err?.message || err));
+  }
+
+  try {
+    const showResponse = await handleLocalProjectToolDispatchImpl(
+      {
+        requestObj: {
+          jsonrpc: "2.0",
+          id: 9,
+          method: "tools/call",
+          params: {
+            name: "runner.show",
+            arguments: {
+              route_name: "telegram-monitor-selftest",
+            },
+          },
+        },
+        toolName: "runner.show",
+        toolArgs: {
+          route_name: "telegram-monitor-selftest",
+        },
+        args: {
+          baseURL: DEFAULT_SITE_URL,
+          timeoutSeconds: 30,
+        },
+        token: "selftest-token",
+        workspaceDir: "",
+        workspaceSignalTrusted: true,
+      },
+      {
+        ...buildLocalProjectDispatchDeps(),
+        resolveRunnerShowSelection: () => ({ name: "telegram-monitor-selftest" }),
+        buildRunnerShowPayload: () => ({
+          ok: true,
+          route_name: "telegram-monitor-selftest",
+          route_config: { project_id: selftestProjectID },
+          resolved_destination: { destination_label: "Selftest Room" },
+          workspace_mapping: { workspace_dir: "C:\\selftest-workspace", workspace_source: "project-workspaces.json:manual_override" },
+          execution_profile: { permission_mode: "read_only" },
+          warnings: [],
+          errors: [],
+        }),
+      },
+    );
+    const showStructured = safeObject(safeObject(showResponse).result)?.structuredContent || {};
+    push(
+      "local_runner_show_tool_dispatches",
+      showStructured.ok === true
+        && String(showStructured.route_name || "").trim() === "telegram-monitor-selftest",
+      `route=${String(showStructured.route_name || "").trim() || "(none)"} workspace=${String(safeObject(showStructured.workspace_mapping).workspace_dir || "").trim() || "-"}`,
+    );
+  } catch (err) {
+    push("local_runner_show_tool_dispatches", false, String(err?.message || err));
+  }
+
   try {
     const startResponse = await handleLocalProjectToolDispatchImpl(
       {
         requestObj: {
           jsonrpc: "2.0",
-          id: 5,
+          id: 10,
           method: "tools/call",
           params: {
             name: "runner.start_detached",
@@ -9791,7 +9984,7 @@ TELEGRAM_BOT_REVIEW_TOKEN=review-token
       {
         requestObj: {
           jsonrpc: "2.0",
-          id: 6,
+          id: 11,
           method: "tools/call",
           params: {
             name: "runner.status",
@@ -9843,7 +10036,7 @@ TELEGRAM_BOT_REVIEW_TOKEN=review-token
       {
         requestObj: {
           jsonrpc: "2.0",
-          id: 7,
+          id: 12,
           method: "tools/call",
           params: {
             name: "runner.stop",

package/lib/local-project-dispatch.mjs

@@ -57,6 +57,9 @@ export async function handleLocalProjectToolDispatch(
   const normalizeMergeAction = requireDependency(deps, "normalizeMergeAction");
   const executeCtxpackMergeActionForTool = requireDependency(deps, "executeCtxpackMergeActionForTool");
   const buildCtxpackMergeExecuteText = requireDependency(deps, "buildCtxpackMergeExecuteText");
+  const buildRunnerProjectUpResult = requireDependency(deps, "buildRunnerProjectUpResult");
+  const resolveRunnerShowSelection = requireDependency(deps, "resolveRunnerShowSelection");
+  const buildRunnerShowPayload = requireDependency(deps, "buildRunnerShowPayload");
   const startDetachedRunnerWithFlags = requireDependency(deps, "startDetachedRunnerWithFlags");
   const buildRunnerDetachedStatusPayload = requireDependency(deps, "buildRunnerDetachedStatusPayload");
   const stopDetachedRunnerWithFlags = requireDependency(deps, "stopDetachedRunnerWithFlags");
@@ -241,6 +244,53 @@ export async function handleLocalProjectToolDispatch(
 
   if (localRunnerToolNames.includes(toolName)) {
     try {
+      if (toolName === "runner.project_up") {
+        const normalizedFlags = {
+          ...toolArgs,
+          ...(Object.prototype.hasOwnProperty.call(toolArgs, "project_id") ? {} : { project_id: resolveProjectID(toolArgs, args, workspaceDir, deps) }),
+          ...(Object.prototype.hasOwnProperty.call(toolArgs, "start") ? {} : { start: false }),
+          ...(Object.prototype.hasOwnProperty.call(toolArgs, "start_detached") ? {} : { start_detached: false }),
+          ...(Object.prototype.hasOwnProperty.call(toolArgs, "json") ? {} : { json: true }),
+        };
+        const result = await buildRunnerProjectUpResult(normalizedFlags);
+        const payload = {
+          ...safeObject(result.summaryPayload),
+          matching_routes: ensureArray(result.matchingRoutes).map((route) => String(safeObject(route).name || "").trim()).filter(Boolean),
+        };
+        const text = [
+          `ok: ${payload.ok ? "true" : "false"}`,
+          `project_id: ${String(payload.project_id || "").trim() || "-"}`,
+          `destination_label: ${String(payload.destination_label || "").trim() || "-"}`,
+          `destination_id: ${String(payload.destination_id || "").trim() || "-"}`,
+          `route_apply_requested: ${payload.route_apply_requested ? "true" : "false"}`,
+          `route_apply_changed: ${payload.route_apply_changed ? "true" : "false"}`,
+          `enabled_routes_for_selection: ${ensureArray(payload.enabled_routes_for_selection).join(", ") || "-"}`,
+          `next_steps: ${ensureArray(payload.next_steps).join(" | ") || "-"}`,
+        ].join("\n");
+        return jsonRpcResult(requestObj, {
+          content: [{ type: "text", text }],
+          structuredContent: payload,
+        });
+      }
+      if (toolName === "runner.show") {
+        const route = resolveRunnerShowSelection(toolArgs);
+        const payload = buildRunnerShowPayload(route, toolArgs);
+        const text = [
+          `ok: ${payload.ok ? "true" : "false"}`,
+          `route_name: ${String(payload.route_name || "").trim() || "-"}`,
+          `project_id: ${String(safeObject(payload.route_config).project_id || "").trim() || "-"}`,
+          `destination_label: ${String(safeObject(payload.resolved_destination).destination_label || "").trim() || "-"}`,
+          `workspace_dir: ${String(safeObject(payload.workspace_mapping).workspace_dir || "").trim() || "-"}`,
+          `workspace_source: ${String(safeObject(payload.workspace_mapping).workspace_source || "").trim() || "-"}`,
+          `permission_mode: ${String(safeObject(payload.execution_profile).permission_mode || "").trim() || "-"}`,
+          `warnings: ${ensureArray(payload.warnings).join(" | ") || "-"}`,
+          `errors: ${ensureArray(payload.errors).join(" | ") || "-"}`,
+        ].join("\n");
+        return jsonRpcResult(requestObj, {
+          content: [{ type: "text", text }],
+          structuredContent: payload,
+        });
+      }
       if (toolName === "runner.start_detached") {
         const payload = await startDetachedRunnerWithFlags(toolArgs, "runner.start_detached");
         const launch = safeObject(payload.launch);

package/package.json

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