@openacp/cli 2026.327.3 → 2026.328.2

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

@@ -7,20 +7,7 @@ import {
 } from "./chunk-AFKX424Q.js";
 import {
   DoctorEngine
-} from "./chunk-QAQDGPB4.js";
-import {
-  BaseRenderer,
-  MessagingAdapter,
-  extractContentText,
-  formatTokens,
-  formatToolSummary,
-  formatToolTitle,
-  progressBar,
-  resolveToolIcon,
-  splitMessage,
-  stripCodeFences,
-  truncateContent
-} from "./chunk-TRXBJEZ5.js";
+} from "./chunk-43JVXFYP.js";
 import {
   CheckpointReader,
   DEFAULT_MAX_TOKENS
@@ -30,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";
@@ -78,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 "";
@@ -125,15 +355,7 @@ function formatToolCall(tool, verbosity = "medium") {
   return text;
 }
 function formatToolUpdate(update, verbosity = "medium") {
-  const si = resolveToolIcon(update);
-  const name = update.name || "Tool";
-  const label = verbosity === "low" ? formatToolTitle(name, update.rawInput, update.displayTitle) : formatToolSummary(name, update.rawInput, update.displaySummary);
-  let text = `${si} <b>${escapeHtml(label)}</b>`;
-  text += formatViewerLinks(update.viewerLinks, update.viewerFilePath);
-  if (verbosity === "high") {
-    text += formatHighDetails(update.rawInput, update.content, 3800);
-  }
-  return text;
+  return formatToolCall(update, verbosity);
 }
 function formatHighDetails(rawInput, content, maxLen) {
   let text = "";
@@ -165,12 +387,8 @@ 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") {
+function formatPlan(plan) {
   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}",
@@ -182,27 +400,97 @@ function formatPlan(plan, verbosity = "medium") {
   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);
 }
+function renderToolCard(snap) {
+  const sections = [];
+  const { totalVisible, completedVisible, allComplete } = snap;
+  const headerCheck = allComplete ? " \u2705" : "";
+  if (totalVisible > 0) {
+    sections.push(
+      `<b>\u{1F4CB} Tools (${completedVisible}/${totalVisible})</b>${headerCheck}`
+    );
+  }
+  const visible = snap.entries.filter((e) => !e.hidden);
+  const completed = visible.filter(
+    (e) => e.status === "completed" || e.status === "done" || e.status === "failed"
+  );
+  const running = visible.filter(
+    (e) => e.status !== "completed" && e.status !== "done" && e.status !== "failed"
+  );
+  for (const entry of completed) {
+    let line = `${entry.icon} ${escapeHtml(entry.label)}`;
+    if (entry.viewerLinks) {
+      const links = [];
+      const fileName = entry.viewerFilePath?.split("/").pop() ?? "";
+      if (entry.viewerLinks.file)
+        links.push(
+          `<a href="${escapeHtml(entry.viewerLinks.file)}">View ${escapeHtml(fileName || "file")}</a>`
+        );
+      if (entry.viewerLinks.diff)
+        links.push(
+          `<a href="${escapeHtml(entry.viewerLinks.diff)}">View diff</a>`
+        );
+      if (links.length > 0) line += `
+    ${links.join(" \xB7 ")}`;
+    }
+    sections.push(line);
+  }
+  if (snap.planEntries && snap.planEntries.length > 0) {
+    const planDone = snap.planEntries.filter(
+      (e) => e.status === "completed"
+    ).length;
+    const planTotal = snap.planEntries.length;
+    sections.push(`\u2500\u2500 Plan: ${planDone}/${planTotal} \u2500\u2500`);
+    const statusIcon = {
+      completed: "\u2705",
+      in_progress: "\u{1F504}",
+      pending: "\u2B1C"
+    };
+    for (let i = 0; i < snap.planEntries.length; i++) {
+      const e = snap.planEntries[i];
+      const icon = statusIcon[e.status] ?? "\u2B1C";
+      sections.push(`${icon} ${i + 1}. ${escapeHtml(e.content)}`);
+    }
+    sections.push("\u2500\u2500\u2500\u2500");
+  }
+  for (const entry of running) {
+    sections.push(`${entry.icon} ${escapeHtml(entry.label)}`);
+  }
+  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;
+    }
+  }
+  if (current) chunks.push(current);
+  return chunks;
+}
 
 // src/plugins/telegram/commands/admin.ts
 import { InlineKeyboard } from "grammy";
