@openacp/cli 2026.328.2 → 2026.330.3

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

@@ -7,7 +7,7 @@ import {
 } from "./chunk-AFKX424Q.js";
 import {
   DoctorEngine
-} from "./chunk-43JVXFYP.js";
+} from "./chunk-GEOXPGCO.js";
 import {
   CheckpointReader,
   DEFAULT_MAX_TOKENS
@@ -65,6 +65,53 @@ 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);
@@ -125,36 +172,6 @@ function splitMessage(text, maxLength) {
   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 "";
@@ -419,58 +436,85 @@ 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(
-          `<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);
+  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));
   }
   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];
@@ -478,12 +522,13 @@ function splitToolCardText(text) {
   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}
 
-${section}` : section;
+${safeSection}` : safeSection;
     if (candidate.length > TELEGRAM_MAX_LENGTH && current) {
       chunks.push(current);
-      current = section;
+      current = safeSection;
     } else {
       current = candidate;
     }
@@ -747,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" }
     );
   }
@@ -783,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 {
     }
@@ -2764,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) {
@@ -2851,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" }
 ];
 
@@ -3556,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();
@@ -3591,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 {
@@ -3627,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() {
@@ -3665,40 +3735,279 @@ 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.tracer?.log("telegram", { action: "thinking:show", sessionId: this.sessionId, msgId: result.message_id });
         if (this.dismissed) {
-          try {
-            await this.api.deleteMessage(this.chatId, result.message_id);
-          } catch {
-          }
         } else {
           this.msgId = result.message_id;
           this.startRefreshTimer();
@@ -3710,19 +4019,27 @@ var ThinkingIndicator = class {
       this.sending = false;
     }
   }
-  /** Dismiss indicator: stops refresh timer and deletes the Telegram message */
+  /** 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();
-    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() {
@@ -3736,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(() => {
@@ -3757,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(() => {
         });
@@ -3774,12 +4093,11 @@ var ToolCard = class {
   msgId;
   lastSentText;
   flushPromise = Promise.resolve();
-  overflowCount = 0;
-  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);
@@ -3801,19 +4119,29 @@ var ToolCard = class {
     return this.msgId;
   }
   async _sendOrEdit(snapshot) {
-    const fullText = renderToolCard(snapshot);
+    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, firstChunk, {
-            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, firstChunk, {
@@ -3823,17 +4151,25 @@ var ToolCard = class {
           })
         );
         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++) {
-        if (i > this.overflowCount) {
+        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
             })
           );
-          this.overflowCount = i;
+          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) {
@@ -3842,64 +4178,112 @@ 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.verbosity = verbosity;
-    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;
-  verbosity;
+  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.thoughtBuffer.reset();
     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
-    );
+    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;
-    await 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;
     await this.thinking.dismiss();
     this.thinking.reset();
-    this.toolCard.addTool(meta, kind, rawInput);
-  }
-  /** Finalize current tool card and create a fresh one (when interrupted by text/thought) */
-  async sealToolCardIfNeeded() {
-    if (!this.toolCard.hasContent()) return;
-    await this.toolCard.finalize();
-    this.toolCard = new ToolCard(
-      this.api,
-      this.chatId,
-      this.threadId,
-      this.sendQueue,
-      this.verbosity
-    );
-  }
-  async onToolUpdate(id, status, viewerLinks, viewerFilePath) {
-    this.toolCard.updateTool(id, status, viewerLinks, viewerFilePath);
+    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;
     await this.thinking.dismiss();
     this.toolCard.updatePlan(entries);
@@ -3919,6 +4303,15 @@ var ActivityTracker = class {
     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
@@ -4179,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;
@@ -4193,6 +4587,7 @@ var MessageDraft = class {
   flushPromise = Promise.resolve();
   lastSentBuffer = "";
   displayTruncated = false;
+  tracer;
   append(text) {
     if (!text) return;
     this.buffer += text;
@@ -4237,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;
@@ -4257,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;
@@ -4269,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;
@@ -4288,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, {
@@ -4298,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 {
@@ -4333,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() {
@@ -4368,7 +4769,7 @@ var DraftManager = class {
   drafts = /* @__PURE__ */ new Map();
   textBuffers = /* @__PURE__ */ new Map();
   finalizedDrafts = /* @__PURE__ */ new Map();
-  getOrCreate(sessionId, threadId) {
+  getOrCreate(sessionId, threadId, tracer = null) {
     let draft = this.drafts.get(sessionId);
     if (!draft) {
       draft = new MessageDraft(
@@ -4376,7 +4777,8 @@ var DraftManager = class {
         this.chatId,
         threadId,
         this.sendQueue,
-        sessionId
+        sessionId,
+        tracer
       );
       this.drafts.set(sessionId, draft);
     }
@@ -4838,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) {
@@ -4867,6 +5291,7 @@ var TelegramAdapter = class extends MessagingAdapter {
   core;
   bot;
   telegramConfig;
+  saveTopicIds;
   permissionHandler;
   assistantSession = null;
   assistantInitializing = false;
@@ -4874,6 +5299,7 @@ var TelegramAdapter = class extends MessagingAdapter {
   assistantTopicId;
   sendQueue = new SendQueue({ minInterval: 3e3 });
   _sessionThreadIds = /* @__PURE__ */ new Map();
+  outputModeResolver = new OutputModeResolver();
   // Extracted managers
   draftManager;
   skillManager;
@@ -4888,21 +5314,33 @@ 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;
   }
-  constructor(core, config) {
+  constructor(core, config, saveTopicIds) {
     super({ configManager: core.configManager }, {
       ...config,
       maxMessageLength: 4096,
@@ -4910,6 +5348,7 @@ var TelegramAdapter = class extends MessagingAdapter {
     });
     this.core = core;
     this.telegramConfig = config;
+    this.saveTopicIds = saveTopicIds;
   }
   async start() {
     this.bot = new Bot(this.telegramConfig.botToken, {
@@ -4981,9 +5420,13 @@ var TelegramAdapter = class extends MessagingAdapter {
       this.telegramConfig.chatId,
       this.telegramConfig,
       async (updates) => {
-        await this.core.configManager.save({
-          channels: { telegram: updates }
-        });
+        if (this.saveTopicIds) {
+          await this.saveTopicIds(updates);
+        } else {
+          await this.core.configManager.save({
+            channels: { telegram: updates }
+          });
+        }
       }
     );
     this.notificationTopicId = topics.notificationTopicId;
@@ -5378,8 +5821,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();
@@ -5462,6 +5907,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;
@@ -5476,33 +5933,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(
       {
@@ -5522,22 +6007,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,
@@ -5549,6 +6051,7 @@ ${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 usageText = formatUsage(meta ?? {}, verbosity);
     let usageMsgId;
@@ -5585,6 +6088,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;
@@ -5640,6 +6144,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);
@@ -5659,6 +6164,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);
@@ -5679,6 +6185,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(
@@ -5693,6 +6200,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;
@@ -5701,6 +6209,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 },
@@ -5740,12 +6249,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(
@@ -5855,6 +6366,7 @@ Task completed.
     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) throw new Error("Session not found");
@@ -5878,13 +6390,13 @@ Task completed.
 };
 
 export {
+  STATUS_ICONS,
+  KIND_ICONS,
   progressBar,
   formatTokens,
   stripCodeFences,
   truncateContent,
   splitMessage,
-  STATUS_ICONS,
-  KIND_ICONS,
   extractContentText,
   formatToolSummary,
   formatToolTitle,
@@ -5895,4 +6407,4 @@ export {
   BaseRenderer,
   TelegramAdapter
 };
-//# sourceMappingURL=chunk-RXMWJHWH.js.map
+//# sourceMappingURL=chunk-XBZIHNKV.js.map