@openacp/cli 2026.327.5 → 2026.328.2

package/dist/{chunk-XWDW3XBE.js → chunk-RXMWJHWH.js}

@@ -7,21 +7,7 @@ import {
 } from "./chunk-AFKX424Q.js";
 import {
   DoctorEngine
-} from "./chunk-QAQDGPB4.js";
-import {
-  BaseRenderer,
-  MessagingAdapter,
-  evaluateNoise,
-  extractContentText,
-  formatTokens,
-  formatToolSummary,
-  formatToolTitle,
-  progressBar,
-  resolveToolIcon,
-  splitMessage,
-  stripCodeFences,
-  truncateContent
-} from "./chunk-32LVIEPW.js";
+} from "./chunk-43JVXFYP.js";
 import {
   CheckpointReader,
   DEFAULT_MAX_TOKENS
@@ -31,10 +17,10 @@ import {
   getSafeFields,
   isHotReloadable,
   resolveOptions
-} from "./chunk-ODUM3D6X.js";
+} from "./chunk-5HKQCYOI.js";
 import {
   createChildLogger
-} from "./chunk-XMMAGAT4.js";
+} from "./chunk-R6KZYF7D.js";
 
 // src/plugins/telegram/adapter.ts
 import { Bot, InputFile } from "grammy";