@@ -390,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";
@@ -426,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.", {
@@ -496,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)})`,
@@ -1240,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}`)
@@ -1262,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,
@@ -1502,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 {
@@ -1575,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) {
@@ -1608,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) {
@@ -1628,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" });
@@ -1655,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);
@@ -2139,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:`, {
@@ -3251,6 +3554,117 @@ function redirectToAssistant(chatId, assistantTopicId) {
   return `\u{1F4AC} Please use the <a href="${link}">\u{1F916} Assistant</a> topic to chat with OpenACP.`;
 }
 
+// src/core/adapter-primitives/primitives/tool-card-state.ts
+var DEBOUNCE_MS = 500;
+var ToolCardState = class {
+  entries = [];
+  planEntries;
+  usage;
+  finalized = false;
+  isFirstFlush = true;
+  debounceTimer;
+  verbosity;
+  onFlush;
+  constructor(config) {
+    this.verbosity = config.verbosity;
+    this.onFlush = config.onFlush;
+  }
+  addTool(meta, kind, rawInput) {
+    if (this.finalized) return;
+    const hidden = this.verbosity !== "high" && evaluateNoise(meta.name, kind, rawInput) !== null;
+    const entry = {
+      id: meta.id,
+      name: meta.name,
+      kind,
+      status: meta.status ?? "running",
+      icon: resolveToolIcon({ status: meta.status ?? "running", kind }),
+      label: formatToolSummary(meta.name, rawInput, meta.displaySummary),
+      viewerLinks: meta.viewerLinks,
+      viewerFilePath: meta.viewerFilePath,
+      hidden
+    };
+    this.entries.push(entry);
+    if (this.isFirstFlush) {
+      this.isFirstFlush = false;
+      this.flush();
+    } else {
+      this.scheduleFlush();
+    }
+  }
+  updateTool(id, status, viewerLinks, viewerFilePath) {
+    if (this.finalized) return;
+    const entry = this.entries.find((e) => e.id === id);
+    if (!entry) return;
+    entry.status = status;
+    entry.icon = resolveToolIcon({ status, kind: entry.kind });
+    if (viewerLinks) entry.viewerLinks = viewerLinks;
+    if (viewerFilePath) entry.viewerFilePath = viewerFilePath;
+    this.scheduleFlush();
+  }
+  updatePlan(entries) {
+    if (this.finalized) return;
+    this.planEntries = entries;
+    if (this.entries.length === 0 && this.isFirstFlush) {
+      this.isFirstFlush = false;
+      this.flush();
+    } else {
+      this.scheduleFlush();
+    }
+  }
+  appendUsage(usage) {
+    if (this.finalized) return;
+    this.usage = usage;
+    this.scheduleFlush();
+  }
+  finalize() {
+    if (this.finalized) return;
+    this.finalized = true;
+    this.clearDebounce();
+    this.flush();
+  }
+  destroy() {
+    this.finalized = true;
+    this.clearDebounce();
+  }
+  hasContent() {
+    return this.entries.length > 0 || this.planEntries !== void 0;
+  }
+  snapshot() {
+    const visible = this.entries.filter((e) => !e.hidden);
+    const completedVisible = visible.filter(
+      (e) => e.status === "completed" || e.status === "done"
+    ).length;
+    const allComplete = visible.length > 0 && completedVisible === visible.length;
+    return {
+      entries: this.entries,
+      planEntries: this.planEntries,
+      usage: this.usage,
+      visibleCount: visible.length,
+      totalVisible: visible.length,
+      completedVisible,
+      allComplete,
+      verbosity: this.verbosity
+    };
+  }
+  flush() {
+    this.clearDebounce();
+    this.onFlush(this.snapshot());
+  }
+  scheduleFlush() {
+    this.clearDebounce();
+    this.debounceTimer = setTimeout(() => {
+      this.debounceTimer = void 0;
+      this.flush();
+    }, DEBOUNCE_MS);
+  }
+  clearDebounce() {
+    if (this.debounceTimer) {
+      clearTimeout(this.debounceTimer);
+      this.debounceTimer = void 0;
+    }
+  }
+};
+
 // src/plugins/telegram/activity.ts
 var log10 = createChildLogger({ module: "telegram:activity" });
 var THINKING_REFRESH_MS = 15e3;
@@ -3279,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");
@@ -3289,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() {
@@ -3308,20 +3737,14 @@ var ThinkingIndicator = class {
       }
       const elapsed = Math.round((Date.now() - this.showTime) / 1e3);
       this.sendQueue.enqueue(() => {
-        if (this.dismissed) return Promise.resolve(void 0);
-        return this.api.sendMessage(
+        if (this.dismissed || !this.msgId) return Promise.resolve(void 0);
+        return this.api.editMessageText(
           this.chatId,
+          this.msgId,
           `\u{1F4AD} <i>Still thinking... (${elapsed}s)</i>`,
-          {
-            message_thread_id: this.threadId,
-            parse_mode: "HTML",
-            disable_notification: true
-          }
+          { parse_mode: "HTML" }
         );
-      }).then((result) => {
-        if (result && !this.dismissed) {
-          this.msgId = result.message_id;
-        }
+      }).then(() => {
       }).catch(() => {
       });
     }, THINKING_REFRESH_MS);
@@ -3333,135 +3756,67 @@ var ThinkingIndicator = class {
     }
   }
 };
-var UsageMessage = class {
-  constructor(api, chatId, threadId, sendQueue) {
+var ToolCard = class {
+  constructor(api, chatId, threadId, sendQueue, verbosity) {
     this.api = api;
     this.chatId = chatId;
     this.threadId = threadId;
     this.sendQueue = sendQueue;
-  }
-  msgId;
-  async send(usage, verbosity = "medium") {
-    const text = formatUsage(usage, verbosity);
-    try {
-      if (this.msgId) {
-        await this.sendQueue.enqueue(
-          () => this.api.editMessageText(this.chatId, this.msgId, text, {
-            parse_mode: "HTML"
-          })
-        );
-      } else {
-        const result = await this.sendQueue.enqueue(
-          () => this.api.sendMessage(this.chatId, text, {
-            message_thread_id: this.threadId,
-            parse_mode: "HTML",
-            disable_notification: true
-          })
-        );
-        if (result) this.msgId = result.message_id;
+    this.state = new ToolCardState({
+      verbosity,
+      onFlush: (snapshot) => {
+        this.flushPromise = this.flushPromise.then(() => this._sendOrEdit(snapshot)).catch(() => {
+        });
       }
-    } catch (err) {
-      log10.warn({ err }, "UsageMessage.send() failed");
-    }
-  }
-  getMsgId() {
-    return this.msgId;
-  }
-  async delete() {
-    if (!this.msgId) return;
-    const id = this.msgId;
-    this.msgId = void 0;
-    try {
-      await this.sendQueue.enqueue(
-        () => this.api.deleteMessage(this.chatId, id)
-      );
-    } catch (err) {
-      log10.warn({ err }, "UsageMessage.delete() failed");
-    }
-  }
-};
-function formatPlanCard(entries, verbosity = "medium") {
-  if (verbosity === "medium") {
-    const done2 = entries.filter((e) => e.status === "completed").length;
-    return `\u{1F4CB} <b>Plan:</b> ${done2}/${entries.length} steps completed`;
-  }
-  const statusIcon = {
-    completed: "\u2705",
-    in_progress: "\u{1F504}",
-    pending: "\u2B1C",
-    failed: "\u274C"
-  };
-  const total = entries.length;
-  const done = entries.filter((e) => e.status === "completed").length;
-  const ratio = total > 0 ? done / total : 0;
-  const filled = Math.round(ratio * 10);
-  const bar = "\u2593".repeat(filled) + "\u2591".repeat(10 - filled);
-  const pct = Math.round(ratio * 100);
-  const header = `\u{1F4CB} <b>Plan</b>
-${bar} ${pct}% \xB7 ${done}/${total}`;
-  const lines = entries.map((e, i) => {
-    const icon = statusIcon[e.status] ?? "\u2B1C";
-    return `${icon} ${i + 1}. ${e.content}`;
-  });
-  return [header, ...lines].join("\n");
-}
-var PlanCard = class {
-  constructor(api, chatId, threadId, sendQueue) {
-    this.api = api;
-    this.chatId = chatId;
-    this.threadId = threadId;
-    this.sendQueue = sendQueue;
+    });
   }
+  state;
   msgId;
-  flushPromise = Promise.resolve();
-  latestEntries;
   lastSentText;
-  flushTimer;
-  verbosity = "medium";
-  setVerbosity(v) {
-    this.verbosity = v;
+  flushPromise = Promise.resolve();
+  overflowCount = 0;
+  addTool(meta, kind, rawInput) {
+    this.state.addTool(meta, kind, rawInput);
   }
-  update(entries) {
-    this.latestEntries = entries;
-    if (this.flushTimer) clearTimeout(this.flushTimer);
-    this.flushTimer = setTimeout(() => {
-      this.flushTimer = void 0;
-      this.flushPromise = this.flushPromise.then(() => this._flush()).catch(() => {
-      });
-    }, 3500);
+  updateTool(id, status, viewerLinks, viewerFilePath) {
+    this.state.updateTool(id, status, viewerLinks, viewerFilePath);
+  }
+  updatePlan(entries) {
+    this.state.updatePlan(entries);
+  }
+  appendUsage(usage) {
+    this.state.appendUsage(usage);
   }
   async finalize() {
-    if (!this.latestEntries) return;
-    if (this.flushTimer) {
-      clearTimeout(this.flushTimer);
-      this.flushTimer = void 0;
-    }
-    await this.flushPromise;
-    this.flushPromise = this.flushPromise.then(() => this._flush()).catch(() => {
-    });
+    this.state.finalize();
     await this.flushPromise;
   }
   destroy() {
-    if (this.flushTimer) {
-      clearTimeout(this.flushTimer);
-      this.flushTimer = void 0;
-    }
+    this.state.destroy();
+  }
+  hasContent() {
+    return this.state.hasContent();
   }
-  async _flush() {
-    if (!this.latestEntries) return;
-    const text = formatPlanCard(this.latestEntries, this.verbosity);
-    if (this.msgId && text === this.lastSentText) return;
-    this.lastSentText = text;
+  getMsgId() {
+    return this.msgId;
+  }
+  async _sendOrEdit(snapshot) {
+    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
@@ -3469,83 +3824,100 @@ var PlanCard = 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 }, "PlanCard flush failed");
+      log10.warn({ err }, "[ToolCard] send/edit failed");
     }
   }
 };
 var ActivityTracker = class {
-  constructor(api, chatId, threadId, sendQueue) {
+  constructor(api, chatId, threadId, sendQueue, verbosity = "medium") {
     this.api = api;
     this.chatId = chatId;
     this.threadId = threadId;
     this.sendQueue = sendQueue;
+    this.verbosity = verbosity;
     this.thinking = new ThinkingIndicator(api, chatId, threadId, sendQueue);
-    this.planCard = new PlanCard(api, chatId, threadId, sendQueue);
-    this.usage = new UsageMessage(api, chatId, threadId, sendQueue);
+    this.toolCard = new ToolCard(api, chatId, threadId, sendQueue, verbosity);
   }
   isFirstEvent = true;
-  hasPlanCard = false;
   thinking;
-  planCard;
-  usage;
+  toolCard;
+  verbosity;
   async onNewPrompt() {
     this.isFirstEvent = true;
-    this.hasPlanCard = false;
-    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() {
-    await this._firstEventGuard();
+    this.isFirstEvent = false;
+    await this.sealToolCardIfNeeded();
     await this.thinking.show();
   }
-  async onPlan(entries, verbosity) {
-    await this._firstEventGuard();
-    this.thinking.dismiss();
-    this.hasPlanCard = true;
-    if (verbosity) this.planCard.setVerbosity(verbosity);
-    this.planCard.update(entries);
+  async onTextStart() {
+    this.isFirstEvent = false;
+    await this.thinking.dismiss();
+    await this.sealToolCardIfNeeded();
   }
-  async onToolCall() {
-    await this._firstEventGuard();
-    this.thinking.dismiss();
+  async onToolCall(meta, kind, rawInput) {
+    this.isFirstEvent = false;
+    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 onTextStart() {
-    await this._firstEventGuard();
-    this.thinking.dismiss();
+  async onToolUpdate(id, status, viewerLinks, viewerFilePath) {
+    this.toolCard.updateTool(id, status, viewerLinks, viewerFilePath);
   }
-  async sendUsage(data, verbosity = "medium") {
-    await this.usage.send(data, verbosity);
+  async onPlan(entries) {
+    this.isFirstEvent = false;
+    await this.thinking.dismiss();
+    this.toolCard.updatePlan(entries);
   }
-  getUsageMsgId() {
-    return this.usage.getMsgId();
+  /** @deprecated Usage is now sent as a separate message by the adapter */
+  async sendUsage(_usage) {
   }
-  async onComplete() {
-    if (this.hasPlanCard) {
-      await this.planCard.finalize();
-    } else {
-      try {
-        await this.sendQueue.enqueue(
-          () => this.api.sendMessage(this.chatId, "\u2705 <b>Done</b>", {
-            message_thread_id: this.threadId,
-            parse_mode: "HTML",
-            disable_notification: true
-          })
-        );
-      } catch (err) {
-        log10.warn({ err }, "ActivityTracker.onComplete() Done send failed");
-      }
-    }
+  getToolCardMsgId() {
+    return this.toolCard.getMsgId();
   }
-  destroy() {
-    this.thinking.dismiss();
-    this.planCard.destroy();
+  async cleanup() {
+    await this.thinking.dismiss();
+    await this.toolCard.finalize();
+    this.toolCard.destroy();
   }
-  async _firstEventGuard() {
-    if (!this.isFirstEvent) return;
-    this.isFirstEvent = false;
-    await this.usage.delete();
+  destroy() {
+    void this.thinking.dismiss();
+    this.toolCard.destroy();
   }
 };
 
@@ -3804,143 +4176,6 @@ function setupActionCallbacks(bot, core, chatId, getAssistantSessionId) {
   });
 }
 
-// src/core/adapter-primitives/primitives/tool-call-tracker.ts
-var ToolCallTracker = class {
-  sessions = /* @__PURE__ */ new Map();
-  track(sessionId, meta, messageId) {
-    if (!this.sessions.has(sessionId)) {
-      this.sessions.set(sessionId, /* @__PURE__ */ new Map());
-    }
-    this.sessions.get(sessionId).set(meta.id, { ...meta, messageId });
-  }
-  update(sessionId, toolId, status, patch) {
-    const tool = this.sessions.get(sessionId)?.get(toolId);
-    if (!tool) return null;
-    tool.status = status;
-    if (patch?.viewerLinks) tool.viewerLinks = patch.viewerLinks;
-    if (patch?.viewerFilePath) tool.viewerFilePath = patch.viewerFilePath;
-    if (patch?.name) tool.name = patch.name;
-    if (patch?.kind) tool.kind = patch.kind;
-    return tool;
-  }
-  getActive(sessionId) {
-    const session = this.sessions.get(sessionId);
-    return session ? [...session.values()] : [];
-  }
-  clear(sessionId) {
-    this.sessions.delete(sessionId);
-  }
-  clearAll() {
-    this.sessions.clear();
-  }
-};
-
-// src/plugins/telegram/tool-call-tracker.ts
-var log11 = createChildLogger({ module: "tool-call-tracker" });
-var TelegramToolCallTracker = class {
-  constructor(bot, chatId, sendQueue) {
-    this.bot = bot;
-    this.chatId = chatId;
-    this.sendQueue = sendQueue;
-  }
-  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") {
-    let resolveReady;
-    const ready = new Promise((r) => {
-      resolveReady = r;
-    });
-    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), {
-          message_thread_id: threadId,
-          parse_mode: "HTML",
-          disable_notification: true
-        })
-      );
-      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 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;
-    if (readyState) {
-      await readyState.ready;
-    }
-    const msgId = Number(tracked.messageId);
-    log11.debug(
-      {
-        toolId: meta.id,
-        status: meta.status,
-        hasViewerLinks: !!tracked.viewerLinks,
-        viewerLinks: tracked.viewerLinks,
-        name: tracked.name,
-        msgId
-      },
-      "Tool completed, preparing edit"
-    );
-    const merged = {
-      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,
-          msgId,
-          formattedText,
-          { parse_mode: "HTML" }
-        )
-      );
-    } catch (err) {
-      log11.warn(
-        {
-          err,
-          msgId,
-          textLen: formattedText.length,
-          hasViewerLinks: !!merged.viewerLinks
-        },
-        "Tool update edit failed"
-      );
-    }
-  }
-  cleanup(sessionId) {
-    const active = this.tracker.getActive(sessionId);
-    for (const tool of active) {
-      this.readyMap.delete(`${sessionId}:${tool.id}`);
-    }
-    this.tracker.clear(sessionId);
-  }
-};
-
 // src/plugins/telegram/streaming.ts
 var FLUSH_INTERVAL = 5e3;
 var MessageDraft = class {
@@ -4132,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) {
@@ -4167,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);
@@ -4189,14 +4428,30 @@ 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);
   }
 };
 
 // src/plugins/telegram/skill-command-manager.ts
-var log12 = createChildLogger({ module: "skill-commands" });
+var log11 = createChildLogger({ module: "skill-commands" });
 var SkillCommandManager = class {
   // sessionId → pinned msgId
   constructor(bot, chatId, sendQueue, sessionManager) {
@@ -4262,7 +4517,7 @@ var SkillCommandManager = class {
         disable_notification: true
       });
     } catch (err) {
-      log12.error({ err, sessionId }, "Failed to send skill commands");
+      log11.error({ err, sessionId }, "Failed to send skill commands");
     }
   }
   async cleanup(sessionId) {
@@ -4290,26 +4545,263 @@ 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) {
     const meta = content.metadata ?? {};
-    return { body: formatToolCall(meta, verbosity), format: "html" };
+    return {
+      body: formatToolCall(meta, verbosity),
+      format: "html"
+    };
   }
   renderToolUpdate(content, verbosity) {
     const meta = content.metadata ?? {};
-    return { body: formatToolUpdate(meta, verbosity), format: "html" };
+    return {
+      body: formatToolUpdate(meta, verbosity),
+      format: "html"
+    };
   }
-  renderPlan(content, verbosity) {
+  renderPlan(content) {
     const meta = content.metadata;
-    return { body: formatPlan({ entries: meta?.entries ?? [] }, verbosity), format: "html" };
+    return {
+      body: formatPlan({ entries: meta?.entries ?? [] }),
+      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" };
+    return {
+      body: `\u274C <b>Error:</b> ${escapeHtml(content.text)}`,
+      format: "html"
+    };
   }
   renderNotification(notification) {
     const emoji = {
@@ -4329,19 +4821,25 @@ var TelegramRenderer = class extends BaseRenderer {
   }
   renderModeChange(content) {
     const modeId = content.metadata?.modeId ?? "";
-    return { body: `\u{1F504} <b>Mode:</b> ${escapeHtml(String(modeId))}`, format: "html" };
+    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" };
+    return {
+      body: `\u{1F916} <b>Model:</b> ${escapeHtml(String(modelId))}`,
+      format: "html"
+    };
   }
 };
 
 // src/plugins/telegram/adapter.ts
-var log13 = createChildLogger({ module: "telegram" });
+var log12 = createChildLogger({ module: "telegram" });
 function patchedFetch(input, init) {
   if (init?.signal && !(init.signal instanceof AbortSignal)) {
     const nativeController = new AbortController();
@@ -4377,7 +4875,6 @@ var TelegramAdapter = class extends MessagingAdapter {
   sendQueue = new SendQueue({ minInterval: 3e3 });
   _sessionThreadIds = /* @__PURE__ */ new Map();
   // Extracted managers
-  toolTracker;
   draftManager;
   skillManager;
   fileService;
@@ -4391,24 +4888,26 @@ var TelegramAdapter = class extends MessagingAdapter {
     }
     return threadId;
   }
-  getOrCreateTracker(sessionId, threadId) {
+  getOrCreateTracker(sessionId, threadId, verbosity = "medium") {
     let tracker = this.sessionTrackers.get(sessionId);
     if (!tracker) {
       tracker = new ActivityTracker(
         this.bot.api,
         this.telegramConfig.chatId,
         threadId,
-        this.sendQueue
+        this.sendQueue,
+        verbosity
       );
       this.sessionTrackers.set(sessionId, tracker);
     }
     return tracker;
   }
   constructor(core, config) {
-    super(
-      { configManager: core.configManager },
-      { ...config, maxMessageLength: 4096, enabled: config.enabled ?? true }
-    );
+    super({ configManager: core.configManager }, {
+      ...config,
+      maxMessageLength: 4096,
+      enabled: config.enabled ?? true
+    });
     this.core = core;
     this.telegramConfig = config;
   }
@@ -4420,11 +4919,6 @@ var TelegramAdapter = class extends MessagingAdapter {
       }
     });
     this.fileService = this.core.fileService;
-    this.toolTracker = new TelegramToolCallTracker(
-      this.bot,
-      this.telegramConfig.chatId,
-      this.sendQueue
-    );
     this.draftManager = new DraftManager(
       this.bot,
       this.telegramConfig.chatId,
@@ -4438,7 +4932,7 @@ var TelegramAdapter = class extends MessagingAdapter {
     );
     this.bot.catch((err) => {
       const rootCause = err.error instanceof Error ? err.error : err;
-      log13.error({ err: rootCause }, "Telegram bot error");
+      log12.error({ err: rootCause }, "Telegram bot error");
     });
     this.bot.api.config.use(async (prev, method, payload, signal) => {
       const maxRetries = 3;
@@ -4456,7 +4950,7 @@ var TelegramAdapter = class extends MessagingAdapter {
         if (rateLimitedMethods.includes(method)) {
           this.sendQueue.onRateLimited();
         }
-        log13.warn(
+        log12.warn(
           { method, retryAfter, attempt: attempt + 1 },
           "Rate limited by Telegram, retrying"
         );
@@ -4503,7 +4997,9 @@ var TelegramAdapter = class extends MessagingAdapter {
     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");
+      const registry = this.core.lifecycleManager?.serviceRegistry?.get(
+        "command-registry"
+      );
       if (!registry) return next();
       const rawCommand = text.split(" ")[0].slice(1);
       const atIdx = rawCommand.indexOf("@");
@@ -4516,7 +5012,10 @@ var TelegramAdapter = class extends MessagingAdapter {
       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 sessionId = topicId != null ? this.core.sessionManager.getSessionByThread(
+          "telegram",
+          String(topicId)
+        )?.id ?? null : null;
         const response = await registry.execute(text, {
           raw: "",
           sessionId,
@@ -4526,7 +5025,11 @@ var TelegramAdapter = class extends MessagingAdapter {
             if (typeof content === "string") {
               await ctx.reply(content);
             } else if (typeof content === "object" && content !== null && "type" in content) {
-              await this.renderCommandResponse(content, chatId, topicId);
+              await this.renderCommandResponse(
+                content,
+                chatId,
+                topicId
+              );
             }
           }
         });
@@ -4541,12 +5044,17 @@ var TelegramAdapter = class extends MessagingAdapter {
     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");
+      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 sessionId = topicId != null ? this.core.sessionManager.getSessionByThread(
+          "telegram",
+          String(topicId)
+        )?.id ?? null : null;
         const response = await registry.execute(command, {
           raw: "",
           sessionId,
@@ -4644,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.", {
@@ -4666,7 +5174,7 @@ var TelegramAdapter = class extends MessagingAdapter {
     this.setupRoutes();
     this.bot.start({
       allowed_updates: ["message", "callback_query"],
-      onStart: () => log13.info(
+      onStart: () => log12.info(
         { chatId: this.telegramConfig.chatId },
         "Telegram bot started"
       )
@@ -4690,10 +5198,10 @@ var TelegramAdapter = class extends MessagingAdapter {
         reply_markup: buildMenuKeyboard()
       });
     } catch (err) {
-      log13.warn({ err }, "Failed to send welcome message");
+      log12.warn({ err }, "Failed to send welcome message");
     }
     try {
-      log13.info("Spawning assistant session...");
+      log12.info("Spawning assistant session...");
       const { session, ready } = await spawnAssistant(
         this.core,
         this,
@@ -4701,19 +5209,19 @@ var TelegramAdapter = class extends MessagingAdapter {
       );
       this.assistantSession = session;
       this.assistantInitializing = true;
-      log13.info(
+      log12.info(
         { sessionId: session.id },
         "Assistant session ready, system prompt running in background"
       );
       ready.then(() => {
         this.assistantInitializing = false;
-        log13.info(
+        log12.info(
           { sessionId: session.id },
           "Assistant ready for user messages"
         );
       });
     } catch (err) {
-      log13.error({ err }, "Failed to spawn assistant");
+      log12.error({ err }, "Failed to spawn assistant");
       this.bot.api.sendMessage(
         this.telegramConfig.chatId,
         `\u26A0\uFE0F <b>Failed to start assistant session.</b>
