metheus-governance-mcp-cli 0.2.78 → 0.2.80

package/README.md

@@ -226,12 +226,13 @@ 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 now uses the shortest practical guided flow: provider -> token -> verify -> optional save-anyway only when verify fails -> optional username fallback only when verify cannot discover it -> optional default bot.
+- `bot add` without flags now uses the shortest practical guided flow: provider -> token -> verify -> optional save-anyway only when verify fails -> optional username fallback only when verify cannot discover it -> optional AI model selection when the resolved defaults leave it blank -> optional default bot.
 - In the normal Telegram path, `bot add` does not ask for a local bot key, a server bot UUID, or an approval / worker / review / monitor choice.
 - For Telegram, the local env key is auto-generated from the matched server bot name or verified username, so you do not have to invent a separate local nickname first.
 - For Telegram, the CLI tries to match the verified bot identity against the server `me/bots` list first. If the server exposes one logical bot name with multiple roles such as `approval`, `worker`, `review`, and `monitor`, the CLI does not ask you to choose one UUID. It binds by server bot name and keeps the local role/AI fields empty so runtime can use the server bot role for each route.
 - When the Telegram username matches exactly one server bot role, the CLI still auto-fills the local `role_profile` and blank AI defaults from your local `bot-runner.json` `role_profiles` mapping.
 - `bot edit` without flags now uses the same sequential flow every time: provider -> bot entry -> username/token review -> grouped server-role review when needed -> AI field choices -> default choice -> save.
+- when the CLI asks for `AI model`, it now shows client-specific model choices first and still allows manual entry when you need a custom model name.
 - if one server bot name maps to multiple server roles, `bot edit` keeps the Telegram env entry bound to the server identity and lets you review the local `role_profiles` for each detected role instead of forcing one role/profile UUID choice up front.
 - In the normal Telegram edit path, the CLI keeps or re-resolves the server bot binding automatically. It no longer asks you to pick `approval / worker / review / monitor` or a server bot UUID first.
 - `bot set-default` without flags starts a guided numbered flow: provider -> bot entry -> confirm default change.

package/lib/bot-commands.mjs

@@ -832,7 +832,7 @@ async function editTelegramBotGuided(ui, parsed, selected, current, flags, deps)
       defaultValue: current.model ? "keep" : "change",
     });
     if (modelAction === "change") {
-      current.model = await promptLine(ui, "AI model", current.model);
+      current.model = await promptAIModel(ui, deps, current.client, current.model);
     } else if (modelAction === "clear") {
       current.model = "";
     }
@@ -1123,19 +1123,16 @@ function printBotShow(provider, state, entry, deps, extras = {}) {
   process.stdout.write(`  token: ${token ? maskSecret(token) : "(not configured)"}\n`);
 }
 
