metheus-governance-mcp-cli 0.2.100 → 0.2.101

package/cli.mjs

@@ -2684,12 +2684,35 @@ function parseTelegramAllowedUpdates(rawValue) {
   return Array.from(new Set(values));
 }
 
+function preferredTelegramServerRoleSort(roles) {
+  const order = ["monitor", "review", "worker", "approval"];
+  return ensureArray(roles).slice().sort((left, right) => {
+    const leftText = String(left || "").trim();
+    const rightText = String(right || "").trim();
+    const leftIndex = order.indexOf(leftText);
+    const rightIndex = order.indexOf(rightText);
+    if (leftIndex >= 0 && rightIndex >= 0) return leftIndex - rightIndex;
+    if (leftIndex >= 0) return -1;
+    if (rightIndex >= 0) return 1;
+    return leftText.localeCompare(rightText);
+  });
+}
+
+function parseTelegramServerRoles(rawValue) {
+  const values = String(rawValue || "")
+    .split(",")
+    .map((value) => String(value || "").trim())
+    .filter(Boolean);
+  if (!values.length) return [];
+  return Array.from(new Set(preferredTelegramServerRoleSort(values)));
+}
+
 function collectTelegramEnvBotEntries(parsedEnv) {
   const parsed = safeObject(parsedEnv);
   const entries = new Map();
   for (const [rawKey, rawValue] of Object.entries(parsed)) {
     const match = String(rawKey || "").trim().match(
-      /^TELEGRAM_BOT_([A-Z0-9_]+)_(TOKEN|USERNAME|SERVER_BOT_ID|ROLE_PROFILE|AI_CLIENT|AI_MODEL|AI_PERMISSION_MODE|AI_REASONING_EFFORT)$/i,
+      /^TELEGRAM_BOT_([A-Z0-9_]+)_(TOKEN|USERNAME|SERVER_BOT_ID|SERVER_NAME|SERVER_ROLES|ROLE_PROFILE|AI_CLIENT|AI_MODEL|AI_PERMISSION_MODE|AI_REASONING_EFFORT)$/i,
     );
     if (!match) continue;
     const botKey = normalizeTelegramBotEnvKey(match[1], "");
@@ -2700,6 +2723,8 @@ function collectTelegramEnvBotEntries(parsedEnv) {
       token: "",
       username: "",
       serverBotID: "",
+      serverBotName: "",
+      serverRoles: [],
       roleProfile: "",
       client: "",
       model: "",
@@ -2713,6 +2738,10 @@ function collectTelegramEnvBotEntries(parsedEnv) {
       entry.username = normalizeTelegramBotUsername(textValue);
     } else if (field === "SERVER_BOT_ID") {
       entry.serverBotID = textValue;
+    } else if (field === "SERVER_NAME") {
+      entry.serverBotName = textValue;
+    } else if (field === "SERVER_ROLES") {
+      entry.serverRoles = parseTelegramServerRoles(textValue);
     } else if (field === "ROLE_PROFILE") {
       entry.roleProfile = normalizeRunnerRoleProfileName(textValue);
     } else if (field === "AI_CLIENT") {
@@ -2738,6 +2767,8 @@ function collectTelegramEnvBotEntries(parsedEnv) {
 
 function telegramBotEntryDisplayNameForState(entry) {
   const current = safeObject(entry);
+  const serverBotName = String(current.serverBotName || "").trim();
+  if (serverBotName) return serverBotName;
   const username = normalizeTelegramBotUsername(current.username || "");
   if (username) return username;
   return normalizeTelegramBotEnvKey(current.key || "", "telegram_bot");
@@ -2752,6 +2783,8 @@ function parseTelegramBotEntryFile(filePath) {
     key: keyFromName || keyFromFile,
     username: normalizeTelegramBotUsername(parsed.TELEGRAM_BOT_NAME || parsed.TELEGRAM_BOT_USERNAME || ""),
     serverBotID: String(parsed.TELEGRAM_BOT_SERVER_BOT_ID || "").trim(),
+    serverBotName: String(parsed.TELEGRAM_BOT_SERVER_NAME || "").trim(),
+    serverRoles: parseTelegramServerRoles(parsed.TELEGRAM_BOT_SERVER_ROLES || ""),
     token: String(parsed.TELEGRAM_BOT_TOKEN || "").trim(),
     roleProfile: normalizeRunnerRoleProfileName(parsed.TELEGRAM_BOT_ROLE_PROFILE || ""),
     client: normalizeLocalAIClientName(parsed.TELEGRAM_BOT_AI_CLIENT || "", ""),
@@ -2813,6 +2846,8 @@ function buildMergedTelegramEnvParsed(globalParsed, entries) {
     const upper = String(entry.key || "").trim().toUpperCase();
     if (!upper) return;
     merged[`TELEGRAM_BOT_${upper}_SERVER_BOT_ID`] = String(entry.serverBotID || "").trim();
+    merged[`TELEGRAM_BOT_${upper}_SERVER_NAME`] = String(entry.serverBotName || "").trim();
+    merged[`TELEGRAM_BOT_${upper}_SERVER_ROLES`] = ensureArray(entry.serverRoles).join(",");
     merged[`TELEGRAM_BOT_${upper}_USERNAME`] = normalizeTelegramBotUsername(entry.username || "");
     merged[`TELEGRAM_BOT_${upper}_TOKEN`] = String(entry.token || "").trim();
     merged[`TELEGRAM_BOT_${upper}_ROLE_PROFILE`] = String(entry.roleProfile || "").trim();
@@ -2874,12 +2909,14 @@ function readTelegramEnvState() {
 }
 
 function isTelegramEntryEnvKey(rawKey) {
-  return /^TELEGRAM_BOT_([A-Z0-9_]+)_(TOKEN|USERNAME|SERVER_BOT_ID|ROLE_PROFILE|AI_CLIENT|AI_MODEL|AI_PERMISSION_MODE|AI_REASONING_EFFORT)$/i
+  return /^TELEGRAM_BOT_([A-Z0-9_]+)_(TOKEN|USERNAME|SERVER_BOT_ID|SERVER_NAME|SERVER_ROLES|ROLE_PROFILE|AI_CLIENT|AI_MODEL|AI_PERMISSION_MODE|AI_REASONING_EFFORT)$/i
     .test(String(rawKey || "").trim());
 }
 
 function telegramEntryCommentNameForEnv(entry) {
   const current = safeObject(entry);
+  const serverBotName = String(current.serverBotName || "").trim();
+  if (serverBotName) return serverBotName;
   const username = normalizeTelegramBotUsername(current.username || "");
   if (username) return username;
   return normalizeTelegramBotEnvKey(current.key || "", "telegram_bot");
@@ -2930,12 +2967,15 @@ function renderNormalizedTelegramEnv(parsedEnv) {
 function renderTelegramBotEntryEnv(entryRaw) {
   const entry = safeObject(entryRaw);
   const botName = telegramEntryCommentNameForEnv(entry);
+  const serverRoles = parseTelegramServerRoles(entry.serverRoles || "");
   const lines = [
     "# Metheus local Telegram bot entry",
     `# Bot: ${botName}`,
     "",
     `TELEGRAM_BOT_NAME=${formatProviderEnvValue(botName)}`,
     `TELEGRAM_BOT_SERVER_BOT_ID=${formatProviderEnvValue(entry.serverBotID || "")}`,
+    `TELEGRAM_BOT_SERVER_NAME=${formatProviderEnvValue(entry.serverBotName || "")}`,
+    `TELEGRAM_BOT_SERVER_ROLES=${formatProviderEnvValue(serverRoles.join(","))}`,
     `TELEGRAM_BOT_TOKEN=${formatProviderEnvValue(entry.token || "")}`,
     `TELEGRAM_BOT_ROLE_PROFILE=${formatProviderEnvValue(entry.roleProfile || "")}`,
     `TELEGRAM_BOT_AI_CLIENT=${formatProviderEnvValue(entry.client || "")}`,
@@ -2954,6 +2994,8 @@ function writeTelegramEnvState(parsedEnv) {
       entry.token
       || entry.username
       || entry.serverBotID
+      || entry.serverBotName
+      || ensureArray(entry.serverRoles).length
       || entry.roleProfile
       || entry.client
       || entry.model
@@ -3009,7 +3051,13 @@ function normalizeExistingProviderEnvFile(provider, filePath) {
 function resolveTelegramEnvConfig(parsedEnv, filePath, config, selectors = {}) {
   const parsed = safeObject(parsedEnv);
   const legacyToken = String(parsed.TELEGRAM_BOT_TOKEN || "").trim();
-  const entries = collectTelegramEnvBotEntries(parsed).filter((entry) => entry.token || entry.username || entry.serverBotID);
+  const entries = collectTelegramEnvBotEntries(parsed).filter((entry) => (
+    entry.token
+    || entry.username
+    || entry.serverBotID
+    || entry.serverBotName
+    || ensureArray(entry.serverRoles).length
+  ));
   const desiredBotID = firstNonEmptyString([
     selectors.serverBotID,
     selectors.botID,
@@ -3037,7 +3085,11 @@ function resolveTelegramEnvConfig(parsedEnv, filePath, config, selectors = {}) {
   }
   if (!selected && desiredUsername) {
     selected = entries.find(
-      (entry) => entry.username === desiredUsername || normalizeTelegramBotUsername(entry.key) === desiredUsername,
+      (entry) => (
+        entry.username === desiredUsername
+        || normalizeTelegramBotUsername(entry.serverBotName) === desiredUsername
+        || normalizeTelegramBotUsername(entry.key) === desiredUsername
+      ),
     ) || null;
   }
   if (!selected && desiredBotKey) {
@@ -3071,6 +3123,8 @@ function resolveTelegramEnvConfig(parsedEnv, filePath, config, selectors = {}) {
       botKey: selected.key,
       botUsername: selected.username,
       serverBotID: selected.serverBotID,
+      serverBotName: selected.serverBotName,
+      serverRoles: ensureArray(selected.serverRoles),
       roleProfile: selected.roleProfile,
       client: selected.client,
       model: selected.model,
@@ -3095,6 +3149,8 @@ function resolveTelegramEnvConfig(parsedEnv, filePath, config, selectors = {}) {
       botKey: "",
       botUsername: "",
       serverBotID: "",
+      serverBotName: "",
+      serverRoles: [],
       roleProfile: "",
       client: "",
       model: "",

package/lib/bot-commands.mjs

@@ -442,6 +442,8 @@ function telegramEntryEnvKeys(botKey) {
   const upper = String(botKey || "").trim().toUpperCase();
   return {
     serverBotID: `TELEGRAM_BOT_${upper}_SERVER_BOT_ID`,
+    serverBotName: `TELEGRAM_BOT_${upper}_SERVER_NAME`,
+    serverRoles: `TELEGRAM_BOT_${upper}_SERVER_ROLES`,
     username: `TELEGRAM_BOT_${upper}_USERNAME`,
     token: `TELEGRAM_BOT_${upper}_TOKEN`,
     roleProfile: `TELEGRAM_BOT_${upper}_ROLE_PROFILE`,
@@ -454,6 +456,8 @@ function telegramEntryEnvKeys(botKey) {
 
 function telegramEntryCommentName(entry) {
   const current = safeObject(entry);
+  const serverBotName = String(current.serverBotName || "").trim();
+  if (serverBotName) return serverBotName;
   const username = String(current.username || "").trim();
   if (username) return username;
   const key = String(current.key || "").trim();
@@ -486,6 +490,8 @@ function upsertTelegramEntry(parsedEnv, entry) {
   const keys = telegramEntryEnvKeys(entry.key);
   const next = { ...parsed };
   next[keys.serverBotID] = String(entry.serverBotID || "").trim();
+  next[keys.serverBotName] = String(entry.serverBotName || "").trim();
+  next[keys.serverRoles] = ensureArray(entry.serverRoles).join(",");
   next[keys.username] = persistTelegramUsername(entry);
   next[keys.token] = String(entry.token || "").trim();
   next[keys.roleProfile] = String(entry.roleProfile || "").trim();
@@ -512,7 +518,7 @@ function telegramKnownKeys(parsedEnv, deps) {
 }
 
 function isTelegramEntryEnvKey(rawKey) {
-  return /^TELEGRAM_BOT_([A-Z0-9_]+)_(TOKEN|USERNAME|SERVER_BOT_ID|ROLE_PROFILE|AI_CLIENT|AI_MODEL|AI_PERMISSION_MODE|AI_REASONING_EFFORT)$/i
+  return /^TELEGRAM_BOT_([A-Z0-9_]+)_(TOKEN|USERNAME|SERVER_BOT_ID|SERVER_NAME|SERVER_ROLES|ROLE_PROFILE|AI_CLIENT|AI_MODEL|AI_PERMISSION_MODE|AI_REASONING_EFFORT)$/i
     .test(String(rawKey || "").trim());
 }
 
@@ -525,6 +531,8 @@ function renderTelegramEnv(parsedEnv, deps) {
       entry.token
       || entry.username
       || entry.serverBotID
+      || entry.serverBotName
+      || ensureArray(entry.serverRoles).length
       || entry.roleProfile
       || entry.client
       || entry.model
@@ -562,6 +570,8 @@ function renderTelegramEnv(parsedEnv, deps) {
       const entryLines = [
         `# Telegram bot entry: ${telegramEntryCommentName(entry)}`,
         `${keys.serverBotID}=${formatEnvValue(entry.serverBotID || "")}`,
+        `${keys.serverBotName}=${formatEnvValue(entry.serverBotName || "")}`,
+        `${keys.serverRoles}=${formatEnvValue(ensureArray(entry.serverRoles).join(","))}`,
       ];
       if (String(entry.username || "").trim()) {
         entryLines.push(`${keys.username}=${formatEnvValue(entry.username || "")}`);
@@ -615,6 +625,39 @@ function renderTokenOnlyProviderEnv(provider, parsedEnv, deps) {
   return `${lines.join("\n").trimEnd()}\n`;
 }
 
+function renderTelegramBotEntryFile(entryRaw) {
+  const entry = safeObject(entryRaw);
+  const botName = telegramEntryCommentName(entry);
+  const serverRoles = ensureArray(entry.serverRoles).join(",");
+  const lines = [
+    "# Metheus local Telegram bot entry",
+    `# Bot: ${botName}`,
+    "",
+    `TELEGRAM_BOT_NAME=${formatEnvValue(botName)}`,
+    `TELEGRAM_BOT_SERVER_BOT_ID=${formatEnvValue(entry.serverBotID || "")}`,
+    `TELEGRAM_BOT_SERVER_NAME=${formatEnvValue(entry.serverBotName || "")}`,
+    `TELEGRAM_BOT_SERVER_ROLES=${formatEnvValue(serverRoles)}`,
+    `TELEGRAM_BOT_TOKEN=${formatEnvValue(entry.token || "")}`,
+    `TELEGRAM_BOT_ROLE_PROFILE=${formatEnvValue(entry.roleProfile || "")}`,
+    `TELEGRAM_BOT_AI_CLIENT=${formatEnvValue(entry.client || "")}`,
+    `TELEGRAM_BOT_AI_MODEL=${formatEnvValue(entry.model || "")}`,
+    `TELEGRAM_BOT_AI_PERMISSION_MODE=${formatEnvValue(entry.permissionMode || "")}`,
+    `TELEGRAM_BOT_AI_REASONING_EFFORT=${formatEnvValue(entry.reasoningEffort || "")}`,
+    "",
+  ];
+  return `${lines.join("\n").trimEnd()}\n`;
+}
+
+function rewriteTelegramEntryFile(entry, deps) {
+  const entryFilePath = String(requireDependency(deps, "telegramBotEntryFilePath")(entry.key) || "").trim();
+  if (!entryFilePath) return;
+  fs.mkdirSync(path.dirname(entryFilePath), { recursive: true });
+  fs.writeFileSync(entryFilePath, renderTelegramBotEntryFile(entry), {
+    encoding: "utf8",
+    mode: 0o600,
+  });
+}
+
 function writeProviderEnvState(provider, parsedEnv, deps) {
   if (provider === "telegram" && typeof deps?.writeTelegramEnvState === "function") {
     return deps.writeTelegramEnvState(parsedEnv);
@@ -644,6 +687,8 @@ function telegramEntriesForDisplay(parsedEnv, deps) {
       entry.token
       || entry.username
       || entry.serverBotID
+      || entry.serverBotName
+      || ensureArray(entry.serverRoles).length
       || entry.roleProfile
       || entry.client
       || entry.model
@@ -659,6 +704,8 @@ function telegramEntriesForDisplay(parsedEnv, deps) {
 
 function telegramEntryDisplayName(entry) {
   const current = safeObject(entry);
+  const serverBotName = String(current.serverBotName || "").trim();
+  if (serverBotName) return serverBotName;
   const username = String(current.username || "").trim();
   if (username) return `@${username}`;
   return String(current.key || "").trim() || "(unnamed)";
@@ -722,7 +769,11 @@ function findTelegramEntryByFlags(parsedEnv, flags, deps) {
   }
   if (requestedName) {
     const match = entries.find(
-      (entry) => entry.username === requestedName || normalizeServerBotIdentityText(entry.key) === requestedName,
+      (entry) => (
+        entry.username === requestedName
+        || normalizeServerBotIdentityText(entry.serverBotName) === requestedName
+        || normalizeServerBotIdentityText(entry.key) === requestedName
+      ),
     );
     if (!match) {
       throw new Error(`Telegram bot entry with server bot name "${requestedName}" was not found`);
@@ -783,6 +834,7 @@ async function editTelegramBotGuided(ui, parsed, selected, current, flags, deps)
     const initialBinding = await resolveTelegramServerBindingDetails(
       {
         serverBotID: current.serverBotID,
+        serverBotName: current.serverBotName,
         botUsername: current.username,
         botKey: current.key,
         roleProfile: current.roleProfile,
@@ -795,8 +847,13 @@ async function editTelegramBotGuided(ui, parsed, selected, current, flags, deps)
       current.__preferServerIdentity = true;
       if (initialBinding.mode === "single") {
         current.serverBotID = String(initialBinding.serverBotID || "").trim();
+        current.serverBotName = String(initialBinding.name || "").trim();
+        current.serverRoles = ensureArray(initialBinding.roles);
         current.roleProfile = String(initialBinding.role || current.roleProfile || "").trim();
         applyRoleProfileDefaults(current, resolveRoleProfileDefaults(current.roleProfile, deps));
+      } else if (initialBinding.mode === "group") {
+        current.serverBotName = String(initialBinding.name || "").trim();
+        current.serverRoles = ensureArray(initialBinding.roles);
       }
     }
   }
@@ -847,6 +904,8 @@ async function editTelegramBotGuided(ui, parsed, selected, current, flags, deps)
     const serverBot = await autoResolveTelegramServerBot(current, flags, deps);
     if (serverBot.matchMode === "group") {
       current.serverBotID = "";
+      current.serverBotName = String(serverBot.name || "").trim();
+      current.serverRoles = preferredRoleSort(serverBot.roles);
       current.__preferServerIdentity = true;
       current.roleProfile = "";
       current.client = "";
@@ -861,6 +920,8 @@ async function editTelegramBotGuided(ui, parsed, selected, current, flags, deps)
       );
     } else if (String(serverBot.botID || "").trim()) {
       current.serverBotID = String(serverBot.botID || "").trim();
+      current.serverBotName = String(serverBot.name || "").trim();
+      current.serverRoles = ensureArray(serverBot.roles);
       current.__preferServerIdentity = true;
       current.roleProfile = String(serverBot.role || current.roleProfile || "").trim();
       serverRoleAutoResolved = String(serverBot.role || current.roleProfile || "").trim() || "__server_binding__";
@@ -995,6 +1056,8 @@ function renderBotListPayload(provider, state, deps) {
         key: entry.key,
         isDefault: entry.isDefault,
         serverBotID: entry.serverBotID,
+        serverBotName: entry.serverBotName,
+        serverRoles: ensureArray(entry.serverRoles),
         username: entry.username,
         tokenConfigured: Boolean(entry.token),
         roleProfile: entry.roleProfile,
@@ -1037,6 +1100,8 @@ function buildBotShowPayload(provider, state, entry, deps, extras = {}) {
         key: selectedEntry.key,
         isDefault: selectedEntry.isDefault,
         serverBotID: selectedEntry.serverBotID,
+        serverBotName: selectedEntry.serverBotName,
+        serverRoles: ensureArray(selectedEntry.serverRoles),
         username: selectedEntry.username,
         tokenConfigured: Boolean(selectedEntry.token),
         roleProfile: selectedEntry.roleProfile,
@@ -1877,7 +1942,12 @@ async function maybePromptGroupedServerRoleProfiles(ui, serverBot, deps) {
 
 function resolveTelegramServerBindingDetailsFromBots(envConfig, bots, deps) {
   const current = safeObject(envConfig);
-  if (!String(current.serverBotID || "").trim() && !String(current.botUsername || "").trim() && !String(current.botKey || "").trim()) {
+  if (
+    !String(current.serverBotID || "").trim()
+    && !String(current.serverBotName || "").trim()
+    && !String(current.botUsername || "").trim()
+    && !String(current.botKey || "").trim()
+  ) {
     return null;
   }
   const resolveGroupedPayload = (matches, matchedBy) => {
@@ -1929,7 +1999,7 @@ function resolveTelegramServerBindingDetailsFromBots(envConfig, bots, deps) {
       detail: `${String(match.name || "").trim() || "(unnamed)"} [${String(match.role || "").trim() || "-"}]`,
     };
   }
-  const normalizedServerIdentity = normalizeServerBotIdentityText(current.botUsername || current.botKey);
+  const normalizedServerIdentity = normalizeServerBotIdentityText(current.serverBotName || current.botUsername || current.botKey);
   const matches = bots.filter((bot) => normalizeServerBotIdentityText(bot.name) === normalizedServerIdentity);
   if (!matches.length) {
     return {
@@ -2014,6 +2084,7 @@ async function buildTelegramEntrySelectionRows(entries, flags, deps) {
       ? resolveTelegramServerBindingDetailsFromBots(
         {
           serverBotID: current.serverBotID,
+          serverBotName: current.serverBotName,
           botUsername: current.username,
           botKey: current.key,
           roleProfile: current.roleProfile,
@@ -2062,6 +2133,7 @@ async function verifyTelegramTokenCandidate(provider, token, apiBaseURL, timeout
 async function autoResolveTelegramServerBot(current, flags, deps) {
   const existingBotID = String(current?.serverBotID || "").trim();
   const preferredIdentity = firstNonEmptyString([
+    current?.serverBotName,
     current?.username,
     current?.key,
   ]);
@@ -2275,6 +2347,8 @@ async function addTelegramBot(ui, flags, deps) {
   const nextParsed = upsertTelegramEntry(parsed, {
     key: botKey,
     serverBotID: String(getServerBotIDFlag(flags) || serverBot.botID || "").trim(),
+    serverBotName: String(serverBot.name || "").trim(),
+    serverRoles: preferredRoleSort(serverBot.roles),
     username,
     __preferServerIdentity: serverBot.matchMode === "group" || Boolean(String(getServerBotIDFlag(flags) || serverBot.botID || "").trim()),
     token,
@@ -2391,6 +2465,23 @@ async function editTelegramBot(ui, flags, deps) {
     if (boolFromRaw(flags.default, false)) {
       parsed.TELEGRAM_DEFAULT_BOT_KEY = current.key;
     }
+    if (current.serverBotID || current.username || current.serverBotName) {
+      const resolvedServerBot = await autoResolveTelegramServerBot(current, flags, deps);
+      if (resolvedServerBot.matchMode === "group") {
+        current.serverBotID = String(getServerBotIDFlag(flags) || current.serverBotID || "").trim();
+        current.serverBotName = String(resolvedServerBot.name || current.serverBotName || "").trim();
+        current.serverRoles = preferredRoleSort(resolvedServerBot.roles);
+        if (!hasOwnFlag(flags, "role-profile")) current.roleProfile = "";
+        if (!(hasOwnFlag(flags, "client") || hasOwnFlag(flags, "ai-client"))) current.client = "";
+        if (!(hasOwnFlag(flags, "model") || hasOwnFlag(flags, "ai-model"))) current.model = "";
+        if (!(hasOwnFlag(flags, "permission-mode") || hasOwnFlag(flags, "ai-permission-mode"))) current.permissionMode = "";
+        if (!(hasOwnFlag(flags, "reasoning-effort") || hasOwnFlag(flags, "ai-reasoning-effort"))) current.reasoningEffort = "";
+      } else if (String(resolvedServerBot.botID || "").trim()) {
+        current.serverBotID = String(resolvedServerBot.botID || "").trim();
+        current.serverBotName = String(resolvedServerBot.name || "").trim();
+        current.serverRoles = ensureArray(resolvedServerBot.roles);
+      }
+    }
     saveTelegramBotEdit(parsed, selected, current, deps);
     return;
   }
@@ -2462,6 +2553,43 @@ async function verifyProviderEntry(ui, provider, flags, deps) {
     if (serverBinding && !serverBinding.ok) {
       overallOK = false;
     }
+    if (serverBinding?.ok && envConfig.botKey) {
+      const selectedEntry = findTelegramEntryByFlags(
+        state.parsed,
+        { "bot-key": envConfig.botKey },
+        deps,
+      );
+      if (selectedEntry) {
+        const desiredServerBotName = String(serverBinding.name || "").trim();
+        const desiredServerRoles = ensureArray(serverBinding.roles);
+        const currentServerRoles = ensureArray(selectedEntry.serverRoles);
+        const currentServerRolesJoined = currentServerRoles.join(",");
+        const desiredServerRolesJoined = desiredServerRoles.join(",");
+        const desiredServerBotID = (
+          String(selectedEntry.serverBotID || "").trim()
+          || (serverBinding.mode === "single" ? String(serverBinding.serverBotID || "").trim() : "")
+        );
+        const needsMetadataBackfill = (
+          String(selectedEntry.serverBotName || "").trim() !== desiredServerBotName
+          || currentServerRolesJoined !== desiredServerRolesJoined
+          || String(selectedEntry.serverBotID || "").trim() !== desiredServerBotID
+        );
+        if (needsMetadataBackfill) {
+          const nextEntry = {
+            ...selectedEntry,
+            serverBotID: desiredServerBotID,
+            serverBotName: desiredServerBotName,
+            serverRoles: desiredServerRoles,
+          };
+          const nextParsed = upsertTelegramEntry(state.parsed, nextEntry);
+          writeProviderEnvState("telegram", nextParsed, deps);
+          rewriteTelegramEntryFile(nextEntry, deps);
+          envConfig.serverBotID = desiredServerBotID;
+          envConfig.serverBotName = desiredServerBotName;
+          envConfig.serverRoles = desiredServerRoles;
+        }
+      }
+    }
     routeLinks = summarizeTelegramRouteLinks(state.parsed, {
       key: envConfig.botKey,
       serverBotID: envConfig.serverBotID,
@@ -2492,6 +2620,8 @@ async function verifyProviderEntry(ui, provider, flags, deps) {
         filePath: envConfig.filePath,
         botKey: envConfig.botKey || "",
         serverBotID: envConfig.serverBotID || "",
+        serverBotName: envConfig.serverBotName || "",
+        serverRoles: ensureArray(envConfig.serverRoles),
         detail: result.detail || "",
         roleProfile: envConfig.roleProfile || "",
         client: envConfig.client || "",
@@ -2508,6 +2638,8 @@ async function verifyProviderEntry(ui, provider, flags, deps) {
       `file: ${envConfig.filePath}`,
       provider === "telegram" ? `bot_key: ${envConfig.botKey || "-"}` : "",
       provider === "telegram" ? `server_bot_id: ${envConfig.serverBotID || "-"}` : "",
+      provider === "telegram" ? `stored_server_name: ${envConfig.serverBotName || "-"}` : "",
+      provider === "telegram" ? `stored_server_roles: ${ensureArray(envConfig.serverRoles).join(", ") || "-"}` : "",
       provider === "telegram" ? `role_profile: ${envConfig.roleProfile || "-"}` : "",
       provider === "telegram" ? `ai_client: ${envConfig.client ? displayLocalAIClientName(envConfig.client) : "-"}` : "",
       provider === "telegram" ? `ai_model: ${envConfig.model || "-"}` : "",

package/lib/selftest-bot-commands.mjs

@@ -353,13 +353,15 @@ export async function runSelftestBotCommands(push, deps) {
     push(
       "bot_add_guided_creates_named_telegram_entry",
       String(addState.TELEGRAM_BOT_NAME || "").toLowerCase().includes("monitorselftestbot")
+        && String(addState.TELEGRAM_BOT_SERVER_NAME || "") === "MonitorSelftestBot"
+        && String(addState.TELEGRAM_BOT_SERVER_ROLES || "") === "monitor"
         && String(addState.TELEGRAM_BOT_TOKEN || "") === "selftest-main-token"
         && String(addState.TELEGRAM_BOT_ROLE_PROFILE || "") === "monitor"
         && String(addState.TELEGRAM_BOT_AI_CLIENT || "") === "codex"
         && String(addState.TELEGRAM_BOT_AI_PERMISSION_MODE || "") === "read_only"
         && String(addState.TELEGRAM_BOT_AI_REASONING_EFFORT || "") === "low"
         && String(addGlobals.TELEGRAM_DEFAULT_BOT_KEY || "") === "monitorselftestbot",
-      `default=${String(addGlobals.TELEGRAM_DEFAULT_BOT_KEY || "")} token=${String(addState.TELEGRAM_BOT_TOKEN || "")} role=${String(addState.TELEGRAM_BOT_ROLE_PROFILE || "")} client=${String(addState.TELEGRAM_BOT_AI_CLIENT || "")}`,
+      `default=${String(addGlobals.TELEGRAM_DEFAULT_BOT_KEY || "")} token=${String(addState.TELEGRAM_BOT_TOKEN || "")} server_name=${String(addState.TELEGRAM_BOT_SERVER_NAME || "")} roles=${String(addState.TELEGRAM_BOT_SERVER_ROLES || "")} role=${String(addState.TELEGRAM_BOT_ROLE_PROFILE || "")} client=${String(addState.TELEGRAM_BOT_AI_CLIENT || "")}`,
     );
 
     const groupedMock = await createMockServer({
@@ -403,10 +405,12 @@ export async function runSelftestBotCommands(push, deps) {
       "bot_add_guided_autoresolves_server_bot_group_without_role_prompt",
         String(groupedState.TELEGRAM_BOT_NAME || "").toLowerCase() === "ryoai_bot"
           && String(groupedState.TELEGRAM_BOT_SERVER_BOT_ID || "") === ""
+          && String(groupedState.TELEGRAM_BOT_SERVER_NAME || "") === "RyoAI_bot"
+          && String(groupedState.TELEGRAM_BOT_SERVER_ROLES || "") === "monitor,review,worker,approval"
           && String(groupedState.TELEGRAM_BOT_ROLE_PROFILE || "") === ""
           && String(groupedState.TELEGRAM_BOT_AI_CLIENT || "") === ""
           && String(groupedState.TELEGRAM_BOT_AI_PERMISSION_MODE || "") === "",
-        `name=${String(groupedState.TELEGRAM_BOT_NAME || "")} server_bot_id=${String(groupedState.TELEGRAM_BOT_SERVER_BOT_ID || "")} role=${String(groupedState.TELEGRAM_BOT_ROLE_PROFILE || "")}`,
+        `name=${String(groupedState.TELEGRAM_BOT_NAME || "")} server_name=${String(groupedState.TELEGRAM_BOT_SERVER_NAME || "")} roles=${String(groupedState.TELEGRAM_BOT_SERVER_ROLES || "")} server_bot_id=${String(groupedState.TELEGRAM_BOT_SERVER_BOT_ID || "")} role=${String(groupedState.TELEGRAM_BOT_ROLE_PROFILE || "")}`,
       );
 
       const groupedEditResult = await runCLI({
@@ -758,11 +762,13 @@ export async function runSelftestBotCommands(push, deps) {
     push(
       "bot_add_accepts_ai_prefixed_option_aliases",
       String(aliasAddState.TELEGRAM_BOT_SERVER_BOT_ID || "") === mock.bots[0].id
+        && String(aliasAddState.TELEGRAM_BOT_SERVER_NAME || "") === "MonitorSelftestBot"
+        && String(aliasAddState.TELEGRAM_BOT_SERVER_ROLES || "") === "monitor"
         && String(aliasAddState.TELEGRAM_BOT_AI_CLIENT || "") === "codex"
         && String(aliasAddState.TELEGRAM_BOT_AI_MODEL || "") === "gpt-5.4"
         && String(aliasAddState.TELEGRAM_BOT_AI_PERMISSION_MODE || "") === "read_only"
         && String(aliasAddState.TELEGRAM_BOT_AI_REASONING_EFFORT || "") === "low",
-      `client=${String(aliasAddState.TELEGRAM_BOT_AI_CLIENT || "")} model=${String(aliasAddState.TELEGRAM_BOT_AI_MODEL || "")}`,
+      `server_name=${String(aliasAddState.TELEGRAM_BOT_SERVER_NAME || "")} roles=${String(aliasAddState.TELEGRAM_BOT_SERVER_ROLES || "")} client=${String(aliasAddState.TELEGRAM_BOT_AI_CLIENT || "")} model=${String(aliasAddState.TELEGRAM_BOT_AI_MODEL || "")}`,
     );
 
     const guidedRemoveBeforeList = await runCLI({

package/package.json

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