@@ -4725,11 +5233,16 @@ 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();
     }
     await this.bot.stop();
-    log13.info("Telegram bot stopped");
+    log12.info("Telegram bot stopped");
   }
   // --- CommandRegistry response rendering ---
   async renderCommandResponse(response, chatId, topicId) {
@@ -4857,7 +5370,7 @@ ${lines.join("\n")}`;
         ctx.replyWithChatAction("typing").catch(() => {
         });
         handleAssistantMessage(this.assistantSession, forwardText).catch(
-          (err) => log13.error({ err }, "Assistant error")
+          (err) => log12.error({ err }, "Assistant error")
         );
         return;
       }
@@ -4878,7 +5391,7 @@ ${lines.join("\n")}`;
         threadId: String(threadId),
         userId: String(ctx.from.id),
         text: forwardText
-      }).catch((err) => log13.error({ err }, "handleMessage error"));
+      }).catch((err) => log12.error({ err }, "handleMessage error"));
     });
     this.bot.on("message:photo", async (ctx) => {
       const threadId = ctx.message.message_thread_id;
@@ -4957,7 +5470,7 @@ ${lines.join("\n")}`;
     if (session.archiving) return;
     const threadId = Number(session.threadId);
     if (!threadId || isNaN(threadId)) {
-      log13.warn(
+      log12.warn(
         { sessionId, threadId: session.threadId },
         "Session has no valid threadId, skipping message"
       );
@@ -4989,15 +5502,9 @@ ${lines.join("\n")}`;
   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,
+    const tracker = this.getOrCreateTracker(sessionId, threadId, verbosity);
+    await this.draftManager.finalize(sessionId, this.assistantSession?.id);
+    await tracker.onToolCall(
       {
         id: meta.id ?? "",
         name: meta.name ?? content.text ?? "Tool",
@@ -5011,58 +5518,57 @@ ${lines.join("\n")}`;
         displayTitle: meta.displayTitle,
         displayKind: meta.displayKind
       },
-      verbosity
+      String(meta.kind ?? ""),
+      meta.rawInput
     );
   }
   async handleToolUpdate(sessionId, content, verbosity) {
+    const threadId = this.getThreadId(sessionId);
     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
+    const tracker = this.getOrCreateTracker(sessionId, threadId, verbosity);
+    await tracker.onToolUpdate(
+      meta.id ?? "",
+      meta.status ?? "completed",
+      meta.viewerLinks,
+      meta.viewerFilePath
     );
   }
   async handlePlan(sessionId, content, verbosity) {
     const threadId = this.getThreadId(sessionId);
     const meta = content.metadata ?? {};
     const entries = meta.entries ?? [];
-    const tracker = this.getOrCreateTracker(sessionId, threadId);
+    const tracker = this.getOrCreateTracker(sessionId, threadId, verbosity);
     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);
+    await this.draftManager.finalize(sessionId, this.assistantSession?.id);
+    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.
@@ -5083,7 +5589,7 @@ Task completed.
     if (!content.attachment) return;
     const { attachment } = content;
     if (attachment.size > 50 * 1024 * 1024) {
-      log13.warn(
+      log12.warn(
         {
           sessionId,
           fileName: attachment.fileName,
@@ -5127,7 +5633,7 @@ Task completed.
         );
       }
     } catch (err) {
-      log13.error(
+      log12.error(
         { err, sessionId, fileName: attachment.fileName },
         "Failed to send attachment"
       );
@@ -5135,38 +5641,26 @@ Task completed.
   }
   async handleSessionEnd(sessionId, _content) {
     const threadId = this.getThreadId(sessionId);
-    await this.draftManager.finalize(
-      sessionId,
-      this.assistantSession?.id
-    );
+    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();
+      await tracker.cleanup();
       this.sessionTrackers.delete(sessionId);
     } else {
       await this.sendQueue.enqueue(
-        () => this.bot.api.sendMessage(
-          this.telegramConfig.chatId,
-          `\u2705 <b>Done</b>`,
-          {
-            message_thread_id: threadId,
-            parse_mode: "HTML",
-            disable_notification: true
-          }
-        )
+        () => this.bot.api.sendMessage(this.telegramConfig.chatId, `\u2705 <b>Done</b>`, {
+          message_thread_id: threadId,
+          parse_mode: "HTML",
+          disable_notification: true
+        })
       );
     }
   }
   async handleError(sessionId, content) {
     const threadId = this.getThreadId(sessionId);
-    await this.draftManager.finalize(
-      sessionId,
-      this.assistantSession?.id
-    );
+    await this.draftManager.finalize(sessionId, this.assistantSession?.id);
     const tracker = this.sessionTrackers.get(sessionId);
     if (tracker) {
       tracker.destroy();
@@ -5199,7 +5693,7 @@ Task completed.
     );
   }
   async sendPermissionRequest(sessionId, request) {
-    log13.info({ sessionId, requestId: request.id }, "Permission request sent");
+    log12.info({ sessionId, requestId: request.id }, "Permission request sent");
     const session = this.core.sessionManager.getSession(sessionId);
     if (!session) return;
     await this.sendQueue.enqueue(
@@ -5208,7 +5702,7 @@ Task completed.
   }
   async sendNotification(notification) {
     if (notification.sessionId === this.assistantSession?.id) return;
-    log13.info(
+    log12.info(
       { sessionId: notification.sessionId, type: notification.type },
       "Notification sent"
     );
@@ -5246,7 +5740,7 @@ Task completed.
     );
   }
   async createSessionThread(sessionId, name) {
-    log13.info({ sessionId, name }, "Session topic created");
+    log12.info({ sessionId, name }, "Session topic created");
     return String(
       await createSessionTopic(this.bot, this.telegramConfig.chatId, name)
     );
@@ -5270,7 +5764,7 @@ Task completed.
     try {
       await this.bot.api.deleteForumTopic(this.telegramConfig.chatId, topicId);
     } catch (err) {
-      log13.warn(
+      log12.warn(
         { err, sessionId, topicId },
         "Failed to delete forum topic (may already be deleted)"
       );
@@ -5300,7 +5794,7 @@ Task completed.
       const buffer = Buffer.from(await response.arrayBuffer());
       return { buffer, filePath: file.file_path };
     } catch (err) {
-      log13.error({ err }, "Failed to download file from Telegram");
+      log12.error({ err }, "Failed to download file from Telegram");
       return null;
     }
   }
@@ -5321,7 +5815,7 @@ Task completed.
       try {
         buffer = await this.fileService.convertOggToWav(buffer);
       } catch (err) {
-        log13.warn({ err }, "OGG\u2192WAV conversion failed, saving original OGG");
+        log12.warn({ err }, "OGG\u2192WAV conversion failed, saving original OGG");
         fileName = "voice.ogg";
         mimeType = "audio/ogg";
         originalFilePath = void 0;
@@ -5352,21 +5846,23 @@ Task completed.
       userId: String(userId),
       text,
       attachments: [att]
-    }).catch((err) => log13.error({ err }, "handleMessage error"));
+    }).catch((err) => log12.error({ err }, "handleMessage error"));
   }
   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;
     await this.draftManager.finalize(session.id, this.assistantSession?.id);
     this.draftManager.cleanup(session.id);
-    this.toolTracker.cleanup(session.id);
     await this.skillManager.cleanup(session.id);
     const tracker = this.sessionTrackers.get(session.id);
     if (tracker) {
@@ -5374,13 +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,
-  ToolCallTracker,
+  MessagingAdapter,
+  BaseRenderer,
   TelegramAdapter
 };
-//# sourceMappingURL=chunk-LP45RCA4.js.map
+//# sourceMappingURL=chunk-RXMWJHWH.js.map