@openacp/cli 0.4.11 → 0.5.1

package/dist/{chunk-66RVSUAR.js → chunk-PHC67OP4.js}

@@ -1,29 +1,25 @@
 import {
   DoctorEngine
-} from "./chunk-3DIPXFZJ.js";
-import {
-  getAgentCapabilities
-} from "./chunk-VA2M52CM.js";
+} from "./chunk-IRGYTNLP.js";
 import {
   buildMenuKeyboard,
   buildSkillMessages,
-  escapeHtml,
-  formatToolCall,
-  formatToolUpdate,
-  formatUsage,
-  handleAgents,
   handleClear,
   handleHelp,
-  handleMenu,
-  markdownToTelegramHtml,
-  splitMessage
-} from "./chunk-BGKQHQB4.js";
+  handleMenu
+} from "./chunk-IURZ4QHG.js";
+import {
+  AgentCatalog
+} from "./chunk-5MH66WUY.js";
+import {
+  getAgentCapabilities
+} from "./chunk-GUHCS6X7.js";
 import {
   getConfigValue,
   getSafeFields,
   isHotReloadable,
   resolveOptions
-} from "./chunk-C33LTDZV.js";
+} from "./chunk-Z46LGZ7R.js";
 import {
   createChildLogger,
   createSessionLogger
@@ -72,7 +68,7 @@ var StderrCapture = class {
 };
 
 // src/core/agent-instance.ts
-import { spawn, execSync } from "child_process";
+import { spawn, execFileSync } from "child_process";
 import { Transform } from "stream";
 import fs from "fs";
 import path from "path";
@@ -123,7 +119,7 @@ function resolveAgentCommand(cmd) {
     }
   }
   try {
-    const fullPath = execSync(`which ${cmd}`, { encoding: "utf-8" }).trim();
+    const fullPath = execFileSync("which", [cmd], { encoding: "utf-8" }).trim();
     if (fullPath) {
       const content = fs.readFileSync(fullPath, "utf-8");
       if (content.startsWith("#!/usr/bin/env node")) {
@@ -501,31 +497,29 @@ ${stderr}`
 
 // src/core/agent-manager.ts
 var AgentManager = class {
-  constructor(config) {
-    this.config = config;
+  constructor(catalog) {
+    this.catalog = catalog;
   }
   getAvailableAgents() {
-    return Object.entries(this.config.agents).map(([name, cfg]) => ({
-      name,
-      command: cfg.command,
-      args: cfg.args,
-      workingDirectory: cfg.workingDirectory,
-      env: cfg.env
+    const installed = this.catalog.getInstalledEntries();
+    return Object.entries(installed).map(([key, agent]) => ({
+      name: key,
+      command: agent.command,
+      args: agent.args,
+      env: agent.env
     }));
   }
   getAgent(name) {
-    const cfg = this.config.agents[name];
-    if (!cfg) return void 0;
-    return { name, ...cfg };
+    return this.catalog.resolve(name);
   }
   async spawn(agentName, workingDirectory) {
     const agentDef = this.getAgent(agentName);
-    if (!agentDef) throw new Error(`Agent "${agentName}" not found in config`);
+    if (!agentDef) throw new Error(`Agent "${agentName}" is not installed. Run "openacp agents install ${agentName}" to add it.`);
     return AgentInstance.spawn(agentDef, workingDirectory);
   }
   async resume(agentName, workingDirectory, agentSessionId) {
     const agentDef = this.getAgent(agentName);
-    if (!agentDef) throw new Error(`Agent "${agentName}" not found in config`);
+    if (!agentDef) throw new Error(`Agent "${agentName}" is not installed. Run "openacp agents install ${agentName}" to add it.`);
     return AgentInstance.resume(agentDef, workingDirectory, agentSessionId);
   }
 };
@@ -652,28 +646,40 @@ var PromptQueue = class {
 };
 
 // src/core/permission-gate.ts
+var DEFAULT_TIMEOUT_MS = 10 * 60 * 1e3;
 var PermissionGate = class {
   request;
   resolveFn;
   rejectFn;
   settled = false;
+  timeoutTimer;
+  timeoutMs;
+  constructor(timeoutMs) {
+    this.timeoutMs = timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  }
   setPending(request) {
     this.request = request;
     this.settled = false;
+    this.clearTimeout();
     return new Promise((resolve2, reject) => {
       this.resolveFn = resolve2;
       this.rejectFn = reject;
+      this.timeoutTimer = setTimeout(() => {
+        this.reject("Permission request timed out (no response received)");
+      }, this.timeoutMs);
     });
   }
   resolve(optionId) {
     if (this.settled || !this.resolveFn) return;
     this.settled = true;
+    this.clearTimeout();
     this.resolveFn(optionId);
     this.cleanup();
   }
   reject(reason) {
     if (this.settled || !this.rejectFn) return;
     this.settled = true;
+    this.clearTimeout();
     this.rejectFn(new Error(reason ?? "Permission rejected"));
     this.cleanup();
   }
@@ -687,6 +693,12 @@ var PermissionGate = class {
   get requestId() {
     return this.request?.id;
   }
+  clearTimeout() {
+    if (this.timeoutTimer) {
+      clearTimeout(this.timeoutTimer);
+      this.timeoutTimer = void 0;
+    }
+  }
   cleanup() {
     this.request = void 0;
     this.resolveFn = void 0;
@@ -1453,6 +1465,7 @@ var JsonFileSessionStore = class {
 var log5 = createChildLogger({ module: "core" });
 var OpenACPCore = class {
   configManager;
+  agentCatalog;
   agentManager;
   sessionManager;
   notificationManager;
@@ -1466,7 +1479,9 @@ var OpenACPCore = class {
   constructor(configManager) {
     this.configManager = configManager;
     const config = configManager.get();
-    this.agentManager = new AgentManager(config);
+    this.agentCatalog = new AgentCatalog();
+    this.agentCatalog.load();
+    this.agentManager = new AgentManager(this.agentCatalog);
     const storePath = path3.join(os.homedir(), ".openacp", "sessions.json");
     this.sessionStore = new JsonFileSessionStore(
       storePath,
@@ -1494,6 +1509,9 @@ var OpenACPCore = class {
     this.adapters.set(name, adapter);
   }
   async start() {
+    this.agentCatalog.refreshRegistryIfStale().catch((err) => {
+      log5.warn({ err }, "Background registry refresh failed");
+    });
     for (const adapter of this.adapters.values()) {
       await adapter.start();
     }
@@ -1631,8 +1649,9 @@ var OpenACPCore = class {
     const config = this.configManager.get();
     const resolvedAgent = agentName || config.defaultAgent;
     log5.info({ channelId, agentName: resolvedAgent }, "New session request");
+    const agentDef = this.agentCatalog.resolve(resolvedAgent);
     const resolvedWorkspace = this.configManager.resolveWorkspace(
-      workspacePath || config.agents[resolvedAgent]?.workingDirectory
+      workspacePath || agentDef?.workingDirectory
     );
     return this.createSession({
       channelId,
@@ -2128,7 +2147,7 @@ var ApiServer = class {
     this.sendJson(res, 200, { version: getVersion() });
   }
   async handleGetEditableConfig(res) {
-    const { getSafeFields: getSafeFields2, resolveOptions: resolveOptions2, getConfigValue: getConfigValue2 } = await import("./config-registry-OGX4YM2U.js");
+    const { getSafeFields: getSafeFields2, resolveOptions: resolveOptions2, getConfigValue: getConfigValue2 } = await import("./config-registry-SNKA2EH2.js");
     const config = this.core.configManager.get();
     const safeFields = getSafeFields2();
     const fields = safeFields.map((def) => ({
@@ -2182,7 +2201,7 @@ var ApiServer = class {
       return;
     }
     target[lastKey] = value;
-    const { ConfigSchema } = await import("./config-XURP6B3S.js");
+    const { ConfigSchema } = await import("./config-PCPIBPUA.js");
     const result = ConfigSchema.safeParse(cloned);
     if (!result.success) {
       this.sendJson(res, 400, {
@@ -2199,7 +2218,7 @@ var ApiServer = class {
     }
     updateTarget[lastKey] = value;
     await this.core.configManager.save(updates, configPath);
-    const { isHotReloadable: isHotReloadable2 } = await import("./config-registry-OGX4YM2U.js");
+    const { isHotReloadable: isHotReloadable2 } = await import("./config-registry-SNKA2EH2.js");
     const needsRestart = !isHotReloadable2(configPath);
     this.sendJson(res, 200, {
       ok: true,
@@ -2485,6 +2504,169 @@ function buildDeepLink(chatId, messageId) {
 // src/adapters/telegram/commands/new-session.ts
 import { InlineKeyboard as InlineKeyboard2 } from "grammy";
 
+// src/adapters/telegram/formatting.ts
+function escapeHtml(text) {
+  if (!text) return "";
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function markdownToTelegramHtml(md) {
+  const codeBlocks = [];
+  const inlineCodes = [];
+  let text = md.replace(/```(\w*)\n?([\s\S]*?)```/g, (_match, lang, code) => {
+    const index = codeBlocks.length;
+    const escapedCode = escapeHtml(code);
+    const langAttr = lang ? ` class="language-${escapeHtml(lang)}"` : "";
+    codeBlocks.push(`<pre><code${langAttr}>${escapedCode}</code></pre>`);
+    return `\0CODE_BLOCK_${index}\0`;
+  });
+  text = text.replace(/`([^`]+)`/g, (_match, code) => {
+    const index = inlineCodes.length;
+    inlineCodes.push(`<code>${escapeHtml(code)}</code>`);
+    return `\0INLINE_CODE_${index}\0`;
+  });
+  text = escapeHtml(text);
+  text = text.replace(/\*\*(.+?)\*\*/g, "<b>$1</b>");
+  text = text.replace(/(?<!\*)\*(?!\*)(.+?)(?<!\*)\*(?!\*)/g, "<i>$1</i>");
+  text = text.replace(/\[([^\]]+)\]\(([^)]+)\)/g, '<a href="$2">$1</a>');
+  text = text.replace(/\x00CODE_BLOCK_(\d+)\x00/g, (_match, idx) => {
+    return codeBlocks[parseInt(idx, 10)];
+  });
+  text = text.replace(/\x00INLINE_CODE_(\d+)\x00/g, (_match, idx) => {
+    return inlineCodes[parseInt(idx, 10)];
+  });
+  return text;
+}
+var STATUS_ICON = {
+  pending: "\u23F3",
+  in_progress: "\u{1F504}",
+  completed: "\u2705",
+  failed: "\u274C"
+};
+var KIND_ICON = {
+  read: "\u{1F4D6}",
+  edit: "\u270F\uFE0F",
+  delete: "\u{1F5D1}\uFE0F",
+  execute: "\u25B6\uFE0F",
+  search: "\u{1F50D}",
+  fetch: "\u{1F310}",
+  think: "\u{1F9E0}",
+  move: "\u{1F4E6}",
+  other: "\u{1F6E0}\uFE0F"
+};
+function extractContentText(content, depth = 0) {
+  if (!content || depth > 5) return "";
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content.map((c) => extractContentText(c, depth + 1)).filter(Boolean).join("\n");
+  }
+  if (typeof content === "object" && content !== null) {
+    const c = content;
+    if (c.type === "text" && typeof c.text === "string") return c.text;
+    if (typeof c.text === "string") return c.text;
+    if (typeof c.content === "string") return c.content;
+    if (c.content && typeof c.content === "object") return extractContentText(c.content, depth + 1);
+    if (c.input) return extractContentText(c.input, depth + 1);
+    if (c.output) return extractContentText(c.output, depth + 1);
+    const keys = Object.keys(c).filter((k) => k !== "type");
+    if (keys.length === 0) return "";
+    return JSON.stringify(c, null, 2);
+  }
+  return String(content);
+}
+function truncateContent(text, maxLen = 3800) {
+  if (text.length <= maxLen) return text;
+  return text.slice(0, maxLen) + "\n\u2026 (truncated)";
+}
+function formatToolCall(tool) {
+  const si = STATUS_ICON[tool.status || ""] || "\u{1F527}";
+  const ki = KIND_ICON[tool.kind || ""] || "\u{1F6E0}\uFE0F";
+  let text = `${si} ${ki} <b>${escapeHtml(tool.name || "Tool")}</b>`;
+  text += formatViewerLinks(tool.viewerLinks, tool.viewerFilePath);
+  if (!tool.viewerLinks) {
+    const details = extractContentText(tool.content);
+    if (details) {
+      text += `
+<pre>${escapeHtml(truncateContent(details))}</pre>`;
+    }
+  }
+  return text;
+}
+function formatToolUpdate(update) {
+  const si = STATUS_ICON[update.status] || "\u{1F527}";
+  const ki = KIND_ICON[update.kind || ""] || "\u{1F6E0}\uFE0F";
+  const name = update.name || "Tool";
+  let text = `${si} ${ki} <b>${escapeHtml(name)}</b>`;
+  text += formatViewerLinks(update.viewerLinks, update.viewerFilePath);
+  if (!update.viewerLinks) {
+    const details = extractContentText(update.content);
+    if (details) {
+      text += `
+<pre>${escapeHtml(truncateContent(details))}</pre>`;
+    }
+  }
+  return text;
+}
+function formatViewerLinks(links, filePath) {
+  if (!links) return "";
+  const fileName = filePath ? filePath.split("/").pop() || filePath : "";
+  let text = "\n";
+  if (links.file) text += `
+\u{1F4C4} <a href="${escapeHtml(links.file)}">View ${escapeHtml(fileName || "file")}</a>`;
+  if (links.diff) text += `
+\u{1F4DD} <a href="${escapeHtml(links.diff)}">View diff${fileName ? ` \u2014 ${escapeHtml(fileName)}` : ""}</a>`;
+  return text;
+}
+function formatTokens(n) {
+  return n >= 1e3 ? `${Math.round(n / 1e3)}k` : String(n);
+}
+function progressBar(ratio) {
+  const filled = Math.round(Math.min(ratio, 1) * 10);
+  return "\u2593".repeat(filled) + "\u2591".repeat(10 - filled);
+}
+function formatUsage(usage) {
+  const { tokensUsed, contextSize } = usage;
+  if (tokensUsed == null) return "\u{1F4CA} Usage data unavailable";
+  if (contextSize == null) return `\u{1F4CA} ${formatTokens(tokensUsed)} tokens`;
+  const ratio = tokensUsed / contextSize;
+  const pct = Math.round(ratio * 100);
+  const bar = progressBar(ratio);
+  const emoji = pct >= 85 ? "\u26A0\uFE0F" : "\u{1F4CA}";
+  return `${emoji} ${formatTokens(tokensUsed)} / ${formatTokens(contextSize)} tokens
+${bar} ${pct}%`;
+}
+function splitMessage(text, maxLength = 3800) {
+  if (text.length <= maxLength) return [text];
+  const chunks = [];
+  let remaining = text;
+  while (remaining.length > 0) {
+    if (remaining.length <= maxLength) {
+      chunks.push(remaining);
+      break;
+    }
+    const wouldLeaveSmall = remaining.length < maxLength * 1.3;
+    const searchLimit = wouldLeaveSmall ? Math.floor(remaining.length / 2) + 300 : maxLength;
+    let splitAt = remaining.lastIndexOf("\n\n", searchLimit);
+    if (splitAt === -1 || splitAt < searchLimit * 0.2) {
+      splitAt = remaining.lastIndexOf("\n", searchLimit);
+    }
+    if (splitAt === -1 || splitAt < searchLimit * 0.2) {
+      splitAt = searchLimit;
+    }
+    const candidate = remaining.slice(0, splitAt);
+    const fences = candidate.match(/```/g);
+    if (fences && fences.length % 2 !== 0) {
+      const closingFence = remaining.indexOf("```", splitAt);
+      if (closingFence !== -1) {
+        const afterFence = remaining.indexOf("\n", closingFence + 3);
+        splitAt = afterFence !== -1 ? afterFence + 1 : closingFence + 3;
+      }
+    }
+    chunks.push(remaining.slice(0, splitAt));
+    remaining = remaining.slice(splitAt).replace(/^\n+/, "");
+  }
+  return chunks;
+}
+
 // src/adapters/telegram/commands/admin.ts
 import { InlineKeyboard } from "grammy";
 var log9 = createChildLogger({ module: "telegram-cmd-admin" });
