@openacp/cli 2026.327.2 → 2026.327.5

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

@@ -11,6 +11,7 @@ import {
 import {
   BaseRenderer,
   MessagingAdapter,
+  evaluateNoise,
   extractContentText,
   formatTokens,
   formatToolSummary,
@@ -20,7 +21,7 @@ import {
   splitMessage,
   stripCodeFences,
   truncateContent
-} from "./chunk-TRXBJEZ5.js";
+} from "./chunk-32LVIEPW.js";
 import {
   CheckpointReader,
   DEFAULT_MAX_TOKENS
@@ -125,15 +126,7 @@ function formatToolCall(tool, verbosity = "medium") {
   return text;
 }
 function formatToolUpdate(update, verbosity = "medium") {
-  const si = resolveToolIcon(update);
-  const name = update.name || "Tool";
-  const label = verbosity === "low" ? formatToolTitle(name, update.rawInput, update.displayTitle) : formatToolSummary(name, update.rawInput, update.displaySummary);
-  let text = `${si} <b>${escapeHtml(label)}</b>`;
-  text += formatViewerLinks(update.viewerLinks, update.viewerFilePath);
-  if (verbosity === "high") {
-    text += formatHighDetails(update.rawInput, update.content, 3800);
-  }
-  return text;
+  return formatToolCall(update, verbosity);
 }
 function formatHighDetails(rawInput, content, maxLen) {
   let text = "";
@@ -165,12 +158,8 @@ function formatViewerLinks(links, filePath) {
 \u{1F4DD} <a href="${escapeHtml(links.diff)}">View diff${fileName ? ` \u2014 ${escapeHtml(fileName)}` : ""}</a>`;
   return text;
 }
-function formatPlan(plan, verbosity = "medium") {
+function formatPlan(plan) {
   const { entries } = plan;
-  if (verbosity === "medium") {
-    const done = entries.filter((e) => e.status === "completed").length;
-    return `\u{1F4CB} <b>Plan:</b> ${done}/${entries.length} steps completed`;
-  }
   const statusIcon = {
     pending: "\u2B1C",
     in_progress: "\u{1F504}",
@@ -203,6 +192,67 @@ ${bar} ${pct}%`;
 function splitMessage2(text, maxLength = 3800) {
   return splitMessage(text, maxLength);
 }
+function renderToolCard(snap) {
+  const sections = [];
+  const { totalVisible, completedVisible, allComplete } = snap;
+  const headerCheck = allComplete ? " \u2705" : "";
+  if (totalVisible > 0) {
+    sections.push(
+      `<b>\u{1F4CB} Tools (${completedVisible}/${totalVisible})</b>${headerCheck}`
+    );
+  }
+  const visible = snap.entries.filter((e) => !e.hidden);
+  const completed = visible.filter(
+    (e) => e.status === "completed" || e.status === "done" || e.status === "failed"
+  );
+  const running = visible.filter(
+    (e) => e.status !== "completed" && e.status !== "done" && e.status !== "failed"
+  );
+  for (const entry of completed) {
+    let line = `${entry.icon} ${escapeHtml(entry.label)}`;
+    if (entry.viewerLinks) {
+      const links = [];
+      const fileName = entry.viewerFilePath?.split("/").pop() ?? "";
+      if (entry.viewerLinks.file)
+        links.push(
+          `\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);
+  }
+  if (snap.planEntries && snap.planEntries.length > 0) {
+    const planDone = snap.planEntries.filter(
+      (e) => e.status === "completed"
+    ).length;
+    const planTotal = snap.planEntries.length;
+    sections.push(`\u2500\u2500 Plan: ${planDone}/${planTotal} \u2500\u2500`);
+    const statusIcon = {
+      completed: "\u2705",
+      in_progress: "\u{1F504}",
+      pending: "\u2B1C"
+    };
+    for (let i = 0; i < snap.planEntries.length; i++) {
+      const e = snap.planEntries[i];
+      const icon = statusIcon[e.status] ?? "\u2B1C";
+      sections.push(`${icon} ${i + 1}. ${escapeHtml(e.content)}`);
+    }
+    sections.push("\u2500\u2500\u2500\u2500");
+  }
+  for (const entry of running) {
+    sections.push(`${entry.icon} ${escapeHtml(entry.label)}`);
+  }
+  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");
+}
 
 // src/plugins/telegram/commands/admin.ts
 import { InlineKeyboard } from "grammy";
@@ -3251,6 +3301,117 @@ function redirectToAssistant(chatId, assistantTopicId) {
   return `\u{1F4AC} Please use the <a href="${link}">\u{1F916} Assistant</a> topic to chat with OpenACP.`;
 }
 
+// src/core/adapter-primitives/primitives/tool-card-state.ts
+var DEBOUNCE_MS = 500;
+var ToolCardState = class {
+  entries = [];
+  planEntries;
+  usage;
+  finalized = false;
+  isFirstFlush = true;
+  debounceTimer;
+  verbosity;
+  onFlush;
+  constructor(config) {
+    this.verbosity = config.verbosity;
+    this.onFlush = config.onFlush;
+  }
+  addTool(meta, kind, rawInput) {
+    if (this.finalized) return;
+    const hidden = this.verbosity !== "high" && evaluateNoise(meta.name, kind, rawInput) !== null;
+    const entry = {
+      id: meta.id,
+      name: meta.name,
+      kind,
+      status: meta.status ?? "running",
+      icon: resolveToolIcon({ status: meta.status ?? "running", kind }),
+      label: formatToolSummary(meta.name, rawInput, meta.displaySummary),
+      viewerLinks: meta.viewerLinks,
+      viewerFilePath: meta.viewerFilePath,
+      hidden
+    };
+    this.entries.push(entry);
+    if (this.isFirstFlush) {
+      this.isFirstFlush = false;
+      this.flush();
+    } else {
+      this.scheduleFlush();
+    }
+  }
+  updateTool(id, status, viewerLinks, viewerFilePath) {
+    if (this.finalized) return;
+    const entry = this.entries.find((e) => e.id === id);
+    if (!entry) return;
+    entry.status = status;
+    entry.icon = resolveToolIcon({ status, kind: entry.kind });
+    if (viewerLinks) entry.viewerLinks = viewerLinks;
+    if (viewerFilePath) entry.viewerFilePath = viewerFilePath;
+    this.scheduleFlush();
+  }
+  updatePlan(entries) {
+    if (this.finalized) return;
+    this.planEntries = entries;
+    if (this.entries.length === 0 && this.isFirstFlush) {
+      this.isFirstFlush = false;
+      this.flush();
+    } else {
+      this.scheduleFlush();
+    }
+  }
+  appendUsage(usage) {
+    if (this.finalized) return;
+    this.usage = usage;
+    this.flush();
+  }
+  finalize() {
+    if (this.finalized) return;
+    this.finalized = true;
+    this.clearDebounce();
+    this.flush();
+  }
+  destroy() {
+    this.finalized = true;
+    this.clearDebounce();
+  }
+  hasContent() {
+    return this.entries.length > 0 || this.planEntries !== void 0;
+  }
+  snapshot() {
+    const visible = this.entries.filter((e) => !e.hidden);
+    const completedVisible = visible.filter(
+      (e) => e.status === "completed" || e.status === "done"
+    ).length;
+    const allComplete = visible.length > 0 && completedVisible === visible.length;
+    return {
+      entries: this.entries,
+      planEntries: this.planEntries,
+      usage: this.usage,
+      visibleCount: visible.length,
+      totalVisible: visible.length,
+      completedVisible,
+      allComplete,
+      verbosity: this.verbosity
+    };
+  }
+  flush() {
+    this.clearDebounce();
+    this.onFlush(this.snapshot());
+  }
+  scheduleFlush() {
+    this.clearDebounce();
+    this.debounceTimer = setTimeout(() => {
+      this.debounceTimer = void 0;
+      this.flush();
+    }, DEBOUNCE_MS);
+  }
+  clearDebounce() {
+    if (this.debounceTimer) {
+      clearTimeout(this.debounceTimer);
+      this.debounceTimer = void 0;
+    }
+  }
+};
+
 // src/plugins/telegram/activity.ts
 var log10 = createChildLogger({ module: "telegram:activity" });
 var THINKING_REFRESH_MS = 15e3;
@@ -3308,20 +3469,14 @@ var ThinkingIndicator = class {
       }
       const elapsed = Math.round((Date.now() - this.showTime) / 1e3);
       this.sendQueue.enqueue(() => {
-        if (this.dismissed) return Promise.resolve(void 0);
-        return this.api.sendMessage(
+        if (this.dismissed || !this.msgId) return Promise.resolve(void 0);
+        return this.api.editMessageText(
           this.chatId,
+          this.msgId,
           `\u{1F4AD} <i>Still thinking... (${elapsed}s)</i>`,
-          {
-            message_thread_id: this.threadId,
-            parse_mode: "HTML",
-            disable_notification: true
-          }
+          { parse_mode: "HTML" }
         );
-      }).then((result) => {
-        if (result && !this.dismissed) {
-          this.msgId = result.message_id;
-        }
+      }).then(() => {
       }).catch(() => {
       });
     }, THINKING_REFRESH_MS);
@@ -3333,123 +3488,52 @@ var ThinkingIndicator = class {
     }
   }
 };
-var UsageMessage = class {
-  constructor(api, chatId, threadId, sendQueue) {
+var ToolCard = class {
+  constructor(api, chatId, threadId, sendQueue, verbosity) {
     this.api = api;
     this.chatId = chatId;
     this.threadId = threadId;
     this.sendQueue = sendQueue;
-  }
-  msgId;
-  async send(usage, verbosity = "medium") {
-    const text = formatUsage(usage, verbosity);
-    try {
-      if (this.msgId) {
-        await this.sendQueue.enqueue(
-          () => this.api.editMessageText(this.chatId, this.msgId, text, {
-            parse_mode: "HTML"
-          })
-        );
-      } else {
-        const result = await this.sendQueue.enqueue(
-          () => this.api.sendMessage(this.chatId, text, {
-            message_thread_id: this.threadId,
-            parse_mode: "HTML",
-            disable_notification: true
-          })
-        );
-        if (result) this.msgId = result.message_id;
+    this.state = new ToolCardState({
+      verbosity,
+      onFlush: (snapshot) => {
+        this.flushPromise = this.flushPromise.then(() => this._sendOrEdit(snapshot)).catch(() => {
+        });
       }
-    } catch (err) {
-      log10.warn({ err }, "UsageMessage.send() failed");
-    }
-  }
-  getMsgId() {
-    return this.msgId;
-  }
-  async delete() {
-    if (!this.msgId) return;
-    const id = this.msgId;
-    this.msgId = void 0;
-    try {
-      await this.sendQueue.enqueue(
-        () => this.api.deleteMessage(this.chatId, id)
-      );
-    } catch (err) {
-      log10.warn({ err }, "UsageMessage.delete() failed");
-    }
-  }
-};
-function formatPlanCard(entries, verbosity = "medium") {
-  if (verbosity === "medium") {
-    const done2 = entries.filter((e) => e.status === "completed").length;
-    return `\u{1F4CB} <b>Plan:</b> ${done2}/${entries.length} steps completed`;
-  }
-  const statusIcon = {
-    completed: "\u2705",
-    in_progress: "\u{1F504}",
-    pending: "\u2B1C",
-    failed: "\u274C"
-  };
-  const total = entries.length;
-  const done = entries.filter((e) => e.status === "completed").length;
-  const ratio = total > 0 ? done / total : 0;
-  const filled = Math.round(ratio * 10);
-  const bar = "\u2593".repeat(filled) + "\u2591".repeat(10 - filled);
-  const pct = Math.round(ratio * 100);
-  const header = `\u{1F4CB} <b>Plan</b>
-${bar} ${pct}% \xB7 ${done}/${total}`;
-  const lines = entries.map((e, i) => {
-    const icon = statusIcon[e.status] ?? "\u2B1C";
-    return `${icon} ${i + 1}. ${e.content}`;
-  });
-  return [header, ...lines].join("\n");
-}
-var PlanCard = class {
-  constructor(api, chatId, threadId, sendQueue) {
-    this.api = api;
-    this.chatId = chatId;
-    this.threadId = threadId;
-    this.sendQueue = sendQueue;
+    });
   }
+  state;
   msgId;
-  flushPromise = Promise.resolve();
-  latestEntries;
   lastSentText;
-  flushTimer;
-  verbosity = "medium";
-  setVerbosity(v) {
-    this.verbosity = v;
+  flushPromise = Promise.resolve();
+  addTool(meta, kind, rawInput) {
+    this.state.addTool(meta, kind, rawInput);
   }
-  update(entries) {
-    this.latestEntries = entries;
-    if (this.flushTimer) clearTimeout(this.flushTimer);
-    this.flushTimer = setTimeout(() => {
-      this.flushTimer = void 0;
-      this.flushPromise = this.flushPromise.then(() => this._flush()).catch(() => {
-      });
-    }, 3500);
+  updateTool(id, status, viewerLinks, viewerFilePath) {
+    this.state.updateTool(id, status, viewerLinks, viewerFilePath);
+  }
+  updatePlan(entries) {
+    this.state.updatePlan(entries);
+  }
+  appendUsage(usage) {
+    this.state.appendUsage(usage);
   }
   async finalize() {
-    if (!this.latestEntries) return;
-    if (this.flushTimer) {
-      clearTimeout(this.flushTimer);
-      this.flushTimer = void 0;
-    }
-    await this.flushPromise;
-    this.flushPromise = this.flushPromise.then(() => this._flush()).catch(() => {
-    });
+    this.state.finalize();
     await this.flushPromise;
   }
   destroy() {
-    if (this.flushTimer) {
-      clearTimeout(this.flushTimer);
-      this.flushTimer = void 0;
-    }
+    this.state.destroy();
   }
-  async _flush() {
-    if (!this.latestEntries) return;
-    const text = formatPlanCard(this.latestEntries, this.verbosity);
+  hasContent() {
+    return this.state.hasContent();
+  }
+  getMsgId() {
+    return this.msgId;
+  }
+  async _sendOrEdit(snapshot) {
+    const text = renderToolCard(snapshot);
+    if (!text) return;
     if (this.msgId && text === this.lastSentText) return;
     this.lastSentText = text;
     try {
@@ -3470,82 +3554,63 @@ var PlanCard = class {
         if (result) this.msgId = result.message_id;
       }
     } catch (err) {
-      log10.warn({ err }, "PlanCard flush failed");
+      log10.warn({ err }, "[ToolCard] send/edit failed");
     }
   }
 };
 var ActivityTracker = class {
-  constructor(api, chatId, threadId, sendQueue) {
+  constructor(api, chatId, threadId, sendQueue, verbosity = "medium") {
     this.api = api;
     this.chatId = chatId;
     this.threadId = threadId;
     this.sendQueue = sendQueue;
     this.thinking = new ThinkingIndicator(api, chatId, threadId, sendQueue);
-    this.planCard = new PlanCard(api, chatId, threadId, sendQueue);
-    this.usage = new UsageMessage(api, chatId, threadId, sendQueue);
+    this.toolCard = new ToolCard(api, chatId, threadId, sendQueue, verbosity);
   }
   isFirstEvent = true;
-  hasPlanCard = false;
   thinking;
-  planCard;
-  usage;
+  toolCard;
   async onNewPrompt() {
     this.isFirstEvent = true;
-    this.hasPlanCard = false;
     this.thinking.dismiss();
     this.thinking.reset();
   }
   async onThought() {
-    await this._firstEventGuard();
+    this.isFirstEvent = false;
     await this.thinking.show();
   }
-  async onPlan(entries, verbosity) {
-    await this._firstEventGuard();
+  async onTextStart() {
+    this.isFirstEvent = false;
     this.thinking.dismiss();
-    this.hasPlanCard = true;
-    if (verbosity) this.planCard.setVerbosity(verbosity);
-    this.planCard.update(entries);
   }
-  async onToolCall() {
-    await this._firstEventGuard();
+  async onToolCall(meta, kind, rawInput) {
+    this.isFirstEvent = false;
     this.thinking.dismiss();
     this.thinking.reset();
+    this.toolCard.addTool(meta, kind, rawInput);
   }
-  async onTextStart() {
-    await this._firstEventGuard();
+  async onToolUpdate(id, status, viewerLinks, viewerFilePath) {
+    this.toolCard.updateTool(id, status, viewerLinks, viewerFilePath);
+  }
+  async onPlan(entries) {
+    this.isFirstEvent = false;
     this.thinking.dismiss();
+    this.toolCard.updatePlan(entries);
   }
-  async sendUsage(data, verbosity = "medium") {
-    await this.usage.send(data, verbosity);
+  async sendUsage(usage) {
+    this.toolCard.appendUsage(usage);
   }
   getUsageMsgId() {
-    return this.usage.getMsgId();
+    return this.toolCard.getMsgId();
   }
-  async onComplete() {
-    if (this.hasPlanCard) {
-      await this.planCard.finalize();
-    } else {
-      try {
-        await this.sendQueue.enqueue(
-          () => this.api.sendMessage(this.chatId, "\u2705 <b>Done</b>", {
-            message_thread_id: this.threadId,
-            parse_mode: "HTML",
-            disable_notification: true
-          })
-        );
-      } catch (err) {
-        log10.warn({ err }, "ActivityTracker.onComplete() Done send failed");
-      }
-    }
+  async cleanup() {
+    this.thinking.dismiss();
+    await this.toolCard.finalize();
+    this.toolCard.destroy();
   }
   destroy() {
     this.thinking.dismiss();
-    this.planCard.destroy();
-  }
-  async _firstEventGuard() {
-    if (!this.isFirstEvent) return;
-    this.isFirstEvent = false;
-    await this.usage.delete();
+    this.toolCard.destroy();
   }
 };
 
@@ -3804,143 +3869,6 @@ function setupActionCallbacks(bot, core, chatId, getAssistantSessionId) {
   });
 }
 
-// src/core/adapter-primitives/primitives/tool-call-tracker.ts
-var ToolCallTracker = class {
-  sessions = /* @__PURE__ */ new Map();
-  track(sessionId, meta, messageId) {
-    if (!this.sessions.has(sessionId)) {
-      this.sessions.set(sessionId, /* @__PURE__ */ new Map());
-    }
-    this.sessions.get(sessionId).set(meta.id, { ...meta, messageId });
-  }
-  update(sessionId, toolId, status, patch) {
-    const tool = this.sessions.get(sessionId)?.get(toolId);
-    if (!tool) return null;
-    tool.status = status;
-    if (patch?.viewerLinks) tool.viewerLinks = patch.viewerLinks;
-    if (patch?.viewerFilePath) tool.viewerFilePath = patch.viewerFilePath;
-    if (patch?.name) tool.name = patch.name;
-    if (patch?.kind) tool.kind = patch.kind;
-    return tool;
-  }
-  getActive(sessionId) {
-    const session = this.sessions.get(sessionId);
-    return session ? [...session.values()] : [];
-  }
-  clear(sessionId) {
-    this.sessions.delete(sessionId);
-  }
-  clearAll() {
-    this.sessions.clear();
-  }
-};
-
-// src/plugins/telegram/tool-call-tracker.ts
-var log11 = createChildLogger({ module: "tool-call-tracker" });
-var TelegramToolCallTracker = class {
-  constructor(bot, chatId, sendQueue) {
-    this.bot = bot;
-    this.chatId = chatId;
-    this.sendQueue = sendQueue;
-  }
-  tracker = new ToolCallTracker();
-  /** Platform-specific ready-promise per tool call, keyed by `${sessionId}:${toolId}`. */
-  readyMap = /* @__PURE__ */ new Map();
-  async trackNewCall(sessionId, threadId, meta, verbosity = "medium") {
-    let resolveReady;
-    const ready = new Promise((r) => {
-      resolveReady = r;
-    });
-    const key = `${sessionId}:${meta.id}`;
-    this.readyMap.set(key, { ready });
-    this.tracker.track(sessionId, meta, "0");
-    try {
-      const msg = await this.sendQueue.enqueue(
-        () => this.bot.api.sendMessage(this.chatId, formatToolCall(meta, verbosity), {
-          message_thread_id: threadId,
-          parse_mode: "HTML",
-          disable_notification: true
-        })
-      );
-      const tracked = this.tracker.update(sessionId, meta.id, meta.status ?? "running");
-      if (tracked) {
-        tracked.messageId = String(msg.message_id);
-      }
-    } finally {
-      resolveReady();
-    }
-  }
-  async updateCall(sessionId, meta, verbosity = "medium") {
-    const key = `${sessionId}:${meta.id}`;
-    const readyState = this.readyMap.get(key);
-    const tracked = this.tracker.update(sessionId, meta.id, meta.status, {
-      viewerLinks: meta.viewerLinks,
-      viewerFilePath: meta.viewerFilePath,
-      name: meta.name,
-      kind: meta.kind
-    });
-    if (!tracked) return;
-    const isTerminal = meta.status === "completed" || meta.status === "failed";
-    if (!isTerminal) return;
-    if (readyState) {
-      await readyState.ready;
-    }
-    const msgId = Number(tracked.messageId);
-    log11.debug(
-      {
-        toolId: meta.id,
-        status: meta.status,
-        hasViewerLinks: !!tracked.viewerLinks,
-        viewerLinks: tracked.viewerLinks,
-        name: tracked.name,
-        msgId
-      },
-      "Tool completed, preparing edit"
-    );
-    const merged = {
-      id: meta.id,
-      name: tracked.name,
-      kind: tracked.kind,
-      rawInput: tracked.rawInput,
-      viewerLinks: tracked.viewerLinks,
-      viewerFilePath: tracked.viewerFilePath,
-      displaySummary: tracked.displaySummary,
-      displayTitle: tracked.displayTitle,
-      displayKind: tracked.displayKind,
-      status: meta.status,
-      content: meta.content
-    };
-    const formattedText = formatToolUpdate(merged, verbosity);
-    try {
-      await this.sendQueue.enqueue(
-        () => this.bot.api.editMessageText(
-          this.chatId,
-          msgId,
-          formattedText,
-          { parse_mode: "HTML" }
-        )
-      );
-    } catch (err) {
-      log11.warn(
-        {
-          err,
-          msgId,
-          textLen: formattedText.length,
-          hasViewerLinks: !!merged.viewerLinks
-        },
-        "Tool update edit failed"
-      );
-    }
-  }
-  cleanup(sessionId) {
-    const active = this.tracker.getActive(sessionId);
-    for (const tool of active) {
-      this.readyMap.delete(`${sessionId}:${tool.id}`);
-    }
-    this.tracker.clear(sessionId);
-  }
-};
-
 // src/plugins/telegram/streaming.ts
 var FLUSH_INTERVAL = 5e3;
 var MessageDraft = class {
@@ -4196,7 +4124,7 @@ var DraftManager = class {
 };
 
 // src/plugins/telegram/skill-command-manager.ts
-var log12 = createChildLogger({ module: "skill-commands" });
+var log11 = createChildLogger({ module: "skill-commands" });
 var SkillCommandManager = class {
   // sessionId → pinned msgId
   constructor(bot, chatId, sendQueue, sessionManager) {
@@ -4262,7 +4190,7 @@ var SkillCommandManager = class {
         disable_notification: true
       });
     } catch (err) {
-      log12.error({ err, sessionId }, "Failed to send skill commands");
+      log11.error({ err, sessionId }, "Failed to send skill commands");
     }
   }
   async cleanup(sessionId) {
@@ -4294,22 +4222,34 @@ var SkillCommandManager = class {
 var TelegramRenderer = class extends BaseRenderer {
   renderToolCall(content, verbosity) {
     const meta = content.metadata ?? {};
-    return { body: formatToolCall(meta, verbosity), format: "html" };
+    return {
+      body: formatToolCall(meta, verbosity),
+      format: "html"
+    };
   }
   renderToolUpdate(content, verbosity) {
     const meta = content.metadata ?? {};
-    return { body: formatToolUpdate(meta, verbosity), format: "html" };
+    return {
+      body: formatToolUpdate(meta, verbosity),
+      format: "html"
+    };
   }
-  renderPlan(content, verbosity) {
+  renderPlan(content) {
     const meta = content.metadata;
-    return { body: formatPlan({ entries: meta?.entries ?? [] }, verbosity), format: "html" };
+    return {
+      body: formatPlan({ entries: meta?.entries ?? [] }),
+      format: "html"
+    };
   }
   renderUsage(content, verbosity) {
     const meta = content.metadata;
     return { body: formatUsage(meta ?? {}, verbosity), format: "html" };
   }
   renderError(content) {
-    return { body: `\u274C <b>Error:</b> ${escapeHtml(content.text)}`, format: "html" };
+    return {
+      body: `\u274C <b>Error:</b> ${escapeHtml(content.text)}`,
+      format: "html"
+    };
   }
   renderNotification(notification) {
     const emoji = {
@@ -4329,19 +4269,25 @@ var TelegramRenderer = class extends BaseRenderer {
   }
   renderModeChange(content) {
     const modeId = content.metadata?.modeId ?? "";
-    return { body: `\u{1F504} <b>Mode:</b> ${escapeHtml(String(modeId))}`, format: "html" };
+    return {
+      body: `\u{1F504} <b>Mode:</b> ${escapeHtml(String(modeId))}`,
+      format: "html"
+    };
   }
   renderConfigUpdate() {
     return { body: "\u2699\uFE0F <b>Config updated</b>", format: "html" };
   }
   renderModelUpdate(content) {
     const modelId = content.metadata?.modelId ?? "";
-    return { body: `\u{1F916} <b>Model:</b> ${escapeHtml(String(modelId))}`, format: "html" };
+    return {
+      body: `\u{1F916} <b>Model:</b> ${escapeHtml(String(modelId))}`,
+      format: "html"
+    };
   }
 };
 
 // src/plugins/telegram/adapter.ts
-var log13 = createChildLogger({ module: "telegram" });
+var log12 = createChildLogger({ module: "telegram" });
 function patchedFetch(input, init) {
   if (init?.signal && !(init.signal instanceof AbortSignal)) {
     const nativeController = new AbortController();
@@ -4377,7 +4323,6 @@ var TelegramAdapter = class extends MessagingAdapter {
   sendQueue = new SendQueue({ minInterval: 3e3 });
   _sessionThreadIds = /* @__PURE__ */ new Map();
   // Extracted managers
-  toolTracker;
   draftManager;
   skillManager;
   fileService;
@@ -4391,24 +4336,26 @@ var TelegramAdapter = class extends MessagingAdapter {
     }
     return threadId;
   }
-  getOrCreateTracker(sessionId, threadId) {
+  getOrCreateTracker(sessionId, threadId, verbosity = "medium") {
     let tracker = this.sessionTrackers.get(sessionId);
     if (!tracker) {
       tracker = new ActivityTracker(
         this.bot.api,
         this.telegramConfig.chatId,
         threadId,
-        this.sendQueue
+        this.sendQueue,
+        verbosity
       );
       this.sessionTrackers.set(sessionId, tracker);
     }
     return tracker;
   }
   constructor(core, config) {
-    super(
-      { configManager: core.configManager },
-      { ...config, maxMessageLength: 4096, enabled: config.enabled ?? true }
-    );
+    super({ configManager: core.configManager }, {
+      ...config,
+      maxMessageLength: 4096,
+      enabled: config.enabled ?? true
+    });
     this.core = core;
     this.telegramConfig = config;
   }
@@ -4420,11 +4367,6 @@ var TelegramAdapter = class extends MessagingAdapter {
       }
     });
     this.fileService = this.core.fileService;
-    this.toolTracker = new TelegramToolCallTracker(
-      this.bot,
-      this.telegramConfig.chatId,
-      this.sendQueue
-    );
     this.draftManager = new DraftManager(
       this.bot,
       this.telegramConfig.chatId,
@@ -4438,7 +4380,7 @@ var TelegramAdapter = class extends MessagingAdapter {
     );
     this.bot.catch((err) => {
       const rootCause = err.error instanceof Error ? err.error : err;
-      log13.error({ err: rootCause }, "Telegram bot error");
+      log12.error({ err: rootCause }, "Telegram bot error");
     });
     this.bot.api.config.use(async (prev, method, payload, signal) => {
       const maxRetries = 3;
@@ -4456,7 +4398,7 @@ var TelegramAdapter = class extends MessagingAdapter {
         if (rateLimitedMethods.includes(method)) {
           this.sendQueue.onRateLimited();
         }
-        log13.warn(
+        log12.warn(
           { method, retryAfter, attempt: attempt + 1 },
           "Rate limited by Telegram, retrying"
         );
@@ -4503,7 +4445,9 @@ var TelegramAdapter = class extends MessagingAdapter {
     this.bot.on("message:text", async (ctx, next) => {
       const text = ctx.message?.text;
       if (!text?.startsWith("/")) return next();
-      const registry = this.core.lifecycleManager?.serviceRegistry?.get("command-registry");
+      const registry = this.core.lifecycleManager?.serviceRegistry?.get(
+        "command-registry"
+      );
       if (!registry) return next();
       const rawCommand = text.split(" ")[0].slice(1);
       const atIdx = rawCommand.indexOf("@");
@@ -4516,7 +4460,10 @@ var TelegramAdapter = class extends MessagingAdapter {
       const chatId = ctx.chat.id;
       const topicId = ctx.message.message_thread_id;
       try {
-        const sessionId = topicId != null ? this.core.sessionManager.getSessionByThread("telegram", String(topicId))?.id ?? null : null;
+        const sessionId = topicId != null ? this.core.sessionManager.getSessionByThread(
+          "telegram",
+          String(topicId)
+        )?.id ?? null : null;
         const response = await registry.execute(text, {
           raw: "",
           sessionId,
@@ -4526,7 +4473,11 @@ var TelegramAdapter = class extends MessagingAdapter {
             if (typeof content === "string") {
               await ctx.reply(content);
             } else if (typeof content === "object" && content !== null && "type" in content) {
-              await this.renderCommandResponse(content, chatId, topicId);
+              await this.renderCommandResponse(
+                content,
+                chatId,
+                topicId
+              );
             }
           }
         });
@@ -4541,12 +4492,17 @@ var TelegramAdapter = class extends MessagingAdapter {
     this.bot.callbackQuery(/^c\//, async (ctx) => {
       const data = ctx.callbackQuery.data;
       const command = this.fromCallbackData(data);
-      const registry = this.core.lifecycleManager?.serviceRegistry?.get("command-registry");
+      const registry = this.core.lifecycleManager?.serviceRegistry?.get(
+        "command-registry"
+      );
       if (!registry) return;
       const chatId = ctx.chat.id;
       const topicId = ctx.callbackQuery.message?.message_thread_id;
       try {
-        const sessionId = topicId != null ? this.core.sessionManager.getSessionByThread("telegram", String(topicId))?.id ?? null : null;
+        const sessionId = topicId != null ? this.core.sessionManager.getSessionByThread(
+          "telegram",
+          String(topicId)
+        )?.id ?? null : null;
         const response = await registry.execute(command, {
           raw: "",
           sessionId,
@@ -4666,7 +4622,7 @@ var TelegramAdapter = class extends MessagingAdapter {
     this.setupRoutes();
     this.bot.start({
       allowed_updates: ["message", "callback_query"],
-      onStart: () => log13.info(
+      onStart: () => log12.info(
         { chatId: this.telegramConfig.chatId },
         "Telegram bot started"
       )
@@ -4690,10 +4646,10 @@ var TelegramAdapter = class extends MessagingAdapter {
         reply_markup: buildMenuKeyboard()
       });
     } catch (err) {
-      log13.warn({ err }, "Failed to send welcome message");
+      log12.warn({ err }, "Failed to send welcome message");
     }
     try {
-      log13.info("Spawning assistant session...");
+      log12.info("Spawning assistant session...");
       const { session, ready } = await spawnAssistant(
         this.core,
         this,
@@ -4701,19 +4657,19 @@ var TelegramAdapter = class extends MessagingAdapter {
       );
       this.assistantSession = session;
       this.assistantInitializing = true;
-      log13.info(
+      log12.info(
         { sessionId: session.id },
         "Assistant session ready, system prompt running in background"
       );
       ready.then(() => {
         this.assistantInitializing = false;
-        log13.info(
+        log12.info(
           { sessionId: session.id },
           "Assistant ready for user messages"
         );
       });
     } catch (err) {
-      log13.error({ err }, "Failed to spawn assistant");
+      log12.error({ err }, "Failed to spawn assistant");
       this.bot.api.sendMessage(
         this.telegramConfig.chatId,
         `\u26A0\uFE0F <b>Failed to start assistant session.</b>
@@ -4729,7 +4685,7 @@ var TelegramAdapter = class extends MessagingAdapter {
       await this.assistantSession.destroy();
     }
     await this.bot.stop();
-    log13.info("Telegram bot stopped");
+    log12.info("Telegram bot stopped");
   }
   // --- CommandRegistry response rendering ---
   async renderCommandResponse(response, chatId, topicId) {
@@ -4857,7 +4813,7 @@ ${lines.join("\n")}`;
         ctx.replyWithChatAction("typing").catch(() => {
         });
         handleAssistantMessage(this.assistantSession, forwardText).catch(
-          (err) => log13.error({ err }, "Assistant error")
+          (err) => log12.error({ err }, "Assistant error")
         );
         return;
       }
@@ -4878,7 +4834,7 @@ ${lines.join("\n")}`;
         threadId: String(threadId),
         userId: String(ctx.from.id),
         text: forwardText
-      }).catch((err) => log13.error({ err }, "handleMessage error"));
+      }).catch((err) => log12.error({ err }, "handleMessage error"));
     });
     this.bot.on("message:photo", async (ctx) => {
       const threadId = ctx.message.message_thread_id;
@@ -4957,7 +4913,7 @@ ${lines.join("\n")}`;
     if (session.archiving) return;
     const threadId = Number(session.threadId);
     if (!threadId || isNaN(threadId)) {
-      log13.warn(
+      log12.warn(
         { sessionId, threadId: session.threadId },
         "Session has no valid threadId, skipping message"
       );
@@ -4989,15 +4945,9 @@ ${lines.join("\n")}`;
   async handleToolCall(sessionId, content, verbosity) {
     const threadId = this.getThreadId(sessionId);
     const meta = content.metadata ?? {};
-    const tracker = this.getOrCreateTracker(sessionId, threadId);
-    await tracker.onToolCall();
-    await this.draftManager.finalize(
-      sessionId,
-      this.assistantSession?.id
-    );
-    await this.toolTracker.trackNewCall(
-      sessionId,
-      threadId,
+    const tracker = this.getOrCreateTracker(sessionId, threadId, verbosity);
+    await this.draftManager.finalize(sessionId, this.assistantSession?.id);
+    await tracker.onToolCall(
       {
         id: meta.id ?? "",
         name: meta.name ?? content.text ?? "Tool",
@@ -5011,52 +4961,40 @@ ${lines.join("\n")}`;
         displayTitle: meta.displayTitle,
         displayKind: meta.displayKind
       },
-      verbosity
+      String(meta.kind ?? ""),
+      meta.rawInput
     );
   }
   async handleToolUpdate(sessionId, content, verbosity) {
+    const threadId = this.getThreadId(sessionId);
     const meta = content.metadata ?? {};
-    await this.toolTracker.updateCall(
-      sessionId,
-      {
-        id: meta.id ?? "",
-        name: meta.name ?? content.text ?? "",
-        kind: meta.kind,
-        status: meta.status ?? "completed",
-        content: meta.content,
-        rawInput: meta.rawInput,
-        viewerLinks: meta.viewerLinks,
-        viewerFilePath: meta.viewerFilePath,
-        displaySummary: meta.displaySummary,
-        displayTitle: meta.displayTitle,
-        displayKind: meta.displayKind
-      },
-      verbosity
+    const tracker = this.getOrCreateTracker(sessionId, threadId, verbosity);
+    await tracker.onToolUpdate(
+      meta.id ?? "",
+      meta.status ?? "completed",
+      meta.viewerLinks,
+      meta.viewerFilePath
     );
   }
   async handlePlan(sessionId, content, verbosity) {
     const threadId = this.getThreadId(sessionId);
     const meta = content.metadata ?? {};
     const entries = meta.entries ?? [];
-    const tracker = this.getOrCreateTracker(sessionId, threadId);
+    const tracker = this.getOrCreateTracker(sessionId, threadId, verbosity);
     await tracker.onPlan(
       entries.map((e) => ({
         content: e.content,
         status: e.status,
         priority: e.priority ?? "medium"
-      })),
-      verbosity
+      }))
     );
   }
   async handleUsage(sessionId, content, verbosity) {
     const threadId = this.getThreadId(sessionId);
     const meta = content.metadata;
-    await this.draftManager.finalize(
-      sessionId,
-      this.assistantSession?.id
-    );
-    const tracker = this.getOrCreateTracker(sessionId, threadId);
-    await tracker.sendUsage(meta ?? {}, verbosity);
+    await this.draftManager.finalize(sessionId, this.assistantSession?.id);
+    const tracker = this.getOrCreateTracker(sessionId, threadId, verbosity);
+    await tracker.sendUsage(meta ?? {});
     if (this.notificationTopicId && sessionId !== this.assistantSession?.id) {
       const sess = this.core.sessionManager.getSession(sessionId);
       const sessionName = sess?.name || "Session";
@@ -5083,7 +5021,7 @@ Task completed.
     if (!content.attachment) return;
     const { attachment } = content;
     if (attachment.size > 50 * 1024 * 1024) {
-      log13.warn(
+      log12.warn(
         {
           sessionId,
           fileName: attachment.fileName,
@@ -5127,7 +5065,7 @@ Task completed.
         );
       }
     } catch (err) {
-      log13.error(
+      log12.error(
         { err, sessionId, fileName: attachment.fileName },
         "Failed to send attachment"
       );
@@ -5135,38 +5073,26 @@ Task completed.
   }
   async handleSessionEnd(sessionId, _content) {
     const threadId = this.getThreadId(sessionId);
-    await this.draftManager.finalize(
-      sessionId,
-      this.assistantSession?.id
-    );
+    await this.draftManager.finalize(sessionId, this.assistantSession?.id);
     this.draftManager.cleanup(sessionId);
-    this.toolTracker.cleanup(sessionId);
     await this.skillManager.cleanup(sessionId);
     const tracker = this.sessionTrackers.get(sessionId);
     if (tracker) {
-      await tracker.onComplete();
-      tracker.destroy();
+      await tracker.cleanup();
       this.sessionTrackers.delete(sessionId);
     } else {
       await this.sendQueue.enqueue(
-        () => this.bot.api.sendMessage(
-          this.telegramConfig.chatId,
-          `\u2705 <b>Done</b>`,
-          {
-            message_thread_id: threadId,
-            parse_mode: "HTML",
-            disable_notification: true
-          }
-        )
+        () => this.bot.api.sendMessage(this.telegramConfig.chatId, `\u2705 <b>Done</b>`, {
+          message_thread_id: threadId,
+          parse_mode: "HTML",
+          disable_notification: true
+        })
       );
     }
   }
   async handleError(sessionId, content) {
     const threadId = this.getThreadId(sessionId);
-    await this.draftManager.finalize(
-      sessionId,
-      this.assistantSession?.id
-    );
+    await this.draftManager.finalize(sessionId, this.assistantSession?.id);
     const tracker = this.sessionTrackers.get(sessionId);
     if (tracker) {
       tracker.destroy();
@@ -5199,7 +5125,7 @@ Task completed.
     );
   }
   async sendPermissionRequest(sessionId, request) {
-    log13.info({ sessionId, requestId: request.id }, "Permission request sent");
+    log12.info({ sessionId, requestId: request.id }, "Permission request sent");
     const session = this.core.sessionManager.getSession(sessionId);
     if (!session) return;
     await this.sendQueue.enqueue(
@@ -5208,7 +5134,7 @@ Task completed.
   }
   async sendNotification(notification) {
     if (notification.sessionId === this.assistantSession?.id) return;
-    log13.info(
+    log12.info(
       { sessionId: notification.sessionId, type: notification.type },
       "Notification sent"
     );
@@ -5246,7 +5172,7 @@ Task completed.
     );
   }
   async createSessionThread(sessionId, name) {
-    log13.info({ sessionId, name }, "Session topic created");
+    log12.info({ sessionId, name }, "Session topic created");
     return String(
       await createSessionTopic(this.bot, this.telegramConfig.chatId, name)
     );
@@ -5270,7 +5196,7 @@ Task completed.
     try {
       await this.bot.api.deleteForumTopic(this.telegramConfig.chatId, topicId);
     } catch (err) {
-      log13.warn(
+      log12.warn(
         { err, sessionId, topicId },
         "Failed to delete forum topic (may already be deleted)"
       );
@@ -5300,7 +5226,7 @@ Task completed.
       const buffer = Buffer.from(await response.arrayBuffer());
       return { buffer, filePath: file.file_path };
     } catch (err) {
-      log13.error({ err }, "Failed to download file from Telegram");
+      log12.error({ err }, "Failed to download file from Telegram");
       return null;
     }
   }
@@ -5321,7 +5247,7 @@ Task completed.
       try {
         buffer = await this.fileService.convertOggToWav(buffer);
       } catch (err) {
-        log13.warn({ err }, "OGG\u2192WAV conversion failed, saving original OGG");
+        log12.warn({ err }, "OGG\u2192WAV conversion failed, saving original OGG");
         fileName = "voice.ogg";
         mimeType = "audio/ogg";
         originalFilePath = void 0;
@@ -5352,7 +5278,7 @@ Task completed.
       userId: String(userId),
       text,
       attachments: [att]
-    }).catch((err) => log13.error({ err }, "handleMessage error"));
+    }).catch((err) => log12.error({ err }, "handleMessage error"));
   }
   async cleanupSkillCommands(sessionId) {
     await this.skillManager.cleanup(sessionId);
@@ -5366,7 +5292,6 @@ Task completed.
     session.archiving = true;
     await this.draftManager.finalize(session.id, this.assistantSession?.id);
     this.draftManager.cleanup(session.id);
-    this.toolTracker.cleanup(session.id);
     await this.skillManager.cleanup(session.id);
     const tracker = this.sessionTrackers.get(session.id);
     if (tracker) {
@@ -5380,7 +5305,6 @@ Task completed.
 export {
   PRODUCT_GUIDE,
   SendQueue,
-  ToolCallTracker,
   TelegramAdapter
 };
-//# sourceMappingURL=chunk-LP45RCA4.js.map
+//# sourceMappingURL=chunk-XWDW3XBE.js.map