@openacp/cli 0.2.30 → 0.3.0

package/dist/{chunk-WKHCVK5P.js → chunk-C6IFPAWN.js}

@@ -523,6 +523,7 @@ var Session = class {
   adapter;
   // Set by wireSessionEvents for renaming
   pendingPermission;
+  dangerousMode = false;
   log;
   constructor(opts) {
     this.id = opts.id || nanoid(12);
@@ -593,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();
@@ -666,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);
   }
@@ -707,11 +715,11 @@ var SessionManager = class {
     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" });
       }
     }
   }
@@ -1044,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;
@@ -1086,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 ---
@@ -1609,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];
@@ -1663,6 +1682,7 @@ var MessageDraft = class {
   flushPromise = Promise.resolve();
   lastSentBuffer = "";
   append(text) {
+    if (!text) return;
     this.buffer += text;
     this.scheduleFlush();
   }
@@ -1709,7 +1729,6 @@ var MessageDraft = class {
         );
         this.lastSentBuffer = this.buffer;
       } catch {
-        this.messageId = void 0;
       }
     }
   }
@@ -1813,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");
@@ -1898,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"));
@@ -1952,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"));
@@ -1981,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) {
@@ -2000,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");
@@ -2047,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 };
 }
@@ -2128,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
@@ -2213,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,
@@ -2222,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(", ");
@@ -2260,6 +2386,279 @@ 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 {
   items = [];
@@ -2472,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();
@@ -2495,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(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;
@@ -2508,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;
@@ -2522,7 +2936,7 @@ var TelegramAdapter = class extends ChannelAdapter {
         if (rateLimitedMethods.includes(method)) {
           this.sendQueue.onRateLimited();
         }
-        log8.warn(
+        log10.warn(
           { method, retryAfter, attempt: attempt + 1 },
           "Rate limited by Telegram, retrying"
         );
@@ -2567,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,
@@ -2591,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.
 
@@ -2624,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() {
@@ -2632,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) => {
@@ -2647,16 +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({
@@ -2664,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
     );
@@ -2676,11 +3114,15 @@ 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,
@@ -2698,6 +3140,8 @@ 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)) {
@@ -2737,7 +3181,7 @@ Workspace: <code>${workspace}</code>
         if (toolState) {
           if (meta.viewerLinks) {
             toolState.viewerLinks = meta.viewerLinks;
-            log8.debug({ toolId: meta.id, viewerLinks: meta.viewerLinks }, "Accumulated viewerLinks");
+            log10.debug({ toolId: meta.id, viewerLinks: meta.viewerLinks }, "Accumulated viewerLinks");
           }
           const viewerFilePath = content.metadata?.viewerFilePath;
           if (viewerFilePath) toolState.viewerFilePath = viewerFilePath;
@@ -2746,7 +3190,7 @@ Workspace: <code>${workspace}</code>
           const isTerminal = meta.status === "completed" || meta.status === "failed";
           if (!isTerminal && !meta.viewerLinks) break;
           await toolState.ready;
-          log8.debug(
+          log10.debug(
             { toolId: meta.id, status: meta.status, hasViewerLinks: !!toolState.viewerLinks, viewerLinks: toolState.viewerLinks, name: toolState.name, msgId: toolState.msgId },
             "Tool completed, preparing edit"
           );
@@ -2768,7 +3212,7 @@ Workspace: <code>${workspace}</code>
               )
             );
           } catch (err) {
-            log8.warn(
+            log10.warn(
               { err, msgId: toolState.msgId, textLen: formattedText.length, hasViewerLinks: !!merged.viewerLinks },
               "Tool update edit failed"
             );
@@ -2777,37 +3221,41 @@ Workspace: <code>${workspace}</code>
         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": {
@@ -2815,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,
@@ -2846,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"
     );
@@ -2870,10 +3340,18 @@ Workspace: <code>${workspace}</code>
     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, {
@@ -2884,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)
     );
@@ -2906,6 +3384,7 @@ Workspace: <code>${workspace}</code>
     );
   }
   async sendSkillCommands(sessionId, commands) {
+    if (sessionId === this.assistantSession?.id) return;
     const session = this.core.sessionManager.getSession(
       sessionId
     );
@@ -2968,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);
   }
@@ -3004,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"
       );
@@ -3018,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);
@@ -3058,4 +3537,4 @@ export {
   ApiServer,
   TelegramAdapter
 };
-//# sourceMappingURL=chunk-WKHCVK5P.js.map
+//# sourceMappingURL=chunk-C6IFPAWN.js.map