@@ -2688,37 +2870,12 @@ async function handleNew(ctx, core, chatId, assistant) {
       return;
     }
   }
-  const userId = ctx.from?.id;
-  if (!userId) return;
-  const agents = core.agentManager.getAvailableAgents();
-  const config = core.configManager.get();
-  if (agentName || agents.length === 1) {
-    const selectedAgent = agentName || config.defaultAgent;
-    await startWorkspaceStep(ctx, core, chatId, userId, selectedAgent);
-    return;
-  }
-  const keyboard = new InlineKeyboard2();
-  for (const agent of agents) {
-    const label = agent.name === config.defaultAgent ? `${agent.name} (default)` : agent.name;
-    keyboard.text(label, `m:new:agent:${agent.name}`).row();
-  }
-  keyboard.text("\u274C Cancel", "m:new:cancel");
-  const msg = await ctx.reply(
-    `\u{1F916} <b>Choose an agent:</b>`,
-    { parse_mode: "HTML", reply_markup: keyboard }
-  );
-  cleanupPending(userId);
-  pendingNewSessions.set(userId, {
-    step: "agent",
-    messageId: msg.message_id,
-    threadId: currentThreadId,
-    timer: setTimeout(() => pendingNewSessions.delete(userId), PENDING_TIMEOUT_MS)
-  });
+  await showAgentPicker(ctx, core, chatId, agentName);
 }
 async function startWorkspaceStep(ctx, core, chatId, userId, agentName) {
   const config = core.configManager.get();
   const baseDir = config.workspace.baseDir;
-  const keyboard = new InlineKeyboard2().text(`\u{1F4C1} Use ${baseDir}`, "m:new:ws:default").row().text("\u270F\uFE0F Enter project path", "m:new:ws:custom").row().text("\u274C Cancel", "m:new:cancel");
+  const keyboard = new InlineKeyboard2().text(`\u{1F4C1} Use ${baseDir}`, "m:new:ws:default").row().text("\u270F\uFE0F Enter project path", "m:new:ws:custom");
   const text = `\u{1F4C1} <b>Where should ${escapeHtml(agentName)} work?</b>
 
 Enter the path to your project folder \u2014 the agent will read, write, and run code there.
@@ -2953,30 +3110,35 @@ async function handlePendingWorkspaceInput(ctx, core, chatId, assistantTopicId)
   return true;
 }
 async function startInteractiveNewSession(ctx, core, chatId, agentName) {
+  await showAgentPicker(ctx, core, chatId, agentName);
+}
+async function showAgentPicker(ctx, core, chatId, agentName) {
   const userId = ctx.from?.id;
   if (!userId) return;
-  const agents = core.agentManager.getAvailableAgents();
+  const installedEntries = core.agentCatalog.getInstalledEntries();
+  const agentKeys = Object.keys(installedEntries);
   const config = core.configManager.get();
-  if (agentName || agents.length === 1) {
+  if (agentName || agentKeys.length === 1) {
     const selectedAgent = agentName || config.defaultAgent;
     await startWorkspaceStep(ctx, core, chatId, userId, selectedAgent);
     return;
   }
   const keyboard = new InlineKeyboard2();
-  for (const agent of agents) {
-    const label = agent.name === config.defaultAgent ? `${agent.name} (default)` : agent.name;
-    keyboard.text(label, `m:new:agent:${agent.name}`).row();
+  for (const key of agentKeys) {
+    const agent = installedEntries[key];
+    const label = key === config.defaultAgent ? `${agent.name} (default)` : agent.name;
+    keyboard.text(label, `m:new:agent:${key}`).row();
   }
-  keyboard.text("\u274C Cancel", "m:new:cancel");
   const msg = await ctx.reply(
     `\u{1F916} <b>Choose an agent:</b>`,
     { parse_mode: "HTML", reply_markup: keyboard }
   );
   cleanupPending(userId);
+  const threadId = ctx.message?.message_thread_id ?? ctx.callbackQuery?.message?.message_thread_id;
   pendingNewSessions.set(userId, {
     step: "agent",
     messageId: msg.message_id,
-    threadId: ctx.callbackQuery?.message?.message_thread_id,
+    threadId,
     timer: setTimeout(() => pendingNewSessions.delete(userId), PENDING_TIMEOUT_MS)
   });
 }
@@ -3350,12 +3512,250 @@ function setupSessionCallbacks(bot, core, chatId, systemTopicIds) {
   });
 }
 
-// src/adapters/telegram/commands/integrate.ts
+// src/adapters/telegram/commands/agents.ts
 import { InlineKeyboard as InlineKeyboard4 } from "grammy";
+var AGENTS_PER_PAGE = 6;
+async function handleAgents(ctx, core, page = 0) {
+  const catalog = core.agentCatalog;
+  const items = catalog.getAvailable();
+  const installed = items.filter((i) => i.installed);
+  const available = items.filter((i) => !i.installed);
+  let text = "<b>\u{1F916} Agents</b>\n\n";
+  if (installed.length > 0) {
+    text += "<b>Installed:</b>\n";
+    for (const item of installed) {
+      text += `\u2705 <b>${escapeHtml(item.name)}</b>`;
+      if (item.description) {
+        text += ` \u2014 <i>${escapeHtml(truncate(item.description, 50))}</i>`;
+      }
+      text += "\n";
+    }
+    text += "\n";
+  }
+  if (available.length > 0) {
+    const totalPages = Math.ceil(available.length / AGENTS_PER_PAGE);
+    const safePage = Math.max(0, Math.min(page, totalPages - 1));
+    const pageItems = available.slice(safePage * AGENTS_PER_PAGE, (safePage + 1) * AGENTS_PER_PAGE);
+    text += `<b>Available to install:</b>`;
+    if (totalPages > 1) {
+      text += ` (${safePage + 1}/${totalPages})`;
+    }
+    text += "\n";
+    for (const item of pageItems) {
+      if (item.available) {
+        text += `\u2B07\uFE0F <b>${escapeHtml(item.name)}</b>`;
+      } else {
+        const deps = item.missingDeps?.join(", ") ?? "requirements not met";
+        text += `\u26A0\uFE0F <b>${escapeHtml(item.name)}</b> <i>(needs: ${escapeHtml(deps)})</i>`;
+      }
+      if (item.description) {
+        text += `
+    <i>${escapeHtml(truncate(item.description, 60))}</i>`;
+      }
+      text += "\n";
+    }
+    const keyboard = new InlineKeyboard4();
+    const installable = pageItems.filter((i) => i.available);
+    for (let i = 0; i < installable.length; i += 2) {
+      const row = installable.slice(i, i + 2);
+      for (const item of row) {
+        keyboard.text(`\u2B07\uFE0F ${item.name}`, `ag:install:${item.key}`);
+      }
+      keyboard.row();
+    }
+    if (totalPages > 1) {
+      if (safePage > 0) {
+        keyboard.text("\u25C0\uFE0F Prev", `ag:page:${safePage - 1}`);
+      }
+      if (safePage < totalPages - 1) {
+        keyboard.text("Next \u25B6\uFE0F", `ag:page:${safePage + 1}`);
+      }
+      keyboard.row();
+    }
+    if (available.some((i) => !i.available)) {
+      text += "\n\u{1F4A1} <i>Agents marked \u26A0\uFE0F need additional setup. Use</i> <code>openacp agents info &lt;name&gt;</code> <i>for details.</i>\n";
+    }
+    await ctx.reply(text, { parse_mode: "HTML", reply_markup: keyboard });
+  } else {
+    text += "<i>All agents are already installed!</i>";
+    await ctx.reply(text, { parse_mode: "HTML" });
+  }
+}
+async function handleInstall(ctx, core) {
+  const text = (ctx.message?.text ?? "").trim();
+  const parts = text.split(/\s+/);
+  const nameOrId = parts[1];
+  if (!nameOrId) {
+    await ctx.reply(
+      "\u{1F4E6} <b>Install an agent</b>\n\nUsage: <code>/install &lt;agent-name&gt;</code>\nExample: <code>/install gemini</code>\n\nUse /agents to browse available agents.",
+      { parse_mode: "HTML" }
+    );
+    return;
+  }
+  await installAgentWithProgress(ctx, core, nameOrId);
+}
+async function handleAgentCallback(ctx, core) {
+  const data = ctx.callbackQuery?.data ?? "";
+  await ctx.answerCallbackQuery();
+  if (data.startsWith("ag:install:")) {
+    const nameOrId = data.replace("ag:install:", "");
+    await installAgentWithProgress(ctx, core, nameOrId);
+    return;
+  }
+  if (data.startsWith("ag:page:")) {
+    const page = parseInt(data.replace("ag:page:", ""), 10);
+    try {
+      const catalog = core.agentCatalog;
+      const items = catalog.getAvailable();
+      const installed = items.filter((i) => i.installed);
+      const available = items.filter((i) => !i.installed);
+      let text = "<b>\u{1F916} Agents</b>\n\n";
+      if (installed.length > 0) {
+        text += "<b>Installed:</b>\n";
+        for (const item of installed) {
+          text += `\u2705 <b>${escapeHtml(item.name)}</b>`;
+          if (item.description) {
+            text += ` \u2014 <i>${escapeHtml(truncate(item.description, 50))}</i>`;
+          }
+          text += "\n";
+        }
+        text += "\n";
+      }
+      const totalPages = Math.ceil(available.length / AGENTS_PER_PAGE);
+      const safePage = Math.max(0, Math.min(page, totalPages - 1));
+      const pageItems = available.slice(safePage * AGENTS_PER_PAGE, (safePage + 1) * AGENTS_PER_PAGE);
+      text += `<b>Available to install:</b>`;
+      if (totalPages > 1) {
+        text += ` (${safePage + 1}/${totalPages})`;
+      }
+      text += "\n";
+      for (const item of pageItems) {
+        if (item.available) {
+          text += `\u2B07\uFE0F <b>${escapeHtml(item.name)}</b>`;
+        } else {
+          const deps = item.missingDeps?.join(", ") ?? "requirements not met";
+          text += `\u26A0\uFE0F <b>${escapeHtml(item.name)}</b> <i>(needs: ${escapeHtml(deps)})</i>`;
+        }
+        if (item.description) {
+          text += `
+    <i>${escapeHtml(truncate(item.description, 60))}</i>`;
+        }
+        text += "\n";
+      }
+      const keyboard = new InlineKeyboard4();
+      const installable = pageItems.filter((i) => i.available);
+      for (let i = 0; i < installable.length; i += 2) {
+        const row = installable.slice(i, i + 2);
+        for (const item of row) {
+          keyboard.text(`\u2B07\uFE0F ${item.name}`, `ag:install:${item.key}`);
+        }
+        keyboard.row();
+      }
+      if (totalPages > 1) {
+        if (safePage > 0) {
+          keyboard.text("\u25C0\uFE0F Prev", `ag:page:${safePage - 1}`);
+        }
+        if (safePage < totalPages - 1) {
+          keyboard.text("Next \u25B6\uFE0F", `ag:page:${safePage + 1}`);
+        }
+        keyboard.row();
+      }
+      await ctx.editMessageText(text, { parse_mode: "HTML", reply_markup: keyboard });
+    } catch {
+    }
+  }
+}
+async function installAgentWithProgress(ctx, core, nameOrId) {
+  const catalog = core.agentCatalog;
+  const msg = await ctx.reply(`\u23F3 Installing <b>${escapeHtml(nameOrId)}</b>...`, { parse_mode: "HTML" });
+  let lastEdit = 0;
+  const EDIT_THROTTLE_MS = 1500;
+  const progress = {
+    onStart(_id, _name) {
+    },
+    async onStep(step) {
+      const now = Date.now();
+      if (now - lastEdit > EDIT_THROTTLE_MS) {
+        lastEdit = now;
+        try {
+          await ctx.api.editMessageText(msg.chat.id, msg.message_id, `\u23F3 <b>${escapeHtml(nameOrId)}</b>: ${escapeHtml(step)}`, { parse_mode: "HTML" });
+        } catch {
+        }
+      }
+    },
+    async onDownloadProgress(percent) {
+      const now = Date.now();
+      if (now - lastEdit > EDIT_THROTTLE_MS) {
+        lastEdit = now;
+        try {
+          const bar = buildProgressBar(percent);
+          await ctx.api.editMessageText(msg.chat.id, msg.message_id, `\u23F3 <b>${escapeHtml(nameOrId)}</b>
+Downloading... ${bar} ${percent}%`, { parse_mode: "HTML" });
+        } catch {
+        }
+      }
+    },
+    async onSuccess(name) {
+      try {
+        const keyboard = new InlineKeyboard4().text(`\u{1F680} Start session with ${name}`, `na:${nameOrId}`);
+        await ctx.api.editMessageText(msg.chat.id, msg.message_id, `\u2705 <b>${escapeHtml(name)}</b> installed!`, { parse_mode: "HTML", reply_markup: keyboard });
+      } catch {
+      }
+    },
+    async onError(error) {
+      try {
+        await ctx.api.editMessageText(msg.chat.id, msg.message_id, `\u274C ${escapeHtml(error)}`, { parse_mode: "HTML" });
+      } catch {
+      }
+    }
+  };
+  const result = await catalog.install(nameOrId, progress);
+  if (result.ok) {
+    const { getAgentCapabilities: getAgentCapabilities2 } = await import("./agent-dependencies-FCLRGMZM.js");
+    const caps = getAgentCapabilities2(result.agentKey);
+    if (caps.integration) {
+      const { installIntegration } = await import("./integrate-X7LI6MUO.js");
+      const intResult = await installIntegration(result.agentKey, caps.integration);
+      if (intResult.success) {
+        try {
+          await ctx.reply(`\u{1F517} Handoff integration installed for <b>${escapeHtml(result.agentKey)}</b>`, { parse_mode: "HTML" });
+        } catch {
+        }
+      }
+    }
+  }
+  if (result.ok && result.setupSteps?.length) {
+    let setupText = `\u{1F4CB} <b>Setup for ${escapeHtml(result.agentKey)}:</b>
+
+`;
+    for (const step of result.setupSteps) {
+      setupText += `\u2192 ${escapeHtml(step)}
+`;
+    }
+    setupText += `
+<i>Run in terminal: openacp agents info ${escapeHtml(result.agentKey)}</i>`;
+    try {
+      await ctx.reply(setupText, { parse_mode: "HTML" });
+    } catch {
+    }
+  }
+}
+function truncate(text, maxLen) {
+  if (text.length <= maxLen) return text;
+  return text.slice(0, maxLen - 1) + "\u2026";
+}
+function buildProgressBar(percent) {
+  const filled = Math.round(percent / 10);
+  const empty = 10 - filled;
+  return "\u2588".repeat(filled) + "\u2591".repeat(empty);
+}
+
+// src/adapters/telegram/commands/integrate.ts
+import { InlineKeyboard as InlineKeyboard5 } from "grammy";
 async function handleIntegrate(ctx, _core) {
-  const { listIntegrations } = await import("./integrate-WUPLRJD3.js");
+  const { listIntegrations } = await import("./integrate-X7LI6MUO.js");
   const agents = listIntegrations();
-  const keyboard = new InlineKeyboard4();
+  const keyboard = new InlineKeyboard5();
   for (const agent of agents) {
     keyboard.text(`\u{1F916} ${agent}`, `i:agent:${agent}`).row();
   }
@@ -3367,7 +3767,7 @@ Select an agent to manage its integrations.`,
   );
 }
 function buildAgentItemsKeyboard(agentName, items) {
-  const keyboard = new InlineKeyboard4();
+  const keyboard = new InlineKeyboard5();
   for (const item of items) {
     const installed = item.isInstalled();
     keyboard.text(
@@ -3386,9 +3786,9 @@ function setupIntegrateCallbacks(bot, core) {
     } catch {
     }
     if (data === "i:back") {
-      const { listIntegrations } = await import("./integrate-WUPLRJD3.js");
+      const { listIntegrations } = await import("./integrate-X7LI6MUO.js");
       const agents = listIntegrations();
-      const keyboard2 = new InlineKeyboard4();
+      const keyboard2 = new InlineKeyboard5();
       for (const agent of agents) {
         keyboard2.text(`\u{1F916} ${agent}`, `i:agent:${agent}`).row();
       }
@@ -3406,7 +3806,7 @@ Select an agent to manage its integrations.`,
     const agentMatch = data.match(/^i:agent:(.+)$/);
     if (agentMatch) {
       const agentName2 = agentMatch[1];
-      const { getIntegration: getIntegration2 } = await import("./integrate-WUPLRJD3.js");
+      const { getIntegration: getIntegration2 } = await import("./integrate-X7LI6MUO.js");
       const integration2 = getIntegration2(agentName2);
       if (!integration2) {
         await ctx.reply(`\u274C No integration available for '${escapeHtml(agentName2)}'.`, { parse_mode: "HTML" });
@@ -3433,7 +3833,7 @@ ${integration2.items.map((i) => `\u2022 <b>${escapeHtml(i.name)}</b> \u2014 ${es
     const action = actionMatch[1];
     const agentName = actionMatch[2];
     const itemId = actionMatch[3];
-    const { getIntegration } = await import("./integrate-WUPLRJD3.js");
+    const { getIntegration } = await import("./integrate-X7LI6MUO.js");
     const integration = getIntegration(agentName);
     if (!integration) return;
     const item = integration.items.find((i) => i.id === itemId);
@@ -3469,12 +3869,12 @@ ${resultText}`,
 }
 
 // src/adapters/telegram/commands/settings.ts
-import { InlineKeyboard as InlineKeyboard5 } from "grammy";
+import { InlineKeyboard as InlineKeyboard6 } from "grammy";
 var log12 = createChildLogger({ module: "telegram-settings" });
 function buildSettingsKeyboard(core) {
   const config = core.configManager.get();
   const fields = getSafeFields();
-  const kb = new InlineKeyboard5();
+  const kb = new InlineKeyboard6();
   for (const field of fields) {
     const value = getConfigValue(config, field.path);
     const label = formatFieldLabel(field, value);
@@ -3545,7 +3945,7 @@ function setupSettingsCallbacks(bot, core, getAssistantSession) {
     if (!fieldDef) return;
     const options = resolveOptions(fieldDef, config) ?? [];
     const currentValue = getConfigValue(config, fieldPath);
-    const kb = new InlineKeyboard5();
+    const kb = new InlineKeyboard6();
     for (const opt of options) {
       const marker = opt === String(currentValue) ? " \u2713" : "";
       kb.text(`${opt}${marker}`, `s:pick:${fieldPath}:${opt}`).row();
@@ -3617,7 +4017,7 @@ Tap to change:`, {
       await ctx.answerCallbackQuery();
     } catch {
     }
-    const { buildMenuKeyboard: buildMenuKeyboard3 } = await import("./menu-CARRTW2F.js");
+    const { buildMenuKeyboard: buildMenuKeyboard3 } = await import("./menu-J5YVH665.js");
     try {
       await ctx.editMessageText(`<b>OpenACP Menu</b>
 Choose an action:`, {
@@ -3655,7 +4055,7 @@ function buildNestedUpdate(dotPath, value) {
 }
 
 // src/adapters/telegram/commands/doctor.ts
-import { InlineKeyboard as InlineKeyboard6 } from "grammy";
+import { InlineKeyboard as InlineKeyboard7 } from "grammy";
 var log13 = createChildLogger({ module: "telegram-cmd-doctor" });
 var pendingFixesStore = /* @__PURE__ */ new Map();
 function renderReport(report) {
@@ -3673,7 +4073,7 @@ function renderReport(report) {
   lines.push(`<b>Result:</b> ${passed} passed, ${warnings} warnings, ${failed} failed${fixedStr}`);
   let keyboard;
   if (report.pendingFixes.length > 0) {
-    keyboard = new InlineKeyboard6();
+    keyboard = new InlineKeyboard7();
     for (let i = 0; i < report.pendingFixes.length; i++) {
       const label = `\u{1F527} Fix: ${report.pendingFixes[i].message.slice(0, 30)}`;
       keyboard.text(label, `m:doctor:fix:${i}`).row();
@@ -3768,6 +4168,7 @@ function setupCommands(bot, core, chatId, assistant) {
   bot.command("status", (ctx) => handleStatus(ctx, core));
   bot.command("sessions", (ctx) => handleTopics(ctx, core));
   bot.command("agents", (ctx) => handleAgents(ctx, core));
+  bot.command("install", (ctx) => handleInstall(ctx, core));
   bot.command("help", (ctx) => handleHelp(ctx));
   bot.command("menu", (ctx) => handleMenu(ctx));
   bot.command("enable_dangerous", (ctx) => handleEnableDangerous(ctx, core));
@@ -3783,6 +4184,12 @@ function setupAllCallbacks(bot, core, chatId, systemTopicIds, getAssistantSessio
   setupSessionCallbacks(bot, core, chatId, systemTopicIds);
   setupSettingsCallbacks(bot, core, getAssistantSession ?? (() => void 0));
   setupDoctorCallbacks(bot);
+  bot.callbackQuery(/^ag:/, (ctx) => handleAgentCallback(ctx, core));
+  bot.callbackQuery(/^na:/, async (ctx) => {
+    const agentKey = ctx.callbackQuery.data.replace("na:", "");
+    await ctx.answerCallbackQuery();
+    await createSessionDirect(ctx, core, chatId, agentKey, core.configManager.get().workspace.baseDir);
+  });
   bot.callbackQuery(/^m:/, async (ctx) => {
     const data = ctx.callbackQuery.data;
     try {
@@ -3827,6 +4234,7 @@ var STATIC_COMMANDS = [
   { command: "status", description: "Show status" },
   { command: "sessions", description: "List all sessions" },
   { command: "agents", description: "List available agents" },
+  { command: "install", description: "Install a new agent" },
   { command: "help", description: "Help" },
   { command: "menu", description: "Show menu" },
   { command: "enable_dangerous", description: "Auto-approve all permission requests (session only)" },
@@ -3840,7 +4248,7 @@ var STATIC_COMMANDS = [
 ];
 
 // src/adapters/telegram/permissions.ts
-import { InlineKeyboard as InlineKeyboard7 } from "grammy";
+import { InlineKeyboard as InlineKeyboard8 } from "grammy";
 import { nanoid as nanoid2 } from "nanoid";
 var log14 = createChildLogger({ module: "telegram-permissions" });
 var PermissionHandler = class {
@@ -3859,7 +4267,7 @@ var PermissionHandler = class {
       requestId: request.id,
       options: request.options.map((o) => ({ id: o.id, isAllow: o.isAllow }))
     });
-    const keyboard = new InlineKeyboard7();
+    const keyboard = new InlineKeyboard8();
     for (const option of request.options) {
       const emoji = option.isAllow ? "\u2705" : "\u274C";
       keyboard.text(`${emoji} ${option.label}`, `p:${callbackKey}:${option.id}`);
@@ -3945,9 +4353,29 @@ A session = one conversation with one AI agent working in one project folder.
 Each session gets its own Telegram topic. Chat there to give instructions to the agent.
 
 ### Agents
-An agent is an AI coding tool (e.g., Claude Code). You can configure multiple agents.
+An agent is an AI coding tool (e.g., Claude Code, Gemini, Cursor, Codex, etc.).
+OpenACP supports 28+ agents from the official ACP Registry (agentclientprotocol.com).
+You can install multiple agents and choose which one to use per session.
 The default agent is used when you don't specify one.
 
+### Agent Management
+- Browse agents: \`/agents\` in Telegram or \`openacp agents\` in CLI
+- Install: tap the install button in /agents, or \`openacp agents install <name>\`
+- Uninstall: \`openacp agents uninstall <name>\`
+- Setup/login: \`openacp agents run <name> -- <args>\` (e.g., \`openacp agents run gemini -- auth login\`)
+- Details: \`openacp agents info <name>\` shows version, dependencies, and setup steps
+
+Some agents need additional setup before they can be used:
+- Claude: requires \`claude login\`
+- Gemini: requires \`openacp agents run gemini -- auth login\`
+- Codex: requires setting \`OPENAI_API_KEY\` environment variable
+- GitHub Copilot: requires \`openacp agents run copilot -- auth login\`
+
+Agents are installed in three ways depending on the agent:
+- **npx** \u2014 Node.js agents, downloaded automatically on first use
+- **uvx** \u2014 Python agents, downloaded automatically on first use
+- **binary** \u2014 Platform-specific binaries, downloaded to \`~/.openacp/agents/\`
+
 ### Project Folder (Workspace)
 The directory where the agent reads, writes, and runs code.
 When creating a session, you choose which folder the agent works in.
@@ -4080,7 +4508,8 @@ Just chat naturally: "How do I create a session?", "What's the status?", "Someth
 | \`/cancel\` | Session topic | Cancel current session |
 | \`/status\` | Anywhere | Show status |
 | \`/sessions\` | Anywhere | List all sessions |
-| \`/agents\` | Anywhere | List available agents |
+| \`/agents\` | Anywhere | Browse & install agents from ACP Registry |
+| \`/install <name>\` | Anywhere | Install an agent |
 | \`/enable_dangerous\` | Session topic | Auto-approve all permissions |
 | \`/disable_dangerous\` | Session topic | Restore permission prompts |
 | \`/handoff\` | Session topic | Transfer session to terminal |
@@ -4127,6 +4556,14 @@ Just chat naturally: "How do I create a session?", "What's the status?", "Someth
 - \`openacp config\` \u2014 Interactive config editor
 - \`openacp reset\` \u2014 Delete all data and start fresh
 
+### Agent Management (CLI)
+- \`openacp agents\` \u2014 List all agents (installed + available from ACP Registry)
+- \`openacp agents install <name>\` \u2014 Install an agent
+- \`openacp agents uninstall <name>\` \u2014 Remove an agent
+- \`openacp agents info <name>\` \u2014 Show details, dependencies, and setup guide
+- \`openacp agents run <name> [-- args]\` \u2014 Run agent CLI directly (for login, config, etc.)
+- \`openacp agents refresh\` \u2014 Force-refresh registry cache
+
 ### Plugins
 - \`openacp install <package>\` \u2014 Install adapter plugin (e.g., \`@openacp/adapter-discord\`)
 - \`openacp uninstall <package>\` \u2014 Remove adapter plugin
@@ -4185,10 +4622,10 @@ Config file: \`~/.openacp/config.json\`
 - **telegram.chatId** \u2014 Your Telegram supergroup ID
 
 ### Agents
-- **agents.<name>.command** \u2014 Agent executable path (e.g., \`claude\`, \`codex\`)
-- **agents.<name>.args** \u2014 Arguments to pass to the agent command
-- **agents.<name>.env** \u2014 Custom environment variables for the agent subprocess
 - **defaultAgent** \u2014 Which agent to use by default
+- Agents are managed via \`/agents\` (Telegram) or \`openacp agents\` (CLI)
+- Installed agents are stored in \`~/.openacp/agents.json\`
+- Agent list is fetched from the ACP Registry CDN and cached locally (24h)
 
 ### Workspace
 - **workspace.baseDir** \u2014 Base directory for project folders (default: \`~/openacp-workspace\`)
@@ -4240,9 +4677,10 @@ Override config with env vars:
 - Check system health: Assistant can run health check
 
 ### Agent not found
-- Check available agents: \`/agents\`
-- Verify agent command is installed and in PATH
-- Check config: agent command + args must be correct
+- Check available agents: \`/agents\` or \`openacp agents\`
+- Install missing agent: \`openacp agents install <name>\`
+- Some agents need login first: \`openacp agents info <name>\` to see setup steps
+- Run agent CLI for setup: \`openacp agents run <name> -- <args>\`
 
 ### Permission request not showing
 - Check Notifications topic for the alert
@@ -4273,6 +4711,9 @@ Override config with env vars:
 
 All data is stored in \`~/.openacp/\`:
 - \`config.json\` \u2014 Configuration
+- \`agents.json\` \u2014 Installed agents (managed by AgentCatalog)
+- \`registry-cache.json\` \u2014 Cached ACP Registry data (refreshes every 24h)
+- \`agents/\` \u2014 Downloaded binary agents
 - \`sessions/\` \u2014 Session records and state
 - \`topics/\` \u2014 Topic-to-session mappings
 - \`logs/\` \u2014 System and session logs
@@ -4304,11 +4745,16 @@ async function spawnAssistant(core, adapter, assistantTopicId) {
     statusCounts.set(r.status, (statusCounts.get(r.status) ?? 0) + 1);
   }
   const topicSummary = Array.from(statusCounts.entries()).map(([status, count]) => ({ status, count }));
+  const installedAgents = Object.keys(core.agentCatalog.getInstalledEntries());
+  const availableItems = core.agentCatalog.getAvailable();
+  const availableAgentCount = availableItems.filter((i) => !i.installed).length;
   const ctx = {
     config,
     activeSessionCount: activeCount,
     totalSessionCount: allRecords.length,
-    topicSummary
+    topicSummary,
+    installedAgents,
+    availableAgentCount
   };
   const systemPrompt = buildAssistantSystemPrompt(ctx);
   const ready = session.enqueuePrompt(systemPrompt).then(() => {
@@ -4340,15 +4786,16 @@ Agents: ${agentList}`;
 Agents: ${agentList}`;
 }
 function buildAssistantSystemPrompt(ctx) {
-  const { config, activeSessionCount, totalSessionCount, topicSummary } = ctx;
-  const agentNames = Object.keys(config.agents).join(", ");
+  const { config, activeSessionCount, totalSessionCount, topicSummary, installedAgents, availableAgentCount } = ctx;
+  const agentNames = installedAgents?.length ? installedAgents.join(", ") : Object.keys(config.agents).join(", ");
   const topicBreakdown = topicSummary.map((s) => `${s.status}: ${s.count}`).join(", ") || "none";
   return `You are the OpenACP Assistant \u2014 a helpful guide for managing AI coding sessions.
 
 ## Current State
 - Active sessions: ${activeSessionCount} / ${totalSessionCount} total
 - Topics by status: ${topicBreakdown}
-- Available agents: ${agentNames}
+- Installed agents: ${agentNames}
+- Available in ACP Registry: ${availableAgentCount ?? "28+"}  more agents (use /agents to browse)
 - Default agent: ${config.defaultAgent}
 - Workspace base directory: ${config.workspace.baseDir}
 
@@ -4356,11 +4803,22 @@ function buildAssistantSystemPrompt(ctx) {
 
 ### Create Session
 - The workspace is the project directory where the agent will work (read, write, execute code). It is NOT the base directory \u2014 it should be a specific project folder like \`~/code/my-project\` or \`${config.workspace.baseDir}/my-app\`.
-- Ask which agent to use (if multiple are configured). Show available: ${agentNames}
+- Ask which agent to use (if multiple are installed). Show installed: ${agentNames}
 - Ask which project directory to use as workspace. Suggest \`${config.workspace.baseDir}\` as the base, but explain the user can provide any path.
 - Confirm before creating: show agent name + full workspace path.
 - Create via: \`openacp api new <agent> <workspace>\`
 
+### Browse & Install Agents
+- Guide users to /agents command to see all available agents (installed + from ACP Registry)
+- The /agents list is paginated with install buttons \u2014 users can tap to install directly
+- For CLI users: \`openacp agents install <name>\`
+- Some agents need login/setup after install \u2014 guide users to \`openacp agents info <name>\` for setup steps
+- To run agent CLI for login: \`openacp agents run <name> -- <args>\`
+- Common setup examples:
+  - Gemini: \`openacp agents run gemini -- auth login\`
+  - GitHub Copilot: \`openacp agents run copilot -- auth login\`
+  - Codex: needs OPENAI_API_KEY environment variable
+
 ### Check Status / List Sessions
 - Run \`openacp api status\` for active sessions overview
 - Run \`openacp api topics\` for full list with statuses
@@ -4413,12 +4871,18 @@ openacp api delete-topic <id> --force    # Force delete active
 openacp api cleanup                      # Cleanup finished topics
 openacp api cleanup --status finished,error
 
+# Agent management (user-facing CLI commands)
+openacp agents                           # List installed + available agents
+openacp agents install <name>            # Install agent from ACP Registry
+openacp agents uninstall <name>          # Remove agent
+openacp agents info <name>               # Show details & setup guide
+openacp agents run <name> -- <args>      # Run agent CLI (for login, etc.)
+openacp agents refresh                   # Force-refresh registry
+
 # System
 openacp api health                       # System health
 openacp config                           # Edit config (interactive)
 openacp config set <key> <value>         # Update config value
-openacp api config                       # Show config (deprecated)
-openacp api config set <key> <value>     # Update config (deprecated)
 openacp api adapters                     # List adapters
 openacp api tunnel                       # Tunnel status
 openacp api notify "message"             # Send notification
@@ -4801,7 +5265,7 @@ var TelegramSendQueue = class {
 
 // src/adapters/telegram/action-detect.ts
 import { nanoid as nanoid3 } from "nanoid";
-import { InlineKeyboard as InlineKeyboard8 } from "grammy";
+import { InlineKeyboard as InlineKeyboard9 } from "grammy";
 var CMD_NEW_RE = /\/new(?:\s+([^\s\u0080-\uFFFF]+)(?:\s+([^\s\u0080-\uFFFF]+))?)?/;
 var CMD_CANCEL_RE = /\/cancel\b/;
 var KW_NEW_RE = /(?:create|new)\s+session/i;
@@ -4848,7 +5312,7 @@ function removeAction(id) {
   actionMap.delete(id);
 }
 function buildActionKeyboard(actionId, action) {
-  const keyboard = new InlineKeyboard8();
+  const keyboard = new InlineKeyboard9();
   if (action.action === "new_session") {
     keyboard.text("\u2705 Create session", `a:${actionId}`);
     keyboard.text("\u274C Cancel", `a:dismiss:${actionId}`);
@@ -5577,7 +6041,7 @@ var TelegramAdapter = class extends ChannelAdapter {
         });
         return;
       }
-      const { getAgentCapabilities: getAgentCapabilities2 } = await import("./agent-registry-7HC6D4CH.js");
+      const { getAgentCapabilities: getAgentCapabilities2 } = await import("./agent-registry-KZANAFXQ.js");
       const caps = getAgentCapabilities2(agentName);
       if (!caps.supportsResume || !caps.resumeCommand) {
         await ctx.reply("This agent does not support session transfer.", {
@@ -5953,4 +6417,4 @@ export {
   TopicManager,
   TelegramAdapter
 };
-//# sourceMappingURL=chunk-66RVSUAR.js.map
+//# sourceMappingURL=chunk-PHC67OP4.js.map