@openacp/cli 2026.327.5 → 2026.330.2

package/dist/{chunk-XWDW3XBE.js → chunk-5ZNBNIK3.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-GEOXPGCO.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,266 @@ function buildDeepLink(chatId, threadId, messageId) {
 // src/plugins/telegram/commands/new-session.ts
 import { InlineKeyboard as InlineKeyboard2 } from "grammy";
 
+// 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"
+};
+var KIND_LABELS = {
+  read: "Read",
+  edit: "Edit",
+  write: "Write",
+  delete: "Delete",
+  execute: "Run",
+  bash: "Bash",
+  command: "Run",
+  terminal: "Terminal",
+  search: "Search",
+  web: "Web",
+  fetch: "Fetch",
+  agent: "Agent",
+  think: "Agent",
+  install: "Install",
+  move: "Move"
+};
+
+// 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/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 +417,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);
@@ -197,61 +436,105 @@ function renderToolCard(snap) {
   const { totalVisible, completedVisible, allComplete } = snap;
   const headerCheck = allComplete ? " \u2705" : "";
   if (totalVisible > 0) {
-    sections.push(
-      `<b>\u{1F4CB} Tools (${completedVisible}/${totalVisible})</b>${headerCheck}`
-    );
+    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(
-          `\u{1F4C4} <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>`
-        );
-      if (links.length > 0) line += `
-  ${links.join(" \xB7 ")}`;
-    }
-    sections.push(line);
+  const DONE = /* @__PURE__ */ new Set(["completed", "done", "failed", "error"]);
+  const visible = snap.specs.filter((s) => !s.isHidden);
+  const completed = visible.filter((s) => DONE.has(s.status));
+  const running = visible.filter((s) => !DONE.has(s.status));
+  for (const spec of completed) {
+    sections.push(renderSpecSection(spec));
   }
   if (snap.planEntries && snap.planEntries.length > 0) {
-    const planDone = snap.planEntries.filter(
-      (e) => e.status === "completed"
-    ).length;
+    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"
-    };
+    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(`${statusIcon[e.status] ?? "\u2B1C"} ${i + 1}. ${escapeHtml(e.content)}`);
     }
     sections.push("\u2500\u2500\u2500\u2500");
   }
-  for (const entry of running) {
-    sections.push(`${entry.icon} ${escapeHtml(entry.label)}`);
+  for (const spec of running) {
+    sections.push(renderSpecSection(spec));
   }
-  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 FILE_KINDS = /* @__PURE__ */ new Set(["read", "edit", "write", "delete"]);
+function shortenTitle(title, kind) {
+  if (!FILE_KINDS.has(kind) || !title.includes("/")) return title;
+  const parenIdx = title.indexOf(" (");
+  const pathPart = parenIdx > 0 ? title.slice(0, parenIdx) : title;
+  const rangePart = parenIdx > 0 ? title.slice(parenIdx) : "";
+  const fileName = pathPart.split("/").pop() || pathPart;
+  return fileName + rangePart;
+}
+function renderSpecSection(spec) {
+  const lines = [];
+  const DONE = /* @__PURE__ */ new Set(["completed", "done", "failed", "error"]);
+  const statusPrefix = spec.status === "error" || spec.status === "failed" ? "\u274C " : DONE.has(spec.status) ? "\u2705 " : "\u{1F504} ";
+  const kindLabel = KIND_LABELS[spec.kind];
+  const displayTitle = shortenTitle(spec.title, spec.kind);
+  const hasUniqueTitle = displayTitle && displayTitle.toLowerCase() !== kindLabel?.toLowerCase() && displayTitle.toLowerCase() !== spec.kind;
+  let titleLine;
+  if (kindLabel) {
+    titleLine = hasUniqueTitle ? `${statusPrefix}${spec.icon} <b>${kindLabel}</b> \xB7 ${escapeHtml(displayTitle)}` : `${statusPrefix}${spec.icon} <b>${kindLabel}</b>`;
+  } else {
+    titleLine = `${statusPrefix}${spec.icon} ${escapeHtml(displayTitle)}`;
+  }
+  if (spec.diffStats) {
+    const { added, removed } = spec.diffStats;
+    if (added > 0 && removed > 0) titleLine += ` \xB7 <i>+${added}/-${removed} lines</i>`;
+    else if (added > 0) titleLine += ` \xB7 <i>+${added} lines</i>`;
+    else if (removed > 0) titleLine += ` \xB7 <i>-${removed} lines</i>`;
+  }
+  lines.push(titleLine);
+  if (spec.description) lines.push(`   <i>${escapeHtml(spec.description)}</i>`);
+  if (spec.command) lines.push(`   <code>${escapeHtml(spec.command)}</code>`);
+  if (spec.inputContent) {
+    const truncated = spec.inputContent.length > 800 ? spec.inputContent.slice(0, 797) + "\u2026" : spec.inputContent;
+    lines.push(`   <pre><code>${escapeHtml(truncated)}</code></pre>`);
+  }
+  if (spec.outputSummary) lines.push(`   \xB7 ${escapeHtml(spec.outputSummary)}`);
+  if (spec.outputContent || spec.outputFallbackContent) {
+    const raw = spec.outputContent ?? spec.outputFallbackContent;
+    const truncated = raw.length > 800 ? raw.slice(0, 797) + "\u2026" : raw;
+    lines.push(`   <pre><code>${escapeHtml(truncated)}</code></pre>`);
+  }
+  if (spec.viewerLinks?.file || spec.viewerLinks?.diff || spec.outputViewerLink) {
+    const linkParts = [];
+    const shortName = displayTitle || kindLabel || spec.kind;
+    if (spec.viewerLinks?.file)
+      linkParts.push(`<a href="${escapeHtml(spec.viewerLinks.file)}">View ${escapeHtml(shortName)}</a>`);
+    if (spec.viewerLinks?.diff)
+      linkParts.push(`<a href="${escapeHtml(spec.viewerLinks.diff)}">View diff</a>`);
+    if (spec.outputViewerLink)
+      linkParts.push(`<a href="${escapeHtml(spec.outputViewerLink)}">View output</a>`);
+    lines.push(`      ${linkParts.join(" \xB7 ")}`);
+  }
+  return lines.join("\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 safeSection = section.length > TELEGRAM_MAX_LENGTH ? section.slice(0, TELEGRAM_MAX_LENGTH - 3) + "..." : section;
+    const candidate = current ? `${current}
+
+${safeSection}` : safeSection;
+    if (candidate.length > TELEGRAM_MAX_LENGTH && current) {
+      chunks.push(current);
+      current = safeSection;
+    } else {
+      current = candidate;
+    }
   }
-  return sections.join("\n");
+  if (current) chunks.push(current);
+  return chunks;
 }
 
 // src/plugins/telegram/commands/admin.ts
@@ -440,6 +723,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 +768,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.", {
@@ -491,33 +792,75 @@ async function handleTTS(ctx, core) {
     });
   }
 }
