metheus-governance-mcp-cli 0.2.64 → 0.2.65

package/README.md

@@ -213,6 +213,7 @@ Direct commands:
 metheus-governance-mcp-cli bot list
 metheus-governance-mcp-cli bot show --provider telegram --bot-key main
 metheus-governance-mcp-cli bot add --provider telegram
+metheus-governance-mcp-cli bot edit
 metheus-governance-mcp-cli bot edit --provider telegram
 metheus-governance-mcp-cli bot remove --provider telegram
 metheus-governance-mcp-cli bot set-default --provider telegram --bot-key main
@@ -224,6 +225,8 @@ 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.
+- `bot edit` without flags starts a guided numbered flow: provider -> bot entry -> guided edit -> step-by-step field choices.
 - Telegram supports named local bot entries with:
   - `SERVER_BOT_ID`
   - `USERNAME`
@@ -244,10 +247,10 @@ Non-interactive examples:
 
 ```bash
 metheus-governance-mcp-cli bot global --provider telegram --non-interactive true --api-base-url http://127.0.0.1:8999/telegram --auto-clear-webhook false --allowed-updates message,edited_message,channel_post
-metheus-governance-mcp-cli bot add --provider telegram --non-interactive true --bot-key main --bot-id <server_bot_uuid> --token <telegram_bot_token> --role-profile monitor --client codex --permission-mode read_only --reasoning-effort low --default true
-metheus-governance-mcp-cli bot edit --provider telegram --bot-key main --non-interactive true --client claude --model claude-3.7-sonnet --permission-mode workspace_write --reasoning-effort medium
+metheus-governance-mcp-cli bot add --provider telegram --non-interactive true --bot-key main --server-bot-id <server_bot_uuid> --username <telegram_username> --token <telegram_bot_token> --role-profile monitor --ai-client codex --ai-model gpt-5-codex --ai-permission-mode read_only --ai-reasoning-effort low --default true
+metheus-governance-mcp-cli bot edit --provider telegram --bot-key main --non-interactive true --ai-client claude --ai-model claude-sonnet --ai-permission-mode workspace_write --ai-reasoning-effort medium
 metheus-governance-mcp-cli bot set-default --provider telegram --bot-key main --non-interactive true
-metheus-governance-mcp-cli bot migrate --provider telegram --bot-key main --bot-id <server_bot_uuid> --bot-name <telegram_username> --role-profile monitor --client codex --permission-mode read_only --reasoning-effort low --non-interactive true
+metheus-governance-mcp-cli bot migrate --provider telegram --bot-key main --server-bot-id <server_bot_uuid> --bot-name <telegram_username> --role-profile monitor --ai-client codex --ai-permission-mode read_only --ai-reasoning-effort low --non-interactive true
 metheus-governance-mcp-cli bot remove --provider telegram --bot-key main --non-interactive true
 metheus-governance-mcp-cli bot verify --provider telegram --bot-key main --json true
 ```

package/lib/bot-commands.mjs

@@ -43,6 +43,35 @@ function firstNonEmptyString(values) {
   return "";
 }
 