@@ -79,6 +65,249 @@ function buildDeepLink(chatId, threadId, messageId) {
 // src/plugins/telegram/commands/new-session.ts
 import { InlineKeyboard as InlineKeyboard2 } from "grammy";
 
+// src/core/adapter-primitives/format-utils.ts
+function progressBar(ratio, length = 10) {
+  const filled = Math.round(Math.min(ratio, 1) * length);
+  return "\u2593".repeat(filled) + "\u2591".repeat(length - filled);
+}
+function formatTokens(n) {
+  if (n >= 1e6) {
+    const m = n / 1e6;
+    return m % 1 === 0 ? `${m}M` : `${parseFloat(m.toFixed(1))}M`;
+  }
+  if (n >= 1e3) {
+    const k = n / 1e3;
+    return k % 1 === 0 ? `${k}k` : `${parseFloat(k.toFixed(1))}k`;
+  }
+  return String(n);
+}
+function stripCodeFences(text) {
+  return text.replace(/```\w*\n?/g, "").replace(/```$/gm, "").trim();
+}
+function truncateContent(text, maxLen) {
+  if (text.length <= maxLen) return text;
+  return text.slice(0, maxLen) + "\n\u2026 (truncated)";
+}
+function splitMessage(text, maxLength) {
+  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;
+    const threshold = maxLength * 0.2;
+    let splitAt = remaining.lastIndexOf("\n\n", searchLimit);
+    if (splitAt === -1 || splitAt < threshold) {
+      splitAt = remaining.lastIndexOf("\n", searchLimit);
+    }
+    if (splitAt === -1 || splitAt < threshold) {
+      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);
+        const fenceSplit = afterFence !== -1 ? afterFence + 1 : closingFence + 3;
+        if (fenceSplit <= maxLength * 2) {
+          splitAt = fenceSplit;
+        }
+      }
+    }
+    chunks.push(remaining.slice(0, splitAt));
+    remaining = remaining.slice(splitAt).replace(/^\n+/, "");
+  }
+  return chunks;
+}
+
+// src/core/adapter-primitives/format-types.ts
+var STATUS_ICONS = {
+  pending: "\u23F3",
+  in_progress: "\u{1F504}",
+  completed: "\u2705",
+  failed: "\u274C",
+  cancelled: "\u{1F6AB}",
+  running: "\u{1F504}",
+  done: "\u2705",
+  error: "\u274C"
+};
+var KIND_ICONS = {
+  read: "\u{1F4D6}",
+  edit: "\u270F\uFE0F",
+  write: "\u270F\uFE0F",
+  delete: "\u{1F5D1}\uFE0F",
+  execute: "\u25B6\uFE0F",
+  command: "\u25B6\uFE0F",
+  bash: "\u25B6\uFE0F",
+  terminal: "\u25B6\uFE0F",
+  search: "\u{1F50D}",
+  web: "\u{1F310}",
+  fetch: "\u{1F310}",
+  agent: "\u{1F9E0}",
+  think: "\u{1F9E0}",
+  install: "\u{1F4E6}",
+  move: "\u{1F4E6}",
+  other: "\u{1F6E0}\uFE0F"
+};
+
+// src/core/adapter-primitives/message-formatter.ts
+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") return String(content);
+  const obj = content;
+  if (obj.text && typeof obj.text === "string") return obj.text;
+  if (obj.content) {
+    if (typeof obj.content === "string") return obj.content;
+    if (Array.isArray(obj.content)) {
+      return obj.content.map((c) => extractContentText(c, depth + 1)).filter(Boolean).join("\n");
+    }
+    return extractContentText(obj.content, depth + 1);
+  }
+  if (obj.input) return extractContentText(obj.input, depth + 1);
+  if (obj.output) return extractContentText(obj.output, depth + 1);
+  const keys = Object.keys(obj).filter((k) => k !== "type");
+  if (keys.length === 0) return "";
+  try {
+    return JSON.stringify(obj, null, 2);
+  } catch {
+    return "";
+  }
+}
+function parseRawInput(rawInput) {
+  try {
+    if (typeof rawInput === "string") {
+      return JSON.parse(rawInput);
+    }
+    if (typeof rawInput === "object" && rawInput !== null) {
+      return rawInput;
+    }
+  } catch {
+  }
+  return {};
+}
+function formatToolSummary(name, rawInput, displaySummary) {
+  if (displaySummary && typeof displaySummary === "string") {
+    return displaySummary;
+  }
+  const args = parseRawInput(rawInput);
+  const lowerName = name.toLowerCase();
+  if (lowerName === "read") {
+    const fp = args.file_path ?? args.filePath ?? "";
+    const limit = args.limit ? ` (${args.limit} lines)` : "";
+    return fp ? `\u{1F4D6} Read ${fp}${limit}` : `\u{1F527} ${name}`;
+  }
+  if (lowerName === "edit") {
+    const fp = args.file_path ?? args.filePath ?? "";
+    return fp ? `\u270F\uFE0F Edit ${fp}` : `\u{1F527} ${name}`;
+  }
+  if (lowerName === "write") {
+    const fp = args.file_path ?? args.filePath ?? "";
+    return fp ? `\u{1F4DD} Write ${fp}` : `\u{1F527} ${name}`;
+  }
+  if (lowerName === "bash" || lowerName === "terminal") {
+    const cmd = String(args.command ?? args.cmd ?? "").slice(0, 60);
+    return cmd ? `\u25B6\uFE0F Run: ${cmd}` : `\u25B6\uFE0F Terminal`;
+  }
+  if (lowerName === "grep") {
+    const pattern = args.pattern ?? "";
+    const path2 = args.path ?? "";
+    return pattern ? `\u{1F50D} Grep "${pattern}"${path2 ? ` in ${path2}` : ""}` : `\u{1F527} ${name}`;
+  }
+  if (lowerName === "glob") {
+    const pattern = args.pattern ?? "";
+    return pattern ? `\u{1F50D} Glob ${pattern}` : `\u{1F527} ${name}`;
+  }
+  if (lowerName === "agent") {
+    const desc = String(args.description ?? "").slice(0, 60);
+    return desc ? `\u{1F9E0} Agent: ${desc}` : `\u{1F527} ${name}`;
+  }
+  if (lowerName === "webfetch" || lowerName === "web_fetch") {
+    const url = String(args.url ?? "").slice(0, 60);
+    return url ? `\u{1F310} Fetch ${url}` : `\u{1F527} ${name}`;
+  }
+  if (lowerName === "websearch" || lowerName === "web_search") {
+    const query = String(args.query ?? "").slice(0, 60);
+    return query ? `\u{1F310} Search "${query}"` : `\u{1F527} ${name}`;
+  }
+  return `\u{1F527} ${name}`;
+}
+function formatToolTitle(name, rawInput, displayTitle) {
+  if (displayTitle && typeof displayTitle === "string") {
+    return displayTitle;
+  }
+  const args = parseRawInput(rawInput);
+  const lowerName = name.toLowerCase();
+  if (["read", "edit", "write"].includes(lowerName)) {
+    return String(args.file_path ?? args.filePath ?? name);
+  }
+  if (lowerName === "bash" || lowerName === "terminal") {
+    return String(args.command ?? args.cmd ?? name).slice(0, 60);
+  }
+  if (lowerName === "grep") {
+    const pattern = args.pattern ?? "";
+    const path2 = args.path ?? "";
+    return pattern ? `"${pattern}"${path2 ? ` in ${path2}` : ""}` : name;
+  }
+  if (lowerName === "glob") {
+    return String(args.pattern ?? name);
+  }
+  if (lowerName === "agent") {
+    return String(args.description ?? name).slice(0, 60);
+  }
+  if (["webfetch", "web_fetch"].includes(lowerName)) {
+    return String(args.url ?? name).slice(0, 60);
+  }
+  if (["websearch", "web_search"].includes(lowerName)) {
+    return String(args.query ?? name).slice(0, 60);
+  }
+  return name;
+}
+function resolveToolIcon(tool) {
+  const statusIcon = STATUS_ICONS[tool.status || ""];
+  if (statusIcon) return statusIcon;
+  const kind = tool.displayKind ?? tool.kind;
+  if (kind && KIND_ICONS[kind]) return KIND_ICONS[kind];
+  return "\u{1F527}";
+}
+var NOISE_RULES = [
+  {
+    match: (name) => name.toLowerCase() === "ls",
+    action: "hide"
+  },
+  {
+    match: (_name, kind, rawInput) => {
+      if (kind !== "read") return false;
+      const args = parseRawInput(rawInput);
+      const p = String(args.file_path ?? args.filePath ?? args.path ?? "");
+      return p.endsWith("/");
+    },
+    action: "hide"
+  },
+  {
+    match: (name) => name.toLowerCase() === "glob",
+    action: "hide"
+  },
+  {
+    match: (name) => name.toLowerCase() === "grep",
+    action: "hide"
+  }
+];
+function evaluateNoise(name, kind, rawInput) {
+  for (const rule of NOISE_RULES) {
+    if (rule.match(name, kind, rawInput)) return rule.action;
+  }
+  return null;
+}
+
 // src/plugins/telegram/formatting.ts
 function escapeHtml(text) {
   if (!text) return "";
@@ -171,23 +400,16 @@ function formatPlan(plan) {
   return `<b>Plan:</b>
 ${lines.join("\n")}`;
 }
-function formatUsage(usage, verbosity = "medium") {
-  const { tokensUsed, contextSize, cost } = usage;
+function formatUsage(usage, _verbosity = "medium") {
+  const { tokensUsed, contextSize } = usage;
   if (tokensUsed == null) return "\u{1F4CA} Usage data unavailable";
-  if (verbosity === "medium") {
-    const costStr = cost != null ? ` \xB7 $${cost.toFixed(2)}` : "";
-    return `\u{1F4CA} ${formatTokens(tokensUsed)} tokens${costStr}`;
-  }
   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}";
-  let text = `${emoji} ${formatTokens(tokensUsed)} / ${formatTokens(contextSize)} tokens
+  return `${emoji} ${formatTokens(tokensUsed)} / ${formatTokens(contextSize)} tokens
 ${bar} ${pct}%`;
-  if (cost != null) text += `
-\u{1F4B0} $${cost.toFixed(2)}`;
-  return text;
 }
 function splitMessage2(text, maxLength = 3800) {
   return splitMessage(text, maxLength);
@@ -215,14 +437,14 @@ function renderToolCard(snap) {
       const fileName = entry.viewerFilePath?.split("/").pop() ?? "";
       if (entry.viewerLinks.file)
         links.push(
-          `\u{1F4C4} <a href="${escapeHtml(entry.viewerLinks.file)}">View ${escapeHtml(fileName || "file")}</a>`
+          `<a href="${escapeHtml(entry.viewerLinks.file)}">View ${escapeHtml(fileName || "file")}</a>`
         );
       if (entry.viewerLinks.diff)
         links.push(
-          `\u{1F4DD} <a href="${escapeHtml(entry.viewerLinks.diff)}">View diff</a>`
+          `<a href="${escapeHtml(entry.viewerLinks.diff)}">View diff</a>`
         );
       if (links.length > 0) line += `
-  ${links.join(" \xB7 ")}`;
+    ${links.join(" \xB7 ")}`;
     }
     sections.push(line);
   }