-var VERBOSITY_LABELS = {
+async function handleVerbosity(ctx, core) {
+  await ctx.reply("\u26A0\uFE0F <code>/verbosity</code> is deprecated. Use <code>/outputmode</code> instead.", { parse_mode: "HTML" });
+  await handleOutputMode(ctx, core);
+}
+var OUTPUT_MODE_LABELS = {
   low: "\u{1F507} Low",
   medium: "\u{1F4CA} Medium",
-  high: "\u{1F4D6} High"
+  high: "\u{1F50D} High"
 };
-async function handleVerbosity(ctx, core) {
+async function handleOutputMode(ctx, core) {
   const args = ctx.message?.text?.split(/\s+/).slice(1) ?? [];
-  const arg = args[0]?.toLowerCase();
-  if (arg === "low" || arg === "medium" || arg === "high") {
+  const arg0 = args[0]?.toLowerCase();
+  const arg1 = args[1]?.toLowerCase();
+  if (arg0 === "session") {
+    const chatId = ctx.chat?.id;
+    const threadId = ctx.message?.message_thread_id;
+    if (!chatId || threadId === void 0) {
+      await ctx.reply("\u26A0\uFE0F This command must be used in a session topic.", { parse_mode: "HTML" });
+      return;
+    }
+    const session = core.sessionManager.getSessionByThread(
+      "telegram",
+      String(threadId)
+    );
+    if (!session) {
+      await ctx.reply("\u26A0\uFE0F No active session found for this topic.", { parse_mode: "HTML" });
+      return;
+    }
+    if (arg1 === "reset") {
+      await core.sessionManager.patchRecord(session.id, { outputMode: void 0 });
+      await ctx.reply("\u{1F504} Session output mode reset to adapter default.", { parse_mode: "HTML" });
+    } else if (arg1 === "low" || arg1 === "medium" || arg1 === "high") {
+      await core.sessionManager.patchRecord(session.id, { outputMode: arg1 });
+      await ctx.reply(
+        `${OUTPUT_MODE_LABELS[arg1]} Session output mode set to <b>${arg1}</b>.`,
+        { parse_mode: "HTML" }
+      );
+    } else {
+      const record = core.sessionManager.getSessionRecord(session.id);
+      const current = record?.outputMode ?? "(adapter default)";
+      await ctx.reply(
+        `\u{1F4CA} Session output mode: <b>${current}</b>
+
+Usage: <code>/outputmode session low|medium|high|reset</code>`,
+        { parse_mode: "HTML" }
+      );
+    }
+    return;
+  }
+  if (arg0 === "low" || arg0 === "medium" || arg0 === "high") {
     await core.configManager.save(
-      { channels: { telegram: { displayVerbosity: arg } } },
-      "channels.telegram.displayVerbosity"
+      { channels: { telegram: { outputMode: arg0 } } },
+      "channels.telegram.outputMode"
     );
     await ctx.reply(
-      `${VERBOSITY_LABELS[arg]} Display verbosity set to <b>${arg}</b>.`,
+      `${OUTPUT_MODE_LABELS[arg0]} Output mode set to <b>${arg0}</b>.`,
       { parse_mode: "HTML" }
     );
   } else {
-    const current = core.configManager.get().channels?.telegram?.displayVerbosity ?? "medium";
+    const current = core.configManager.get().channels?.telegram?.outputMode ?? "medium";
     await ctx.reply(
-      `\u{1F4CA} Current verbosity: <b>${current}</b>
+      `\u{1F4CA} Current output mode: <b>${current}</b>
 
-Usage: <code>/verbosity low|medium|high</code>
+Usage: <code>/outputmode low|medium|high</code>
+Session override: <code>/outputmode session low|medium|high|reset</code>
 
-\u2022 <b>low</b> \u2014 minimal output, title only
-\u2022 <b>medium</b> \u2014 balanced (default)
-\u2022 <b>high</b> \u2014 full detail with content`,
+\u2022 <b>low</b> \u2014 minimal: title only
+\u2022 <b>medium</b> \u2014 balanced: description + output summary (default)
+\u2022 <b>high</b> \u2014 full detail: inline output, IN/OUT blocks`,
       { parse_mode: "HTML" }
     );
   }
@@ -527,12 +870,12 @@ function setupVerbosityCallbacks(bot, core) {
     const level = ctx.callbackQuery.data.slice(3);
     if (level !== "low" && level !== "medium" && level !== "high") return;
     await core.configManager.save(
-      { channels: { telegram: { displayVerbosity: level } } },
-      "channels.telegram.displayVerbosity"
+      { channels: { telegram: { outputMode: level } } },
+      "channels.telegram.outputMode"
     );
     try {
       await ctx.answerCallbackQuery({
-        text: `${VERBOSITY_LABELS[level]} Verbosity: ${level}`
+        text: `${OUTPUT_MODE_LABELS[level]} Output mode: ${level}`
       });
     } catch {
     }
@@ -546,7 +889,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 +1633,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 +1668,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 +1892,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 +1965,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 +1998,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 +2018,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 +2045,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 +2529,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:`, {
@@ -2511,6 +2851,7 @@ function setupCommands(bot, core, chatId, assistant) {
   bot.command("archive", (ctx) => handleArchive(ctx, core));
   bot.command("text_to_speech", (ctx) => handleTTS(ctx, core));
   bot.command("verbosity", (ctx) => handleVerbosity(ctx, core));
+  bot.command("outputmode", (ctx) => handleOutputMode(ctx, core));
   bot.command("resume", (ctx) => handleResume(ctx, core, chatId, assistant));
 }
 function setupAllCallbacks(bot, core, chatId, systemTopicIds, getAssistantSession) {
@@ -2598,7 +2939,8 @@ var STATIC_COMMANDS = [
   { command: "tunnels", description: "List active tunnels" },
   { command: "archive", description: "Archive session topic (recreate with clean history)" },
   { command: "text_to_speech", description: "Toggle Text to Speech (/text_to_speech on, /text_to_speech off)" },
-  { command: "verbosity", description: "Set display verbosity (/verbosity low|medium|high)" },
+  { command: "verbosity", description: "Deprecated: use /outputmode instead" },
+  { command: "outputmode", description: "Control output display level (low/medium/high)" },
   { command: "resume", description: "Resume with conversation history from Entire checkpoints" }
 ];
 
@@ -3303,34 +3645,29 @@ function redirectToAssistant(chatId, assistantTopicId) {
 
 // src/core/adapter-primitives/primitives/tool-card-state.ts
 var DEBOUNCE_MS = 500;
+var DONE_STATUSES = /* @__PURE__ */ new Set(["completed", "done", "failed", "error"]);
 var ToolCardState = class {
-  entries = [];
+  specs = [];
   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);
+  updateFromSpec(spec) {
+    const existingIdx = this.specs.findIndex((s) => s.id === spec.id);
+    if (existingIdx >= 0) {
+      this.specs[existingIdx] = spec;
+    } else {
+      this.specs.push(spec);
+    }
+    if (this.finalized) {
+      this.onFlush(this.snapshot());
+      return;
+    }
     if (this.isFirstFlush) {
       this.isFirstFlush = false;
       this.flush();
@@ -3338,20 +3675,10 @@ var ToolCardState = class {
       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) {
+    if (this.specs.length === 0 && this.isFirstFlush) {
       this.isFirstFlush = false;
       this.flush();
     } else {
@@ -3361,7 +3688,7 @@ var ToolCardState = class {
   appendUsage(usage) {
     if (this.finalized) return;
     this.usage = usage;
-    this.flush();
+    this.scheduleFlush();
   }
   finalize() {
     if (this.finalized) return;
@@ -3374,23 +3701,19 @@ var ToolCardState = class {
     this.clearDebounce();
   }
   hasContent() {
-    return this.entries.length > 0 || this.planEntries !== void 0;
+    return this.specs.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 visible = this.specs.filter((s) => !s.isHidden);
+    const completedVisible = visible.filter((s) => DONE_STATUSES.has(s.status)).length;
     const allComplete = visible.length > 0 && completedVisible === visible.length;
     return {
-      entries: this.entries,
+      specs: this.specs,
       planEntries: this.planEntries,
       usage: this.usage,
-      visibleCount: visible.length,
       totalVisible: visible.length,
       completedVisible,
-      allComplete,
-      verbosity: this.verbosity
+      allComplete
     };
   }
   flush() {
@@ -3412,37 +3735,283 @@ var ToolCardState = class {
   }
 };
 
+// src/core/adapter-primitives/stream-accumulator.ts
+var ToolStateMap = class {
+  entries = /* @__PURE__ */ new Map();
+  pendingUpdates = /* @__PURE__ */ new Map();
+  /**
+   * Creates or updates an entry from a tool_call event.
+   * If a pending update exists for this id, applies it immediately.
+   */
+  upsert(meta, kind, rawInput) {
+    const isNoise = evaluateNoise(meta.name, kind, rawInput) !== null;
+    const entry = {
+      id: meta.id,
+      name: meta.name,
+      kind,
+      rawInput,
+      content: null,
+      status: meta.status ?? "running",
+      viewerLinks: meta.viewerLinks,
+      displaySummary: meta.displaySummary,
+      displayTitle: meta.displayTitle,
+      displayKind: meta.displayKind,
+      isNoise
+    };
+    this.entries.set(meta.id, entry);
+    const pending = this.pendingUpdates.get(meta.id);
+    if (pending) {
+      this.pendingUpdates.delete(meta.id);
+      this._applyUpdate(entry, pending);
+    }
+    return entry;
+  }
+  /**
+   * Updates an existing entry from a tool_call_update event.
+   * If the entry doesn't exist yet (out-of-order delivery), buffers the update.
+   */
+  merge(id, status, rawInput, content, viewerLinks, diffStats) {
+    const entry = this.entries.get(id);
+    if (!entry) {
+      this.pendingUpdates.set(id, { status, rawInput, content, viewerLinks, diffStats });
+      return void 0;
+    }
+    this._applyUpdate(entry, { status, rawInput, content, viewerLinks, diffStats });
+    return entry;
+  }
+  _applyUpdate(entry, update) {
+    entry.status = update.status;
+    if (update.rawInput !== void 0) {
+      entry.rawInput = update.rawInput;
+    }
+    if (update.content !== void 0) {
+      entry.content = update.content ?? null;
+    }
+    if (update.viewerLinks !== void 0) {
+      entry.viewerLinks = update.viewerLinks;
+    }
+    if (update.diffStats !== void 0) {
+      entry.diffStats = update.diffStats;
+    }
+  }
+  get(id) {
+    return this.entries.get(id);
+  }
+  clear() {
+    this.entries.clear();
+    this.pendingUpdates.clear();
+  }
+};
+var ThoughtBuffer = class {
+  chunks = [];
+  sealed = false;
+  append(chunk) {
+    if (this.sealed) return;
+    this.chunks.push(chunk);
+  }
+  seal() {
+    this.sealed = true;
+    return this.chunks.join("");
+  }
+  getText() {
+    return this.chunks.join("");
+  }
+  isSealed() {
+    return this.sealed;
+  }
+  reset() {
+    this.chunks = [];
+    this.sealed = false;
+  }
+};
+
+// src/core/adapter-primitives/display-spec-builder.ts
+var EXECUTE_KINDS = /* @__PURE__ */ new Set(["execute", "bash", "command", "terminal"]);
+var INLINE_MAX_LINES = 15;
+var INLINE_MAX_CHARS = 800;
+function asRecord(value) {
+  if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+    return value;
+  }
+  return {};
+}
+function capitalize(s) {
+  return s.length === 0 ? s : s[0].toUpperCase() + s.slice(1);
+}
+function buildTitle(entry, kind) {
+  if (entry.displayTitle) return entry.displayTitle;
+  if (entry.displaySummary) return entry.displaySummary;
+  const input = asRecord(entry.rawInput);
+  if (kind === "read") {
+    const filePath = typeof input.file_path === "string" ? input.file_path : null;
+    if (filePath) {
+      const startLine = typeof input.start_line === "number" ? input.start_line : null;
+      const endLine = typeof input.end_line === "number" ? input.end_line : null;
+      if (startLine !== null && endLine !== null) return `${filePath} (lines ${startLine}\u2013${endLine})`;
+      if (startLine !== null) return `${filePath} (from line ${startLine})`;
+      const offset = typeof input.offset === "number" ? input.offset : null;
+      const limit = typeof input.limit === "number" ? input.limit : null;
+      if (offset !== null && limit !== null) return `${filePath} (lines ${offset}\u2013${offset + limit - 1})`;
+      if (offset !== null) return `${filePath} (from line ${offset})`;
+      return filePath;
+    }
+    return capitalize(entry.name);
+  }
+  if (kind === "edit" || kind === "write" || kind === "delete") {
+    const filePath = typeof input.file_path === "string" ? input.file_path : typeof input.path === "string" ? input.path : null;
+    if (filePath) return filePath;
+    return capitalize(entry.name);
+  }
+  if (EXECUTE_KINDS.has(kind)) {
+    const description = typeof input.description === "string" ? input.description : null;
+    if (description) return description;
+    const command = typeof input.command === "string" ? input.command : null;
+    if (command) return command.length > 60 ? command.slice(0, 57) + "..." : command;
+    return capitalize(entry.name);
+  }
+  if (kind === "agent") {
+    const skill = typeof input.skill === "string" ? input.skill : null;
+    const description = typeof input.description === "string" ? input.description : null;
+    const subtype = typeof input.subagent_type === "string" ? input.subagent_type : null;
+    if (skill) return skill;
+    if (description) return description.length > 60 ? description.slice(0, 57) + "..." : description;
+    if (subtype) return subtype;
+    return capitalize(entry.name);
+  }
+  if (kind === "search") {
+    const pattern = typeof input.pattern === "string" ? input.pattern : typeof input.query === "string" ? input.query : null;
+    if (pattern) {
+      let title = `${capitalize(entry.name)} "${pattern}"`;
+      const glob = typeof input.glob === "string" ? input.glob : null;
+      const type = typeof input.type === "string" ? input.type : null;
+      if (glob) title += ` (glob: ${glob})`;
+      else if (type) title += ` (type: ${type})`;
+      return title;
+    }
+    return capitalize(entry.name);
+  }
+  if (entry.name.toLowerCase() === "skill" && typeof input.skill === "string" && input.skill) {
+    return input.skill;
+  }
+  return entry.name;
+}
+function buildOutputSummary(content) {
+  const lines = content.split("\n").length;
+  return `${lines} line${lines === 1 ? "" : "s"} of output`;
+}
+function isTitleFromCommand(title, command) {
+  return title === command || command.length > 60 && title === command.slice(0, 57) + "...";
+}
+var DisplaySpecBuilder = class {
+  constructor(tunnelService) {
+    this.tunnelService = tunnelService;
+  }
+  buildToolSpec(entry, mode, sessionContext) {
+    const effectiveKind = entry.displayKind ?? entry.kind;
+    const icon = KIND_ICONS[effectiveKind] ?? KIND_ICONS["other"] ?? "\u{1F6E0}\uFE0F";
+    const title = buildTitle(entry, effectiveKind);
+    const isHidden = entry.isNoise && mode !== "high";
+    const includeMeta = mode !== "low";
+    const input = asRecord(entry.rawInput);
+    const rawDescription = typeof input.description === "string" ? input.description : null;
+    const descLower = rawDescription?.toLowerCase();
+    const description = includeMeta && rawDescription && rawDescription !== title && descLower !== effectiveKind && descLower !== entry.name.toLowerCase() ? rawDescription : null;
+    const rawCommand = EXECUTE_KINDS.has(effectiveKind) && typeof input.command === "string" ? input.command : null;
+    const command = includeMeta && rawCommand && !isTitleFromCommand(title, rawCommand) ? rawCommand : null;
+    const inputContent = null;
+    const content = entry.content;
+    let outputSummary = null;
+    let outputContent = null;
+    let outputViewerLink = void 0;
+    let outputFallbackContent = void 0;
+    if (content && content.trim().length > 0 && includeMeta) {
+      outputSummary = buildOutputSummary(content);
+      const isLong = content.split("\n").length > INLINE_MAX_LINES || content.length > INLINE_MAX_CHARS;
+      if (isLong) {
+        const publicUrl = this.tunnelService?.getPublicUrl();
+        const hasPublicTunnel = !!publicUrl && !publicUrl.startsWith("http://localhost") && !publicUrl.startsWith("http://127.0.0.1");
+        if (this.tunnelService && sessionContext && hasPublicTunnel) {
+          const label = typeof input.command === "string" ? input.command : entry.name;
+          const id = this.tunnelService.getStore().storeOutput(sessionContext.id, label, content);
+          if (id !== null) {
+            outputViewerLink = this.tunnelService.outputUrl(id);
+          }
+        } else if (mode === "high") {
+          outputFallbackContent = content;
+        }
+      } else if (mode === "high") {
+        outputContent = content;
+      }
+    }
+    const diffStats = includeMeta ? entry.diffStats ?? null : null;
+    return {
+      id: entry.id,
+      kind: effectiveKind,
+      icon,
+      title,
+      description,
+      command,
+      inputContent,
+      outputSummary,
+      outputContent,
+      diffStats,
+      viewerLinks: entry.viewerLinks,
+      outputViewerLink,
+      outputFallbackContent,
+      status: entry.status,
+      isNoise: entry.isNoise,
+      isHidden
+    };
+  }
+  buildThoughtSpec(content, mode) {
+    const indicator = "Thinking...";
+    return {
+      indicator,
+      content: mode === "high" ? content : null
+    };
+  }
+};
+
 // src/plugins/telegram/activity.ts
 var log10 = createChildLogger({ module: "telegram:activity" });
 var THINKING_REFRESH_MS = 15e3;
 var THINKING_MAX_MS = 3 * 60 * 1e3;
 var ThinkingIndicator = class {
-  constructor(api, chatId, threadId, sendQueue) {
+  constructor(api, chatId, threadId, sendQueue, sessionId = "", tracer = null) {
     this.api = api;
     this.chatId = chatId;
     this.threadId = threadId;
     this.sendQueue = sendQueue;
+    this.sessionId = sessionId;
+    this.tracer = tracer;
   }
   msgId;
   sending = false;
   dismissed = false;
   refreshTimer;
   showTime = 0;
+  tracer;
   async show() {
-    if (this.msgId || this.sending || this.dismissed) return;
+    if (this.sending || this.dismissed) return;
+    if (this.msgId) return;
     this.sending = true;
     this.showTime = Date.now();
+    const text = "\u{1F4AD} <i>Thinking...</i>";
     try {
       const result = await this.sendQueue.enqueue(
-        () => this.api.sendMessage(this.chatId, "\u{1F4AD} <i>Thinking...</i>", {
+        () => this.api.sendMessage(this.chatId, text, {
           message_thread_id: this.threadId,
           parse_mode: "HTML",
           disable_notification: true
         })
       );
-      if (result && !this.dismissed) {
-        this.msgId = result.message_id;
-        this.startRefreshTimer();
+      if (result) {
+        this.tracer?.log("telegram", { action: "thinking:show", sessionId: this.sessionId, msgId: result.message_id });
+        if (this.dismissed) {
+        } else {
+          this.msgId = result.message_id;
+          this.startRefreshTimer();
+        }
       }
     } catch (err) {
       log10.warn({ err }, "ThinkingIndicator.show() failed");
@@ -3450,11 +4019,27 @@ var ThinkingIndicator = class {
       this.sending = false;
     }
   }
-  /** Clear state — stops refresh timer, no Telegram API call */
-  dismiss() {
+  /** Edit the indicator message to append a viewer link, then dismiss. */
+  async finalizeWithViewerLink(url) {
+    this.stopRefreshTimer();
+    if (this.msgId && !this.dismissed) {
+      const text = `\u{1F4AD} <i>Thinking...</i>      <a href="${escapeHtml(url)}">View thinking</a>`;
+      await this.sendQueue.enqueue(() => {
+        if (!this.msgId) return Promise.resolve(void 0);
+        return this.api.editMessageText(this.chatId, this.msgId, text, { parse_mode: "HTML" });
+      }).catch(() => {
+      });
+    }
     this.dismissed = true;
     this.msgId = void 0;
+  }
+  /** Dismiss indicator: stops refresh timer. Message is left in chat to reduce API calls. */
+  async dismiss() {
+    if (this.dismissed) return;
+    this.dismissed = true;
+    this.tracer?.log("telegram", { action: "thinking:dismiss", sessionId: this.sessionId });
     this.stopRefreshTimer();
+    this.msgId = void 0;
   }
   /** Reset for a new prompt cycle */
   reset() {
@@ -3468,12 +4053,13 @@ var ThinkingIndicator = class {
         return;
       }
       const elapsed = Math.round((Date.now() - this.showTime) / 1e3);
+      const refreshText = `\u{1F4AD} <i>Still thinking... (${elapsed}s)</i>`;
       this.sendQueue.enqueue(() => {
         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>`,
+          refreshText,
           { parse_mode: "HTML" }
         );
       }).then(() => {
@@ -3489,13 +4075,14 @@ var ThinkingIndicator = class {
   }
 };
 var ToolCard = class {
-  constructor(api, chatId, threadId, sendQueue, verbosity) {
+  constructor(api, chatId, threadId, sendQueue, sessionId = "", tracer = null) {
     this.api = api;
     this.chatId = chatId;
     this.threadId = threadId;
     this.sendQueue = sendQueue;
+    this.tracer = tracer;
+    this.sessionId = sessionId;
     this.state = new ToolCardState({
-      verbosity,
       onFlush: (snapshot) => {
         this.flushPromise = this.flushPromise.then(() => this._sendOrEdit(snapshot)).catch(() => {
         });
@@ -3506,11 +4093,11 @@ var ToolCard = class {
   msgId;
   lastSentText;
   flushPromise = Promise.resolve();
-  addTool(meta, kind, rawInput) {
-    this.state.addTool(meta, kind, rawInput);
-  }
-  updateTool(id, status, viewerLinks, viewerFilePath) {
-    this.state.updateTool(id, status, viewerLinks, viewerFilePath);
+  overflowMsgIds = [];
+  tracer;
+  sessionId;
+  updateFromSpec(spec) {
+    this.state.updateFromSpec(spec);
   }
   updatePlan(entries) {
     this.state.updatePlan(entries);
@@ -3532,26 +4119,58 @@ 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;
+    let snapshotToRender = snapshot;
+    let fullText = renderToolCard(snapshotToRender);
+    if (fullText.length > 4096) {
+      snapshotToRender = {
+        ...snapshot,
+        specs: snapshot.specs.map(
+          (s) => s.outputContent ? { ...s, outputContent: null } : s
+        )
+      };
+      fullText = renderToolCard(snapshotToRender);
+    }
+    if (!fullText) return;
+    if (this.msgId && fullText === this.lastSentText) return;
+    this.lastSentText = fullText;
+    const chunks = splitToolCardText(fullText);
+    this.tracer?.log("telegram", { action: "toolCard:render", sessionId: this.sessionId, chunks: chunks.length, total: snapshot.totalVisible, completed: snapshot.completedVisible, allComplete: snapshot.allComplete, msgId: this.msgId, entries: snapshot.specs.map((s) => ({ id: s.id, kind: s.kind, icon: s.icon, title: s.title })), html: fullText });
     try {
+      const firstChunk = chunks[0];
       if (this.msgId) {
         await this.sendQueue.enqueue(
-          () => this.api.editMessageText(this.chatId, this.msgId, text, {
-            parse_mode: "HTML"
-          })
+          () => this.api.editMessageText(this.chatId, this.msgId, firstChunk, { parse_mode: "HTML" })
         );
+        this.tracer?.log("telegram", { action: "telegram:edit", sessionId: this.sessionId, msgId: this.msgId, html: firstChunk });
       } 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
           })
         );
         if (result) this.msgId = result.message_id;
+        this.tracer?.log("telegram", { action: "telegram:send", sessionId: this.sessionId, msgId: result?.message_id, html: firstChunk });
+      }
+      for (let i = 1; i < chunks.length; i++) {
+        const overflowIdx = i - 1;
+        if (overflowIdx < this.overflowMsgIds.length) {
+          await this.sendQueue.enqueue(
+            () => this.api.editMessageText(this.chatId, this.overflowMsgIds[overflowIdx], chunks[i], { parse_mode: "HTML" })
+          );
+          this.tracer?.log("telegram", { action: "telegram:edit:overflow", sessionId: this.sessionId, msgId: this.overflowMsgIds[overflowIdx] });
+        } else {
+          const result = await this.sendQueue.enqueue(
+            () => this.api.sendMessage(this.chatId, chunks[i], {
+              message_thread_id: this.threadId,
+              parse_mode: "HTML",
+              disable_notification: true
+            })
+          );
+          if (result) this.overflowMsgIds.push(result.message_id);
+          this.tracer?.log("telegram", { action: "telegram:send:overflow", sessionId: this.sessionId, msgId: result?.message_id });
+        }
       }
     } catch (err) {
       log10.warn({ err }, "[ToolCard] send/edit failed");
@@ -3559,59 +4178,140 @@ var ToolCard = class {
   }
 };
 var ActivityTracker = class {
-  constructor(api, chatId, threadId, sendQueue, verbosity = "medium") {
+  constructor(api, chatId, threadId, sendQueue, outputMode = "medium", sessionId = "", tracer = null, tunnelService, sessionContext) {
     this.api = api;
     this.chatId = chatId;
     this.threadId = threadId;
     this.sendQueue = sendQueue;
-    this.thinking = new ThinkingIndicator(api, chatId, threadId, sendQueue);
-    this.toolCard = new ToolCard(api, chatId, threadId, sendQueue, verbosity);
+    this._outputMode = outputMode;
+    this.tracer = tracer;
+    this.sessionId = sessionId;
+    this.sessionContext = sessionContext;
+    this.tunnelService = tunnelService;
+    this.specBuilder = new DisplaySpecBuilder(tunnelService);
+    this.toolStateMap = new ToolStateMap();
+    this.thoughtBuffer = new ThoughtBuffer();
+    this.thinking = new ThinkingIndicator(api, chatId, threadId, sendQueue, sessionId, tracer);
+    this.toolCard = new ToolCard(api, chatId, threadId, sendQueue, sessionId, tracer);
   }
   isFirstEvent = true;
   thinking;
   toolCard;
+  previousToolCard;
+  toolStateMap;
+  previousToolStateMap;
+  specBuilder;
+  thoughtBuffer;
+  _outputMode;
+  tracer;
+  sessionId;
+  sessionContext;
+  tunnelService;
+  setOutputMode(mode) {
+    this._outputMode = mode;
+  }
   async onNewPrompt() {
+    this.tracer?.log("telegram", { action: "tracker:newPrompt", sessionId: this.sessionId });
     this.isFirstEvent = true;
-    this.thinking.dismiss();
+    this.thoughtBuffer.reset();
+    await this.thinking.dismiss();
     this.thinking.reset();
+    await this.toolCard.finalize();
+    this.previousToolCard = void 0;
+    this.previousToolStateMap = void 0;
+    this.toolStateMap.clear();
+    this.toolCard = new ToolCard(this.api, this.chatId, this.threadId, this.sendQueue, this.sessionId, this.tracer);
   }
-  async onThought() {
+  async onThought(text) {
+    this.tracer?.log("telegram", { action: "tracker:thought", sessionId: this.sessionId });
     this.isFirstEvent = false;
+    if (!this.thoughtBuffer.isSealed()) this.thoughtBuffer.append(text);
+    await this.sealToolCardIfNeeded();
     await this.thinking.show();
   }
   async onTextStart() {
+    this.tracer?.log("telegram", { action: "tracker:textStart", sessionId: this.sessionId });
     this.isFirstEvent = false;
-    this.thinking.dismiss();
+    this.thoughtBuffer.seal();
+    if (this._outputMode === "high" && this.tunnelService && this.sessionContext) {
+      const thoughtText = this.thoughtBuffer.getText();
+      if (thoughtText.trim().length > 0) {
+        const id = this.tunnelService.getStore().storeOutput(
+          this.sessionContext.id,
+          "thinking",
+          thoughtText
+        );
+        if (id !== null) {
+          await this.thinking.finalizeWithViewerLink(this.tunnelService.outputUrl(id));
+        } else {
+          await this.thinking.dismiss();
+        }
+      } else {
+        await this.thinking.dismiss();
+      }
+    } else {
+      await this.thinking.dismiss();
+    }
+    await this.sealToolCardIfNeeded();
   }
   async onToolCall(meta, kind, rawInput) {
+    this.tracer?.log("telegram", { action: "tracker:toolCall", sessionId: this.sessionId, meta, kind, rawInput });
     this.isFirstEvent = false;
-    this.thinking.dismiss();
+    await this.thinking.dismiss();
     this.thinking.reset();
-    this.toolCard.addTool(meta, kind, rawInput);
-  }
-  async onToolUpdate(id, status, viewerLinks, viewerFilePath) {
-    this.toolCard.updateTool(id, status, viewerLinks, viewerFilePath);
+    const entry = this.toolStateMap.upsert(meta, kind, rawInput);
+    const spec = this.specBuilder.buildToolSpec(entry, this._outputMode, this.sessionContext);
+    this.toolCard.updateFromSpec(spec);
+  }
+  async onToolUpdate(id, status, viewerLinks, viewerFilePath, content, rawInput, diffStats) {
+    this.tracer?.log("telegram", { action: "tracker:toolUpdate", sessionId: this.sessionId, toolId: id, status, viewerLinks, viewerFilePath, hasPrevCard: !!this.previousToolCard });
+    if (this.previousToolStateMap?.get(id)) {
+      this.previousToolStateMap.merge(id, status, rawInput, content, viewerLinks, diffStats);
+      const prevEntry = this.previousToolStateMap.get(id);
+      if (prevEntry) {
+        const prevSpec = this.specBuilder.buildToolSpec(prevEntry, this._outputMode, this.sessionContext);
+        this.previousToolCard?.updateFromSpec(prevSpec);
+      }
+    }
+    const existed = !!this.toolStateMap.get(id);
+    const entry = this.toolStateMap.merge(id, status, rawInput, content, viewerLinks, diffStats);
+    if (!existed || !entry) return;
+    if (viewerLinks || entry.viewerLinks) {
+      log10.debug({ toolId: id, status, hasIncomingLinks: !!viewerLinks, hasEntryLinks: !!entry.viewerLinks, entryLinks: entry.viewerLinks }, "toolUpdate: viewer links trace");
+    }
+    const spec = this.specBuilder.buildToolSpec(entry, this._outputMode, this.sessionContext);
+    this.toolCard.updateFromSpec(spec);
   }
   async onPlan(entries) {
+    this.tracer?.log("telegram", { action: "tracker:plan", sessionId: this.sessionId, 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();
   }
+  async sealToolCardIfNeeded() {
+    if (!this.toolCard.hasContent()) return;
+    this.tracer?.log("telegram", { action: "tracker:seal", sessionId: this.sessionId });
+    await this.toolCard.finalize();
+    this.previousToolCard = this.toolCard;
+    this.previousToolStateMap = this.toolStateMap;
+    this.toolStateMap = new ToolStateMap();
+    this.toolCard = new ToolCard(this.api, this.chatId, this.threadId, this.sendQueue, this.sessionId, this.tracer);
+  }
 };
 
 // src/core/adapter-primitives/primitives/send-queue.ts
@@ -3872,12 +4572,13 @@ function setupActionCallbacks(bot, core, chatId, getAssistantSessionId) {
 // src/plugins/telegram/streaming.ts
 var FLUSH_INTERVAL = 5e3;
 var MessageDraft = class {
-  constructor(bot, chatId, threadId, sendQueue, sessionId) {
+  constructor(bot, chatId, threadId, sendQueue, sessionId, tracer = null) {
     this.bot = bot;
     this.chatId = chatId;
     this.threadId = threadId;
     this.sendQueue = sendQueue;
     this.sessionId = sessionId;
+    this.tracer = tracer;
   }
   buffer = "";
   messageId;
@@ -3886,6 +4587,7 @@ var MessageDraft = class {
   flushPromise = Promise.resolve();
   lastSentBuffer = "";
   displayTruncated = false;
+  tracer;
   append(text) {
     if (!text) return;
     this.buffer += text;
@@ -3930,6 +4632,7 @@ var MessageDraft = class {
         );
         if (result) {
           this.messageId = result.message_id;
+          this.tracer?.log("telegram", { action: "draft:send", sessionId: this.sessionId, msgId: result.message_id, textLen: snapshot.length, truncated, text: snapshot });
           if (!truncated) {
             this.lastSentBuffer = snapshot;
             this.displayTruncated = false;
@@ -3950,6 +4653,7 @@ var MessageDraft = class {
           { type: "text", key: this.sessionId }
         );
         if (result !== void 0) {
+          this.tracer?.log("telegram", { action: "draft:edit", sessionId: this.sessionId, msgId: this.messageId, textLen: snapshot.length, truncated, text: snapshot });
           if (!truncated) {
             this.lastSentBuffer = snapshot;
             this.displayTruncated = false;
@@ -3962,6 +4666,7 @@ var MessageDraft = class {
     }
   }
   async finalize() {
+    this.tracer?.log("telegram", { action: "draft:finalize", sessionId: this.sessionId, bufferLen: this.buffer.length, msgId: this.messageId });
     if (this.flushTimer) {
       clearTimeout(this.flushTimer);
       this.flushTimer = void 0;
@@ -3981,6 +4686,7 @@ var MessageDraft = class {
             }),
             { type: "other" }
           );
+          this.tracer?.log("telegram", { action: "draft:finalize:edit", sessionId: this.sessionId, msgId: this.messageId });
         } else {
           const msg = await this.sendQueue.enqueue(
             () => this.bot.api.sendMessage(this.chatId, fullHtml, {
@@ -3991,6 +4697,7 @@ var MessageDraft = class {
             { type: "other" }
           );
           if (msg) this.messageId = msg.message_id;
+          this.tracer?.log("telegram", { action: "draft:finalize:send", sessionId: this.sessionId, msgId: msg?.message_id });
         }
         return this.messageId;
       } catch {
@@ -4026,6 +4733,7 @@ var MessageDraft = class {
       chunkPromises.push(promise);
     }
     await Promise.all(chunkPromises);
+    this.tracer?.log("telegram", { action: "draft:finalize:split", sessionId: this.sessionId, chunks: mdChunks.length });
     return this.messageId;
   }
   getMessageId() {
@@ -4060,7 +4768,8 @@ var DraftManager = class {
   }
   drafts = /* @__PURE__ */ new Map();
   textBuffers = /* @__PURE__ */ new Map();
-  getOrCreate(sessionId, threadId) {
+  finalizedDrafts = /* @__PURE__ */ new Map();
+  getOrCreate(sessionId, threadId, tracer = null) {
     let draft = this.drafts.get(sessionId);
     if (!draft) {
       draft = new MessageDraft(
@@ -4068,7 +4777,8 @@ var DraftManager = class {
         this.chatId,
         threadId,
         this.sendQueue,
-        sessionId
+        sessionId,
+        tracer
       );
       this.drafts.set(sessionId, draft);
     }
@@ -4095,6 +4805,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 +4830,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 +4947,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) {
@@ -4286,6 +5240,28 @@ var TelegramRenderer = class extends BaseRenderer {
   }
 };
 
+// src/core/adapter-primitives/output-mode-resolver.ts
+var VALID_MODES = /* @__PURE__ */ new Set(["low", "medium", "high"]);
+function toOutputMode(v) {
+  return typeof v === "string" && VALID_MODES.has(v) ? v : void 0;
+}
+var OutputModeResolver = class {
+  resolve(configManager, adapterName, sessionId, sessionManager) {
+    const config = configManager.get();
+    let mode = toOutputMode(config.outputMode) ?? "medium";
+    const channels = config.channels;
+    const channelCfg = channels?.[adapterName];
+    const adapterMode = toOutputMode(channelCfg?.outputMode);
+    if (adapterMode) mode = adapterMode;
+    if (sessionId && sessionManager) {
+      const session = sessionManager.getSession(sessionId);
+      const sessionMode = session?.record?.outputMode;
+      if (sessionMode) mode = sessionMode;
+    }
+    return mode;
+  }
+};
+
 // src/plugins/telegram/adapter.ts
 var log12 = createChildLogger({ module: "telegram" });
 function patchedFetch(input, init) {
@@ -4322,6 +5298,7 @@ var TelegramAdapter = class extends MessagingAdapter {
   assistantTopicId;
   sendQueue = new SendQueue({ minInterval: 3e3 });
   _sessionThreadIds = /* @__PURE__ */ new Map();
+  outputModeResolver = new OutputModeResolver();
   // Extracted managers
   draftManager;
   skillManager;
@@ -4336,17 +5313,29 @@ var TelegramAdapter = class extends MessagingAdapter {
     }
     return threadId;
   }
-  getOrCreateTracker(sessionId, threadId, verbosity = "medium") {
+  getOrCreateTracker(sessionId, threadId, outputMode = "medium") {
     let tracker = this.sessionTrackers.get(sessionId);
     if (!tracker) {
+      const tunnelService = this.core.lifecycleManager?.serviceRegistry?.get("tunnel");
+      const session = this.core.sessionManager.getSession(sessionId);
+      const sessionContext = session ? {
+        id: sessionId,
+        workingDirectory: session.workingDirectory
+      } : void 0;
       tracker = new ActivityTracker(
         this.bot.api,
         this.telegramConfig.chatId,
         threadId,
         this.sendQueue,
-        verbosity
+        outputMode,
+        sessionId,
+        this.getTracer(sessionId),
+        tunnelService,
+        sessionContext
       );
       this.sessionTrackers.set(sessionId, tracker);
+    } else {
+      tracker.setOutputMode(outputMode);
     }
     return tracker;
   }
@@ -4600,7 +5589,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 +5670,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();
     }
@@ -4821,8 +5815,10 @@ ${lines.join("\n")}`;
         "telegram",
         String(threadId)
       )?.id;
-      if (sessionId)
+      if (sessionId) {
+        this.getTracer(sessionId)?.log("telegram", { action: "incoming:message", sessionId, userId: String(ctx.from?.id), text: ctx.message?.text });
         await this.draftManager.finalize(sessionId, this.assistantSession?.id);
+      }
       if (sessionId) {
         const tracker = this.sessionTrackers.get(sessionId);
         if (tracker) await tracker.onNewPrompt();
@@ -4905,6 +5901,18 @@ ${lines.join("\n")}`;
     });
   }
   // --- MessagingAdapter overrides ---
+  /**
+   * Per-session serial dispatch queues.
+   * SessionBridge fires sendMessage() as fire-and-forget, so multiple events
+   * (tool_call, tool_update, text) can arrive concurrently. Without serialization,
+   * fast handlers (tool_update) overtake slow ones (tool_call with draftManager.finalize),
+   * causing out-of-order processing where a tool's completion update is processed before
+   * its creation event. This queue ensures events are processed in the order they arrive.
+   */
+  _dispatchQueues = /* @__PURE__ */ new Map();
+  getTracer(sessionId) {
+    return this.core.sessionManager.getSession(sessionId)?.agentInstance?.debugTracer ?? null;
+  }
   async sendMessage(sessionId, content) {
     if (this.assistantInitializing && sessionId === this.assistantSession?.id)
       return;
@@ -4919,33 +5927,61 @@ ${lines.join("\n")}`;
       );
       return;
     }
-    this._sessionThreadIds.set(sessionId, threadId);
-    try {
-      await super.sendMessage(sessionId, content);
-    } finally {
-      this._sessionThreadIds.delete(sessionId);
-    }
+    const prev = this._dispatchQueues.get(sessionId) ?? Promise.resolve();
+    const next = prev.then(async () => {
+      this.getTracer(sessionId)?.log("telegram", { action: "dispatch:enter", sessionId, message: content });
+      this._sessionThreadIds.set(sessionId, threadId);
+      try {
+        await super.sendMessage(sessionId, content);
+      } finally {
+        this._sessionThreadIds.delete(sessionId);
+      }
+    }).catch((err) => {
+      log12.warn({ err, sessionId }, "Dispatch queue error");
+    });
+    this._dispatchQueues.set(sessionId, next);
+    await next;
   }
-  async handleThought(sessionId, _content, _verbosity) {
+  async handleThought(sessionId, content, _verbosity) {
+    this.getTracer(sessionId)?.log("telegram", { action: "handle:thought", sessionId, text: content.text });
     const threadId = this.getThreadId(sessionId);
-    const tracker = this.getOrCreateTracker(sessionId, threadId);
-    await tracker.onThought();
+    const mode = this.outputModeResolver.resolve(
+      this.context.configManager,
+      this.name,
+      sessionId,
+      this.core.sessionManager
+    );
+    const tracker = this.getOrCreateTracker(sessionId, threadId, mode);
+    await tracker.onThought(content.text);
   }
   async handleText(sessionId, content) {
+    this.getTracer(sessionId)?.log("telegram", { action: "handle:text", sessionId, text: content.text });
     const threadId = this.getThreadId(sessionId);
     if (!this.draftManager.hasDraft(sessionId)) {
-      const tracker = this.getOrCreateTracker(sessionId, threadId);
-      tracker.onTextStart().catch(() => {
-      });
+      const mode = this.outputModeResolver.resolve(
+        this.context.configManager,
+        this.name,
+        sessionId,
+        this.core.sessionManager
+      );
+      const tracker = this.getOrCreateTracker(sessionId, threadId, mode);
+      await tracker.onTextStart();
     }
-    const draft = this.draftManager.getOrCreate(sessionId, threadId);
+    const draft = this.draftManager.getOrCreate(sessionId, threadId, this.getTracer(sessionId));
     draft.append(content.text);
     this.draftManager.appendText(sessionId, content.text);
   }
-  async handleToolCall(sessionId, content, verbosity) {
+  async handleToolCall(sessionId, content, _verbosity) {
     const threadId = this.getThreadId(sessionId);
     const meta = content.metadata ?? {};
-    const tracker = this.getOrCreateTracker(sessionId, threadId, verbosity);
+    this.getTracer(sessionId)?.log("telegram", { action: "handle:toolCall", sessionId, toolId: meta.id, toolName: meta.name, kind: meta.kind, status: meta.status, displaySummary: meta.displaySummary, rawInput: meta.rawInput });
+    const mode = this.outputModeResolver.resolve(
+      this.context.configManager,
+      this.name,
+      sessionId,
+      this.core.sessionManager
+    );
+    const tracker = this.getOrCreateTracker(sessionId, threadId, mode);
     await this.draftManager.finalize(sessionId, this.assistantSession?.id);
     await tracker.onToolCall(
       {
@@ -4965,22 +6001,39 @@ ${lines.join("\n")}`;
       meta.rawInput
     );
   }
-  async handleToolUpdate(sessionId, content, verbosity) {
+  async handleToolUpdate(sessionId, content, _verbosity) {
     const threadId = this.getThreadId(sessionId);
     const meta = content.metadata ?? {};
-    const tracker = this.getOrCreateTracker(sessionId, threadId, verbosity);
+    this.getTracer(sessionId)?.log("telegram", { action: "handle:toolUpdate", sessionId, toolId: meta.id, name: meta.name, kind: meta.kind, status: meta.status, viewerLinks: meta.viewerLinks, viewerFilePath: meta.viewerFilePath });
+    const mode = this.outputModeResolver.resolve(
+      this.context.configManager,
+      this.name,
+      sessionId,
+      this.core.sessionManager
+    );
+    const tracker = this.getOrCreateTracker(sessionId, threadId, mode);
     await tracker.onToolUpdate(
       meta.id ?? "",
       meta.status ?? "completed",
       meta.viewerLinks,
-      meta.viewerFilePath
+      meta.viewerFilePath,
+      typeof meta.content === "string" ? meta.content : null,
+      meta.rawInput ?? void 0,
+      meta.diffStats
     );
   }
-  async handlePlan(sessionId, content, verbosity) {
+  async handlePlan(sessionId, content, _verbosity) {
     const threadId = this.getThreadId(sessionId);
     const meta = content.metadata ?? {};
     const entries = meta.entries ?? [];
-    const tracker = this.getOrCreateTracker(sessionId, threadId, verbosity);
+    this.getTracer(sessionId)?.log("telegram", { action: "handle:plan", sessionId, entryCount: entries.length });
+    const mode = this.outputModeResolver.resolve(
+      this.context.configManager,
+      this.name,
+      sessionId,
+      this.core.sessionManager
+    );
+    const tracker = this.getOrCreateTracker(sessionId, threadId, mode);
     await tracker.onPlan(
       entries.map((e) => ({
         content: e.content,
@@ -4992,15 +6045,27 @@ ${lines.join("\n")}`;
   async handleUsage(sessionId, content, verbosity) {
     const threadId = this.getThreadId(sessionId);
     const meta = content.metadata;
+    this.getTracer(sessionId)?.log("telegram", { action: "handle:usage", sessionId, tokensUsed: meta?.tokensUsed, contextSize: meta?.contextSize, cost: meta?.cost });
     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.
@@ -5017,6 +6082,7 @@ Task completed.
     }
   }
   async handleAttachment(sessionId, content) {
+    this.getTracer(sessionId)?.log("telegram", { action: "handle:attachment", sessionId, type: content.attachment?.type, fileName: content.attachment?.fileName });
     const threadId = this.getThreadId(sessionId);
     if (!content.attachment) return;
     const { attachment } = content;
@@ -5072,6 +6138,7 @@ Task completed.
     }
   }
   async handleSessionEnd(sessionId, _content) {
+    this.getTracer(sessionId)?.log("telegram", { action: "handle:sessionEnd", sessionId });
     const threadId = this.getThreadId(sessionId);
     await this.draftManager.finalize(sessionId, this.assistantSession?.id);
     this.draftManager.cleanup(sessionId);
@@ -5091,6 +6158,7 @@ Task completed.
     }
   }
   async handleError(sessionId, content) {
+    this.getTracer(sessionId)?.log("telegram", { action: "handle:error", sessionId, text: content.text });
     const threadId = this.getThreadId(sessionId);
     await this.draftManager.finalize(sessionId, this.assistantSession?.id);
     const tracker = this.sessionTrackers.get(sessionId);
@@ -5111,6 +6179,7 @@ Task completed.
     );
   }
   async handleSystem(sessionId, content) {
+    this.getTracer(sessionId)?.log("telegram", { action: "handle:system", sessionId, text: content.text });
     const threadId = this.getThreadId(sessionId);
     await this.sendQueue.enqueue(
       () => this.bot.api.sendMessage(
@@ -5125,6 +6194,7 @@ Task completed.
     );
   }
   async sendPermissionRequest(sessionId, request) {
+    this.getTracer(sessionId)?.log("telegram", { action: "permission:send", sessionId, requestId: request.id, description: request.description });
     log12.info({ sessionId, requestId: request.id }, "Permission request sent");
     const session = this.core.sessionManager.getSession(sessionId);
     if (!session) return;
@@ -5133,6 +6203,7 @@ Task completed.
     );
   }
   async sendNotification(notification) {
+    this.getTracer(notification.sessionId)?.log("telegram", { action: "notification:send", sessionId: notification.sessionId, type: notification.type });
     if (notification.sessionId === this.assistantSession?.id) return;
     log12.info(
       { sessionId: notification.sessionId, type: notification.type },
@@ -5172,12 +6243,14 @@ Task completed.
     );
   }
   async createSessionThread(sessionId, name) {
+    this.getTracer(sessionId)?.log("telegram", { action: "thread:create", sessionId, name });
     log12.info({ sessionId, name }, "Session topic created");
     return String(
       await createSessionTopic(this.bot, this.telegramConfig.chatId, name)
     );
   }
   async renameSessionThread(sessionId, newName) {
+    this.getTracer(sessionId)?.log("telegram", { action: "thread:rename", sessionId, newName });
     const session = this.core.sessionManager.getSession(sessionId);
     if (!session) return;
     await renameSessionTopic(
@@ -5283,10 +6356,14 @@ 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) {
+    this.getTracer(sessionId)?.log("telegram", { action: "thread:archive", 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 +6376,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 {
+  STATUS_ICONS,
+  KIND_ICONS,
+  progressBar,
+  formatTokens,
+  stripCodeFences,
+  truncateContent,
+  splitMessage,
+  extractContentText,
+  formatToolSummary,
+  formatToolTitle,
+  resolveToolIcon,
   PRODUCT_GUIDE,
   SendQueue,
+  MessagingAdapter,
+  BaseRenderer,
   TelegramAdapter
 };
-//# sourceMappingURL=chunk-XWDW3XBE.js.map
+//# sourceMappingURL=chunk-5ZNBNIK3.js.map