+function hasOwnFlag(flags, key) {
+  return Object.prototype.hasOwnProperty.call(safeObject(flags), key);
+}
+
+function getServerBotIDFlag(flags) {
+  const parsedFlags = safeObject(flags);
+  return firstNonEmptyString([parsedFlags["server-bot-id"], parsedFlags["bot-id"]]);
+}
+
+function getAIClientFlag(flags) {
+  const parsedFlags = safeObject(flags);
+  return firstNonEmptyString([parsedFlags["ai-client"], parsedFlags.client]);
+}
+
+function getAIModelFlag(flags) {
+  const parsedFlags = safeObject(flags);
+  return firstNonEmptyString([parsedFlags["ai-model"], parsedFlags.model]);
+}
+
+function getAIPermissionModeFlag(flags) {
+  const parsedFlags = safeObject(flags);
+  return firstNonEmptyString([parsedFlags["ai-permission-mode"], parsedFlags["permission-mode"]]);
+}
+
+function getAIReasoningEffortFlag(flags) {
+  const parsedFlags = safeObject(flags);
+  return firstNonEmptyString([parsedFlags["ai-reasoning-effort"], parsedFlags["reasoning-effort"]]);
+}
+
 function maskSecret(rawValue) {
   const text = String(rawValue || "").trim();
   if (!text) return "";
@@ -76,8 +105,8 @@ function printBotUsage(deps) {
       `  ${cliName} bot setup`,
       `  ${cliName} bot list [--provider <telegram|slack|kakaotalk>] [--json <true|false>]`,
       `  ${cliName} bot show [--provider <telegram|slack|kakaotalk>] [--bot-key <key>] [--bot-id <uuid>] [--bot-name <name>] [--json <true|false>]`,
-      `  ${cliName} bot add [--provider <telegram|slack|kakaotalk>] [--non-interactive <true|false>] [--yes <true|false>]`,
-      `  ${cliName} bot edit [--provider <telegram|slack|kakaotalk>] [--non-interactive <true|false>] [--bot-key <key>]`,
+      `  ${cliName} bot add [--provider <telegram|slack|kakaotalk>] [--base-url <url>] [--timeout-seconds <n>] [--non-interactive <true|false>] [--bot-key <key>] [--server-bot-id <uuid>] [--username <name>] [--token <token>] [--role-profile <name>] [--ai-client <name>] [--ai-model <name>] [--ai-permission-mode <mode>] [--ai-reasoning-effort <level>] [--default <true|false>] [--verify <true|false>]`,
+      `  ${cliName} bot edit [--provider <telegram|slack|kakaotalk>] [--base-url <url>] [--timeout-seconds <n>] [--non-interactive <true|false>] [--bot-key <key>] [--server-bot-id <uuid>] [--username <name>] [--token <token>] [--role-profile <name>] [--ai-client <name>] [--ai-model <name>] [--ai-permission-mode <mode>] [--ai-reasoning-effort <level>]`,
       `  ${cliName} bot remove [--provider <telegram|slack|kakaotalk>] [--non-interactive <true|false>] [--bot-key <key>]`,
       `  ${cliName} bot set-default --provider telegram [--bot-key <key>] [--non-interactive <true|false>]`,
       `  ${cliName} bot migrate --provider telegram [--bot-key <key>] [--bot-id <uuid>] [--bot-name <name>] [--keep-legacy-token <true|false>] [--non-interactive <true|false>]`,
@@ -89,6 +118,27 @@ function printBotUsage(deps) {
 }
 
 function createPrompter() {
+  const scriptedPromptAnswersRaw = String(process.env.METHEUS_SCRIPTED_PROMPT_ANSWERS || "").trim();
+  if (scriptedPromptAnswersRaw) {
+    let scriptedAnswers = [];
+    try {
+      const parsed = JSON.parse(scriptedPromptAnswersRaw);
+      scriptedAnswers = ensureArray(parsed).map((value) => String(value ?? ""));
+    } catch {
+      scriptedAnswers = scriptedPromptAnswersRaw.split(/\r?\n/).map((value) => String(value ?? ""));
+    }
+    let answerIndex = 0;
+    return {
+      ask(promptText) {
+        process.stdout.write(promptText);
+        const answer = answerIndex < scriptedAnswers.length ? scriptedAnswers[answerIndex] : "";
+        answerIndex += 1;
+        process.stdout.write(`${answer}\n`);
+        return Promise.resolve(String(answer || ""));
+      },
+      close() {},
+    };
+  }
   return {
     ask(promptText) {
       return new Promise((resolve) => {
@@ -163,6 +213,19 @@ async function promptChoice(ui, title, options, { defaultIndex = 0, allowCancel
   }
 }
 
+async function promptKeepChangeClear(ui, title, { allowClear = true, defaultValue = "keep" } = {}) {
+  const options = [
+    { value: "keep", label: "Keep current value" },
+    { value: "change", label: "Change value" },
+  ];
+  if (allowClear) {
+    options.push({ value: "clear", label: "Clear value" });
+  }
+  const defaultIndex = Math.max(0, options.findIndex((option) => option.value === defaultValue));
+  const selected = await promptChoice(ui, title, options, { defaultIndex });
+  return selected?.value || "keep";
+}
+
 function loadProviderEnvState(provider, deps) {
   const ensureTemplate = requireDependency(deps, "ensureProviderEnvTemplate");
   const filePathResolver = requireDependency(deps, "providerEnvFilePath");
@@ -399,6 +462,175 @@ function findTelegramEntryByFlags(parsedEnv, flags, deps) {
   return null;
 }
 
+function saveTelegramBotEdit(parsed, selected, current, deps) {
+  let nextParsed = parsed;
+  if (current.key !== selected.key) {
+    nextParsed = removeTelegramEntry(nextParsed, selected.key);
+  }
+  nextParsed = upsertTelegramEntry(nextParsed, current);
+  if (String(parsed.TELEGRAM_DEFAULT_BOT_KEY || "").trim() === selected.key) {
+    nextParsed.TELEGRAM_DEFAULT_BOT_KEY = current.key;
+  }
+  const filePath = writeProviderEnvState("telegram", nextParsed, deps);
+  process.stdout.write(`Saved Telegram bot entry "${current.key}" to ${filePath}\n`);
+  return filePath;
+}
+
+async function editTelegramBotGuided(ui, parsed, selected, current, flags, deps) {
+  const bindingAction = await promptKeepChangeClear(ui, "Server bot binding", {
+    allowClear: true,
+    defaultValue: current.serverBotID ? "keep" : "change",
+  });
+  if (bindingAction === "change") {
+    const serverBot = await chooseServerBot(
+      ui,
+      "telegram",
+      flags["base-url"] || deps.defaultSiteURL,
+      intFromRaw(flags["timeout-seconds"], 15) || 15,
+      deps,
+    );
+    current.serverBotID = serverBot.botID;
+    if (!current.roleProfile && serverBot.role) {
+      current.roleProfile = serverBot.role;
+    }
+  } else if (bindingAction === "clear") {
+    current.serverBotID = "";
+  }
+
+  const usernameAction = await promptKeepChangeClear(ui, "Telegram username", {
+    allowClear: true,
+    defaultValue: current.username ? "keep" : "change",
+  });
+  if (usernameAction === "change") {
+    current.username = requireDependency(deps, "normalizeTelegramBotUsername")(
+      await promptRequiredLine(ui, "Telegram username (without @)", current.username),
+      "",
+    );
+  } else if (usernameAction === "clear") {
+    current.username = "";
+  }
+
+  const tokenAction = await promptKeepChangeClear(ui, "Telegram token", {
+    allowClear: false,
+    defaultValue: "keep",
+  });
+  if (tokenAction === "change") {
+    current.token = await promptRequiredLine(ui, "Telegram bot token", current.token);
+    if (await promptYesNo(ui, "Verify updated token now?", true)) {
+      const verifyResult = await verifyTelegramTokenCandidate(
+        "telegram",
+        current.token,
+        String(parsed.TELEGRAM_API_BASE_URL || "").trim(),
+        intFromRaw(flags["timeout-seconds"], 15) || 15,
+        deps,
+      );
+      process.stdout.write(`Verify: ${verifyResult.ok ? "OK" : "FAIL"}${verifyResult.detail ? ` - ${verifyResult.detail}` : ""}\n`);
+      const maybeUsername = extractVerifiedTelegramUsername(verifyResult.detail);
+      if (verifyResult.ok && maybeUsername && !current.username) {
+        current.username = maybeUsername;
+      }
+    }
+  }
+
+  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),
+    );
+  } 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 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 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", {
+    allowClear: false,
+    defaultValue: "keep",
+  });
+  if (botKeyAction === "change") {
+    const normalizeBotKey = requireDependency(deps, "normalizeTelegramBotEnvKey");
+    let nextKey = normalizeBotKey(await promptRequiredLine(ui, "Local bot key", current.key), current.key);
+    const existing = new Set(telegramEntriesForDisplay(parsed, deps).map((entry) => entry.key).filter((key) => key !== current.key));
+    while (existing.has(nextKey)) {
+      process.stdout.write(`Telegram bot key "${nextKey}" already exists.\n`);
+      nextKey = normalizeBotKey(await promptRequiredLine(ui, "Local bot key", `${nextKey}_2`), `${nextKey}_2`);
+    }
+    current.key = nextKey;
+  }
+
+  const defaultChoice = await promptChoice(
+    ui,
+    "Default Telegram bot setting",
+    [
+      { value: "keep", label: "Keep current default setting", description: String(parsed.TELEGRAM_DEFAULT_BOT_KEY || "").trim() === selected.key ? "currently default" : "not default" },
+      { value: "set", label: "Set this bot as default" },
+      { value: "unset", label: "Do not make this bot default" },
+    ],
+    { defaultIndex: 0 },
+  );
+  if (defaultChoice?.value === "set") {
+    parsed.TELEGRAM_DEFAULT_BOT_KEY = current.key;
+  } else if (defaultChoice?.value === "unset" && String(parsed.TELEGRAM_DEFAULT_BOT_KEY || "").trim() === selected.key) {
+    parsed.TELEGRAM_DEFAULT_BOT_KEY = "";
+  }
+
+  if (!await promptYesNo(ui, `Save changes for "${current.key}" now?`, true)) {
+    process.stdout.write("Cancelled.\n");
+    return;
+  }
+  saveTelegramBotEdit(parsed, selected, current, deps);
+}
+
 async function selectProvider(ui, initialProvider, deps) {
   const normalizeProvider = requireDependency(deps, "normalizeBotProvider");
   const provider = String(initialProvider || "").trim();
@@ -708,7 +940,7 @@ async function addTelegramBot(ui, flags, deps) {
   const nonInteractive = boolFromRaw(flags["non-interactive"] ?? flags.yes, false);
   const serverBot = nonInteractive
     ? {
-      botID: String(flags["server-bot-id"] || flags["bot-id"] || "").trim(),
+      botID: getServerBotIDFlag(flags),
       role: String(flags.role || "").trim(),
       name: "",
     }
@@ -783,27 +1015,27 @@ async function addTelegramBot(ui, flags, deps) {
   );
   const client = requireDependency(deps, "normalizeLocalAIClientName")(
     nonInteractive
-      ? String(flags.client || "").trim()
-      : await promptAIClient(ui, deps, flags.client || ""),
+      ? getAIClientFlag(flags)
+      : await promptAIClient(ui, deps, getAIClientFlag(flags)),
     "",
   );
-  const model = nonInteractive ? String(flags.model || "").trim() : await promptLine(ui, "AI model", String(flags.model || "").trim());
+  const model = nonInteractive ? getAIModelFlag(flags) : await promptLine(ui, "AI model", getAIModelFlag(flags));
   const permissionMode = requireDependency(deps, "normalizeLocalAIPermissionMode")(
     nonInteractive
-      ? String(flags["permission-mode"] || "").trim()
-      : await promptPermissionMode(ui, String(flags["permission-mode"] || "").trim()),
+      ? getAIPermissionModeFlag(flags)
+      : await promptPermissionMode(ui, getAIPermissionModeFlag(flags)),
     "",
   );
   const reasoningEffort = requireDependency(deps, "normalizeLocalAIReasoningEffort")(
     nonInteractive
-      ? String(flags["reasoning-effort"] || "").trim()
-      : await promptReasoningEffort(ui, String(flags["reasoning-effort"] || "").trim()),
+      ? getAIReasoningEffortFlag(flags)
+      : await promptReasoningEffort(ui, getAIReasoningEffortFlag(flags)),
     "",
   );
 
   const nextParsed = upsertTelegramEntry(parsed, {
     key: botKey,
-    serverBotID: String(flags["server-bot-id"] || serverBot.botID || "").trim(),
+    serverBotID: String(getServerBotIDFlag(flags) || serverBot.botID || "").trim(),
     username,
     token,
     roleProfile,
@@ -888,8 +1120,8 @@ async function editTelegramBot(ui, flags, deps) {
   }
   let current = { ...selected };
   if (nonInteractive) {
-    if (flags["server-bot-id"] || flags["bot-id"]) {
-      current.serverBotID = String(flags["server-bot-id"] || flags["bot-id"] || "").trim();
+    if (getServerBotIDFlag(flags)) {
+      current.serverBotID = getServerBotIDFlag(flags);
     }
     if (Object.prototype.hasOwnProperty.call(flags, "username")) {
       current.username = requireDependency(deps, "normalizeTelegramBotUsername")(flags.username || "");
@@ -900,25 +1132,35 @@ async function editTelegramBot(ui, flags, deps) {
     if (Object.prototype.hasOwnProperty.call(flags, "role-profile")) {
       current.roleProfile = requireDependency(deps, "normalizeRunnerRoleProfileName")(flags["role-profile"] || "");
     }
-    if (Object.prototype.hasOwnProperty.call(flags, "client")) {
-      current.client = requireDependency(deps, "normalizeLocalAIClientName")(flags.client || "", "");
+    if (hasOwnFlag(flags, "client") || hasOwnFlag(flags, "ai-client")) {
+      current.client = requireDependency(deps, "normalizeLocalAIClientName")(getAIClientFlag(flags), "");
     }
-    if (Object.prototype.hasOwnProperty.call(flags, "model")) {
-      current.model = String(flags.model || "").trim();
+    if (hasOwnFlag(flags, "model") || hasOwnFlag(flags, "ai-model")) {
+      current.model = getAIModelFlag(flags);
     }
-    if (Object.prototype.hasOwnProperty.call(flags, "permission-mode")) {
-      current.permissionMode = requireDependency(deps, "normalizeLocalAIPermissionMode")(flags["permission-mode"] || "", "");
+    if (hasOwnFlag(flags, "permission-mode") || hasOwnFlag(flags, "ai-permission-mode")) {
+      current.permissionMode = requireDependency(deps, "normalizeLocalAIPermissionMode")(getAIPermissionModeFlag(flags), "");
     }
-    if (Object.prototype.hasOwnProperty.call(flags, "reasoning-effort")) {
-      current.reasoningEffort = requireDependency(deps, "normalizeLocalAIReasoningEffort")(flags["reasoning-effort"] || "", "");
+    if (hasOwnFlag(flags, "reasoning-effort") || hasOwnFlag(flags, "ai-reasoning-effort")) {
+      current.reasoningEffort = requireDependency(deps, "normalizeLocalAIReasoningEffort")(getAIReasoningEffortFlag(flags), "");
     }
     if (boolFromRaw(flags.default, false)) {
       parsed.TELEGRAM_DEFAULT_BOT_KEY = current.key;
     }
-    let nextParsed = parsed;
-    nextParsed = upsertTelegramEntry(nextParsed, current);
-    const filePath = writeProviderEnvState("telegram", nextParsed, deps);
-    process.stdout.write(`Saved Telegram bot entry "${current.key}" to ${filePath}\n`);
+    saveTelegramBotEdit(parsed, selected, current, deps);
+    return;
+  }
+  const editMode = await promptChoice(
+    ui,
+    `How do you want to edit Telegram bot "${current.key}"?`,
+    [
+      { value: "guided", label: "Guided edit (Recommended)", description: "Step-by-step prompts with numbered choices" },
+      { value: "field_menu", label: "Field menu", description: "Choose one field at a time until save" },
+    ],
+    { defaultIndex: 0 },
+  );
+  if (editMode?.value === "guided") {
+    await editTelegramBotGuided(ui, parsed, selected, current, flags, deps);
     return;
   }
   while (true) {
@@ -942,16 +1184,7 @@ async function editTelegramBot(ui, flags, deps) {
     );
     if (!choice) return;
     if (choice.value === "save") {
-      let nextParsed = parsed;
-      if (current.key !== selected.key) {
-        nextParsed = removeTelegramEntry(nextParsed, selected.key);
-      }
-      nextParsed = upsertTelegramEntry(nextParsed, current);
-      if (String(parsed.TELEGRAM_DEFAULT_BOT_KEY || "").trim() === selected.key) {
-        nextParsed.TELEGRAM_DEFAULT_BOT_KEY = current.key;
-      }
-      const filePath = writeProviderEnvState("telegram", nextParsed, deps);
-      process.stdout.write(`Saved Telegram bot entry "${current.key}" to ${filePath}\n`);
+      saveTelegramBotEdit(parsed, selected, current, deps);
       return;
     }
     if (choice.value === "server_bot_id") {
@@ -1410,14 +1643,14 @@ async function runBotMigrate(ui, flags, deps) {
   }
   const nextParsed = upsertTelegramEntry(parsed, {
     key: botKey,
-    serverBotID: String(flags["server-bot-id"] || flags["bot-id"] || "").trim(),
+    serverBotID: getServerBotIDFlag(flags),
     username: requireDependency(deps, "normalizeTelegramBotUsername")(flags["bot-name"] || flags.username || ""),
     token: legacyToken,
     roleProfile: requireDependency(deps, "normalizeRunnerRoleProfileName")(flags["role-profile"] || ""),
-    client: requireDependency(deps, "normalizeLocalAIClientName")(flags.client || "", ""),
-    model: String(flags.model || "").trim(),
-    permissionMode: requireDependency(deps, "normalizeLocalAIPermissionMode")(flags["permission-mode"] || "", ""),
-    reasoningEffort: requireDependency(deps, "normalizeLocalAIReasoningEffort")(flags["reasoning-effort"] || "", ""),
+    client: requireDependency(deps, "normalizeLocalAIClientName")(getAIClientFlag(flags), ""),
+    model: getAIModelFlag(flags),
+    permissionMode: requireDependency(deps, "normalizeLocalAIPermissionMode")(getAIPermissionModeFlag(flags), ""),
+    reasoningEffort: requireDependency(deps, "normalizeLocalAIReasoningEffort")(getAIReasoningEffortFlag(flags), ""),
   });
   if (!hasNamedTelegramEntry(parsed, deps) || !String(nextParsed.TELEGRAM_DEFAULT_BOT_KEY || "").trim()) {
     nextParsed.TELEGRAM_DEFAULT_BOT_KEY = botKey;

package/lib/selftest-bot-commands.mjs

@@ -225,29 +225,36 @@ export async function runSelftestBotCommands(push, deps) {
       cliPath,
       args: [
         "bot", "add",
-        "--provider", "telegram",
-        "--non-interactive", "true",
         "--base-url", baseURL,
         "--timeout-seconds", "5",
-        "--bot-key", "main_test",
-        "--bot-id", mock.bots[0].id,
-        "--token", "selftest-main-token",
-        "--role-profile", "monitor",
-        "--client", "codex",
-        "--permission-mode", "read_only",
-        "--reasoning-effort", "low",
-        "--default", "true",
-        "--verify", "true",
       ],
-      env,
+      env: {
+        ...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
+          "3", // role profile: monitor
+          "2", // ai client: codex
+          "gpt-5-codex",
+          "2", // permission: read_only
+          "2", // reasoning: low
+          "y", // set as default
+        ]),
+      },
     });
     const addState = parseSimpleEnvText(fs.readFileSync(telegramEnvPath, "utf8"));
     push(
-      "bot_add_creates_named_telegram_entry",
+      "bot_add_guided_creates_named_telegram_entry",
       String(addState.TELEGRAM_BOT_MAIN_TEST_SERVER_BOT_ID || "") === mock.bots[0].id
+        && String(addState.TELEGRAM_BOT_MAIN_TEST_USERNAME || "").trim().toLowerCase() === "monitorselftestbot"
         && String(addState.TELEGRAM_BOT_MAIN_TEST_AI_CLIENT || "") === "codex"
+        && String(addState.TELEGRAM_BOT_MAIN_TEST_AI_MODEL || "") === "gpt-5-codex"
         && String(addState.TELEGRAM_DEFAULT_BOT_KEY || "") === "main_test",
-      `default=${String(addState.TELEGRAM_DEFAULT_BOT_KEY || "")} client=${String(addState.TELEGRAM_BOT_MAIN_TEST_AI_CLIENT || "")}`,
+      `default=${String(addState.TELEGRAM_DEFAULT_BOT_KEY || "")} client=${String(addState.TELEGRAM_BOT_MAIN_TEST_AI_CLIENT || "")} model=${String(addState.TELEGRAM_BOT_MAIN_TEST_AI_MODEL || "")}`,
     );
 
     const showResult = await runCLI({
@@ -268,6 +275,43 @@ export async function runSelftestBotCommands(push, deps) {
       `key=${String(safeObject(showPayload.entry).key || "")} client=${String(safeObject(showPayload.entry).client || "")}`,
     );
 
+    await runCLI({
+      cliPath,
+      args: ["bot", "edit"],
+      env: {
+        ...env,
+        METHEUS_SCRIPTED_PROMPT_ANSWERS: JSON.stringify([
+        "1", // provider: telegram
+        "1", // bot entry: main_test
+        "1", // edit mode: guided
+        "1", // keep server bot binding
+        "1", // keep username
+        "1", // keep token
+        "1", // keep role profile
+        "2", // change AI client
+        "4", // gemini
+        "2", // change AI model
+        "guided-gemini-pro",
+        "2", // change permission mode
+        "3", // workspace_write
+        "2", // change reasoning effort
+        "3", // medium
+        "1", // keep bot key
+        "1", // keep default setting
+        "y", // save
+        ]),
+      },
+    });
+    const guidedState = parseSimpleEnvText(fs.readFileSync(telegramEnvPath, "utf8"));
+    push(
+      "bot_edit_guided_prompts_update_ai_binding_fields",
+      String(guidedState.TELEGRAM_BOT_MAIN_TEST_AI_CLIENT || "") === "gemini"
+        && String(guidedState.TELEGRAM_BOT_MAIN_TEST_AI_MODEL || "") === "guided-gemini-pro"
+        && String(guidedState.TELEGRAM_BOT_MAIN_TEST_AI_PERMISSION_MODE || "") === "workspace_write"
+        && String(guidedState.TELEGRAM_BOT_MAIN_TEST_AI_REASONING_EFFORT || "") === "medium",
+      `client=${String(guidedState.TELEGRAM_BOT_MAIN_TEST_AI_CLIENT || "")} model=${String(guidedState.TELEGRAM_BOT_MAIN_TEST_AI_MODEL || "")}`,
+    );
+
     await runCLI({
       cliPath,
       args: [
@@ -359,6 +403,49 @@ export async function runSelftestBotCommands(push, deps) {
       `entries=${String(ensureArray(telegramEntry.entries).length)}`,
     );
 
+    await runCLI({
+      cliPath,
+      args: [
+        "bot", "add",
+        "--provider", "telegram",
+        "--non-interactive", "true",
+        "--base-url", baseURL,
+        "--timeout-seconds", "5",
+        "--bot-key", "explicit_test",
+        "--server-bot-id", mock.bots[0].id,
+        "--username", "MonitorSelftestBot",
+        "--token", "selftest-main-token",
+        "--role-profile", "monitor",
+        "--ai-client", "codex",
+        "--ai-model", "gpt-5-codex",
+        "--ai-permission-mode", "read_only",
+        "--ai-reasoning-effort", "low",
+        "--verify", "true",
+      ],
+      env,
+    });
+    const aliasAddState = parseSimpleEnvText(fs.readFileSync(telegramEnvPath, "utf8"));
+    push(
+      "bot_add_accepts_ai_prefixed_option_aliases",
+      String(aliasAddState.TELEGRAM_BOT_EXPLICIT_TEST_SERVER_BOT_ID || "") === mock.bots[0].id
+        && String(aliasAddState.TELEGRAM_BOT_EXPLICIT_TEST_AI_CLIENT || "") === "codex"
+        && String(aliasAddState.TELEGRAM_BOT_EXPLICIT_TEST_AI_MODEL || "") === "gpt-5-codex"
+        && String(aliasAddState.TELEGRAM_BOT_EXPLICIT_TEST_AI_PERMISSION_MODE || "") === "read_only"
+        && String(aliasAddState.TELEGRAM_BOT_EXPLICIT_TEST_AI_REASONING_EFFORT || "") === "low",
+      `client=${String(aliasAddState.TELEGRAM_BOT_EXPLICIT_TEST_AI_CLIENT || "")} model=${String(aliasAddState.TELEGRAM_BOT_EXPLICIT_TEST_AI_MODEL || "")}`,
+    );
+
+    await runCLI({
+      cliPath,
+      args: [
+        "bot", "remove",
+        "--provider", "telegram",
+        "--bot-key", "explicit_test",
+        "--non-interactive", "true",
+      ],
+      env,
+    });
+
     const migratedEnv = parseSimpleEnvText(fs.readFileSync(telegramEnvPath, "utf8"));
     migratedEnv.TELEGRAM_BOT_TOKEN = "legacy-selftest-token";
     fs.writeFileSync(

package/package.json

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