@@ -247,11 +469,27 @@ function renderToolCard(snap) {
   for (const entry of running) {
     sections.push(`${entry.icon} ${escapeHtml(entry.label)}`);
   }
-  if (snap.usage?.tokensUsed != null) {
-    if (sections.length > 0) sections.push("\u2500\u2500\u2500");
-    sections.push(formatUsage(snap.usage, snap.verbosity));
+  return sections.join("\n\n");
+}
+var TELEGRAM_MAX_LENGTH = 4096;
+function splitToolCardText(text) {
+  if (text.length <= TELEGRAM_MAX_LENGTH) return [text];
+  const sections = text.split("\n\n");
+  const chunks = [];
+  let current = "";
+  for (const section of sections) {
+    const candidate = current ? `${current}
+
+${section}` : section;
+    if (candidate.length > TELEGRAM_MAX_LENGTH && current) {
+      chunks.push(current);
+      current = section;
+    } else {
+      current = candidate;
+    }
   }
-  return sections.join("\n");
+  if (current) chunks.push(current);
+  return chunks;
 }
 
 // src/plugins/telegram/commands/admin.ts
@@ -440,6 +678,15 @@ function setupTTSCallbacks(bot, core) {
       }
       return;
     }
+    if (session.voiceMode !== "on" && !core.speechService?.isTTSAvailable()) {
+      try {
+        await ctx.answerCallbackQuery({
+          text: "\u26A0\uFE0F TTS provider not installed. Use /tts install to set up."
+        });
+      } catch {
+      }
+      return;
+    }
     const newMode = session.voiceMode === "on" ? "off" : "on";
     session.setVoiceMode(newMode);
     const toastText = newMode === "on" ? "\u{1F50A} Text to Speech enabled" : "\u{1F507} Text to Speech disabled";
@@ -476,6 +723,15 @@ async function handleTTS(ctx, core) {
   }
   const args = ctx.message?.text?.split(/\s+/).slice(1) ?? [];
   const arg = args[0]?.toLowerCase();
