metheus-governance-mcp-cli 0.2.67 → 0.2.69

package/README.md

@@ -225,10 +225,11 @@ metheus-governance-mcp-cli bot verify --provider telegram --bot-key main
 Behavior:
 
 - `bot setup` asks for `Telegram / Slack / KakaoTalk` first, then prompts with numbered actions.
-- `bot add` without flags starts a guided question flow: provider -> server bot -> local bot key -> token -> verify -> role/AI binding -> default bot choice.
-- When you choose a server Telegram bot profile such as `RyoAI_bot [monitor]`, the CLI automatically uses that server role as the local `role_profile` and fills blank AI defaults from your local `bot-runner.json` `role_profiles` mapping.
+- `bot add` without flags starts a guided question flow: provider -> bot responsibility -> local bot key -> token -> verify.
+- For Telegram, the CLI asks for the server-side bot responsibility first and automatically resolves the matching server bot profile when the role is unique.
+- When you choose a Telegram responsibility such as `monitor`, the CLI automatically uses that server role as the local `role_profile` and fills blank AI defaults from your local `bot-runner.json` `role_profiles` mapping.
 - `bot edit` without flags starts a guided numbered flow: provider -> bot entry -> guided edit -> step-by-step field choices.
-- In guided `bot edit`, changing the bound server Telegram bot profile can also auto-fill blank local AI fields from the selected server role.
+- In guided `bot edit`, changing the bound Telegram responsibility can also auto-fill blank local AI fields from the selected server role and skip redundant role/AI prompts.
 - `bot set-default` without flags starts a guided numbered flow: provider -> bot entry -> confirm default change.
 - `bot verify` without flags starts a guided numbered flow: provider -> bot entry -> output format.
 - `bot remove` without flags starts a guided numbered flow: provider -> bot entry -> confirm removal.
@@ -381,6 +382,12 @@ Role profile fields:
 - `permission_mode`: `read_only`, `workspace_write`, `danger_full_access`
 - `reasoning_effort`: `low`, `medium`, `high`
 
+Recommended role mapping:
+- `monitor`: `read_only` + `low`
+- `review`: `read_only` + `medium`
+- `worker`: `danger_full_access` + `medium`
+- `approval`: `danger_full_access` + `high`
+
 Role profile note:
 - Claude maps `reasoning_effort` to `--effort`.
 - Codex maps `reasoning_effort` to `-c model_reasoning_effort="..."`.

package/cli.mjs

@@ -809,13 +809,13 @@ function defaultBotRunnerRoleProfiles() {
     worker: {
       client: "codex",
       model: "",
-      permission_mode: "workspace_write",
+      permission_mode: "danger_full_access",
       reasoning_effort: "medium",
     },
     approval: {
       client: "gemini",
       model: "",
-      permission_mode: "read_only",
+      permission_mode: "danger_full_access",
       reasoning_effort: "high",
     },
   };

package/lib/bot-commands.mjs

