@openacp/cli 0.6.10 → 2026.326.2

package/dist/{chunk-CS3KCJ5D.js → chunk-RKB2ZK6S.js}

@@ -1,7 +1,11 @@
 import {
   PRODUCT_GUIDE,
-  dispatchMessage,
-  evaluateNoise,
+  SendQueue,
+  ToolCallTracker
+} from "./chunk-5ZOFBTOR.js";
+import {
+  BaseRenderer,
+  MessagingAdapter,
   extractContentText,
   formatTokens,
   formatToolSummary,
@@ -11,38 +15,35 @@ import {
   splitMessage,
   stripCodeFences,
   truncateContent
-} from "./chunk-OWP7RZ62.js";
-import {
-  CheckpointReader,
-  DEFAULT_MAX_TOKENS
-} from "./chunk-LGP2YGRL.js";
-import {
-  ChannelAdapter
-} from "./chunk-LBIKITQT.js";
-import {
-  DoctorEngine
-} from "./chunk-NVPG6JCL.js";
+} from "./chunk-V2M243KZ.js";
 import {
   buildMenuKeyboard,
   buildSkillMessages,
   handleClear,
   handleHelp,
   handleMenu
-} from "./chunk-7QJS2XBD.js";
+} from "./chunk-AFKX424Q.js";
+import {
+  DoctorEngine
+} from "./chunk-L7YNNBI5.js";
+import {
+  CheckpointReader,
+  DEFAULT_MAX_TOKENS
+} from "./chunk-APS6UEFU.js";
 import {
   getConfigValue,
   getSafeFields,
   isHotReloadable,
   resolveOptions
-} from "./chunk-JHYXKVV2.js";
+} from "./chunk-ODUM3D6X.js";
 import {
   createChildLogger
-} from "./chunk-GAK6PIBW.js";
+} from "./chunk-XMMAGAT4.js";
 
-// src/adapters/telegram/adapter.ts
+// src/plugins/telegram/adapter.ts
 import { Bot, InputFile } from "grammy";
 