+  if (arg === "on" || !arg) {
+    if (!core.speechService?.isTTSAvailable()) {
+      await ctx.reply(
+        "\u26A0\uFE0F TTS provider not installed.\n\nUse <code>/tts install</code> to install Edge TTS plugin.",
+        { parse_mode: "HTML" }
+      );
+      return;
+    }
+  }
   if (arg === "on") {
     session.setVoiceMode("on");
     await ctx.reply("\u{1F50A} Text to Speech enabled for this session.", {
@@ -546,7 +802,7 @@ async function handleUpdate(ctx, core) {
     );
     return;
   }
-  const { getCurrentVersion, getLatestVersion, compareVersions, runUpdate } = await import("./version-NQZBM5M7.js");
+  const { getCurrentVersion, getLatestVersion, compareVersions, runUpdate } = await import("./version-AXXV6IV2.js");
   const current = getCurrentVersion();
   const statusMsg = await ctx.reply(
     `\u{1F50D} Checking for updates... (current: v${escapeHtml(current)})`,
@@ -1290,9 +1546,22 @@ async function handleArchive(ctx, core) {
   if (!threadId) return;
   const session = core.sessionManager.getSessionByThread("telegram", String(threadId));
   const record = !session ? core.sessionManager.getRecordByThread("telegram", String(threadId)) : void 0;
-  const identifier = session?.id ?? record?.sessionId ?? `topic:${threadId}`;
+  if (!session && !record) {
+    await ctx.reply("This topic is not linked to a session.", { parse_mode: "HTML" });
+    return;
+  }
+  const identifier = session?.id ?? record?.sessionId;
+  if (!identifier) {
+    await ctx.reply("Could not determine session for this topic.", { parse_mode: "HTML" });
+    return;
+  }
+  const status = session?.status ?? record?.status;
+  if (status === "initializing") {
+    await ctx.reply("Cannot archive a session that is still initializing. Wait for it to become active.", { parse_mode: "HTML" });
+    return;
+  }
   await ctx.reply(
-    "\u26A0\uFE0F <b>Archive this session?</b>\n\nThis will:\n\u2022 Delete this topic and all messages\n\u2022 Stop the agent session (if running)\n\u2022 Remove the session record\n\n<i>This action cannot be undone.</i>",
+    "\u26A0\uFE0F <b>Archive this session?</b>\n\nThis will:\n\u2022 Delete this topic and recreate it (clearing chat history)\n\u2022 The agent session will keep running\n\n<i>Chat history cannot be recovered.</i>",
     {
       parse_mode: "HTML",
       reply_markup: new InlineKeyboard3().text("\u{1F5D1} Yes, archive", `ar:yes:${identifier}`).text("\u274C Cancel", `ar:no:${identifier}`)
@@ -1312,37 +1581,21 @@ async function handleArchiveConfirm(ctx, core, chatId) {
     await ctx.editMessageText("Archive cancelled.", { parse_mode: "HTML" });
     return;
   }
-  await ctx.editMessageText("\u{1F504} Archiving...", { parse_mode: "HTML" });
-  if (identifier.startsWith("topic:")) {
-    const topicId = Number(identifier.slice("topic:".length));
-    try {
-      await ctx.api.deleteForumTopic(chatId, topicId);
-      core.notificationManager.notifyAll({
-        sessionId: "system",
-        sessionName: `Orphan topic #${topicId}`,
-        type: "completed",
-        summary: `Orphan topic #${topicId} archived and deleted.`
-      });
-    } catch (err) {
-      core.notificationManager.notifyAll({
-        sessionId: "system",
-        sessionName: `Orphan topic #${topicId}`,
-        type: "error",
-        summary: `Failed to delete orphan topic #${topicId}: ${err.message}`
-      });
-    }
-    return;
-  }
   const result = await core.archiveSession(identifier);
   if (result.ok) {
-    core.notificationManager.notifyAll({
-      sessionId: identifier,
-      type: "completed",
-      summary: `Session archived and deleted.`
-    });
+    const adapter = core.adapters.get("telegram");
+    if (adapter) {
+      try {
+        await adapter.sendMessage(identifier, {
+          type: "text",
+          text: "Chat history cleared. Session is still active \u2014 send a message to continue."
+        });
+      } catch {
+      }
+    }
   } else {
     try {
-      await ctx.editMessageText(`\u274C Failed to archive: <code>${escapeHtml(result.error)}</code>`, { parse_mode: "HTML" });
+      await ctx.editMessageText(`Failed to archive: <code>${escapeHtml(result.error)}</code>`, { parse_mode: "HTML" });
     } catch {
       core.notificationManager.notifyAll({
         sessionId: identifier,
@@ -1552,10 +1805,10 @@ Downloading... ${bar} ${percent}%`, { parse_mode: "HTML" });
   };
   const result = await catalog.install(nameOrId, progress);
   if (result.ok) {
-    const { getAgentCapabilities } = await import("./agent-dependencies-WS7Z2DFW.js");
+    const { getAgentCapabilities } = await import("./agent-dependencies-ED2ZTUHG.js");
     const caps = getAgentCapabilities(result.agentKey);
     if (caps.integration) {
-      const { installIntegration } = await import("./integrate-G6CVXTGT.js");
+      const { installIntegration } = await import("./integrate-JIEZYDOR.js");
       const intResult = await installIntegration(result.agentKey, caps.integration);
       if (intResult.success) {
         try {
@@ -1625,7 +1878,7 @@ function buildProgressBar(percent) {
 // src/plugins/telegram/commands/integrate.ts
 import { InlineKeyboard as InlineKeyboard5 } from "grammy";
 async function handleIntegrate(ctx, _core) {
-  const { listIntegrations } = await import("./integrate-G6CVXTGT.js");
+  const { listIntegrations } = await import("./integrate-JIEZYDOR.js");
   const agents = listIntegrations();
   const keyboard = new InlineKeyboard5();
   for (const agent of agents) {
@@ -1658,7 +1911,7 @@ function setupIntegrateCallbacks(bot, core) {
     } catch {
     }
     if (data === "i:back") {
-      const { listIntegrations } = await import("./integrate-G6CVXTGT.js");
+      const { listIntegrations } = await import("./integrate-JIEZYDOR.js");
       const agents = listIntegrations();
       const keyboard2 = new InlineKeyboard5();
       for (const agent of agents) {
@@ -1678,7 +1931,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-G6CVXTGT.js");
+      const { getIntegration: getIntegration2 } = await import("./integrate-JIEZYDOR.js");
       const integration2 = getIntegration2(agentName2);
       if (!integration2) {
         await ctx.reply(`\u274C No integration available for '${escapeHtml(agentName2)}'.`, { parse_mode: "HTML" });
@@ -1705,7 +1958,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-G6CVXTGT.js");
+    const { getIntegration } = await import("./integrate-JIEZYDOR.js");
     const integration = getIntegration(agentName);
     if (!integration) return;
     const item = integration.items.find((i) => i.id === itemId);
@@ -2189,7 +2442,7 @@ Tap to change:`, {
       await ctx.answerCallbackQuery();
     } catch {
     }
-    const { buildMenuKeyboard: buildMenuKeyboard3 } = await import("./menu-YDQ2LWAR.js");
+    const { buildMenuKeyboard: buildMenuKeyboard3 } = await import("./menu-ALFN37IR.js");
     try {
       await ctx.editMessageText(`<b>OpenACP Menu</b>
 Choose an action:`, {
@@ -3361,7 +3614,7 @@ var ToolCardState = class {
   appendUsage(usage) {
     if (this.finalized) return;
     this.usage = usage;
-    this.flush();
+    this.scheduleFlush();
   }
   finalize() {
     if (this.finalized) return;
@@ -3440,9 +3693,16 @@ var ThinkingIndicator = class {
           disable_notification: true
         })
       );
-      if (result && !this.dismissed) {
-        this.msgId = result.message_id;
-        this.startRefreshTimer();
+      if (result) {
+        if (this.dismissed) {
+          try {
+            await this.api.deleteMessage(this.chatId, result.message_id);
+          } catch {
+          }
+        } else {
+          this.msgId = result.message_id;
+          this.startRefreshTimer();
+        }
       }
     } catch (err) {
       log10.warn({ err }, "ThinkingIndicator.show() failed");
@@ -3450,11 +3710,19 @@ var ThinkingIndicator = class {
       this.sending = false;
     }
   }
-  /** Clear state — stops refresh timer, no Telegram API call */
-  dismiss() {
+  /** Dismiss indicator: stops refresh timer and deletes the Telegram message */
+  async dismiss() {
+    if (this.dismissed) return;
     this.dismissed = true;
-    this.msgId = void 0;
     this.stopRefreshTimer();
+    const msgId = this.msgId;
+    this.msgId = void 0;
+    if (msgId) {
+      try {
+        await this.api.deleteMessage(this.chatId, msgId);
+      } catch {
+      }
+    }
   }
   /** Reset for a new prompt cycle */
   reset() {
@@ -3506,6 +3774,7 @@ var ToolCard = class {
   msgId;
   lastSentText;
   flushPromise = Promise.resolve();
+  overflowCount = 0;
   addTool(meta, kind, rawInput) {
     this.state.addTool(meta, kind, rawInput);
   }
@@ -3532,20 +3801,22 @@ var ToolCard = class {
     return this.msgId;
   }
   async _sendOrEdit(snapshot) {
-    const text = renderToolCard(snapshot);
-    if (!text) return;
-    if (this.msgId && text === this.lastSentText) return;
-    this.lastSentText = text;
+    const fullText = renderToolCard(snapshot);
+    if (!fullText) return;
+    if (this.msgId && fullText === this.lastSentText) return;
+    this.lastSentText = fullText;
+    const chunks = splitToolCardText(fullText);
     try {
+      const firstChunk = chunks[0];
       if (this.msgId) {
         await this.sendQueue.enqueue(
-          () => this.api.editMessageText(this.chatId, this.msgId, text, {
+          () => this.api.editMessageText(this.chatId, this.msgId, firstChunk, {
             parse_mode: "HTML"
           })
         );
       } else {
         const result = await this.sendQueue.enqueue(
-          () => this.api.sendMessage(this.chatId, text, {
+          () => this.api.sendMessage(this.chatId, firstChunk, {
             message_thread_id: this.threadId,
             parse_mode: "HTML",
             disable_notification: true
@@ -3553,6 +3824,18 @@ var ToolCard = class {
         );
         if (result) this.msgId = result.message_id;
       }
+      for (let i = 1; i < chunks.length; i++) {
+        if (i > this.overflowCount) {
+          await this.sendQueue.enqueue(
+            () => this.api.sendMessage(this.chatId, chunks[i], {
+              message_thread_id: this.threadId,
+              parse_mode: "HTML",
+              disable_notification: true
+            })
+          );
+          this.overflowCount = i;
+        }
+      }
     } catch (err) {
       log10.warn({ err }, "[ToolCard] send/edit failed");
     }
@@ -3564,52 +3847,76 @@ var ActivityTracker = class {
     this.chatId = chatId;
     this.threadId = threadId;
     this.sendQueue = sendQueue;
+    this.verbosity = verbosity;
     this.thinking = new ThinkingIndicator(api, chatId, threadId, sendQueue);
     this.toolCard = new ToolCard(api, chatId, threadId, sendQueue, verbosity);
   }
   isFirstEvent = true;
   thinking;
   toolCard;
+  verbosity;
   async onNewPrompt() {
     this.isFirstEvent = true;
-    this.thinking.dismiss();
+    await this.thinking.dismiss();
     this.thinking.reset();
+    await this.toolCard.finalize();
+    this.toolCard = new ToolCard(
+      this.api,
+      this.chatId,
+      this.threadId,
+      this.sendQueue,
+      this.verbosity
+    );
   }
   async onThought() {
     this.isFirstEvent = false;
+    await this.sealToolCardIfNeeded();
     await this.thinking.show();
   }
   async onTextStart() {
     this.isFirstEvent = false;
-    this.thinking.dismiss();
+    await this.thinking.dismiss();
+    await this.sealToolCardIfNeeded();
   }
   async onToolCall(meta, kind, rawInput) {
     this.isFirstEvent = false;
-    this.thinking.dismiss();
+    await this.thinking.dismiss();
     this.thinking.reset();
     this.toolCard.addTool(meta, kind, rawInput);
   }
+  /** Finalize current tool card and create a fresh one (when interrupted by text/thought) */
+  async sealToolCardIfNeeded() {
+    if (!this.toolCard.hasContent()) return;
+    await this.toolCard.finalize();
+    this.toolCard = new ToolCard(
+      this.api,
+      this.chatId,
+      this.threadId,
+      this.sendQueue,
+      this.verbosity
+    );
+  }
   async onToolUpdate(id, status, viewerLinks, viewerFilePath) {
     this.toolCard.updateTool(id, status, viewerLinks, viewerFilePath);
   }
   async onPlan(entries) {
     this.isFirstEvent = false;
-    this.thinking.dismiss();
+    await this.thinking.dismiss();
     this.toolCard.updatePlan(entries);
   }
-  async sendUsage(usage) {
-    this.toolCard.appendUsage(usage);
+  /** @deprecated Usage is now sent as a separate message by the adapter */
+  async sendUsage(_usage) {
   }
-  getUsageMsgId() {
+  getToolCardMsgId() {
     return this.toolCard.getMsgId();
   }
   async cleanup() {
-    this.thinking.dismiss();
+    await this.thinking.dismiss();
     await this.toolCard.finalize();
     this.toolCard.destroy();
   }
   destroy() {
-    this.thinking.dismiss();
+    void this.thinking.dismiss();
     this.toolCard.destroy();
   }
 };
@@ -4060,6 +4367,7 @@ var DraftManager = class {
   }
   drafts = /* @__PURE__ */ new Map();
   textBuffers = /* @__PURE__ */ new Map();
+  finalizedDrafts = /* @__PURE__ */ new Map();
   getOrCreate(sessionId, threadId) {
     let draft = this.drafts.get(sessionId);
     if (!draft) {
@@ -4095,6 +4403,9 @@ var DraftManager = class {
     if (!draft) return;
     this.drafts.delete(sessionId);
     const finalMsgId = await draft.finalize();
+    if (finalMsgId) {
+      this.finalizedDrafts.set(sessionId, { messageId: finalMsgId, draft });
+    }
     if (assistantSessionId && sessionId === assistantSessionId) {
       const fullText = this.textBuffers.get(sessionId);
       this.textBuffers.delete(sessionId);
@@ -4117,9 +4428,25 @@ var DraftManager = class {
       this.textBuffers.delete(sessionId);
     }
   }
+  /**
+   * Strip a regex pattern from the active or finalized draft for a session.
+   * Used by tts_strip to remove [TTS]...[/TTS] blocks after TTS audio is sent.
+   */
+  async stripPattern(sessionId, pattern) {
+    const draft = this.drafts.get(sessionId);
+    if (draft) {
+      await draft.stripPattern(pattern);
+      return;
+    }
+    const finalized = this.finalizedDrafts.get(sessionId);
+    if (finalized) {
+      await finalized.draft.stripPattern(pattern);
+    }
+  }
   cleanup(sessionId) {
     this.drafts.delete(sessionId);
     this.textBuffers.delete(sessionId);
+    this.finalizedDrafts.delete(sessionId);
   }
 };
 
@@ -4218,6 +4545,231 @@ var SkillCommandManager = class {
   }
 };
 
+// src/core/adapter-primitives/messaging-adapter.ts
+var HIDDEN_ON_LOW = /* @__PURE__ */ new Set(["thought", "usage"]);
+var MessagingAdapter = class {
+  constructor(context, adapterConfig) {
+    this.context = context;
+    this.adapterConfig = adapterConfig;
+  }
+  // === Message dispatch flow ===
+  async sendMessage(sessionId, content) {
+    const verbosity = this.getVerbosity();
+    if (!this.shouldDisplay(content, verbosity)) return;
+    await this.dispatchMessage(sessionId, content, verbosity);
+  }
+  async dispatchMessage(sessionId, content, verbosity) {
+    switch (content.type) {
+      case "text":
+        return this.handleText(sessionId, content);
+      case "thought":
+        return this.handleThought(sessionId, content, verbosity);
+      case "tool_call":
+        return this.handleToolCall(sessionId, content, verbosity);
+      case "tool_update":
+        return this.handleToolUpdate(sessionId, content, verbosity);
+      case "plan":
+        return this.handlePlan(sessionId, content, verbosity);
+      case "usage":
+        return this.handleUsage(sessionId, content, verbosity);
+      case "error":
+        return this.handleError(sessionId, content);
+      case "attachment":
+        return this.handleAttachment(sessionId, content);
+      case "system_message":
+        return this.handleSystem(sessionId, content);
+      case "session_end":
+        return this.handleSessionEnd(sessionId, content);
+      case "mode_change":
+        return this.handleModeChange(sessionId, content);
+      case "config_update":
+        return this.handleConfigUpdate(sessionId, content);
+      case "model_update":
+        return this.handleModelUpdate(sessionId, content);
+      case "user_replay":
+        return this.handleUserReplay(sessionId, content);
+      case "resource":
+        return this.handleResource(sessionId, content);
+      case "resource_link":
+        return this.handleResourceLink(sessionId, content);
+    }
+  }
+  // === Default handlers — all protected, all overridable ===
+  async handleText(_sessionId, _content) {
+  }
+  async handleThought(_sessionId, _content, _verbosity) {
+  }
+  async handleToolCall(_sessionId, _content, _verbosity) {
+  }
+  async handleToolUpdate(_sessionId, _content, _verbosity) {
+  }
+  async handlePlan(_sessionId, _content, _verbosity) {
+  }
+  async handleUsage(_sessionId, _content, _verbosity) {
+  }
+  async handleError(_sessionId, _content) {
+  }
+  async handleAttachment(_sessionId, _content) {
+  }
+  async handleSystem(_sessionId, _content) {
+  }
+  async handleSessionEnd(_sessionId, _content) {
+  }
+  async handleModeChange(_sessionId, _content) {
+  }
+  async handleConfigUpdate(_sessionId, _content) {
+  }
+  async handleModelUpdate(_sessionId, _content) {
+  }
+  async handleUserReplay(_sessionId, _content) {
+  }
+  async handleResource(_sessionId, _content) {
+  }
+  async handleResourceLink(_sessionId, _content) {
+  }
+  // === Helpers ===
+  getVerbosity() {
+    const config = this.context.configManager.get();
+    const channelConfig = config.channels;
+    const v = channelConfig?.[this.name]?.displayVerbosity ?? this.adapterConfig.displayVerbosity;
+    if (v === "low" || v === "high") return v;
+    return "medium";
+  }
+  shouldDisplay(content, verbosity) {
+    if (verbosity === "low" && HIDDEN_ON_LOW.has(content.type)) return false;
+    if (content.type === "tool_call") {
+      const meta = content.metadata ?? {};
+      const toolName = meta.name ?? content.text ?? "";
+      const toolKind = String(meta.kind ?? "other");
+      const noiseAction = evaluateNoise(toolName, toolKind, meta.rawInput);
+      if (noiseAction === "hide" && verbosity !== "high") return false;
+      if (noiseAction === "collapse" && verbosity === "low") return false;
+    }
+    return true;
+  }
+};
+
+// src/core/adapter-primitives/rendering/renderer.ts
+var BaseRenderer = class {
+  renderText(content) {
+    return { body: content.text, format: "plain" };
+  }
+  renderToolCall(content, verbosity) {
+    const meta = content.metadata ?? {};
+    const name = meta.name ?? content.text ?? "Tool";
+    const icon = resolveToolIcon(meta);
+    const label = verbosity === "low" ? formatToolTitle(
+      name,
+      meta.rawInput,
+      meta.displayTitle
+    ) : formatToolSummary(
+      name,
+      meta.rawInput,
+      meta.displaySummary
+    );
+    return { body: `${icon} ${label}`, format: "plain" };
+  }
+  renderToolUpdate(content, verbosity) {
+    const meta = content.metadata ?? {};
+    const name = meta.name ?? content.text ?? "Tool";
+    const icon = resolveToolIcon(meta);
+    const label = verbosity === "low" ? formatToolTitle(
+      name,
+      meta.rawInput,
+      meta.displayTitle
+    ) : formatToolSummary(
+      name,
+      meta.rawInput,
+      meta.displaySummary
+    );
+    return { body: `${icon} ${label}`, format: "plain" };
+  }
+  renderPlan(content) {
+    const entries = content.metadata?.entries ?? [];
+    const lines = entries.map((e, i) => {
+      const icon = e.status === "completed" ? "\u2705" : e.status === "in_progress" ? "\u{1F504}" : "\u2B1C";
+      return `${icon} ${i + 1}. ${e.content}`;
+    });
+    return { body: `\u{1F4CB} Plan
+${lines.join("\n")}`, format: "plain" };
+  }
+  renderUsage(content, verbosity) {
+    const meta = content.metadata;
+    if (!meta?.tokensUsed)
+      return { body: "\u{1F4CA} Usage data unavailable", format: "plain" };
+    const costStr = meta.cost != null ? ` \xB7 $${meta.cost.toFixed(2)}` : "";
+    if (verbosity === "medium") {
+      return {
+        body: `\u{1F4CA} ${formatTokens(meta.tokensUsed)} tokens${costStr}`,
+        format: "plain"
+      };
+    }
+    if (!meta.contextSize)
+      return {
+        body: `\u{1F4CA} ${formatTokens(meta.tokensUsed)} tokens`,
+        format: "plain"
+      };
+    const ratio = meta.tokensUsed / meta.contextSize;
+    const pct = Math.round(ratio * 100);
+    const bar = progressBar(ratio);
+    let text = `\u{1F4CA} ${formatTokens(meta.tokensUsed)} / ${formatTokens(meta.contextSize)} tokens
+${bar} ${pct}%`;
+    if (meta.cost != null) text += `
+\u{1F4B0} $${meta.cost.toFixed(2)}`;
+    return { body: text, format: "plain" };
+  }
+  renderPermission(request) {
+    return {
+      body: request.description,
+      format: "plain",
+      actions: request.options.map((o) => ({
+        id: o.id,
+        label: o.label,
+        isAllow: o.isAllow
+      }))
+    };
+  }
+  renderError(content) {
+    return { body: `\u274C Error: ${content.text}`, format: "plain" };
+  }
+  renderNotification(notification) {
+    const emoji = {
+      completed: "\u2705",
+      error: "\u274C",
+      permission: "\u{1F510}",
+      input_required: "\u{1F4AC}",
+      budget_warning: "\u26A0\uFE0F"
+    };
+    return {
+      body: `${emoji[notification.type] || "\u2139\uFE0F"} ${notification.sessionName || "Session"}
+${notification.summary}`,
+      format: "plain"
+    };
+  }
+  renderSystemMessage(content) {
+    return { body: content.text, format: "plain" };
+  }
+  renderModeChange(content) {
+    const modeId = content.metadata?.modeId ?? "";
+    return { body: `\u{1F504} Mode: ${modeId}`, format: "plain" };
+  }
+  renderConfigUpdate() {
+    return { body: "\u2699\uFE0F Config updated", format: "plain" };
+  }
+  renderModelUpdate(content) {
+    const modelId = content.metadata?.modelId ?? "";
+    return { body: `\u{1F916} Model: ${modelId}`, format: "plain" };
+  }
+  renderResource(content) {
+    const uri = content.metadata?.uri ?? "";
+    return { body: `\u{1F4C4} Resource: ${content.text} (${uri})`, format: "plain" };
+  }
+  renderResourceLink(content) {
+    const uri = content.metadata?.uri ?? "";
+    return { body: `\u{1F517} ${content.text}: ${uri}`, format: "plain" };
+  }
+};
+
 // src/plugins/telegram/renderer.ts
 var TelegramRenderer = class extends BaseRenderer {
   renderToolCall(content, verbosity) {
@@ -4600,7 +5152,7 @@ var TelegramAdapter = class extends MessagingAdapter {
         });
         return;
       }
-      const { getAgentCapabilities } = await import("./agent-registry-5LZT7CUB.js");
+      const { getAgentCapabilities } = await import("./agent-registry-YOGP656W.js");
       const caps = getAgentCapabilities(agentName);
       if (!caps.supportsResume || !caps.resumeCommand) {
         await ctx.reply("This agent does not support session transfer.", {
@@ -4681,6 +5233,11 @@ var TelegramAdapter = class extends MessagingAdapter {
     }
   }
   async stop() {
+    for (const tracker of this.sessionTrackers.values()) {
+      tracker.destroy();
+    }
+    this.sessionTrackers.clear();
+    this.sendQueue.clear();
     if (this.assistantSession) {
       await this.assistantSession.destroy();
     }
@@ -4993,14 +5550,25 @@ ${lines.join("\n")}`;
     const threadId = this.getThreadId(sessionId);
     const meta = content.metadata;
     await this.draftManager.finalize(sessionId, this.assistantSession?.id);
-    const tracker = this.getOrCreateTracker(sessionId, threadId, verbosity);
-    await tracker.sendUsage(meta ?? {});
+    const usageText = formatUsage(meta ?? {}, verbosity);
+    let usageMsgId;
+    try {
+      const result = await this.sendQueue.enqueue(
+        () => this.bot.api.sendMessage(this.telegramConfig.chatId, usageText, {
+          message_thread_id: threadId,
+          parse_mode: "HTML",
+          disable_notification: true
+        })
+      );
+      usageMsgId = result?.message_id;
+    } catch (err) {
+      log12.warn({ err, sessionId }, "Failed to send usage message");
+    }
     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.
@@ -5283,10 +5851,13 @@ Task completed.
   async cleanupSkillCommands(sessionId) {
     await this.skillManager.cleanup(sessionId);
   }
+  async stripTTSBlock(sessionId) {
+    await this.draftManager.stripPattern(sessionId, /\[TTS\][\s\S]*?\[\/TTS\]/g);
+  }
   async archiveSessionTopic(sessionId) {
     const core = this.core;
     const session = core.sessionManager.getSession(sessionId);
-    if (!session) return;
+    if (!session) throw new Error("Session not found");
     const chatId = this.telegramConfig.chatId;
     const oldTopicId = Number(session.threadId);
     session.archiving = true;
@@ -5299,12 +5870,29 @@ Task completed.
       this.sessionTrackers.delete(session.id);
     }
     await deleteSessionTopic(this.bot, chatId, oldTopicId);
+    const topicName = session.name ?? `Session ${session.id.slice(0, 6)}`;
+    const newTopicId = await createSessionTopic(this.bot, chatId, topicName);
+    session.archiving = false;
+    return String(newTopicId);
   }
 };
 
 export {
+  progressBar,
+  formatTokens,
+  stripCodeFences,
+  truncateContent,
+  splitMessage,
+  STATUS_ICONS,
+  KIND_ICONS,
+  extractContentText,
+  formatToolSummary,
+  formatToolTitle,
+  resolveToolIcon,
   PRODUCT_GUIDE,
   SendQueue,
+  MessagingAdapter,
+  BaseRenderer,
   TelegramAdapter
 };
-//# sourceMappingURL=chunk-XWDW3XBE.js.map
+//# sourceMappingURL=chunk-RXMWJHWH.js.map