@openacp/cli 0.2.29 → 0.3.0

package/dist/{chunk-6HORD4FS.js → chunk-C6IFPAWN.js}

@@ -1,7 +1,7 @@
 import {
   createChildLogger,
   createSessionLogger
-} from "./chunk-MNJDYDGH.js";
+} from "./chunk-JOSJGZGF.js";
 
 // src/core/streams.ts
 function nodeToWebWritable(nodeStream) {
@@ -304,6 +304,8 @@ ${stderr}`
             event = {
               type: "tool_update",
               id: update.toolCallId,
+              name: update.title ?? void 0,
+              kind: update.kind ?? void 0,
               status: update.status ?? "pending",
               content: update.content ?? void 0,
               rawInput: update.rawInput ?? void 0,
@@ -521,6 +523,7 @@ var Session = class {
   adapter;
   // Set by wireSessionEvents for renaming
   pendingPermission;
+  dangerousMode = false;
   log;
   constructor(opts) {
     this.id = opts.id || nanoid(12);
@@ -591,7 +594,8 @@ var Session = class {
   async warmup() {
     this.promptRunning = true;
     const prevHandler = this.agentInstance.onSessionUpdate;
-    this.agentInstance.onSessionUpdate = () => {
+    this.agentInstance.onSessionUpdate = (event) => {
+      if (event.type === "commands_update") prevHandler(event);
     };
     try {
       const start = Date.now();
@@ -664,6 +668,12 @@ var SessionManager = class {
     }
     return void 0;
   }
+  getRecordByThread(channelId, threadId) {
+    return this.store?.findByPlatform(
+      channelId,
+      (p) => String(p.topicId) === threadId
+    );
+  }
   registerSession(session) {
     this.sessions.set(session.id, session);
   }
@@ -691,15 +701,25 @@ var SessionManager = class {
       await this.store.save({ ...record, status });
     }
   }
+  async updateSessionName(sessionId, name) {
+    if (!this.store) return;
+    const record = this.store.get(sessionId);
+    if (record) {
+      await this.store.save({ ...record, name });
+    }
+  }
+  getSessionRecord(sessionId) {
+    return this.store?.get(sessionId);
+  }
   async cancelSession(sessionId) {
     const session = this.sessions.get(sessionId);
     if (session) {
       await session.cancel();
-      if (this.store) {
-        const record = this.store.get(sessionId);
-        if (record) {
-          await this.store.save({ ...record, status: "cancelled" });
-        }
+    }
+    if (this.store) {
+      const record = this.store.get(sessionId);
+      if (record && record.status !== "cancelled") {
+        await this.store.save({ ...record, status: "cancelled" });
       }
     }
   }
@@ -871,17 +891,21 @@ function extractFileInfo(name, kind, content, rawInput, meta) {
   let info = null;
   if (meta) {
     const m = meta;
-    const file = m?.claudeCode?.toolResponse?.file;
+    const tr = m?.claudeCode?.toolResponse;
+    const file = tr?.file;
     if (file?.filePath && file?.content) {
       info = { filePath: file.filePath, content: file.content };
     }
+    if (!info && tr?.filePath && tr?.content) {
+      info = { filePath: tr.filePath, content: tr.content };
+    }
   }
   if (!info && rawInput) {
     const ri = rawInput;
     const filePath = ri?.file_path || ri?.filePath || ri?.path;
     if (typeof filePath === "string") {
       const parsed = content ? parseContent(content) : null;
-      info = { filePath, content: parsed?.content || ri?.content };
+      info = { filePath, content: parsed?.content || ri?.content, oldContent: parsed?.oldContent };
     }
   }
   if (!info && content) {
@@ -1028,9 +1052,9 @@ var OpenACPCore = class {
       );
       const adapter = this.adapters.get(message.channelId);
       if (adapter) {
-        await adapter.sendMessage("system", {
+        await adapter.sendMessage(message.threadId, {
           type: "error",
-          text: `Max concurrent sessions (${config.security.maxConcurrentSessions}) reached. Cancel a session first.`
+          text: `\u26A0\uFE0F Session limit reached (${config.security.maxConcurrentSessions}). Please cancel existing sessions with /cancel before starting new ones.`
         });
       }
       return;
@@ -1070,11 +1094,19 @@ var OpenACPCore = class {
       channelId,
       currentThreadId
     );
-    if (!currentSession) return null;
+    if (currentSession) {
+      return this.handleNewSession(
+        channelId,
+        currentSession.agentName,
+        currentSession.workingDirectory
+      );
+    }
+    const record = this.sessionManager.getRecordByThread(channelId, currentThreadId);
+    if (!record || record.status === "cancelled" || record.status === "error") return null;
     return this.handleNewSession(
       channelId,
-      currentSession.agentName,
-      currentSession.workingDirectory
+      record.agentName,
+      record.workingDir
     );
   }
   // --- Lazy Resume ---
@@ -1144,6 +1176,7 @@ var OpenACPCore = class {
       case "tool_call": {
         const metadata = {
           id: event.id,
+          name: event.name,
           kind: event.kind,
           status: event.status,
           content: event.content,
@@ -1155,6 +1188,8 @@ var OpenACPCore = class {
       case "tool_update": {
         const metadata = {
           id: event.id,
+          name: event.name,
+          kind: event.kind,
           status: event.status,
           content: event.content
         };
@@ -1538,6 +1573,7 @@ function extractContentText(content, depth = 0) {
     if (c.type === "text" && typeof c.text === "string") return c.text;
     if (typeof c.text === "string") return c.text;
     if (typeof c.content === "string") return c.content;
+    if (c.content && typeof c.content === "object") return extractContentText(c.content, depth + 1);
     if (c.input) return extractContentText(c.input, depth + 1);
     if (c.output) return extractContentText(c.output, depth + 1);
     const keys = Object.keys(c).filter((k) => k !== "type");
@@ -1554,12 +1590,14 @@ function formatToolCall(tool) {
   const si = STATUS_ICON[tool.status || ""] || "\u{1F527}";
   const ki = KIND_ICON[tool.kind || ""] || "\u{1F6E0}\uFE0F";
   let text = `${si} ${ki} <b>${escapeHtml(tool.name || "Tool")}</b>`;
-  const details = extractContentText(tool.content);
-  if (details) {
-    text += `
+  text += formatViewerLinks(tool.viewerLinks, tool.viewerFilePath);
+  if (!tool.viewerLinks) {
+    const details = extractContentText(tool.content);
+    if (details) {
+      text += `
 <pre>${escapeHtml(truncateContent(details))}</pre>`;
+    }
   }
-  text += formatViewerLinks(tool.viewerLinks, tool.viewerFilePath);
   return text;
 }
 function formatToolUpdate(update) {
@@ -1567,12 +1605,14 @@ function formatToolUpdate(update) {
   const ki = KIND_ICON[update.kind || ""] || "\u{1F6E0}\uFE0F";
   const name = update.name || "Tool";
   let text = `${si} ${ki} <b>${escapeHtml(name)}</b>`;
-  const details = extractContentText(update.content);
-  if (details) {
-    text += `
+  text += formatViewerLinks(update.viewerLinks, update.viewerFilePath);
+  if (!update.viewerLinks) {
+    const details = extractContentText(update.content);
+    if (details) {
+      text += `
 <pre>${escapeHtml(truncateContent(details))}</pre>`;
+    }
   }
-  text += formatViewerLinks(update.viewerLinks, update.viewerFilePath);
   return text;
 }
 function formatViewerLinks(links, filePath) {
@@ -1585,20 +1625,23 @@ function formatViewerLinks(links, filePath) {
 \u{1F4DD} <a href="${escapeHtml(links.diff)}">View diff${fileName ? ` \u2014 ${escapeHtml(fileName)}` : ""}</a>`;
   return text;
 }
-function formatPlan(plan) {
-  const statusIcon = { pending: "\u2B1C", in_progress: "\u{1F504}", completed: "\u2705" };
-  const lines = plan.entries.map(
-    (e, i) => `${statusIcon[e.status] || "\u2B1C"} ${i + 1}. ${escapeHtml(e.content)}`
-  );
-  return `<b>Plan:</b>
-${lines.join("\n")}`;
+function formatTokens(n) {
+  return n >= 1e3 ? `${Math.round(n / 1e3)}k` : String(n);
+}
+function progressBar(ratio) {
+  const filled = Math.round(Math.min(ratio, 1) * 10);
+  return "\u2593".repeat(filled) + "\u2591".repeat(10 - filled);
 }
 function formatUsage(usage) {
-  const parts = [];
-  if (usage.tokensUsed != null) parts.push(`Tokens: ${usage.tokensUsed.toLocaleString()}`);
-  if (usage.contextSize != null) parts.push(`Context: ${usage.contextSize.toLocaleString()}`);
-  if (usage.cost) parts.push(`Cost: $${usage.cost.amount.toFixed(4)}`);
-  return `\u{1F4CA} ${parts.join(" | ")}`;
+  const { tokensUsed, contextSize } = usage;
+  if (tokensUsed == null) return "\u{1F4CA} Usage data unavailable";
+  if (contextSize == null) return `\u{1F4CA} ${formatTokens(tokensUsed)} tokens`;
+  const ratio = tokensUsed / contextSize;
+  const pct = Math.round(ratio * 100);
+  const bar = progressBar(ratio);
+  const emoji = pct >= 85 ? "\u26A0\uFE0F" : "\u{1F4CA}";
+  return `${emoji} ${formatTokens(tokensUsed)} / ${formatTokens(contextSize)} tokens
+${bar} ${pct}%`;
 }
 function splitMessage(text, maxLength = 4096) {
   if (text.length <= maxLength) return [text];
@@ -1623,94 +1666,68 @@ function splitMessage(text, maxLength = 4096) {
 }
 
 // src/adapters/telegram/streaming.ts
-var nextDraftId = 1;
+var FLUSH_INTERVAL = 5e3;
 var MessageDraft = class {
-  // Only set in fallback mode (sendMessageDraft returns true, not Message)
-  constructor(bot, chatId, threadId, throttleMs = 200, sendQueue) {
+  constructor(bot, chatId, threadId, sendQueue, sessionId) {
     this.bot = bot;
     this.chatId = chatId;
     this.threadId = threadId;
     this.sendQueue = sendQueue;
-    this.draftId = nextDraftId++;
-    this.minInterval = throttleMs;
+    this.sessionId = sessionId;
   }
-  draftId;
   buffer = "";
-  lastFlush = 0;
+  messageId;
+  firstFlushPending = false;
   flushTimer;
   flushPromise = Promise.resolve();
-  minInterval;
-  useFallback = false;
-  messageId;
+  lastSentBuffer = "";
   append(text) {
+    if (!text) return;
     this.buffer += text;
     this.scheduleFlush();
   }
   scheduleFlush() {
-    const now = Date.now();
-    const elapsed = now - this.lastFlush;
-    if (elapsed >= this.minInterval) {
+    if (this.flushTimer) return;
+    this.flushTimer = setTimeout(() => {
+      this.flushTimer = void 0;
       this.flushPromise = this.flushPromise.then(() => this.flush()).catch(() => {
       });
-    } else if (!this.flushTimer) {
-      this.flushTimer = setTimeout(() => {
-        this.flushTimer = void 0;
-        this.flushPromise = this.flushPromise.then(() => this.flush()).catch(() => {
-        });
-      }, this.minInterval - elapsed);
-    }
+    }, FLUSH_INTERVAL);
   }
   async flush() {
     if (!this.buffer) return;
-    this.lastFlush = Date.now();
+    if (this.firstFlushPending) return;
     const html = markdownToTelegramHtml(this.buffer);
     const truncated = html.length > 4096 ? html.slice(0, 4090) + "\n..." : html;
     if (!truncated) return;
-    if (this.useFallback) {
-      await this.flushFallback(truncated);
-      return;
-    }
-    try {
-      await this.bot.api.sendMessageDraft(this.chatId, this.draftId, truncated, {
-        message_thread_id: this.threadId,
-        parse_mode: "HTML"
-      });
-    } catch {
-      this.useFallback = true;
-      this.minInterval = 1e3;
-      await this.flushFallback(truncated);
-    }
-  }
-  async flushFallback(html) {
-    const exec = this.sendQueue ? (fn) => this.sendQueue.enqueue(fn) : (fn) => fn();
-    try {
-      if (!this.messageId) {
-        const msg = await exec(
-          () => this.bot.api.sendMessage(this.chatId, html, {
+    if (!this.messageId) {
+      this.firstFlushPending = true;
+      try {
+        const result = await this.sendQueue.enqueue(
+          () => this.bot.api.sendMessage(this.chatId, truncated, {
             message_thread_id: this.threadId,
             parse_mode: "HTML",
             disable_notification: true
-          })
-        );
-        this.messageId = msg.message_id;
-      } else {
-        await exec(
-          () => this.bot.api.editMessageText(this.chatId, this.messageId, html, {
-            parse_mode: "HTML"
-          })
+          }),
+          { type: "other" }
         );
+        if (result) {
+          this.messageId = result.message_id;
+          this.lastSentBuffer = this.buffer;
+        }
+      } catch {
+      } finally {
+        this.firstFlushPending = false;
       }
-    } catch {
+    } else {
       try {
-        if (!this.messageId) {
-          const msg = await exec(
-            () => this.bot.api.sendMessage(this.chatId, this.buffer.slice(0, 4096), {
-              message_thread_id: this.threadId,
-              disable_notification: true
-            })
-          );
-          this.messageId = msg.message_id;
-        }
+        await this.sendQueue.enqueue(
+          () => this.bot.api.editMessageText(this.chatId, this.messageId, truncated, {
+            parse_mode: "HTML"
+          }),
+          { type: "text", key: this.sessionId }
+        );
+        this.lastSentBuffer = this.buffer;
       } catch {
       }
     }
@@ -1722,31 +1739,47 @@ var MessageDraft = class {
     }
     await this.flushPromise;
     if (!this.buffer) return this.messageId;
+    if (this.messageId && this.buffer === this.lastSentBuffer) {
+      return this.messageId;
+    }
     const html = markdownToTelegramHtml(this.buffer);
     const chunks = splitMessage(html);
     try {
       for (let i = 0; i < chunks.length; i++) {
         const chunk = chunks[i];
         if (i === 0 && this.messageId) {
-          await this.bot.api.editMessageText(this.chatId, this.messageId, chunk, {
-            parse_mode: "HTML"
-          });
+          await this.sendQueue.enqueue(
+            () => this.bot.api.editMessageText(this.chatId, this.messageId, chunk, {
+              parse_mode: "HTML"
+            }),
+            { type: "other" }
+          );
         } else {
-          const msg = await this.bot.api.sendMessage(this.chatId, chunk, {
-            message_thread_id: this.threadId,
-            parse_mode: "HTML",
-            disable_notification: true
-          });
-          this.messageId = msg.message_id;
+          const msg = await this.sendQueue.enqueue(
+            () => this.bot.api.sendMessage(this.chatId, chunk, {
+              message_thread_id: this.threadId,
+              parse_mode: "HTML",
+              disable_notification: true
+            }),
+            { type: "other" }
+          );
+          if (msg) {
+            this.messageId = msg.message_id;
+          }
         }
       }
     } catch {
-      try {
-        await this.bot.api.sendMessage(this.chatId, this.buffer.slice(0, 4096), {
-          message_thread_id: this.threadId,
-          disable_notification: true
-        });
-      } catch {
+      if (this.buffer !== this.lastSentBuffer) {
+        try {
+          await this.sendQueue.enqueue(
+            () => this.bot.api.sendMessage(this.chatId, this.buffer.slice(0, 4096), {
+              message_thread_id: this.threadId,
+              disable_notification: true
+            }),
+            { type: "other" }
+          );
+        } catch {
+        }
       }
     }
     return this.messageId;
@@ -1799,6 +1832,8 @@ function setupCommands(bot, core, chatId, assistant) {
   bot.command("agents", (ctx) => handleAgents(ctx, core));
   bot.command("help", (ctx) => handleHelp(ctx));
   bot.command("menu", (ctx) => handleMenu(ctx));
+  bot.command("enable_dangerous", (ctx) => handleEnableDangerous(ctx, core));
+  bot.command("disable_dangerous", (ctx) => handleDisableDangerous(ctx, core));
 }
 function buildMenuKeyboard() {
   return new InlineKeyboard().text("\u{1F195} New Session", "m:new").text("\u{1F4AC} New Chat", "m:new_chat").row().text("\u26D4 Cancel", "m:cancel").text("\u{1F4CA} Status", "m:status").row().text("\u{1F916} Agents", "m:agents").text("\u2753 Help", "m:help");
@@ -1884,7 +1919,8 @@ async function handleNew(ctx, core, chatId, assistant) {
 <b>Workspace:</b> <code>${escapeHtml(session.workingDirectory)}</code>`,
       {
         message_thread_id: threadId,
-        parse_mode: "HTML"
+        parse_mode: "HTML",
+        reply_markup: buildDangerousModeKeyboard(session.id, false)
       }
     );
     session.warmup().catch((err) => log6.error({ err }, "Warm-up error"));
@@ -1938,7 +1974,8 @@ async function handleNewChat(ctx, core, chatId) {
 <b>Workspace:</b> <code>${escapeHtml(session.workingDirectory)}</code>`,
       {
         message_thread_id: newThreadId,
-        parse_mode: "HTML"
+        parse_mode: "HTML",
+        reply_markup: buildDangerousModeKeyboard(session.id, false)
       }
     );
     session.warmup().catch((err) => log6.error({ err }, "Warm-up error"));
@@ -1967,6 +2004,13 @@ async function handleCancel(ctx, core, assistant) {
     log6.info({ sessionId: session.id }, "Cancel session command");
     await session.cancel();
     await ctx.reply("\u26D4 Session cancelled.", { parse_mode: "HTML" });
+    return;
+  }
+  const record = core.sessionManager.getRecordByThread("telegram", String(threadId));
+  if (record && record.status !== "cancelled" && record.status !== "error") {
+    log6.info({ sessionId: record.sessionId }, "Cancel session command (from store)");
+    await core.sessionManager.cancelSession(record.sessionId);
+    await ctx.reply("\u26D4 Session cancelled.", { parse_mode: "HTML" });
   }
 }
 async function handleStatus(ctx, core) {
@@ -1986,9 +2030,20 @@ async function handleStatus(ctx, core) {
         { parse_mode: "HTML" }
       );
     } else {
-      await ctx.reply("No active session in this topic.", {
-        parse_mode: "HTML"
-      });
+      const record = core.sessionManager.getRecordByThread("telegram", String(threadId));
+      if (record) {
+        await ctx.reply(
+          `<b>Session:</b> ${escapeHtml(record.name || record.sessionId)}
+<b>Agent:</b> ${escapeHtml(record.agentName)}
+<b>Status:</b> ${escapeHtml(record.status)} (not loaded)
+<b>Workspace:</b> <code>${escapeHtml(record.workingDir)}</code>`,
+          { parse_mode: "HTML" }
+        );
+      } else {
+        await ctx.reply("No active session in this topic.", {
+          parse_mode: "HTML"
+        });
+      }
     }
   } else {
     const sessions = core.sessionManager.listSessions("telegram");
@@ -2033,6 +2088,81 @@ Or just chat in the \u{1F916} Assistant topic for help!`,
     { parse_mode: "HTML" }
   );
 }
+function buildDangerousModeKeyboard(sessionId, enabled) {
+  return new InlineKeyboard().text(
+    enabled ? "\u{1F510} Disable Dangerous Mode" : "\u2620\uFE0F Enable Dangerous Mode",
+    `d:${sessionId}`
+  );
+}
+function setupDangerousModeCallbacks(bot, core) {
+  bot.callbackQuery(/^d:/, async (ctx) => {
+    const sessionId = ctx.callbackQuery.data.slice(2);
+    const session = core.sessionManager.getSession(sessionId);
+    if (!session) {
+      try {
+        await ctx.answerCallbackQuery({ text: "\u26A0\uFE0F Session not found or already ended." });
+      } catch {
+      }
+      return;
+    }
+    session.dangerousMode = !session.dangerousMode;
+    log6.info({ sessionId, dangerousMode: session.dangerousMode }, "Dangerous mode toggled via button");
+    const toastText = session.dangerousMode ? "\u2620\uFE0F Dangerous mode enabled \u2014 permissions auto-approved" : "\u{1F510} Dangerous mode disabled \u2014 permissions shown normally";
+    try {
+      await ctx.answerCallbackQuery({ text: toastText });
+    } catch {
+    }
+    try {
+      await ctx.editMessageReplyMarkup({
+        reply_markup: buildDangerousModeKeyboard(sessionId, session.dangerousMode)
+      });
+    } catch {
+    }
+  });
+}
+async function handleEnableDangerous(ctx, core) {
+  const threadId = ctx.message?.message_thread_id;
+  if (!threadId) {
+    await ctx.reply("\u26A0\uFE0F This command only works inside 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 in this topic.", { parse_mode: "HTML" });
+    return;
+  }
+  if (session.dangerousMode) {
+    await ctx.reply("\u2620\uFE0F Dangerous mode is already enabled.", { parse_mode: "HTML" });
+    return;
+  }
+  session.dangerousMode = true;
+  await ctx.reply(
+    `\u26A0\uFE0F <b>Dangerous mode enabled</b>
+
+All permission requests will be auto-approved. Claude can run arbitrary commands without asking.
+
+Use /disable_dangerous to restore normal behaviour.`,
+    { parse_mode: "HTML" }
+  );
+}
+async function handleDisableDangerous(ctx, core) {
+  const threadId = ctx.message?.message_thread_id;
+  if (!threadId) {
+    await ctx.reply("\u26A0\uFE0F This command only works inside 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 in this topic.", { parse_mode: "HTML" });
+    return;
+  }
+  if (!session.dangerousMode) {
+    await ctx.reply("\u{1F510} Dangerous mode is already disabled.", { parse_mode: "HTML" });
+    return;
+  }
+  session.dangerousMode = false;
+  await ctx.reply("\u{1F510} <b>Dangerous mode disabled</b>\n\nPermission requests will be shown normally.", { parse_mode: "HTML" });
+}
 function botFromCtx(ctx) {
   return { api: ctx.api };
 }
@@ -2114,7 +2244,9 @@ var STATIC_COMMANDS = [
   { command: "status", description: "Show status" },
   { command: "agents", description: "List available agents" },
   { command: "help", description: "Help" },
-  { command: "menu", description: "Show menu" }
+  { command: "menu", description: "Show menu" },
+  { command: "enable_dangerous", description: "Auto-approve all permission requests (session only)" },
+  { command: "disable_dangerous", description: "Restore normal permission prompts (session only)" }
 ];
 
 // src/adapters/telegram/permissions.ts
@@ -2155,7 +2287,7 @@ ${escapeHtml(request.description)}`,
       }
     );
     const deepLink = buildDeepLink(this.chatId, msg.message_id);
-    await this.sendNotification({
+    void this.sendNotification({
       sessionId: session.id,
       sessionName: session.name,
       type: "permission",
@@ -2199,8 +2331,10 @@ ${escapeHtml(request.description)}`,
 };
 
 // src/adapters/telegram/assistant.ts
+var log8 = createChildLogger({ module: "telegram-assistant" });
 async function spawnAssistant(core, adapter, assistantTopicId) {
   const config = core.configManager.get();
+  log8.info({ agent: config.defaultAgent }, "Creating assistant session...");
   const session = await core.sessionManager.createSession(
     "telegram",
     config.defaultAgent,
@@ -2208,10 +2342,16 @@ async function spawnAssistant(core, adapter, assistantTopicId) {
     core.agentManager
   );
   session.threadId = String(assistantTopicId);
-  const systemPrompt = buildAssistantSystemPrompt(config);
-  await session.enqueuePrompt(systemPrompt);
+  session.name = "Assistant";
+  log8.info({ sessionId: session.id }, "Assistant agent spawned");
   core.wireSessionEvents(session, adapter);
-  return session;
+  const systemPrompt = buildAssistantSystemPrompt(config);
+  const ready = session.enqueuePrompt(systemPrompt).then(() => {
+    log8.info({ sessionId: session.id }, "Assistant system prompt completed");
+  }).catch((err) => {
+    log8.warn({ err }, "Assistant system prompt failed");
+  });
+  return { session, ready };
 }
 function buildAssistantSystemPrompt(config) {
   const agentNames = Object.keys(config.agents).join(", ");
@@ -2246,36 +2386,342 @@ function redirectToAssistant(chatId, assistantTopicId) {
   return `\u{1F4AC} Please use the <a href="${link}">\u{1F916} Assistant</a> topic to chat with OpenACP.`;
 }
 
+// src/adapters/telegram/activity.ts
+var log9 = createChildLogger({ module: "telegram:activity" });
+var THINKING_REFRESH_MS = 15e3;
+var THINKING_MAX_MS = 3 * 60 * 1e3;
+var ThinkingIndicator = class {
+  constructor(api, chatId, threadId, sendQueue) {
+    this.api = api;
+    this.chatId = chatId;
+    this.threadId = threadId;
+    this.sendQueue = sendQueue;
+  }
+  msgId;
+  sending = false;
+  dismissed = false;
+  refreshTimer;
+  showTime = 0;
+  async show() {
+    if (this.msgId || this.sending || this.dismissed) return;
+    this.sending = true;
+    this.showTime = Date.now();
+    try {
+      const result = await this.sendQueue.enqueue(
+        () => this.api.sendMessage(this.chatId, "\u{1F4AD} <i>Thinking...</i>", {
+          message_thread_id: this.threadId,
+          parse_mode: "HTML",
+          disable_notification: true
+        })
+      );
+      if (result && !this.dismissed) {
+        this.msgId = result.message_id;
+        this.startRefreshTimer();
+      }
+    } catch (err) {
+      log9.warn({ err }, "ThinkingIndicator.show() failed");
+    } finally {
+      this.sending = false;
+    }
+  }
+  /** Clear state — stops refresh timer, no Telegram API call */
+  dismiss() {
+    this.dismissed = true;
+    this.msgId = void 0;
+    this.stopRefreshTimer();
+  }
+  /** Reset for a new prompt cycle */
+  reset() {
+    this.dismissed = false;
+  }
+  startRefreshTimer() {
+    this.stopRefreshTimer();
+    this.refreshTimer = setInterval(() => {
+      if (this.dismissed || !this.msgId || Date.now() - this.showTime >= THINKING_MAX_MS) {
+        this.stopRefreshTimer();
+        return;
+      }
+      const elapsed = Math.round((Date.now() - this.showTime) / 1e3);
+      this.sendQueue.enqueue(() => {
+        if (this.dismissed) return Promise.resolve(void 0);
+        return this.api.sendMessage(this.chatId, `\u{1F4AD} <i>Still thinking... (${elapsed}s)</i>`, {
+          message_thread_id: this.threadId,
+          parse_mode: "HTML",
+          disable_notification: true
+        });
+      }).then((result) => {
+        if (result && !this.dismissed) {
+          this.msgId = result.message_id;
+        }
+      }).catch(() => {
+      });
+    }, THINKING_REFRESH_MS);
+  }
+  stopRefreshTimer() {
+    if (this.refreshTimer) {
+      clearInterval(this.refreshTimer);
+      this.refreshTimer = void 0;
+    }
+  }
+};
+var UsageMessage = class {
+  constructor(api, chatId, threadId, sendQueue) {
+    this.api = api;
+    this.chatId = chatId;
+    this.threadId = threadId;
+    this.sendQueue = sendQueue;
+  }
+  msgId;
+  async send(usage) {
+    const text = formatUsage(usage);
+    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;
+      }
+    } catch (err) {
+      log9.warn({ err }, "UsageMessage.send() failed");
+    }
+  }
+  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) {
+      log9.warn({ err }, "UsageMessage.delete() failed");
+    }
+  }
+};
+function formatPlanCard(entries) {
+  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;
+  }
+  msgId;
+  flushPromise = Promise.resolve();
+  latestEntries;
+  flushTimer;
+  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);
+  }
+  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(() => {
+    });
+    await this.flushPromise;
+  }
+  destroy() {
+    if (this.flushTimer) {
+      clearTimeout(this.flushTimer);
+      this.flushTimer = void 0;
+    }
+  }
+  async _flush() {
+    if (!this.latestEntries) return;
+    const text = formatPlanCard(this.latestEntries);
+    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;
+      }
+    } catch (err) {
+      log9.warn({ err }, "PlanCard flush failed");
+    }
+  }
+};
+var ActivityTracker = class {
+  constructor(api, chatId, threadId, sendQueue) {
+    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);
+  }
+  isFirstEvent = true;
+  hasPlanCard = false;
+  thinking;
+  planCard;
+  usage;
+  async onNewPrompt() {
+    this.isFirstEvent = true;
+    this.hasPlanCard = false;
+    this.thinking.dismiss();
+    this.thinking.reset();
+  }
+  async onThought() {
+    await this._firstEventGuard();
+    await this.thinking.show();
+  }
+  async onPlan(entries) {
+    await this._firstEventGuard();
+    this.thinking.dismiss();
+    this.hasPlanCard = true;
+    this.planCard.update(entries);
+  }
+  async onToolCall() {
+    await this._firstEventGuard();
+    this.thinking.dismiss();
+    this.thinking.reset();
+  }
+  async onTextStart() {
+    await this._firstEventGuard();
+    this.thinking.dismiss();
+  }
+  async sendUsage(data) {
+    await this.usage.send(data);
+  }
+  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) {
+        log9.warn({ err }, "ActivityTracker.onComplete() Done send failed");
+      }
+    }
+  }
+  destroy() {
+    this.planCard.destroy();
+  }
+  async _firstEventGuard() {
+    if (!this.isFirstEvent) return;
+    this.isFirstEvent = false;
+    await this.usage.delete();
+  }
+};
+
 // src/adapters/telegram/send-queue.ts
 var TelegramSendQueue = class {
-  queue = Promise.resolve();
+  items = [];
+  processing = false;
   lastExec = 0;
   minInterval;
-  constructor(minInterval = 100) {
+  constructor(minInterval = 3e3) {
     this.minInterval = minInterval;
   }
-  enqueue(fn) {
-    let resolve;
-    let reject;
-    const resultPromise = new Promise((res, rej) => {
-      resolve = res;
-      reject = rej;
-    });
-    this.queue = this.queue.then(async () => {
-      const elapsed = Date.now() - this.lastExec;
-      if (elapsed < this.minInterval) {
-        await new Promise((r) => setTimeout(r, this.minInterval - elapsed));
-      }
-      try {
-        const result = await fn();
-        resolve(result);
-      } catch (err) {
-        reject(err);
-      } finally {
-        this.lastExec = Date.now();
+  enqueue(fn, opts) {
+    const type = opts?.type ?? "other";
+    const key = opts?.key;
+    return new Promise((resolve, reject) => {
+      if (type === "text" && key) {
+        const idx = this.items.findIndex(
+          (item) => item.type === "text" && item.key === key
+        );
+        if (idx !== -1) {
+          this.items[idx].resolve(void 0);
+          this.items[idx] = { fn, type, key, resolve, reject };
+          this.scheduleProcess();
+          return;
+        }
       }
+      this.items.push({ fn, type, key, resolve, reject });
+      this.scheduleProcess();
     });
-    return resultPromise;
+  }
+  onRateLimited() {
+    const remaining = [];
+    for (const item of this.items) {
+      if (item.type === "text") {
+        item.resolve(void 0);
+      } else {
+        remaining.push(item);
+      }
+    }
+    this.items = remaining;
+  }
+  scheduleProcess() {
+    if (this.processing) return;
+    if (this.items.length === 0) return;
+    const elapsed = Date.now() - this.lastExec;
+    const delay = Math.max(0, this.minInterval - elapsed);
+    this.processing = true;
+    setTimeout(() => void this.processNext(), delay);
+  }
+  async processNext() {
+    const item = this.items.shift();
+    if (!item) {
+      this.processing = false;
+      return;
+    }
+    try {
+      const result = await item.fn();
+      item.resolve(result);
+    } catch (err) {
+      item.reject(err);
+    } finally {
+      this.lastExec = Date.now();
+      this.processing = false;
+      this.scheduleProcess();
+    }
   }
 };
 
@@ -2284,8 +2730,8 @@ import { nanoid as nanoid4 } from "nanoid";
 import { InlineKeyboard as InlineKeyboard3 } from "grammy";
 var CMD_NEW_RE = /\/new(?:\s+([^\s\u0080-\uFFFF]+)(?:\s+([^\s\u0080-\uFFFF]+))?)?/;
 var CMD_CANCEL_RE = /\/cancel\b/;
-var KW_NEW_RE = /(?:tao|tạo|create|new)\s+session/i;
-var KW_CANCEL_RE = /(?:huy|huỷ|cancel|dung|dừng)\s+session/i;
+var KW_NEW_RE = /(?:create|new)\s+session/i;
+var KW_CANCEL_RE = /(?:cancel|stop)\s+session/i;
 function detectAction(text) {
   if (!text) return null;
   const cancelCmd = CMD_CANCEL_RE.exec(text);
@@ -2330,11 +2776,11 @@ function removeAction(id) {
 function buildActionKeyboard(actionId, action) {
   const keyboard = new InlineKeyboard3();
   if (action.action === "new_session") {
-    keyboard.text("\u2705 T\u1EA1o session", `a:${actionId}`);
-    keyboard.text("\u274C Hu\u1EF7", `a:dismiss:${actionId}`);
+    keyboard.text("\u2705 Create session", `a:${actionId}`);
+    keyboard.text("\u274C Cancel", `a:dismiss:${actionId}`);
   } else {
-    keyboard.text("\u26D4 Hu\u1EF7 session", `a:${actionId}`);
-    keyboard.text("\u274C Kh\xF4ng", `a:dismiss:${actionId}`);
+    keyboard.text("\u26D4 Cancel session", `a:${actionId}`);
+    keyboard.text("\u274C No", `a:dismiss:${actionId}`);
   }
   return keyboard;
 }
@@ -2348,19 +2794,19 @@ function setupActionCallbacks(bot, core, chatId, getAssistantSessionId) {
       });
     } catch {
     }
-    await ctx.answerCallbackQuery({ text: "\u0110\xE3 hu\u1EF7" });
+    await ctx.answerCallbackQuery({ text: "Dismissed" });
   });
   bot.callbackQuery(/^a:(?!dismiss)/, async (ctx) => {
     const actionId = ctx.callbackQuery.data.replace("a:", "");
     const action = getAction(actionId);
     if (!action) {
-      await ctx.answerCallbackQuery({ text: "Action \u0111\xE3 h\u1EBFt h\u1EA1n" });
+      await ctx.answerCallbackQuery({ text: "Action expired" });
       return;
     }
     removeAction(actionId);
     try {
       if (action.action === "new_session") {
-        await ctx.answerCallbackQuery({ text: "\u23F3 \u0110ang t\u1EA1o session..." });
+        await ctx.answerCallbackQuery({ text: "\u23F3 Creating session..." });
         const { threadId } = await executeNewSession(
           bot,
           core,
@@ -2386,13 +2832,13 @@ function setupActionCallbacks(bot, core, chatId, getAssistantSessionId) {
         const assistantId = getAssistantSessionId();
         const cancelled = await executeCancelSession(core, assistantId);
         if (cancelled) {
-          await ctx.answerCallbackQuery({ text: "\u26D4 Session \u0111\xE3 hu\u1EF7" });
+          await ctx.answerCallbackQuery({ text: "\u26D4 Session cancelled" });
           const originalText = ctx.callbackQuery.message?.text ?? "";
           try {
             await ctx.editMessageText(
               originalText + `
 
-\u26D4 Session "${cancelled.name ?? cancelled.id}" \u0111\xE3 hu\u1EF7`,
+\u26D4 Session "${cancelled.name ?? cancelled.id}" cancelled`,
               { parse_mode: "HTML" }
             );
           } catch {
@@ -2402,7 +2848,7 @@ function setupActionCallbacks(bot, core, chatId, getAssistantSessionId) {
           }
         } else {
           await ctx.answerCallbackQuery({
-            text: "Kh\xF4ng c\xF3 session n\xE0o \u0111ang ch\u1EA1y"
+            text: "No active session"
           });
           try {
             await ctx.editMessageReplyMarkup({
@@ -2413,7 +2859,7 @@ function setupActionCallbacks(bot, core, chatId, getAssistantSessionId) {
         }
       }
     } catch {
-      await ctx.answerCallbackQuery({ text: "\u274C L\u1ED7i, th\u1EED l\u1EA1i sau" });
+      await ctx.answerCallbackQuery({ text: "\u274C Error, try again later" });
       try {
         await ctx.editMessageReplyMarkup({
           reply_markup: { inline_keyboard: [] }
@@ -2425,7 +2871,7 @@ function setupActionCallbacks(bot, core, chatId, getAssistantSessionId) {
 }
 
 // src/adapters/telegram/adapter.ts
-var log8 = createChildLogger({ module: "telegram" });
+var log10 = createChildLogger({ module: "telegram" });
 function patchedFetch(input, init) {
   if (init?.signal && !(init.signal instanceof AbortSignal)) {
     const nativeController = new AbortController();
@@ -2448,11 +2894,26 @@ var TelegramAdapter = class extends ChannelAdapter {
   // sessionId → (toolCallId → state)
   permissionHandler;
   assistantSession = null;
+  assistantInitializing = false;
   notificationTopicId;
   assistantTopicId;
   skillMessages = /* @__PURE__ */ new Map();
   // sessionId → pinned messageId
-  sendQueue = new TelegramSendQueue();
+  sendQueue = new TelegramSendQueue(3e3);
+  sessionTrackers = /* @__PURE__ */ new Map();
+  getOrCreateTracker(sessionId, threadId) {
+    let tracker = this.sessionTrackers.get(sessionId);
+    if (!tracker) {
+      tracker = new ActivityTracker(
+        this.bot.api,
+        this.telegramConfig.chatId,
+        threadId,
+        this.sendQueue
+      );
+      this.sessionTrackers.set(sessionId, tracker);
+    }
+    return tracker;
+  }
   constructor(core, config) {
     super(core, config);
     this.telegramConfig = config;
@@ -2461,7 +2922,7 @@ var TelegramAdapter = class extends ChannelAdapter {
     this.bot = new Bot(this.telegramConfig.botToken, { client: { fetch: patchedFetch } });
     this.bot.catch((err) => {
       const rootCause = err.error instanceof Error ? err.error : err;
-      log8.error({ err: rootCause }, "Telegram bot error");
+      log10.error({ err: rootCause }, "Telegram bot error");
     });
     this.bot.api.config.use(async (prev, method, payload, signal) => {
       const maxRetries = 3;
@@ -2471,7 +2932,11 @@ var TelegramAdapter = class extends ChannelAdapter {
           return result;
         }
         const retryAfter = (result.parameters?.retry_after ?? 5) + 1;
-        log8.warn(
+        const rateLimitedMethods = ["sendMessage", "editMessageText", "editMessageReplyMarkup"];
+        if (rateLimitedMethods.includes(method)) {
+          this.sendQueue.onRateLimited();
+        }
+        log10.warn(
           { method, retryAfter, attempt: attempt + 1 },
           "Rate limited by Telegram, retrying"
         );
@@ -2516,6 +2981,7 @@ var TelegramAdapter = class extends ChannelAdapter {
       (notification) => this.sendNotification(notification)
     );
     setupSkillCallbacks(this.bot, this.core);
+    setupDangerousModeCallbacks(this.bot, this.core);
     setupActionCallbacks(
       this.bot,
       this.core,
@@ -2540,26 +3006,15 @@ var TelegramAdapter = class extends ChannelAdapter {
     this.setupRoutes();
     this.bot.start({
       allowed_updates: ["message", "callback_query"],
-      onStart: () => log8.info(
+      onStart: () => log10.info(
         { chatId: this.telegramConfig.chatId },
         "Telegram bot started"
       )
     });
-    try {
-      this.assistantSession = await spawnAssistant(
-        this.core,
-        this,
-        this.assistantTopicId
-      );
-    } catch (err) {
-      log8.error({ err }, "Failed to spawn assistant");
-    }
     try {
       const config = this.core.configManager.get();
       const agents = this.core.agentManager.getAvailableAgents();
-      const agentList = agents.map(
-        (a) => `${escapeHtml(a.name)}${a.name === config.defaultAgent ? " (default)" : ""}`
-      ).join(", ");
+      const agentList = agents.map((a) => `${escapeHtml(a.name)}${a.name === config.defaultAgent ? " (default)" : ""}`).join(", ");
       const workspace = escapeHtml(config.workspace.baseDir);
       const welcomeText = `\u{1F44B} <b>OpenACP Assistant</b> is online.
 
@@ -2573,7 +3028,32 @@ Workspace: <code>${workspace}</code>
         reply_markup: buildMenuKeyboard()
       });
     } catch (err) {
-      log8.warn({ err }, "Failed to send welcome message");
+      log10.warn({ err }, "Failed to send welcome message");
+    }
+    try {
+      log10.info("Spawning assistant session...");
+      const { session, ready } = await spawnAssistant(
+        this.core,
+        this,
+        this.assistantTopicId
+      );
+      this.assistantSession = session;
+      this.assistantInitializing = true;
+      log10.info({ sessionId: session.id }, "Assistant session ready, system prompt running in background");
+      ready.then(() => {
+        this.assistantInitializing = false;
+        log10.info({ sessionId: session.id }, "Assistant ready for user messages");
+      });
+    } catch (err) {
+      log10.error({ err }, "Failed to spawn assistant");
+      this.bot.api.sendMessage(
+        this.telegramConfig.chatId,
+        `\u26A0\uFE0F <b>Failed to start assistant session.</b>
+
+<code>${err instanceof Error ? err.message : String(err)}</code>`,
+        { message_thread_id: this.assistantTopicId, parse_mode: "HTML" }
+      ).catch(() => {
+      });
     }
   }
   async stop() {
@@ -2581,7 +3061,7 @@ Workspace: <code>${workspace}</code>
       await this.assistantSession.destroy();
     }
     await this.bot.stop();
-    log8.info("Telegram bot stopped");
+    log10.info("Telegram bot stopped");
   }
   setupRoutes() {
     this.bot.on("message:text", async (ctx) => {
@@ -2596,13 +3076,24 @@ Workspace: <code>${workspace}</code>
       }
       if (threadId === this.notificationTopicId) return;
       if (threadId === this.assistantTopicId) {
+        if (!this.assistantSession) {
+          await ctx.reply("\u26A0\uFE0F Assistant is not available yet. Please try again shortly.", { parse_mode: "HTML" });
+          return;
+        }
+        await this.finalizeDraft(this.assistantSession.id);
         ctx.replyWithChatAction("typing").catch(() => {
         });
         handleAssistantMessage(this.assistantSession, ctx.message.text).catch(
-          (err) => log8.error({ err }, "Assistant error")
+          (err) => log10.error({ err }, "Assistant error")
         );
         return;
       }
+      const sessionId = this.core.sessionManager.getSessionByThread("telegram", String(threadId))?.id;
+      if (sessionId) await this.finalizeDraft(sessionId);
+      if (sessionId) {
+        const tracker = this.sessionTrackers.get(sessionId);
+        if (tracker) await tracker.onNewPrompt();
+      }
       ctx.replyWithChatAction("typing").catch(() => {
       });
       this.core.handleMessage({
@@ -2610,11 +3101,12 @@ Workspace: <code>${workspace}</code>
         threadId: String(threadId),
         userId: String(ctx.from.id),
         text: ctx.message.text
-      }).catch((err) => log8.error({ err }, "handleMessage error"));
+      }).catch((err) => log10.error({ err }, "handleMessage error"));
     });
   }
   // --- ChannelAdapter implementations ---
   async sendMessage(sessionId, content) {
+    if (this.assistantInitializing && sessionId === this.assistantSession?.id) return;
     const session = this.core.sessionManager.getSession(
       sessionId
     );
@@ -2622,17 +3114,21 @@ Workspace: <code>${workspace}</code>
     const threadId = Number(session.threadId);
     switch (content.type) {
       case "thought": {
+        const tracker = this.getOrCreateTracker(sessionId, threadId);
+        await tracker.onThought();
         break;
       }
       case "text": {
         let draft = this.sessionDrafts.get(sessionId);
         if (!draft) {
+          const tracker = this.getOrCreateTracker(sessionId, threadId);
+          await tracker.onTextStart();
           draft = new MessageDraft(
             this.bot,
             this.telegramConfig.chatId,
             threadId,
-            this.telegramConfig.streamThrottleMs,
-            this.sendQueue
+            this.sendQueue,
+            sessionId
           );
           this.sessionDrafts.set(sessionId, draft);
         }
@@ -2644,8 +3140,25 @@ Workspace: <code>${workspace}</code>
         break;
       }
       case "tool_call": {
+        const tracker = this.getOrCreateTracker(sessionId, threadId);
+        await tracker.onToolCall();
         await this.finalizeDraft(sessionId);
         const meta = content.metadata;
+        if (!this.toolCallMessages.has(sessionId)) {
+          this.toolCallMessages.set(sessionId, /* @__PURE__ */ new Map());
+        }
+        let resolveReady;
+        const ready = new Promise((r) => {
+          resolveReady = r;
+        });
+        this.toolCallMessages.get(sessionId).set(meta.id, {
+          msgId: 0,
+          name: meta.name,
+          kind: meta.kind,
+          viewerLinks: meta.viewerLinks,
+          viewerFilePath: content.metadata?.viewerFilePath,
+          ready
+        });
         const msg = await this.sendQueue.enqueue(
           () => this.bot.api.sendMessage(
             this.telegramConfig.chatId,
@@ -2657,79 +3170,92 @@ Workspace: <code>${workspace}</code>
             }
           )
         );
-        if (!this.toolCallMessages.has(sessionId)) {
-          this.toolCallMessages.set(sessionId, /* @__PURE__ */ new Map());
-        }
-        this.toolCallMessages.get(sessionId).set(meta.id, {
-          msgId: msg.message_id,
-          name: meta.name,
-          kind: meta.kind,
-          viewerLinks: meta.viewerLinks,
-          viewerFilePath: content.metadata?.viewerFilePath
-        });
+        const toolEntry = this.toolCallMessages.get(sessionId).get(meta.id);
+        toolEntry.msgId = msg.message_id;
+        resolveReady();
         break;
       }
       case "tool_update": {
         const meta = content.metadata;
         const toolState = this.toolCallMessages.get(sessionId)?.get(meta.id);
         if (toolState) {
-          const viewerLinks = meta.viewerLinks || toolState.viewerLinks;
-          const viewerFilePath = content.metadata?.viewerFilePath || toolState.viewerFilePath;
-          if (meta.viewerLinks) toolState.viewerLinks = meta.viewerLinks;
+          if (meta.viewerLinks) {
+            toolState.viewerLinks = meta.viewerLinks;
+            log10.debug({ toolId: meta.id, viewerLinks: meta.viewerLinks }, "Accumulated viewerLinks");
+          }
+          const viewerFilePath = content.metadata?.viewerFilePath;
           if (viewerFilePath) toolState.viewerFilePath = viewerFilePath;
+          if (meta.name) toolState.name = meta.name;
+          if (meta.kind) toolState.kind = meta.kind;
+          const isTerminal = meta.status === "completed" || meta.status === "failed";
+          if (!isTerminal && !meta.viewerLinks) break;
+          await toolState.ready;
+          log10.debug(
+            { toolId: meta.id, status: meta.status, hasViewerLinks: !!toolState.viewerLinks, viewerLinks: toolState.viewerLinks, name: toolState.name, msgId: toolState.msgId },
+            "Tool completed, preparing edit"
+          );
           const merged = {
             ...meta,
-            name: meta.name || toolState.name,
-            kind: meta.kind || toolState.kind,
-            viewerLinks,
-            viewerFilePath
+            name: toolState.name,
+            kind: toolState.kind,
+            viewerLinks: toolState.viewerLinks,
+            viewerFilePath: toolState.viewerFilePath
           };
+          const formattedText = formatToolUpdate(merged);
           try {
             await this.sendQueue.enqueue(
               () => this.bot.api.editMessageText(
                 this.telegramConfig.chatId,
                 toolState.msgId,
-                formatToolUpdate(merged),
+                formattedText,
                 { parse_mode: "HTML" }
               )
             );
-          } catch {
+          } catch (err) {
+            log10.warn(
+              { err, msgId: toolState.msgId, textLen: formattedText.length, hasViewerLinks: !!merged.viewerLinks },
+              "Tool update edit failed"
+            );
           }
         }
         break;
       }
       case "plan": {
-        await this.finalizeDraft(sessionId);
-        await this.sendQueue.enqueue(
-          () => this.bot.api.sendMessage(
-            this.telegramConfig.chatId,
-            formatPlan(
-              content.metadata
-            ),
-            {
-              message_thread_id: threadId,
-              parse_mode: "HTML",
-              disable_notification: true
-            }
-          )
+        const meta = content.metadata;
+        const tracker = this.getOrCreateTracker(sessionId, threadId);
+        await tracker.onPlan(
+          meta.entries.map((e) => ({
+            content: e.content,
+            status: e.status,
+            priority: e.priority ?? "medium"
+          }))
         );
         break;
       }
       case "usage": {
+        const meta = content.metadata;
         await this.finalizeDraft(sessionId);
-        await this.sendQueue.enqueue(
-          () => this.bot.api.sendMessage(
-            this.telegramConfig.chatId,
-            formatUsage(
-              content.metadata
-            ),
-            {
-              message_thread_id: threadId,
+        const tracker = this.getOrCreateTracker(sessionId, threadId);
+        await tracker.sendUsage(meta);
+        if (this.notificationTopicId && sessionId !== this.assistantSession?.id) {
+          const sess = this.core.sessionManager.getSession(sessionId);
+          const sessionName = sess?.name || "Session";
+          const chatIdStr = String(this.telegramConfig.chatId);
+          const numericId = chatIdStr.startsWith("-100") ? chatIdStr.slice(4) : chatIdStr.replace("-", "");
+          const deepLink = `https://t.me/c/${numericId}/${threadId}`;
+          const text = `\u2705 <b>${escapeHtml(sessionName)}</b>
+Task completed.
+
+<a href="${deepLink}">\u2192 Go to topic</a>`;
+          this.sendQueue.enqueue(
+            () => this.bot.api.sendMessage(this.telegramConfig.chatId, text, {
+              message_thread_id: this.notificationTopicId,
               parse_mode: "HTML",
-              disable_notification: true
-            }
-          )
-        );
+              disable_notification: false
+            })
+          ).catch(() => {
+          });
+        }
         break;
       }
       case "session_end": {
@@ -2737,21 +3263,33 @@ Workspace: <code>${workspace}</code>
         this.sessionDrafts.delete(sessionId);
         this.toolCallMessages.delete(sessionId);
         await this.cleanupSkillCommands(sessionId);
-        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
-            }
-          )
-        );
+        const tracker = this.sessionTrackers.get(sessionId);
+        if (tracker) {
+          await tracker.onComplete();
+          tracker.destroy();
+          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
+              }
+            )
+          );
+        }
         break;
       }
       case "error": {
         await this.finalizeDraft(sessionId);
+        const tracker = this.sessionTrackers.get(sessionId);
+        if (tracker) {
+          tracker.destroy();
+          this.sessionTrackers.delete(sessionId);
+        }
         await this.sendQueue.enqueue(
           () => this.bot.api.sendMessage(
             this.telegramConfig.chatId,
@@ -2768,17 +3306,27 @@ Workspace: <code>${workspace}</code>
     }
   }
   async sendPermissionRequest(sessionId, request) {
-    log8.info({ sessionId, requestId: request.id }, "Permission request sent");
+    log10.info({ sessionId, requestId: request.id }, "Permission request sent");
     const session = this.core.sessionManager.getSession(
       sessionId
     );
     if (!session) return;
+    if (session.dangerousMode) {
+      const allowOption = request.options.find((o) => o.isAllow);
+      if (allowOption && session.pendingPermission?.requestId === request.id) {
+        log10.info({ sessionId, requestId: request.id, optionId: allowOption.id }, "Dangerous mode: auto-approving permission");
+        session.pendingPermission.resolve(allowOption.id);
+        session.pendingPermission = void 0;
+      }
+      return;
+    }
     await this.sendQueue.enqueue(
       () => this.permissionHandler.sendPermissionRequest(session, request)
     );
   }
   async sendNotification(notification) {
-    log8.info(
+    if (notification.sessionId === this.assistantSession?.id) return;
+    log10.info(
       { sessionId: notification.sessionId, type: notification.type },
       "Notification sent"
     );
@@ -2789,13 +3337,21 @@ Workspace: <code>${workspace}</code>
       permission: "\u{1F510}",
       input_required: "\u{1F4AC}"
     };
-    let text = `${emoji[notification.type] || "\u2139\uFE0F"} <b>${escapeHtml(notification.sessionName || notification.sessionId)}</b>
+    let text = `${emoji[notification.type] || "\u2139\uFE0F"} <b>${escapeHtml(notification.sessionName || "New session")}</b>
 `;
     text += escapeHtml(notification.summary);
-    if (notification.deepLink) {
+    const deepLink = notification.deepLink ?? (() => {
+      const session = this.core.sessionManager.getSession(notification.sessionId);
+      const threadId = session?.threadId;
+      if (!threadId) return void 0;
+      const chatIdStr = String(this.telegramConfig.chatId);
+      const numericId = chatIdStr.startsWith("-100") ? chatIdStr.slice(4) : chatIdStr.replace("-", "");
+      return `https://t.me/c/${numericId}/${threadId}`;
+    })();
+    if (deepLink) {
       text += `
 
-<a href="${notification.deepLink}">\u2192 Go to message</a>`;
+<a href="${deepLink}">\u2192 Go to topic</a>`;
     }
     await this.sendQueue.enqueue(
       () => this.bot.api.sendMessage(this.telegramConfig.chatId, text, {
@@ -2806,7 +3362,7 @@ Workspace: <code>${workspace}</code>
     );
   }
   async createSessionThread(sessionId, name) {
-    log8.info({ sessionId, name }, "Session topic created");
+    log10.info({ sessionId, name }, "Session topic created");
     return String(
       await createSessionTopic(this.bot, this.telegramConfig.chatId, name)
     );
@@ -2822,14 +3378,26 @@ Workspace: <code>${workspace}</code>
       Number(session.threadId),
       newName
     );
+    await this.core.sessionManager.updateSessionName(
+      sessionId,
+      newName
+    );
   }
   async sendSkillCommands(sessionId, commands) {
+    if (sessionId === this.assistantSession?.id) return;
     const session = this.core.sessionManager.getSession(
       sessionId
     );
     if (!session) return;
     const threadId = Number(session.threadId);
     if (!threadId) return;
+    if (!this.skillMessages.has(sessionId)) {
+      const record = this.core.sessionManager.getSessionRecord(sessionId);
+      const platform = record?.platform;
+      if (platform?.skillMsgId) {
+        this.skillMessages.set(sessionId, platform.skillMsgId);
+      }
+    }
     if (commands.length === 0) {
       await this.cleanupSkillCommands(sessionId);
       return;
@@ -2864,6 +3432,13 @@ Workspace: <code>${workspace}</code>
         )
       );
       this.skillMessages.set(sessionId, msg.message_id);
+      const record = this.core.sessionManager.getSessionRecord(sessionId);
+      if (record) {
+        await this.core.sessionManager.updateSessionPlatform(
+          sessionId,
+          { ...record.platform, skillMsgId: msg.message_id }
+        );
+      }
       await this.bot.api.pinChatMessage(
         this.telegramConfig.chatId,
         msg.message_id,
@@ -2872,7 +3447,7 @@ Workspace: <code>${workspace}</code>
         }
       );
     } catch (err) {
-      log8.error({ err, sessionId }, "Failed to send skill commands");
+      log10.error({ err, sessionId }, "Failed to send skill commands");
     }
     await this.updateCommandAutocomplete(session.agentName, commands);
   }
@@ -2891,6 +3466,11 @@ Workspace: <code>${workspace}</code>
     }
     this.skillMessages.delete(sessionId);
     clearSkillCallbacks(sessionId);
+    const record = this.core.sessionManager.getSessionRecord(sessionId);
+    if (record) {
+      const { skillMsgId: _removed, ...rest } = record.platform;
+      await this.core.sessionManager.updateSessionPlatform(sessionId, rest);
+    }
   }
   async updateCommandAutocomplete(agentName, skillCommands) {
     const prefix = `[${agentName}] `;
@@ -2903,12 +3483,12 @@ Workspace: <code>${workspace}</code>
       await this.bot.api.setMyCommands(all, {
         scope: { type: "chat", chat_id: this.telegramConfig.chatId }
       });
-      log8.info(
+      log10.info(
         { count: all.length, skills: validSkills.length },
         "Updated command autocomplete"
       );
     } catch (err) {
-      log8.error(
+      log10.error(
         { err, commands: all },
         "Failed to update command autocomplete"
       );
@@ -2917,8 +3497,8 @@ Workspace: <code>${workspace}</code>
   async finalizeDraft(sessionId) {
     const draft = this.sessionDrafts.get(sessionId);
     if (!draft) return;
-    const finalMsgId = await draft.finalize();
     this.sessionDrafts.delete(sessionId);
+    const finalMsgId = await draft.finalize();
     if (sessionId === this.assistantSession?.id) {
       const fullText = this.sessionTextBuffers.get(sessionId);
       this.sessionTextBuffers.delete(sessionId);
@@ -2957,4 +3537,4 @@ export {
   ApiServer,
   TelegramAdapter
 };
-//# sourceMappingURL=chunk-6HORD4FS.js.map
+//# sourceMappingURL=chunk-C6IFPAWN.js.map