-// src/adapters/telegram/topics.ts
+// src/plugins/telegram/topics.ts
 async function ensureTopics(bot, chatId, config, saveConfig) {
   let notificationTopicId = config.notificationTopicId;
   let assistantTopicId = config.assistantTopicId;
@@ -79,10 +80,10 @@ function buildDeepLink(chatId, threadId, messageId) {
   return `https://t.me/c/${cleanId}/${threadId}`;
 }
 
-// src/adapters/telegram/commands/new-session.ts
+// src/plugins/telegram/commands/new-session.ts
 import { InlineKeyboard as InlineKeyboard2 } from "grammy";
 
-// src/adapters/telegram/formatting.ts
+// src/plugins/telegram/formatting.ts
 function escapeHtml(text) {
   if (!text) return "";
   return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
@@ -169,6 +170,23 @@ function formatViewerLinks(links, filePath) {
 \u{1F4DD} <a href="${escapeHtml(links.diff)}">View diff${fileName ? ` \u2014 ${escapeHtml(fileName)}` : ""}</a>`;
   return text;
 }
+function formatPlan(plan, verbosity = "medium") {
+  const { entries } = plan;
+  if (verbosity === "medium") {
+    const done = entries.filter((e) => e.status === "completed").length;
+    return `\u{1F4CB} <b>Plan:</b> ${done}/${entries.length} steps completed`;
+  }
+  const statusIcon = {
+    pending: "\u2B1C",
+    in_progress: "\u{1F504}",
+    completed: "\u2705"
+  };
+  const lines = entries.map(
+    (e, i) => `${statusIcon[e.status] || "\u2B1C"} ${i + 1}. ${escapeHtml(e.content)}`
+  );
+  return `<b>Plan:</b>
+${lines.join("\n")}`;
+}
 function formatUsage(usage, verbosity = "medium") {
   const { tokensUsed, contextSize, cost } = usage;
   if (tokensUsed == null) return "\u{1F4CA} Usage data unavailable";
@@ -228,7 +246,7 @@ function splitMessage2(text, maxLength = 3800) {
   return splitMessage(text, maxLength);
 }
 
-// src/adapters/telegram/commands/admin.ts
+// src/plugins/telegram/commands/admin.ts
 import { InlineKeyboard } from "grammy";
 var log = createChildLogger({ module: "telegram-cmd-admin" });
 function setupDangerousModeCallbacks(bot, core) {
@@ -586,7 +604,7 @@ async function handleRestart(ctx, core) {
   await core.requestRestart();
 }
 
-// src/adapters/telegram/commands/new-session.ts
+// src/plugins/telegram/commands/new-session.ts
 var log2 = createChildLogger({ module: "telegram-cmd-new-session" });
 var pendingNewSessions = /* @__PURE__ */ new Map();
 var PENDING_TIMEOUT_MS = 5 * 60 * 1e3;
@@ -974,7 +992,7 @@ Or just the folder name like <code>my-project</code> (will use ${core.configMana
   });
 }
 
-// src/adapters/telegram/commands/session.ts
+// src/plugins/telegram/commands/session.ts
 import { InlineKeyboard as InlineKeyboard3 } from "grammy";
 var log3 = createChildLogger({ module: "telegram-cmd-session" });
 async function handleCancel(ctx, core, assistant) {
@@ -1399,7 +1417,7 @@ async function handleSummaryCallback(ctx, core, chatId) {
   }
 }
 
-// src/adapters/telegram/commands/agents.ts
+// src/plugins/telegram/commands/agents.ts
 import { InlineKeyboard as InlineKeyboard4 } from "grammy";
 var AGENTS_PER_PAGE = 6;
 async function handleAgents(ctx, core, page = 0) {
@@ -1598,10 +1616,10 @@ Downloading... ${bar} ${percent}%`, { parse_mode: "HTML" });
   };
   const result = await catalog.install(nameOrId, progress);
   if (result.ok) {
-    const { getAgentCapabilities } = await import("./agent-dependencies-4OWBMZWZ.js");
+    const { getAgentCapabilities } = await import("./agent-dependencies-WS7Z2DFW.js");
     const caps = getAgentCapabilities(result.agentKey);
     if (caps.integration) {
-      const { installIntegration } = await import("./integrate-PNEHRY2I.js");
+      const { installIntegration } = await import("./integrate-5C6KSU6D.js");
       const intResult = await installIntegration(result.agentKey, caps.integration);
       if (intResult.success) {
         try {
@@ -1668,10 +1686,10 @@ function buildProgressBar(percent) {
   return "\u2588".repeat(filled) + "\u2591".repeat(empty);
 }
 
-// src/adapters/telegram/commands/integrate.ts
+// src/plugins/telegram/commands/integrate.ts
 import { InlineKeyboard as InlineKeyboard5 } from "grammy";
 async function handleIntegrate(ctx, _core) {
-  const { listIntegrations } = await import("./integrate-PNEHRY2I.js");
+  const { listIntegrations } = await import("./integrate-5C6KSU6D.js");
   const agents = listIntegrations();
   const keyboard = new InlineKeyboard5();
   for (const agent of agents) {
@@ -1704,7 +1722,7 @@ function setupIntegrateCallbacks(bot, core) {
     } catch {
     }
     if (data === "i:back") {
-      const { listIntegrations } = await import("./integrate-PNEHRY2I.js");
+      const { listIntegrations } = await import("./integrate-5C6KSU6D.js");
       const agents = listIntegrations();
       const keyboard2 = new InlineKeyboard5();
       for (const agent of agents) {
@@ -1724,7 +1742,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-PNEHRY2I.js");
+      const { getIntegration: getIntegration2 } = await import("./integrate-5C6KSU6D.js");
       const integration2 = getIntegration2(agentName2);
       if (!integration2) {
         await ctx.reply(`\u274C No integration available for '${escapeHtml(agentName2)}'.`, { parse_mode: "HTML" });
@@ -1751,7 +1769,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-PNEHRY2I.js");
+    const { getIntegration } = await import("./integrate-5C6KSU6D.js");
     const integration = getIntegration(agentName);
     if (!integration) return;
     const item = integration.items.find((i) => i.id === itemId);
@@ -1786,7 +1804,7 @@ ${resultText}`,
   });
 }
 
-// src/adapters/telegram/commands/resume.ts
+// src/plugins/telegram/commands/resume.ts
 import * as fs from "fs";
 import * as path from "path";
 import * as os from "os";
@@ -2063,7 +2081,7 @@ Or just the folder name (will use workspace baseDir)`,
   });
 }
 
-// src/adapters/telegram/commands/settings.ts
+// src/plugins/telegram/commands/settings.ts
 import { InlineKeyboard as InlineKeyboard7 } from "grammy";
 var log5 = createChildLogger({ module: "telegram-settings" });
 function buildSettingsKeyboard(core) {
@@ -2235,7 +2253,7 @@ Tap to change:`, {
       await ctx.answerCallbackQuery();
     } catch {
     }
-    const { buildMenuKeyboard: buildMenuKeyboard3 } = await import("./menu-YY5MKHEK.js");
+    const { buildMenuKeyboard: buildMenuKeyboard3 } = await import("./menu-YDQ2LWAR.js");
     try {
       await ctx.editMessageText(`<b>OpenACP Menu</b>
 Choose an action:`, {
@@ -2272,7 +2290,7 @@ function buildNestedUpdate(dotPath, value) {
   return result;
 }
 
-// src/adapters/telegram/commands/doctor.ts
+// src/plugins/telegram/commands/doctor.ts
 import { InlineKeyboard as InlineKeyboard8 } from "grammy";
 var log6 = createChildLogger({ module: "telegram-cmd-doctor" });
 var pendingFixesStore = /* @__PURE__ */ new Map();
@@ -2378,7 +2396,7 @@ function setupDoctorCallbacks(bot) {
   });
 }
 
-// src/adapters/telegram/commands/tunnel.ts
+// src/plugins/telegram/commands/tunnel.ts
 import { InlineKeyboard as InlineKeyboard9 } from "grammy";
 var log7 = createChildLogger({ module: "telegram-cmd-tunnel" });
 async function handleTunnel(ctx, core) {
@@ -2534,7 +2552,7 @@ function setupTunnelCallbacks(bot, core) {
   });
 }
 
-// src/adapters/telegram/commands/index.ts
+// src/plugins/telegram/commands/index.ts
 function setupCommands(bot, core, chatId, assistant) {
   bot.command("new", (ctx) => handleNew(ctx, core, chatId, assistant));
   bot.command("newchat", (ctx) => handleNewChat(ctx, core, chatId));
@@ -2653,7 +2671,7 @@ var STATIC_COMMANDS = [
   { command: "resume", description: "Resume with conversation history from Entire checkpoints" }
 ];
 
-// src/adapters/telegram/permissions.ts
+// src/plugins/telegram/permissions.ts
 import { InlineKeyboard as InlineKeyboard10 } from "grammy";
 import { nanoid } from "nanoid";
 var log8 = createChildLogger({ module: "telegram-permissions" });
@@ -2733,7 +2751,7 @@ ${escapeHtml(request.description)}`,
   }
 };
 
-// src/adapters/telegram/assistant.ts
+// src/plugins/telegram/assistant.ts
 var log9 = createChildLogger({ module: "telegram-assistant" });
 async function spawnAssistant(core, adapter, assistantTopicId) {
   const config = core.configManager.get();
@@ -2934,7 +2952,7 @@ function redirectToAssistant(chatId, assistantTopicId) {
   return `\u{1F4AC} Please use the <a href="${link}">\u{1F916} Assistant</a> topic to chat with OpenACP.`;
 }
 
-// src/adapters/telegram/activity.ts
+// src/plugins/telegram/activity.ts
 var log10 = createChildLogger({ module: "telegram:activity" });
 var THINKING_REFRESH_MS = 15e3;
 var THINKING_MAX_MS = 3 * 60 * 1e3;
@@ -3232,73 +3250,7 @@ var ActivityTracker = class {
   }
 };
 
-// src/adapters/telegram/send-queue.ts
-var TelegramSendQueue = class {
-  items = [];
-  processing = false;
-  lastExec = 0;
-  minInterval;
-  constructor(minInterval = 3e3) {
-    this.minInterval = minInterval;
-  }
-  enqueue(fn, opts) {
-    const type = opts?.type ?? "other";
-    const key = opts?.key;
-    return new Promise((resolve, reject) => {
-      if (type === "text" && key) {
-        const idx = this.items.findIndex(
-          (item) => item.type === "text" && item.key === key
-        );
-        if (idx !== -1) {
-          this.items[idx].resolve(void 0);
-          this.items[idx] = { fn, type, key, resolve, reject };
-          this.scheduleProcess();
-          return;
-        }
-      }
-      this.items.push({ fn, type, key, resolve, reject });
-      this.scheduleProcess();
-    });
-  }
-  onRateLimited() {
-    const remaining = [];
-    for (const item of this.items) {
-      if (item.type === "text") {
-        item.resolve(void 0);
-      } else {
-        remaining.push(item);
-      }
-    }
-    this.items = remaining;
-  }
-  scheduleProcess() {
-    if (this.processing) return;
-    if (this.items.length === 0) return;
-    const elapsed = Date.now() - this.lastExec;
-    const delay = Math.max(0, this.minInterval - elapsed);
-    this.processing = true;
-    setTimeout(() => void this.processNext(), delay);
-  }
-  async processNext() {
-    const item = this.items.shift();
-    if (!item) {
-      this.processing = false;
-      return;
-    }
-    try {
-      const result = await item.fn();
-      item.resolve(result);
-    } catch (err) {
-      item.reject(err);
-    } finally {
-      this.lastExec = Date.now();
-      this.processing = false;
-      this.scheduleProcess();
-    }
-  }
-};
-
-// src/adapters/telegram/action-detect.ts
+// src/plugins/telegram/action-detect.ts
 import { nanoid as nanoid2 } from "nanoid";
 import { InlineKeyboard as InlineKeyboard11 } from "grammy";
 var CMD_NEW_RE = /\/new(?:\s+([^\s\u0080-\uFFFF]+)(?:\s+([^\s\u0080-\uFFFF]+))?)?/;
@@ -3455,32 +3407,25 @@ function setupActionCallbacks(bot, core, chatId, getAssistantSessionId) {
   });
 }
 
-// src/adapters/telegram/tool-call-tracker.ts
+// src/plugins/telegram/tool-call-tracker.ts
 var log11 = createChildLogger({ module: "tool-call-tracker" });
-var ToolCallTracker = class {
+var TelegramToolCallTracker = class {
   constructor(bot, chatId, sendQueue) {
     this.bot = bot;
     this.chatId = chatId;
     this.sendQueue = sendQueue;
   }
-  sessions = /* @__PURE__ */ new Map();
+  tracker = new ToolCallTracker();
+  /** Platform-specific ready-promise per tool call, keyed by `${sessionId}:${toolId}`. */
+  readyMap = /* @__PURE__ */ new Map();
   async trackNewCall(sessionId, threadId, meta, verbosity = "medium") {
-    if (!this.sessions.has(sessionId)) {
-      this.sessions.set(sessionId, /* @__PURE__ */ new Map());
-    }
     let resolveReady;
     const ready = new Promise((r) => {
       resolveReady = r;
     });
-    this.sessions.get(sessionId).set(meta.id, {
-      msgId: 0,
-      name: meta.name,
-      kind: meta.kind,
-      rawInput: meta.rawInput,
-      viewerLinks: meta.viewerLinks,
-      viewerFilePath: meta.viewerFilePath,
-      ready
-    });
+    const key = `${sessionId}:${meta.id}`;
+    this.readyMap.set(key, { ready });
+    this.tracker.track(sessionId, meta, "0");
     try {
       const msg = await this.sendQueue.enqueue(
         () => this.bot.api.sendMessage(this.chatId, formatToolCall(meta, verbosity), {
@@ -3489,53 +3434,60 @@ var ToolCallTracker = class {
           disable_notification: true
         })
       );
-      const toolEntry = this.sessions.get(sessionId).get(meta.id);
-      toolEntry.msgId = msg.message_id;
+      const tracked = this.tracker.update(sessionId, meta.id, meta.status ?? "running");
+      if (tracked) {
+        tracked.messageId = String(msg.message_id);
+      }
     } finally {
       resolveReady();
     }
   }
   async updateCall(sessionId, meta, verbosity = "medium") {
-    const toolState = this.sessions.get(sessionId)?.get(meta.id);
-    if (!toolState) return;
-    if (meta.viewerLinks) {
-      toolState.viewerLinks = meta.viewerLinks;
-      log11.debug(
-        { toolId: meta.id, viewerLinks: meta.viewerLinks },
-        "Accumulated viewerLinks"
-      );
-    }
-    if (meta.viewerFilePath) toolState.viewerFilePath = meta.viewerFilePath;
-    if (meta.name) toolState.name = meta.name;
-    if (meta.kind) toolState.kind = meta.kind;
+    const key = `${sessionId}:${meta.id}`;
+    const readyState = this.readyMap.get(key);
+    const tracked = this.tracker.update(sessionId, meta.id, meta.status, {
+      viewerLinks: meta.viewerLinks,
+      viewerFilePath: meta.viewerFilePath,
+      name: meta.name,
+      kind: meta.kind
+    });
+    if (!tracked) return;
     const isTerminal = meta.status === "completed" || meta.status === "failed";
     if (!isTerminal) return;
-    await toolState.ready;
+    if (readyState) {
+      await readyState.ready;
+    }
+    const msgId = Number(tracked.messageId);
     log11.debug(
       {
         toolId: meta.id,
         status: meta.status,
-        hasViewerLinks: !!toolState.viewerLinks,
-        viewerLinks: toolState.viewerLinks,
-        name: toolState.name,
-        msgId: toolState.msgId
+        hasViewerLinks: !!tracked.viewerLinks,
+        viewerLinks: tracked.viewerLinks,
+        name: tracked.name,
+        msgId
       },
       "Tool completed, preparing edit"
     );
     const merged = {
-      ...meta,
-      name: toolState.name,
-      kind: toolState.kind,
-      rawInput: toolState.rawInput,
-      viewerLinks: toolState.viewerLinks,
-      viewerFilePath: toolState.viewerFilePath
+      id: meta.id,
+      name: tracked.name,
+      kind: tracked.kind,
+      rawInput: tracked.rawInput,
+      viewerLinks: tracked.viewerLinks,
+      viewerFilePath: tracked.viewerFilePath,
+      displaySummary: tracked.displaySummary,
+      displayTitle: tracked.displayTitle,
+      displayKind: tracked.displayKind,
+      status: meta.status,
+      content: meta.content
     };
     const formattedText = formatToolUpdate(merged, verbosity);
     try {
       await this.sendQueue.enqueue(
         () => this.bot.api.editMessageText(
           this.chatId,
-          toolState.msgId,
+          msgId,
           formattedText,
           { parse_mode: "HTML" }
         )
@@ -3544,7 +3496,7 @@ var ToolCallTracker = class {
       log11.warn(
         {
           err,
-          msgId: toolState.msgId,
+          msgId,
           textLen: formattedText.length,
           hasViewerLinks: !!merged.viewerLinks
         },
@@ -3553,11 +3505,15 @@ var ToolCallTracker = class {
     }
   }
   cleanup(sessionId) {
-    this.sessions.delete(sessionId);
+    const active = this.tracker.getActive(sessionId);
+    for (const tool of active) {
+      this.readyMap.delete(`${sessionId}:${tool.id}`);
+    }
+    this.tracker.clear(sessionId);
   }
 };
 
-// src/adapters/telegram/streaming.ts
+// src/plugins/telegram/streaming.ts
 var FLUSH_INTERVAL = 5e3;
 var MessageDraft = class {
   constructor(bot, chatId, threadId, sendQueue, sessionId) {
@@ -3739,7 +3695,7 @@ var MessageDraft = class {
   }
 };
 
-// src/adapters/telegram/draft-manager.ts
+// src/plugins/telegram/draft-manager.ts
 var DraftManager = class {
   constructor(bot, chatId, sendQueue) {
     this.bot = bot;
@@ -3811,7 +3767,7 @@ var DraftManager = class {
   }
 };
 
-// src/adapters/telegram/skill-command-manager.ts
+// src/plugins/telegram/skill-command-manager.ts
 var log12 = createChildLogger({ module: "skill-commands" });
 var SkillCommandManager = class {
   // sessionId → pinned msgId
@@ -3906,7 +3862,57 @@ var SkillCommandManager = class {
   }
 };
 
-// src/adapters/telegram/adapter.ts
+// src/plugins/telegram/renderer.ts
+var TelegramRenderer = class extends BaseRenderer {
+  renderToolCall(content, verbosity) {
+    const meta = content.metadata ?? {};
+    return { body: formatToolCall(meta, verbosity), format: "html" };
+  }
+  renderToolUpdate(content, verbosity) {
+    const meta = content.metadata ?? {};
+    return { body: formatToolUpdate(meta, verbosity), format: "html" };
+  }
+  renderPlan(content, verbosity) {
+    const meta = content.metadata;
+    return { body: formatPlan({ entries: meta?.entries ?? [] }, verbosity), format: "html" };
+  }
+  renderUsage(content, verbosity) {
+    const meta = content.metadata;
+    return { body: formatUsage(meta ?? {}, verbosity), format: "html" };
+  }
+  renderError(content) {
+    return { body: `\u274C <b>Error:</b> ${escapeHtml(content.text)}`, format: "html" };
+  }
+  renderNotification(notification) {
+    const emoji = {
+      completed: "\u2705",
+      error: "\u274C",
+      permission: "\u{1F510}",
+      input_required: "\u{1F4AC}",
+      budget_warning: "\u26A0\uFE0F"
+    };
+    let text = `${emoji[notification.type] || "\u2139\uFE0F"} <b>${escapeHtml(notification.sessionName || "Session")}</b>
+`;
+    text += escapeHtml(notification.summary);
+    return { body: text, format: "html" };
+  }
+  renderSystemMessage(content) {
+    return { body: escapeHtml(content.text), format: "html" };
+  }
+  renderModeChange(content) {
+    const modeId = content.metadata?.modeId ?? "";
+    return { body: `\u{1F504} <b>Mode:</b> ${escapeHtml(String(modeId))}`, format: "html" };
+  }
+  renderConfigUpdate() {
+    return { body: "\u2699\uFE0F <b>Config updated</b>", format: "html" };
+  }
+  renderModelUpdate(content) {
+    const modelId = content.metadata?.modelId ?? "";
+    return { body: `\u{1F916} <b>Model:</b> ${escapeHtml(String(modelId))}`, format: "html" };
+  }
+};
+
+// src/plugins/telegram/adapter.ts
 var log13 = createChildLogger({ module: "telegram" });
 function patchedFetch(input, init) {
   if (init?.signal && !(init.signal instanceof AbortSignal)) {
@@ -3921,7 +3927,18 @@ function patchedFetch(input, init) {
   }
   return fetch(input, init);
 }
-var TelegramAdapter = class extends ChannelAdapter {
+var TelegramAdapter = class extends MessagingAdapter {
+  name = "telegram";
+  renderer = new TelegramRenderer();
+  capabilities = {
+    streaming: true,
+    richFormatting: true,
+    threads: true,
+    reactions: true,
+    fileUpload: true,
+    voice: true
+  };
+  core;
   bot;
   telegramConfig;
   permissionHandler;
@@ -3929,18 +3946,22 @@ var TelegramAdapter = class extends ChannelAdapter {
   assistantInitializing = false;
   notificationTopicId;
   assistantTopicId;
-  sendQueue = new TelegramSendQueue(3e3);
+  sendQueue = new SendQueue({ minInterval: 3e3 });
+  _sessionThreadIds = /* @__PURE__ */ new Map();
   // Extracted managers
   toolTracker;
   draftManager;
   skillManager;
   fileService;
   sessionTrackers = /* @__PURE__ */ new Map();
-  get verbosity() {
-    const live = this.core.configManager.get().channels?.telegram;
-    const v = live?.displayVerbosity ?? this.telegramConfig.displayVerbosity;
-    if (v === "low" || v === "high") return v;
-    return "medium";
+  callbackCache = /* @__PURE__ */ new Map();
+  callbackCounter = 0;
+  getThreadId(sessionId) {
+    const threadId = this._sessionThreadIds.get(sessionId);
+    if (threadId === void 0) {
+      throw new Error(`No threadId stored for session ${sessionId}`);
+    }
+    return threadId;
   }
   getOrCreateTracker(sessionId, threadId) {
     let tracker = this.sessionTrackers.get(sessionId);
@@ -3956,7 +3977,11 @@ var TelegramAdapter = class extends ChannelAdapter {
     return tracker;
   }
   constructor(core, config) {
-    super(core, config);
+    super(
+      { configManager: core.configManager },
+      { ...config, maxMessageLength: 4096, enabled: config.enabled ?? true }
+    );
+    this.core = core;
     this.telegramConfig = config;
   }
   async start() {
@@ -3967,7 +3992,7 @@ var TelegramAdapter = class extends ChannelAdapter {
       }
     });
     this.fileService = this.core.fileService;
-    this.toolTracker = new ToolCallTracker(
+    this.toolTracker = new TelegramToolCallTracker(
       this.bot,
       this.telegramConfig.chatId,
       this.sendQueue
@@ -4047,6 +4072,67 @@ var TelegramAdapter = class extends ChannelAdapter {
       (sessionId) => this.core.sessionManager.getSession(sessionId),
       (notification) => this.sendNotification(notification)
     );
+    this.bot.on("message:text", async (ctx, next) => {
+      const text = ctx.message?.text;
+      if (!text?.startsWith("/")) return next();
+      const registry = this.core.lifecycleManager?.serviceRegistry?.get("command-registry");
+      if (!registry) return next();
+      const commandName = text.split(" ")[0].slice(1).split("@")[0];
+      const def = registry.get(commandName);
+      if (!def) return next();
+      const chatId = ctx.chat.id;
+      const topicId = ctx.message.message_thread_id;
+      try {
+        const sessionId = topicId != null ? this.core.sessionManager.getSessionByThread("telegram", String(topicId))?.id ?? null : null;
+        const response = await registry.execute(text, {
+          raw: "",
+          sessionId,
+          channelId: "telegram",
+          userId: String(ctx.from?.id),
+          reply: async (content) => {
+            if (typeof content === "string") {
+              await ctx.reply(content);
+            } else if (typeof content === "object" && content !== null && "type" in content) {
+              await this.renderCommandResponse(content, chatId, topicId);
+            }
+          }
+        });
+        if (response.type !== "silent") {
+          await this.renderCommandResponse(response, chatId, topicId);
+        }
+      } catch (err) {
+        await ctx.reply(`\u26A0\uFE0F Command failed: ${String(err)}`);
+      }
+    });
+    this.bot.callbackQuery(/^c\//, async (ctx) => {
+      const data = ctx.callbackQuery.data;
+      const command = this.fromCallbackData(data);
+      const registry = this.core.lifecycleManager?.serviceRegistry?.get("command-registry");
+      if (!registry) return;
+      const chatId = ctx.chat.id;
+      const topicId = ctx.callbackQuery.message?.message_thread_id;
+      try {
+        const sessionId = topicId != null ? this.core.sessionManager.getSessionByThread("telegram", String(topicId))?.id ?? null : null;
+        const response = await registry.execute(command, {
+          raw: "",
+          sessionId,
+          channelId: "telegram",
+          userId: String(ctx.from?.id),
+          reply: async (content) => {
+            if (typeof content === "string") {
+              await ctx.editMessageText(content).catch(() => {
+              });
+            }
+          }
+        });
+        await ctx.answerCallbackQuery();
+        if (response.type !== "silent") {
+          await this.renderCommandResponse(response, chatId, topicId);
+        }
+      } catch {
+        await ctx.answerCallbackQuery({ text: "Command failed" });
+      }
+    });
     setupDangerousModeCallbacks(this.bot, this.core);
     setupTTSCallbacks(this.bot, this.core);
     setupVerbosityCallbacks(this.bot, this.core);
@@ -4124,7 +4210,7 @@ var TelegramAdapter = class extends ChannelAdapter {
         });
         return;
       }
-      const { getAgentCapabilities } = await import("./agent-registry-WT4NXPYG.js");
+      const { getAgentCapabilities } = await import("./agent-registry-5LZT7CUB.js");
       const caps = getAgentCapabilities(agentName);
       if (!caps.supportsResume || !caps.resumeCommand) {
         await ctx.reply("This agent does not support session transfer.", {
@@ -4211,6 +4297,87 @@ var TelegramAdapter = class extends ChannelAdapter {
     await this.bot.stop();
     log13.info("Telegram bot stopped");
   }
+  // --- CommandRegistry response rendering ---
+  async renderCommandResponse(response, chatId, topicId) {
+    switch (response.type) {
+      case "text":
+        await this.bot.api.sendMessage(chatId, response.text, {
+          message_thread_id: topicId
+        });
+        break;
+      case "error":
+        await this.bot.api.sendMessage(
+          chatId,
+          `\u26A0\uFE0F ${response.message}`,
+          { message_thread_id: topicId }
+        );
+        break;
+      case "menu": {
+        const keyboard = response.options.map((opt) => [
+          {
+            text: `${opt.label}${opt.hint ? ` \u2014 ${opt.hint}` : ""}`,
+            callback_data: this.toCallbackData(opt.command)
+          }
+        ]);
+        await this.bot.api.sendMessage(chatId, response.title, {
+          message_thread_id: topicId,
+          reply_markup: { inline_keyboard: keyboard }
+        });
+        break;
+      }
+      case "list": {
+        const lines = response.items.map(
+          (i) => `\u2022 ${i.label}${i.detail ? ` \u2014 ${i.detail}` : ""}`
+        );
+        const text = `${response.title}
+${lines.join("\n")}`;
+        await this.bot.api.sendMessage(chatId, text, {
+          message_thread_id: topicId
+        });
+        break;
+      }
+      case "confirm": {
+        const buttons = [
+          [
+            {
+              text: "\u2705 Yes",
+              callback_data: this.toCallbackData(response.onYes)
+            }
+          ]
+        ];
+        if (response.onNo) {
+          buttons[0].push({
+            text: "\u274C No",
+            callback_data: this.toCallbackData(response.onNo)
+          });
+        }
+        await this.bot.api.sendMessage(chatId, response.question, {
+          message_thread_id: topicId,
+          reply_markup: { inline_keyboard: buttons }
+        });
+        break;
+      }
+      case "silent":
+        break;
+    }
+  }
+  toCallbackData(command) {
+    const data = `c/${command}`;
+    if (data.length <= 64) return data;
+    const id = String(++this.callbackCounter);
+    this.callbackCache.set(id, command);
+    if (this.callbackCache.size > 1e3) {
+      const first = this.callbackCache.keys().next().value;
+      if (first) this.callbackCache.delete(first);
+    }
+    return `c/#${id}`;
+  }
+  fromCallbackData(data) {
+    if (data.startsWith("c/#")) {
+      return this.callbackCache.get(data.slice(3)) ?? data.slice(2);
+    }
+    return data.slice(2);
+  }
   setupRoutes() {
     this.bot.on("message:text", async (ctx) => {
       const threadId = ctx.message.message_thread_id;
@@ -4347,250 +4514,255 @@ var TelegramAdapter = class extends ChannelAdapter {
       );
     });
   }
-  // --- MessageHandlers for dispatchMessage ---
-  messageHandlers = {
-    onThought: async (ctx, _content) => {
-      const tracker = this.getOrCreateTracker(ctx.sessionId, ctx.threadId);
-      await tracker.onThought();
-    },
-    onText: async (ctx, content) => {
-      if (!this.draftManager.hasDraft(ctx.sessionId)) {
-        const tracker = this.getOrCreateTracker(ctx.sessionId, ctx.threadId);
-        tracker.onTextStart().catch(() => {
-        });
-      }
-      const draft = this.draftManager.getOrCreate(ctx.sessionId, ctx.threadId);
-      draft.append(content.text);
-      this.draftManager.appendText(ctx.sessionId, content.text);
-    },
-    onToolCall: async (ctx, content) => {
-      const meta = content.metadata ?? {};
-      const toolName = meta.name ?? content.text ?? "Tool";
-      const toolKind = String(meta.kind ?? "other");
-      const noiseAction = evaluateNoise(toolName, toolKind, meta.rawInput);
-      if (noiseAction === "hide" && this.verbosity !== "high") return;
-      if (noiseAction === "collapse" && this.verbosity === "low") return;
-      const tracker = this.getOrCreateTracker(ctx.sessionId, ctx.threadId);
-      await tracker.onToolCall();
-      await this.draftManager.finalize(
-        ctx.sessionId,
-        this.assistantSession?.id
-      );
-      await this.toolTracker.trackNewCall(
-        ctx.sessionId,
-        ctx.threadId,
-        {
-          id: meta.id ?? "",
-          name: meta.name ?? content.text ?? "Tool",
-          kind: meta.kind,
-          status: meta.status,
-          content: meta.content,
-          rawInput: meta.rawInput,
-          viewerLinks: meta.viewerLinks,
-          viewerFilePath: meta.viewerFilePath,
-          displaySummary: meta.displaySummary,
-          displayTitle: meta.displayTitle,
-          displayKind: meta.displayKind
-        },
-        this.verbosity
+  // --- MessagingAdapter overrides ---
+  async sendMessage(sessionId, content) {
+    if (this.assistantInitializing && sessionId === this.assistantSession?.id)
+      return;
+    const session = this.core.sessionManager.getSession(sessionId);
+    if (!session) return;
+    if (session.archiving) return;
+    const threadId = Number(session.threadId);
+    if (!threadId || isNaN(threadId)) {
+      log13.warn(
+        { sessionId, threadId: session.threadId },
+        "Session has no valid threadId, skipping message"
       );
-    },
-    onToolUpdate: async (ctx, content) => {
-      const meta = content.metadata ?? {};
-      await this.toolTracker.updateCall(
-        ctx.sessionId,
+      return;
+    }
+    this._sessionThreadIds.set(sessionId, threadId);
+    try {
+      await super.sendMessage(sessionId, content);
+    } finally {
+      this._sessionThreadIds.delete(sessionId);
+    }
+  }
+  async handleThought(sessionId, _content, _verbosity) {
+    const threadId = this.getThreadId(sessionId);
+    const tracker = this.getOrCreateTracker(sessionId, threadId);
+    await tracker.onThought();
+  }
+  async handleText(sessionId, content) {
+    const threadId = this.getThreadId(sessionId);
+    if (!this.draftManager.hasDraft(sessionId)) {
+      const tracker = this.getOrCreateTracker(sessionId, threadId);
+      tracker.onTextStart().catch(() => {
+      });
+    }
+    const draft = this.draftManager.getOrCreate(sessionId, threadId);
+    draft.append(content.text);
+    this.draftManager.appendText(sessionId, content.text);
+  }
+  async handleToolCall(sessionId, content, verbosity) {
+    const threadId = this.getThreadId(sessionId);
+    const meta = content.metadata ?? {};
+    const tracker = this.getOrCreateTracker(sessionId, threadId);
+    await tracker.onToolCall();
+    await this.draftManager.finalize(
+      sessionId,
+      this.assistantSession?.id
+    );
+    await this.toolTracker.trackNewCall(
+      sessionId,
+      threadId,
+      {
+        id: meta.id ?? "",
+        name: meta.name ?? content.text ?? "Tool",
+        kind: meta.kind,
+        status: meta.status,
+        content: meta.content,
+        rawInput: meta.rawInput,
+        viewerLinks: meta.viewerLinks,
+        viewerFilePath: meta.viewerFilePath,
+        displaySummary: meta.displaySummary,
+        displayTitle: meta.displayTitle,
+        displayKind: meta.displayKind
+      },
+      verbosity
+    );
+  }
+  async handleToolUpdate(sessionId, content, verbosity) {
+    const meta = content.metadata ?? {};
+    await this.toolTracker.updateCall(
+      sessionId,
+      {
+        id: meta.id ?? "",
+        name: meta.name ?? content.text ?? "",
+        kind: meta.kind,
+        status: meta.status ?? "completed",
+        content: meta.content,
+        rawInput: meta.rawInput,
+        viewerLinks: meta.viewerLinks,
+        viewerFilePath: meta.viewerFilePath,
+        displaySummary: meta.displaySummary,
+        displayTitle: meta.displayTitle,
+        displayKind: meta.displayKind
+      },
+      verbosity
+    );
+  }
+  async handlePlan(sessionId, content, verbosity) {
+    const threadId = this.getThreadId(sessionId);
+    const meta = content.metadata ?? {};
+    const entries = meta.entries ?? [];
+    const tracker = this.getOrCreateTracker(sessionId, threadId);
+    await tracker.onPlan(
+      entries.map((e) => ({
+        content: e.content,
+        status: e.status,
+        priority: e.priority ?? "medium"
+      })),
+      verbosity
+    );
+  }
+  async handleUsage(sessionId, content, verbosity) {
+    const threadId = this.getThreadId(sessionId);
+    const meta = content.metadata;
+    await this.draftManager.finalize(
+      sessionId,
+      this.assistantSession?.id
+    );
+    const tracker = this.getOrCreateTracker(sessionId, threadId);
+    await tracker.sendUsage(meta ?? {}, verbosity);
+    if (this.notificationTopicId && sessionId !== this.assistantSession?.id) {
+      const sess = this.core.sessionManager.getSession(sessionId);
+      const sessionName = sess?.name || "Session";
+      const chatIdStr = String(this.telegramConfig.chatId);
+      const numericId = chatIdStr.startsWith("-100") ? chatIdStr.slice(4) : chatIdStr.replace("-", "");
+      const usageMsgId = tracker.getUsageMsgId();
+      const deepLink = usageMsgId ? `https://t.me/c/${numericId}/${threadId}/${usageMsgId}` : `https://t.me/c/${numericId}/${threadId}`;
+      const text = `\u2705 <b>${escapeHtml(sessionName)}</b>
+Task completed.
+
+<a href="${deepLink}">\u2192 Go to topic</a>`;
+      this.sendQueue.enqueue(
+        () => this.bot.api.sendMessage(this.telegramConfig.chatId, text, {
+          message_thread_id: this.notificationTopicId,
+          parse_mode: "HTML",
+          disable_notification: false
+        })
+      ).catch(() => {
+      });
+    }
+  }
+  async handleAttachment(sessionId, content) {
+    const threadId = this.getThreadId(sessionId);
+    if (!content.attachment) return;
+    const { attachment } = content;
+    if (attachment.size > 50 * 1024 * 1024) {
+      log13.warn(
         {
-          id: meta.id ?? "",
-          name: meta.name ?? content.text ?? "",
-          kind: meta.kind,
-          status: meta.status ?? "completed",
-          content: meta.content,
-          rawInput: meta.rawInput,
-          viewerLinks: meta.viewerLinks,
-          viewerFilePath: meta.viewerFilePath,
-          displaySummary: meta.displaySummary,
-          displayTitle: meta.displayTitle,
-          displayKind: meta.displayKind
+          sessionId,
+          fileName: attachment.fileName,
+          size: attachment.size
         },
-        this.verbosity
+        "File too large for Telegram (>50MB)"
       );
-    },
-    onPlan: async (ctx, content) => {
-      const meta = content.metadata ?? {};
-      const entries = meta.entries ?? [];
-      const tracker = this.getOrCreateTracker(ctx.sessionId, ctx.threadId);
-      await tracker.onPlan(
-        entries.map((e) => ({
-          content: e.content,
-          status: e.status,
-          priority: e.priority ?? "medium"
-        })),
-        this.verbosity
-      );
-    },
-    onUsage: async (ctx, content) => {
-      const meta = content.metadata;
-      await this.draftManager.finalize(
-        ctx.sessionId,
-        this.assistantSession?.id
+      await this.sendQueue.enqueue(
+        () => this.bot.api.sendMessage(
+          this.telegramConfig.chatId,
+          `\u26A0\uFE0F File too large to send (${Math.round(attachment.size / 1024 / 1024)}MB): ${escapeHtml(attachment.fileName)}`,
+          { message_thread_id: threadId, parse_mode: "HTML" }
+        )
       );
-      const tracker = this.getOrCreateTracker(ctx.sessionId, ctx.threadId);
-      await tracker.sendUsage(meta ?? {}, this.verbosity);
-      if (this.notificationTopicId && ctx.sessionId !== this.assistantSession?.id) {
-        const sess = this.core.sessionManager.getSession(ctx.sessionId);
-        const sessionName = sess?.name || "Session";
-        const chatIdStr = String(this.telegramConfig.chatId);
-        const numericId = chatIdStr.startsWith("-100") ? chatIdStr.slice(4) : chatIdStr.replace("-", "");
-        const usageMsgId = tracker.getUsageMsgId();
-        const deepLink = usageMsgId ? `https://t.me/c/${numericId}/${ctx.threadId}/${usageMsgId}` : `https://t.me/c/${numericId}/${ctx.threadId}`;
-        const text = `\u2705 <b>${escapeHtml(sessionName)}</b>
-Task completed.
-
-<a href="${deepLink}">\u2192 Go to topic</a>`;
-        this.sendQueue.enqueue(
-          () => this.bot.api.sendMessage(this.telegramConfig.chatId, text, {
-            message_thread_id: this.notificationTopicId,
-            parse_mode: "HTML",
-            disable_notification: false
+      return;
+    }
+    try {
+      const inputFile = new InputFile(attachment.filePath);
+      if (attachment.type === "image") {
+        await this.sendQueue.enqueue(
+          () => this.bot.api.sendPhoto(this.telegramConfig.chatId, inputFile, {
+            message_thread_id: threadId
           })
-        ).catch(() => {
-        });
-      }
-    },
-    onAttachment: async (ctx, content) => {
-      if (!content.attachment) return;
-      const { attachment } = content;
-      if (attachment.size > 50 * 1024 * 1024) {
-        log13.warn(
-          {
-            sessionId: ctx.sessionId,
-            fileName: attachment.fileName,
-            size: attachment.size
-          },
-          "File too large for Telegram (>50MB)"
         );
+      } else if (attachment.type === "audio") {
         await this.sendQueue.enqueue(
-          () => this.bot.api.sendMessage(
-            this.telegramConfig.chatId,
-            `\u26A0\uFE0F File too large to send (${Math.round(attachment.size / 1024 / 1024)}MB): ${escapeHtml(attachment.fileName)}`,
-            { message_thread_id: ctx.threadId, parse_mode: "HTML" }
-          )
+          () => this.bot.api.sendVoice(this.telegramConfig.chatId, inputFile, {
+            message_thread_id: threadId
+          })
         );
-        return;
-      }
-      try {
-        const inputFile = new InputFile(attachment.filePath);
-        if (attachment.type === "image") {
-          await this.sendQueue.enqueue(
-            () => this.bot.api.sendPhoto(this.telegramConfig.chatId, inputFile, {
-              message_thread_id: ctx.threadId
-            })
-          );
-        } else if (attachment.type === "audio") {
-          await this.sendQueue.enqueue(
-            () => this.bot.api.sendVoice(this.telegramConfig.chatId, inputFile, {
-              message_thread_id: ctx.threadId
-            })
-          );
-          const draft = this.draftManager.getDraft(ctx.sessionId);
-          if (draft) {
-            draft.stripPattern(/\[TTS\][\s\S]*?\[\/TTS\]/g).catch(() => {
-            });
-          }
-        } else {
-          await this.sendQueue.enqueue(
-            () => this.bot.api.sendDocument(this.telegramConfig.chatId, inputFile, {
-              message_thread_id: ctx.threadId
-            })
-          );
+        const draft = this.draftManager.getDraft(sessionId);
+        if (draft) {
+          draft.stripPattern(/\[TTS\][\s\S]*?\[\/TTS\]/g).catch(() => {
+          });
         }
-      } catch (err) {
-        log13.error(
-          { err, sessionId: ctx.sessionId, fileName: attachment.fileName },
-          "Failed to send attachment"
-        );
-      }
-    },
-    onSessionEnd: async (ctx, _content) => {
-      await this.draftManager.finalize(
-        ctx.sessionId,
-        this.assistantSession?.id
-      );
-      this.draftManager.cleanup(ctx.sessionId);
-      this.toolTracker.cleanup(ctx.sessionId);
-      await this.skillManager.cleanup(ctx.sessionId);
-      const tracker = this.sessionTrackers.get(ctx.sessionId);
-      if (tracker) {
-        await tracker.onComplete();
-        tracker.destroy();
-        this.sessionTrackers.delete(ctx.sessionId);
       } else {
         await this.sendQueue.enqueue(
-          () => this.bot.api.sendMessage(
-            this.telegramConfig.chatId,
-            `\u2705 <b>Done</b>`,
-            {
-              message_thread_id: ctx.threadId,
-              parse_mode: "HTML",
-              disable_notification: true
-            }
-          )
+          () => this.bot.api.sendDocument(this.telegramConfig.chatId, inputFile, {
+            message_thread_id: threadId
+          })
         );
       }
-    },
-    onError: async (ctx, content) => {
-      await this.draftManager.finalize(
-        ctx.sessionId,
-        this.assistantSession?.id
-      );
-      const tracker = this.sessionTrackers.get(ctx.sessionId);
-      if (tracker) {
-        tracker.destroy();
-        this.sessionTrackers.delete(ctx.sessionId);
-      }
-      await this.sendQueue.enqueue(
-        () => this.bot.api.sendMessage(
-          this.telegramConfig.chatId,
-          `\u274C <b>Error:</b> ${escapeHtml(content.text)}`,
-          {
-            message_thread_id: ctx.threadId,
-            parse_mode: "HTML",
-            disable_notification: true
-          }
-        )
+    } catch (err) {
+      log13.error(
+        { err, sessionId, fileName: attachment.fileName },
+        "Failed to send attachment"
       );
-    },
-    onSystemMessage: async (ctx, content) => {
+    }
+  }
+  async handleSessionEnd(sessionId, _content) {
+    const threadId = this.getThreadId(sessionId);
+    await this.draftManager.finalize(
+      sessionId,
+      this.assistantSession?.id
+    );
+    this.draftManager.cleanup(sessionId);
+    this.toolTracker.cleanup(sessionId);
+    await this.skillManager.cleanup(sessionId);
+    const tracker = this.sessionTrackers.get(sessionId);
+    if (tracker) {
+      await tracker.onComplete();
+      tracker.destroy();
+      this.sessionTrackers.delete(sessionId);
+    } else {
       await this.sendQueue.enqueue(
         () => this.bot.api.sendMessage(
           this.telegramConfig.chatId,
-          escapeHtml(content.text),
+          `\u2705 <b>Done</b>`,
           {
-            message_thread_id: ctx.threadId,
+            message_thread_id: threadId,
             parse_mode: "HTML",
             disable_notification: true
           }
         )
       );
     }
-  };
-  // --- ChannelAdapter implementations ---
-  async sendMessage(sessionId, content) {
-    if (this.assistantInitializing && sessionId === this.assistantSession?.id)
-      return;
-    const session = this.core.sessionManager.getSession(sessionId);
-    if (!session) return;
-    if (session.archiving) return;
-    const threadId = Number(session.threadId);
-    if (!threadId || isNaN(threadId)) {
-      log13.warn(
-        { sessionId, threadId: session.threadId },
-        "Session has no valid threadId, skipping message"
-      );
-      return;
+  }
+  async handleError(sessionId, content) {
+    const threadId = this.getThreadId(sessionId);
+    await this.draftManager.finalize(
+      sessionId,
+      this.assistantSession?.id
+    );
+    const tracker = this.sessionTrackers.get(sessionId);
+    if (tracker) {
+      tracker.destroy();
+      this.sessionTrackers.delete(sessionId);
     }
-    const ctx = { sessionId, threadId };
-    await dispatchMessage(this.messageHandlers, ctx, content, this.verbosity);
+    await this.sendQueue.enqueue(
+      () => this.bot.api.sendMessage(
+        this.telegramConfig.chatId,
+        `\u274C <b>Error:</b> ${escapeHtml(content.text)}`,
+        {
+          message_thread_id: threadId,
+          parse_mode: "HTML",
+          disable_notification: true
+        }
+      )
+    );
+  }
+  async handleSystem(sessionId, content) {
+    const threadId = this.getThreadId(sessionId);
+    await this.sendQueue.enqueue(
+      () => this.bot.api.sendMessage(
+        this.telegramConfig.chatId,
+        escapeHtml(content.text),
+        {
+          message_thread_id: threadId,
+          parse_mode: "HTML",
+          disable_notification: true
+        }
+      )
+    );
   }
   async sendPermissionRequest(sessionId, request) {
     log13.info({ sessionId, requestId: request.id }, "Permission request sent");
@@ -4785,4 +4957,4 @@ Task completed.
 export {
   TelegramAdapter
 };
-//# sourceMappingURL=chunk-CS3KCJ5D.js.map
+//# sourceMappingURL=chunk-RKB2ZK6S.js.map