-async function chooseTelegramEntry(ui, parsedEnv, deps, title = "Select Telegram bot entry") {
+async function chooseTelegramEntry(ui, parsedEnv, deps, title = "Select Telegram bot entry", flags = {}) {
   const entries = telegramEntriesForDisplay(parsedEnv, deps);
   if (!entries.length) {
     throw new Error("no Telegram bot entries are configured");
   }
+  const displayRows = await buildTelegramEntrySelectionRows(entries, flags, deps);
   const selected = await promptChoice(
     ui,
     title,
-    entries.map((entry) => ({
-      value: entry.key,
-      label: `${telegramEntryDisplayName(entry)}${entry.isDefault ? " [default]" : ""}`,
-      description: telegramEntryDisplayDescription(entry),
-    })),
+    displayRows,
     { defaultIndex: 0 },
   );
   return entries.find((entry) => entry.key === selected.value) || entries[0];
@@ -1164,7 +1161,7 @@ async function resolveTelegramEntryForShow(ui, parsedEnv, flags, deps) {
   if (nonInteractive) {
     throw new Error("Telegram bot selector is required when multiple entries exist; pass --bot-key, --bot-id, or --bot-name");
   }
-  return chooseTelegramEntry(ui, parsedEnv, deps, "Select Telegram bot entry");
+  return chooseTelegramEntry(ui, parsedEnv, deps, "Select Telegram bot entry", flags);
 }
 
 async function chooseServerBot(ui, provider, baseURL, timeoutSeconds, deps, options = {}) {
@@ -1452,6 +1449,60 @@ async function promptAIClient(ui, deps, defaultValue = "") {
   return String(selected?.value || "").trim();
 }
 
+function suggestedAIModelsForClient(clientName) {
+  const normalizedClient = String(clientName || "").trim().toLowerCase();
+  if (normalizedClient === "codex") {
+    return [
+      { value: "gpt-5-codex", label: "gpt-5-codex", description: "recommended Codex model" },
+    ];
+  }
+  if (normalizedClient === "claude") {
+    return [
+      { value: "claude-sonnet-4", label: "claude-sonnet-4", description: "recommended Claude model" },
+      { value: "claude-3.7-sonnet", label: "claude-3.7-sonnet", description: "older Claude Sonnet variant" },
+    ];
+  }
+  if (normalizedClient === "gemini") {
+    return [
+      { value: "gemini-2.5-pro", label: "gemini-2.5-pro", description: "recommended Gemini model" },
+    ];
+  }
+  if (normalizedClient === "sample") {
+    return [
+      { value: "sample", label: "sample", description: "sample adapter model placeholder" },
+    ];
+  }
+  return [];
+}
+
+async function promptAIModel(ui, deps, clientName, defaultValue = "", title = "Select AI model") {
+  const normalizedClient = requireDependency(deps, "normalizeLocalAIClientName")(clientName || "", "");
+  const currentValue = String(defaultValue || "").trim();
+  const suggestions = suggestedAIModelsForClient(normalizedClient);
+  const options = [
+    { value: "", label: "(blank)", description: "leave AI model empty" },
+  ];
+  if (currentValue && !suggestions.some((item) => item.value === currentValue)) {
+    options.push({
+      value: currentValue,
+      label: currentValue,
+      description: "current saved model",
+    });
+  }
+  options.push(...suggestions);
+  options.push({
+    value: "__manual__",
+    label: "Manual entry",
+    description: "type the model name yourself",
+  });
+  const selectedIndex = Math.max(0, options.findIndex((item) => item.value === currentValue));
+  const selected = await promptChoice(ui, title, options, { defaultIndex: selectedIndex >= 0 ? selectedIndex : 0 });
+  if (String(selected?.value || "") === "__manual__") {
+    return String(await promptRequiredLine(ui, "AI model", currentValue)).trim();
+  }
+  return String(selected?.value || "").trim();
+}
+
 async function promptPermissionMode(ui, defaultValue = "") {
   const options = [
     { value: "", label: "(blank)", description: "leave permission mode empty" },
@@ -1635,7 +1686,7 @@ async function promptRoleExecutionProfile(ui, roleName, deps) {
     await promptAIClient(ui, deps, current.client),
     "",
   );
-  current.model = await promptLine(ui, `AI model for role "${current.role}"`, current.model);
+  current.model = await promptAIModel(ui, deps, current.client, current.model, `Select AI model for role "${current.role}"`);
   current.permissionMode = requireDependency(deps, "normalizeLocalAIPermissionMode")(
     await promptPermissionMode(ui, current.permissionMode),
     "",
@@ -1725,34 +1776,11 @@ async function maybePromptGroupedServerRoleProfiles(ui, serverBot, deps) {
   return true;
 }
 
-async function resolveTelegramServerBindingDetails(envConfig, flags, deps) {
+function resolveTelegramServerBindingDetailsFromBots(envConfig, bots, deps) {
   const current = safeObject(envConfig);
   if (!String(current.serverBotID || "").trim() && !String(current.botUsername || "").trim() && !String(current.botKey || "").trim()) {
     return null;
   }
-  const lookup = await requireDependency(deps, "listServerBots")({
-    provider: "telegram",
-    baseURL: flags["base-url"] || deps.defaultSiteURL,
-    timeoutSeconds: intFromRaw(flags["timeout-seconds"], 15) || 15,
-  });
-  if (!lookup?.ok) {
-    return {
-      ok: false,
-      mode: "lookup_error",
-      matchedBy: "",
-      name: "",
-      role: "",
-      roles: [],
-      effectiveRoleProfile: null,
-      effectiveRoleProfiles: {},
-      detail: `server bot lookup unavailable: ${lookup?.error || "unknown error"}`,
-    };
-  }
-  const bots = ensureArray(lookup.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);
   const resolveGroupedPayload = (matches, matchedBy) => {
     const roles = preferredRoleSort(summarizeServerBotRoles(matches));
     return {
@@ -1837,6 +1865,88 @@ async function resolveTelegramServerBindingDetails(envConfig, flags, deps) {
   };
 }
 
+async function resolveTelegramServerBindingDetails(envConfig, flags, deps) {
+  const lookup = await requireDependency(deps, "listServerBots")({
+    provider: "telegram",
+    baseURL: flags["base-url"] || deps.defaultSiteURL,
+    timeoutSeconds: intFromRaw(flags["timeout-seconds"], 15) || 15,
+  });
+  if (!lookup?.ok) {
+    return {
+      ok: false,
+      mode: "lookup_error",
+      matchedBy: "",
+      name: "",
+      role: "",
+      roles: [],
+      effectiveRoleProfile: null,
+      effectiveRoleProfiles: {},
+      detail: `server bot lookup unavailable: ${lookup?.error || "unknown error"}`,
+    };
+  }
+  const bots = ensureArray(lookup.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);
+  return resolveTelegramServerBindingDetailsFromBots(envConfig, bots, deps);
+}
+
+async function buildTelegramEntrySelectionRows(entries, flags, deps) {
+  const listServerBots = requireDependency(deps, "listServerBots");
+  let bots = [];
+  try {
+    const lookup = await listServerBots({
+      provider: "telegram",
+      baseURL: flags["base-url"] || deps.defaultSiteURL,
+      timeoutSeconds: intFromRaw(flags["timeout-seconds"], 15) || 15,
+    });
+    bots = ensureArray(lookup?.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);
+  } catch {
+    bots = [];
+  }
+  return ensureArray(entries).map((entry) => {
+    const current = safeObject(entry);
+    const binding = bots.length
+      ? resolveTelegramServerBindingDetailsFromBots(
+        {
+          serverBotID: current.serverBotID,
+          botUsername: current.username,
+          botKey: current.key,
+          roleProfile: current.roleProfile,
+        },
+        bots,
+        deps,
+      )
+      : null;
+    const serverName = String(binding?.name || "").trim();
+    const singleRole = String(binding?.role || "").trim();
+    const groupedRoles = ensureArray(binding?.roles).filter(Boolean);
+    let label = telegramEntryDisplayName(entry);
+    if (serverName && singleRole) {
+      label = `${serverName} [${singleRole}]`;
+    } else if (serverName && groupedRoles.length) {
+      label = `${serverName} [${groupedRoles.join(", ")}]`;
+    } else if (serverName) {
+      label = serverName;
+    }
+    const descriptionParts = [
+      current.key ? `local:${current.key}` : "",
+      current.serverBotID ? `server:${current.serverBotID}` : "",
+      current.client ? `AI:${current.client}` : "",
+    ].filter(Boolean);
+    return {
+      value: current.key,
+      label: `${label}${current.isDefault ? " [default]" : ""}`,
+      description: descriptionParts.join(" "),
+    };
+  });
+}
+
 function buildTemporaryTelegramEnvConfig({ token, apiBaseURL }) {
   return {
     ok: true,
@@ -2030,8 +2140,8 @@ async function addTelegramBot(ui, flags, deps) {
     : (autoUseServerRoleRouting
       ? getAIModelFlag(flags)
       : (autoApplyRoleDefaults
-        ? firstNonEmptyString([getAIModelFlag(flags), roleProfileDefaults.model])
-        : await promptLine(ui, "AI model", firstNonEmptyString([getAIModelFlag(flags), roleProfileDefaults.model]))));
+        ? await promptAIModel(ui, deps, client, firstNonEmptyString([getAIModelFlag(flags), roleProfileDefaults.model]))
+        : await promptAIModel(ui, deps, client, firstNonEmptyString([getAIModelFlag(flags), roleProfileDefaults.model]))));
   const permissionMode = requireDependency(deps, "normalizeLocalAIPermissionMode")(
     nonInteractive
       ? firstNonEmptyString([getAIPermissionModeFlag(flags), roleProfileDefaults.permissionMode])
@@ -2053,6 +2163,17 @@ async function addTelegramBot(ui, flags, deps) {
     "",
   );
 
+  if (serverGroupMatched) {
+    await maybePromptGroupedServerRoleProfiles(
+      ui,
+      {
+        name: String(serverBot.name || username || botKey).trim(),
+        roles: preferredRoleSort(serverBot.roles),
+      },
+      deps,
+    );
+  }
+
   const nextParsed = upsertTelegramEntry(parsed, {
     key: botKey,
     serverBotID: String(getServerBotIDFlag(flags) || serverBot.botID || "").trim(),
@@ -2125,7 +2246,7 @@ async function editTelegramGlobalSettings(ui, flags, deps) {
       process.stdout.write("No Telegram bot entries exist yet.\n");
       return;
     }
-    const selected = await chooseTelegramEntry(ui, parsed, deps, "Select default Telegram bot");
+    const selected = await chooseTelegramEntry(ui, parsed, deps, "Select default Telegram bot", flags);
     parsed.TELEGRAM_DEFAULT_BOT_KEY = selected.key;
   }
   const filePath = writeProviderEnvState("telegram", parsed, deps);
@@ -2138,7 +2259,7 @@ async function editTelegramBot(ui, flags, deps) {
   const nonInteractive = boolFromRaw(flags["non-interactive"] ?? flags.yes, false);
   const selected = nonInteractive
     ? findTelegramEntryByFlags(parsed, flags, deps)
-    : await chooseTelegramEntry(ui, parsed, deps);
+    : await chooseTelegramEntry(ui, parsed, deps, "Select Telegram bot entry", flags);
   if (!selected) {
     throw new Error("Telegram bot selector is required for non-interactive edit");
   }
@@ -2178,10 +2299,10 @@ async function editTelegramBot(ui, flags, deps) {
   await editTelegramBotGuided(ui, parsed, selected, current, flags, deps);
 }
 
-async function removeTelegramBot(ui, deps) {
+async function removeTelegramBot(ui, flags, deps) {
   const state = loadProviderEnvState("telegram", deps);
   const parsed = { ...state.parsed };
-  const selected = await chooseTelegramEntry(ui, parsed, deps, "Select Telegram bot entry to remove");
+  const selected = await chooseTelegramEntry(ui, parsed, deps, "Select Telegram bot entry to remove", flags);
   if (!selected) return;
   if (!await promptConfirmChoice(ui, `Remove Telegram bot "${selected.key}"?`, {
     confirmLabel: "Remove bot",
@@ -2216,7 +2337,7 @@ async function verifyProviderEntry(ui, provider, flags, deps) {
         botName: requestedBotName,
       };
     } else {
-      const selected = await chooseTelegramEntry(ui, state.parsed, deps, "Select Telegram bot entry to verify");
+      const selected = await chooseTelegramEntry(ui, state.parsed, deps, "Select Telegram bot entry to verify", flags);
       selectors = {
         botKey: selected.key,
         botID: selected.serverBotID,
@@ -2556,7 +2677,7 @@ async function runBotRemove(ui, flags, deps) {
       process.stdout.write(`Removed Telegram bot "${selected.key}" from ${filePath}\n`);
       return;
     }
-    await removeTelegramBot(ui, deps);
+    await removeTelegramBot(ui, flags, deps);
     return;
   }
   await removeTokenOnlyProvider(ui, provider, flags, deps);
@@ -2583,7 +2704,7 @@ async function runBotSetDefault(ui, flags, deps) {
   const nonInteractive = boolFromRaw(flags["non-interactive"] ?? flags.yes, false);
   const selected = nonInteractive
     ? findTelegramEntryByFlags(parsed, flags, deps)
-    : await chooseTelegramEntry(ui, parsed, deps, "Select default Telegram bot");
+    : await chooseTelegramEntry(ui, parsed, deps, "Select default Telegram bot", flags);
   if (!selected) {
     throw new Error("Telegram bot selector is required for set-default");
   }

package/lib/selftest-bot-commands.mjs

@@ -364,14 +364,14 @@ export async function runSelftestBotCommands(push, deps) {
             "3", // select role to edit: worker
             "2", // worker: edit settings
             "3", // worker AI client: claude
-            "worker-sonnet-4",
+            "2", // worker AI model: claude-sonnet-4
             "4", // worker permission: danger_full_access
             "4", // worker reasoning: high
             "y", // edit another role
             "3", // select role to edit: approval
             "2", // approval: edit settings
             "4", // approval AI client: gemini
-            "approval-pro-2",
+            "2", // approval AI model: gemini-2.5-pro
             "4", // approval permission: danger_full_access
             "4", // approval reasoning: high
             "n", // stop editing roles
@@ -390,11 +390,11 @@ export async function runSelftestBotCommands(push, deps) {
       push(
         "bot_edit_grouped_server_roles_updates_role_profiles",
         String(safeObject(safeObject(groupedRunnerConfig.role_profiles || {}).worker).client || "") === "claude"
-          && String(safeObject(safeObject(groupedRunnerConfig.role_profiles || {}).worker).model || "") === "worker-sonnet-4"
+          && String(safeObject(safeObject(groupedRunnerConfig.role_profiles || {}).worker).model || "") === "claude-sonnet-4"
           && String(safeObject(safeObject(groupedRunnerConfig.role_profiles || {}).worker).permission_mode || "") === "danger_full_access"
           && String(safeObject(safeObject(groupedRunnerConfig.role_profiles || {}).worker).reasoning_effort || "") === "high"
           && String(safeObject(safeObject(groupedRunnerConfig.role_profiles || {}).approval).client || "") === "gemini"
-          && String(safeObject(safeObject(groupedRunnerConfig.role_profiles || {}).approval).model || "") === "approval-pro-2",
+          && String(safeObject(safeObject(groupedRunnerConfig.role_profiles || {}).approval).model || "") === "gemini-2.5-pro",
         `worker=${JSON.stringify(safeObject(safeObject(groupedRunnerConfig.role_profiles || {}).worker))} approval=${JSON.stringify(safeObject(safeObject(groupedRunnerConfig.role_profiles || {}).approval))}`,
       );
 
@@ -503,7 +503,7 @@ export async function runSelftestBotCommands(push, deps) {
         "2", // change AI client
         "4", // gemini
         "2", // change AI model
-        "guided-gemini-pro",
+        "2", // gemini model: gemini-2.5-pro
         "2", // change permission mode
         "3", // workspace_write
         "2", // change reasoning effort
@@ -522,7 +522,7 @@ export async function runSelftestBotCommands(push, deps) {
     push(
       "bot_edit_guided_prompts_update_ai_binding_fields",
       String(guidedState.TELEGRAM_BOT_MONITORSELFTESTBOT_AI_CLIENT || "") === "gemini"
-        && String(guidedState.TELEGRAM_BOT_MONITORSELFTESTBOT_AI_MODEL || "") === "guided-gemini-pro"
+        && String(guidedState.TELEGRAM_BOT_MONITORSELFTESTBOT_AI_MODEL || "") === "gemini-2.5-pro"
         && String(guidedState.TELEGRAM_BOT_MONITORSELFTESTBOT_AI_PERMISSION_MODE || "") === "workspace_write"
         && String(guidedState.TELEGRAM_BOT_MONITORSELFTESTBOT_AI_REASONING_EFFORT || "") === "medium",
       `client=${String(guidedState.TELEGRAM_BOT_MONITORSELFTESTBOT_AI_CLIENT || "")} model=${String(guidedState.TELEGRAM_BOT_MONITORSELFTESTBOT_AI_MODEL || "")}`,

package/package.json

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