@@ -497,6 +497,7 @@ function saveTelegramBotEdit(parsed, selected, current, deps) {
 }
 
 async function editTelegramBotGuided(ui, parsed, selected, current, flags, deps) {
+  let serverRoleAutoResolved = "";
   const bindingAction = await promptKeepChangeClear(ui, "Server bot binding", {
     allowClear: true,
     defaultValue: current.serverBotID ? "keep" : "change",
@@ -513,6 +514,7 @@ async function editTelegramBotGuided(ui, parsed, selected, current, flags, deps)
     if (!current.roleProfile && serverBot.role) {
       current.roleProfile = serverBot.role;
     }
+    serverRoleAutoResolved = String(serverBot.role || current.roleProfile || "").trim();
     applyRoleProfileDefaults(current, resolveRoleProfileDefaults(current.roleProfile || serverBot.role, deps));
   } else if (bindingAction === "clear") {
     current.serverBotID = "";
@@ -553,66 +555,68 @@ async function editTelegramBotGuided(ui, parsed, selected, current, flags, deps)
     }
   }
 
-  const roleAction = await promptKeepChangeClear(ui, "Role profile", {
-    allowClear: true,
-    defaultValue: current.roleProfile ? "keep" : "change",
-  });
-  if (roleAction === "change") {
-    current.roleProfile = requireDependency(deps, "normalizeRunnerRoleProfileName")(
-      await promptTelegramRoleProfile(ui, deps, current.roleProfile),
-    );
-    applyRoleProfileDefaults(current, resolveRoleProfileDefaults(current.roleProfile, deps));
-  } else if (roleAction === "clear") {
-    current.roleProfile = "";
-  }
+  if (!serverRoleAutoResolved) {
+    const roleAction = await promptKeepChangeClear(ui, "Role profile", {
+      allowClear: true,
+      defaultValue: current.roleProfile ? "keep" : "change",
+    });
+    if (roleAction === "change") {
+      current.roleProfile = requireDependency(deps, "normalizeRunnerRoleProfileName")(
+        await promptTelegramRoleProfile(ui, deps, current.roleProfile),
+      );
+      applyRoleProfileDefaults(current, resolveRoleProfileDefaults(current.roleProfile, deps));
+    } else if (roleAction === "clear") {
+      current.roleProfile = "";
+    }
 
-  const clientAction = await promptKeepChangeClear(ui, "AI client", {
-    allowClear: true,
-    defaultValue: current.client ? "keep" : "change",
-  });
-  if (clientAction === "change") {
-    current.client = requireDependency(deps, "normalizeLocalAIClientName")(
-      await promptAIClient(ui, deps, current.client),
-      "",
-    );
-  } else if (clientAction === "clear") {
-    current.client = "";
-  }
+    const clientAction = await promptKeepChangeClear(ui, "AI client", {
+      allowClear: true,
+      defaultValue: current.client ? "keep" : "change",
+    });
+    if (clientAction === "change") {
+      current.client = requireDependency(deps, "normalizeLocalAIClientName")(
+        await promptAIClient(ui, deps, current.client),
+        "",
+      );
+    } else if (clientAction === "clear") {
+      current.client = "";
+    }
 
-  const modelAction = await promptKeepChangeClear(ui, "AI model", {
-    allowClear: true,
-    defaultValue: current.model ? "keep" : "change",
-  });
-  if (modelAction === "change") {
-    current.model = await promptLine(ui, "AI model", current.model);
-  } else if (modelAction === "clear") {
-    current.model = "";
-  }
+    const modelAction = await promptKeepChangeClear(ui, "AI model", {
+      allowClear: true,
+      defaultValue: current.model ? "keep" : "change",
+    });
+    if (modelAction === "change") {
+      current.model = await promptLine(ui, "AI model", current.model);
+    } else if (modelAction === "clear") {
+      current.model = "";
+    }
 
-  const permissionAction = await promptKeepChangeClear(ui, "AI permission mode", {
-    allowClear: true,
-    defaultValue: current.permissionMode ? "keep" : "change",
-  });
-  if (permissionAction === "change") {
-    current.permissionMode = requireDependency(deps, "normalizeLocalAIPermissionMode")(
-      await promptPermissionMode(ui, current.permissionMode),
-      "",
-    );
-  } else if (permissionAction === "clear") {
-    current.permissionMode = "";
-  }
+    const permissionAction = await promptKeepChangeClear(ui, "AI permission mode", {
+      allowClear: true,
+      defaultValue: current.permissionMode ? "keep" : "change",
+    });
+    if (permissionAction === "change") {
+      current.permissionMode = requireDependency(deps, "normalizeLocalAIPermissionMode")(
+        await promptPermissionMode(ui, current.permissionMode),
+        "",
+      );
+    } else if (permissionAction === "clear") {
+      current.permissionMode = "";
+    }
 
-  const reasoningAction = await promptKeepChangeClear(ui, "AI reasoning effort", {
-    allowClear: true,
-    defaultValue: current.reasoningEffort ? "keep" : "change",
-  });
-  if (reasoningAction === "change") {
-    current.reasoningEffort = requireDependency(deps, "normalizeLocalAIReasoningEffort")(
-      await promptReasoningEffort(ui, current.reasoningEffort),
-      "",
-    );
-  } else if (reasoningAction === "clear") {
-    current.reasoningEffort = "";
+    const reasoningAction = await promptKeepChangeClear(ui, "AI reasoning effort", {
+      allowClear: true,
+      defaultValue: current.reasoningEffort ? "keep" : "change",
+    });
+    if (reasoningAction === "change") {
+      current.reasoningEffort = requireDependency(deps, "normalizeLocalAIReasoningEffort")(
+        await promptReasoningEffort(ui, current.reasoningEffort),
+        "",
+      );
+    } else if (reasoningAction === "clear") {
+      current.reasoningEffort = "";
+    }
   }
 
   const botKeyAction = await promptKeepChangeClear(ui, "Local bot key", {
@@ -843,7 +847,11 @@ async function resolveTelegramEntryForShow(ui, parsedEnv, flags, deps) {
 async function chooseServerBot(ui, provider, baseURL, timeoutSeconds, deps) {
   const lookup = requireDependency(deps, "listServerBots");
   const result = await lookup({ provider, baseURL, timeoutSeconds });
-  const bots = ensureArray(result?.bots);
+  const bots = ensureArray(result?.bots).map((bot) => ({
+    id: String(bot?.id || "").trim(),
+    role: String(bot?.role || bot?.bot_role || "").trim(),
+    name: String(bot?.name || "").trim(),
+  })).filter((bot) => bot.id);
   if (!bots.length) {
     if (result?.error) {
       process.stdout.write(`Server bot profiles unavailable: ${result.error}\n`);
@@ -855,11 +863,90 @@ async function chooseServerBot(ui, provider, baseURL, timeoutSeconds, deps) {
       name: "",
     };
   }
+  if (bots.length === 1) {
+    const match = bots[0] || {};
+    return {
+      botID: String(match.id || "").trim(),
+      role: String(match.role || "").trim(),
+      name: String(match.name || "").trim(),
+    };
+  }
+  const preferredRoleOrder = ["monitor", "review", "worker", "approval"];
+  const roleGroups = new Map();
+  bots.forEach((bot) => {
+    const roleKey = String(bot.role || "").trim() || "(no role)";
+    if (!roleGroups.has(roleKey)) {
+      roleGroups.set(roleKey, []);
+    }
+    roleGroups.get(roleKey).push(bot);
+  });
+  const sortedRoles = [...roleGroups.keys()].sort((left, right) => {
+    const leftIndex = preferredRoleOrder.indexOf(left);
+    const rightIndex = preferredRoleOrder.indexOf(right);
+    if (leftIndex >= 0 && rightIndex >= 0) return leftIndex - rightIndex;
+    if (leftIndex >= 0) return -1;
+    if (rightIndex >= 0) return 1;
+    return left.localeCompare(right);
+  });
+  const roleChoice = await promptChoice(
+    ui,
+    `Select ${providerLabel(provider, deps)} bot responsibility`,
+    [
+      ...sortedRoles.map((role) => {
+        const matches = ensureArray(roleGroups.get(role));
+        if (matches.length === 1) {
+          return {
+            value: `role:${role}`,
+            label: role,
+            description: `${matches[0].name || "(unnamed)"} -> ${matches[0].id}`,
+          };
+        }
+        return {
+          value: `group:${role}`,
+          label: role,
+          description: `${matches.length} server bot profiles`,
+        };
+      }),
+      {
+        value: "__manual__",
+        label: "Manual entry",
+        description: "type the server bot UUID yourself",
+      },
+      {
+        value: "__blank__",
+        label: "Leave empty",
+        description: "skip server bot UUID binding",
+      },
+    ],
+    { defaultIndex: 0 },
+  );
+  if (!roleChoice || roleChoice.value === "__blank__") {
+    return { botID: "", role: "", name: "" };
+  }
+  if (roleChoice.value === "__manual__") {
+    const manualID = await promptLine(ui, "Server bot UUID", "");
+    return {
+      botID: manualID,
+      role: "",
+      name: "",
+    };
+  }
+  if (String(roleChoice.value || "").startsWith("role:")) {
+    const selectedRole = String(roleChoice.value || "").slice(5);
+    const match = ensureArray(roleGroups.get(selectedRole))[0] || {};
+    return {
+      botID: String(match.id || "").trim(),
+      role: String(match.role || "").trim(),
+      name: String(match.name || "").trim(),
+    };
+  }
+  const selectedRole = String(roleChoice.value || "").slice(6);
+  const matches = ensureArray(roleGroups.get(selectedRole));
   const choice = await promptChoice(
     ui,
-    `Select server ${providerLabel(provider, deps)} bot profile`,
+    `Select server ${providerLabel(provider, deps)} bot profile for role "${selectedRole}"`,
     [
-      ...bots.map((bot) => ({
+      ...matches.map((bot) => ({
         value: bot.id,
         label: `${bot.name || "(unnamed)"} [${bot.role || "-"}]`,
         description: bot.id,
@@ -884,11 +971,11 @@ async function chooseServerBot(ui, provider, baseURL, timeoutSeconds, deps) {
     const manualID = await promptLine(ui, "Server bot UUID", "");
     return {
       botID: manualID,
-      role: "",
+      role: selectedRole,
       name: "",
     };
   }
-  const match = bots.find((bot) => bot.id === choice.value) || {};
+  const match = matches.find((bot) => bot.id === choice.value) || {};
   return {
     botID: String(match.id || "").trim(),
     role: String(match.role || "").trim(),
@@ -1070,34 +1157,52 @@ async function addTelegramBot(ui, flags, deps) {
   const username = requireDependency(deps, "normalizeTelegramBotUsername")(
     nonInteractive
       ? String(flags.username || usernameDefault).trim()
-      : await promptLine(ui, "Telegram username (without @)", usernameDefault),
+      : (usernameDefault || await promptLine(ui, "Telegram username (without @)", usernameDefault)),
   );
   const defaultRoleProfile = firstNonEmptyString([flags["role-profile"], serverBot.role, ""]);
+  const roleProfileAutoResolved = !nonInteractive && !String(flags["role-profile"] || "").trim() && Boolean(defaultRoleProfile);
   const roleProfile = requireDependency(deps, "normalizeRunnerRoleProfileName")(
     nonInteractive
       ? String(flags["role-profile"] || defaultRoleProfile).trim()
-      : await promptTelegramRoleProfile(ui, deps, defaultRoleProfile),
+      : (roleProfileAutoResolved ? defaultRoleProfile : await promptTelegramRoleProfile(ui, deps, defaultRoleProfile)),
   );
   const roleProfileDefaults = resolveRoleProfileDefaults(roleProfile, deps);
+  const aiFlagOverrides = hasOwnFlag(flags, "client")
+    || hasOwnFlag(flags, "ai-client")
+    || hasOwnFlag(flags, "model")
+    || hasOwnFlag(flags, "ai-model")
+    || hasOwnFlag(flags, "permission-mode")
+    || hasOwnFlag(flags, "ai-permission-mode")
+    || hasOwnFlag(flags, "reasoning-effort")
+    || hasOwnFlag(flags, "ai-reasoning-effort");
+  const autoApplyRoleDefaults = !nonInteractive && roleProfileAutoResolved && !aiFlagOverrides;
   const client = requireDependency(deps, "normalizeLocalAIClientName")(
     nonInteractive
       ? firstNonEmptyString([getAIClientFlag(flags), roleProfileDefaults.client])
-      : await promptAIClient(ui, deps, firstNonEmptyString([getAIClientFlag(flags), roleProfileDefaults.client])),
+      : (autoApplyRoleDefaults
+        ? firstNonEmptyString([getAIClientFlag(flags), roleProfileDefaults.client])
+        : await promptAIClient(ui, deps, firstNonEmptyString([getAIClientFlag(flags), roleProfileDefaults.client]))),
     "",
   );
   const model = nonInteractive
     ? firstNonEmptyString([getAIModelFlag(flags), roleProfileDefaults.model])
-    : await promptLine(ui, "AI model", firstNonEmptyString([getAIModelFlag(flags), roleProfileDefaults.model]));
+    : (autoApplyRoleDefaults
+      ? firstNonEmptyString([getAIModelFlag(flags), roleProfileDefaults.model])
+      : await promptLine(ui, "AI model", firstNonEmptyString([getAIModelFlag(flags), roleProfileDefaults.model])));
   const permissionMode = requireDependency(deps, "normalizeLocalAIPermissionMode")(
     nonInteractive
       ? firstNonEmptyString([getAIPermissionModeFlag(flags), roleProfileDefaults.permissionMode])
-      : await promptPermissionMode(ui, firstNonEmptyString([getAIPermissionModeFlag(flags), roleProfileDefaults.permissionMode])),
+      : (autoApplyRoleDefaults
+        ? firstNonEmptyString([getAIPermissionModeFlag(flags), roleProfileDefaults.permissionMode])
+        : await promptPermissionMode(ui, firstNonEmptyString([getAIPermissionModeFlag(flags), roleProfileDefaults.permissionMode]))),
     "",
   );
   const reasoningEffort = requireDependency(deps, "normalizeLocalAIReasoningEffort")(
     nonInteractive
       ? firstNonEmptyString([getAIReasoningEffortFlag(flags), roleProfileDefaults.reasoningEffort])
-      : await promptReasoningEffort(ui, firstNonEmptyString([getAIReasoningEffortFlag(flags), roleProfileDefaults.reasoningEffort])),
+      : (autoApplyRoleDefaults
+        ? firstNonEmptyString([getAIReasoningEffortFlag(flags), roleProfileDefaults.reasoningEffort])
+        : await promptReasoningEffort(ui, firstNonEmptyString([getAIReasoningEffortFlag(flags), roleProfileDefaults.reasoningEffort]))),
     "",
   );
 
@@ -1113,9 +1218,10 @@ async function addTelegramBot(ui, flags, deps) {
     reasoningEffort,
   });
 
+  const hasCurrentDefault = Boolean(String(parsed.TELEGRAM_DEFAULT_BOT_KEY || "").trim());
   if (
     boolFromRaw(flags.default, false)
-    || (!nonInteractive && await promptYesNo(ui, "Set this bot as TELEGRAM_DEFAULT_BOT_KEY?", !String(parsed.TELEGRAM_DEFAULT_BOT_KEY || "").trim()))
+    || (!nonInteractive && !hasCurrentDefault && await promptYesNo(ui, "Set this bot as TELEGRAM_DEFAULT_BOT_KEY?", true))
   ) {
     nextParsed.TELEGRAM_DEFAULT_BOT_KEY = botKey;
   }

package/lib/selftest-bot-commands.mjs

@@ -271,17 +271,9 @@ export async function runSelftestBotCommands(push, deps) {
         ...env,
         METHEUS_SCRIPTED_PROMPT_ANSWERS: JSON.stringify([
           "1", // provider: telegram
-          "1", // server bot: first listed bot
           "main_test",
           "selftest-main-token",
           "y", // verify now
-          "", // keep verified username
-          "", // keep role profile default from selected server role
-          "", // keep AI client default from role profile
-          "", // keep AI model default from role profile
-          "", // keep permission default from role profile
-          "", // keep reasoning default from role profile
-          "y", // set as default
         ]),
       },
     });
@@ -294,7 +286,7 @@ export async function runSelftestBotCommands(push, deps) {
         && String(addState.TELEGRAM_BOT_MAIN_TEST_AI_CLIENT || "") === "codex"
         && String(addState.TELEGRAM_BOT_MAIN_TEST_AI_PERMISSION_MODE || "") === "read_only"
         && String(addState.TELEGRAM_BOT_MAIN_TEST_AI_REASONING_EFFORT || "") === "low"
-        && String(addState.TELEGRAM_DEFAULT_BOT_KEY || "") === "main_test",
+        && String(addState.TELEGRAM_DEFAULT_BOT_KEY || "") === "main",
       `default=${String(addState.TELEGRAM_DEFAULT_BOT_KEY || "")} role=${String(addState.TELEGRAM_BOT_MAIN_TEST_ROLE_PROFILE || "")} client=${String(addState.TELEGRAM_BOT_MAIN_TEST_AI_CLIENT || "")}`,
     );
 

package/package.json

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

package/postinstall.mjs

@@ -80,6 +80,24 @@ function botRunnerTemplate() {
           permission_mode: "read_only",
           reasoning_effort: "low",
         },
+        review: {
+          client: "claude",
+          model: "",
+          permission_mode: "read_only",
+          reasoning_effort: "medium",
+        },
+        worker: {
+          client: "codex",
+          model: "",
+          permission_mode: "danger_full_access",
+          reasoning_effort: "medium",
+        },
+        approval: {
+          client: "gemini",
+          model: "",
+          permission_mode: "danger_full_access",
+          reasoning_effort: "high",
+        },
       },
       bot_bindings: {
         "<binding_key>": {