@openacp/cli 0.4.9 → 0.4.10

package/dist/{chunk-45DFYWJT.js → chunk-KPI4HGJC.js}

@@ -2428,12 +2428,14 @@ function splitMessage(text, maxLength = 3800) {
       chunks.push(remaining);
       break;
     }
-    let splitAt = remaining.lastIndexOf("\n\n", maxLength);
-    if (splitAt === -1 || splitAt < maxLength * 0.2) {
-      splitAt = remaining.lastIndexOf("\n", maxLength);
+    const wouldLeaveSmall = remaining.length < maxLength * 1.3;
+    const searchLimit = wouldLeaveSmall ? Math.floor(remaining.length / 2) + 300 : maxLength;
+    let splitAt = remaining.lastIndexOf("\n\n", searchLimit);
+    if (splitAt === -1 || splitAt < searchLimit * 0.2) {
+      splitAt = remaining.lastIndexOf("\n", searchLimit);
     }
-    if (splitAt === -1 || splitAt < maxLength * 0.2) {
-      splitAt = maxLength;
+    if (splitAt === -1 || splitAt < searchLimit * 0.2) {
+      splitAt = searchLimit;
     }
     const candidate = remaining.slice(0, splitAt);
     const fences = candidate.match(/```/g);
@@ -2466,6 +2468,7 @@ var MessageDraft = class {
   flushTimer;
   flushPromise = Promise.resolve();
   lastSentBuffer = "";
+  displayTruncated = false;
   append(text) {
     if (!text) return;
     this.buffer += text;
@@ -2482,16 +2485,20 @@ var MessageDraft = class {
   async flush() {
     if (!this.buffer) return;
     if (this.firstFlushPending) return;
-    let displayBuffer = this.buffer;
-    if (displayBuffer.length > 3800) {
-      let cutAt = displayBuffer.lastIndexOf("\n", 3800);
-      if (cutAt < 800) cutAt = 3800;
-      displayBuffer = displayBuffer.slice(0, cutAt) + "\n\u2026";
-    }
-    let html = markdownToTelegramHtml(displayBuffer);
+    const snapshot = this.buffer;
+    let html = markdownToTelegramHtml(snapshot);
     if (!html) return;
+    let truncated = false;
     if (html.length > 4096) {
-      html = html.slice(0, 4090) + "\n\u2026";
+      const ratio = 4e3 / html.length;
+      const targetLen = Math.floor(snapshot.length * ratio);
+      let cutAt = snapshot.lastIndexOf("\n", targetLen);
+      if (cutAt < targetLen * 0.5) cutAt = targetLen;
+      html = markdownToTelegramHtml(snapshot.slice(0, cutAt) + "\n\u2026");
+      truncated = true;
+      if (html.length > 4096) {
+        html = html.slice(0, 4090) + "\n\u2026";
+      }
     }
     if (!this.messageId) {
       this.firstFlushPending = true;
@@ -2506,7 +2513,12 @@ var MessageDraft = class {
         );
         if (result) {
           this.messageId = result.message_id;
-          this.lastSentBuffer = this.buffer;
+          if (!truncated) {
+            this.lastSentBuffer = snapshot;
+            this.displayTruncated = false;
+          } else {
+            this.displayTruncated = true;
+          }
         }
       } catch {
       } finally {
@@ -2514,13 +2526,20 @@ var MessageDraft = class {
       }
     } else {
       try {
-        await this.sendQueue.enqueue(
+        const result = await this.sendQueue.enqueue(
           () => this.bot.api.editMessageText(this.chatId, this.messageId, html, {
             parse_mode: "HTML"
           }),
           { type: "text", key: this.sessionId }
         );
-        this.lastSentBuffer = this.buffer;
+        if (result !== void 0) {
+          if (!truncated) {
+            this.lastSentBuffer = snapshot;
+            this.displayTruncated = false;
+          } else {
+            this.displayTruncated = true;
+          }
+        }
       } catch {
       }
     }
@@ -2532,9 +2551,34 @@ var MessageDraft = class {
     }
     await this.flushPromise;
     if (!this.buffer) return this.messageId;
-    if (this.messageId && this.buffer === this.lastSentBuffer) {
+    if (this.messageId && this.buffer === this.lastSentBuffer && !this.displayTruncated) {
       return this.messageId;
     }
+    const fullHtml = markdownToTelegramHtml(this.buffer);
+    if (fullHtml.length <= 4096) {
+      try {
+        if (this.messageId) {
+          await this.sendQueue.enqueue(
+            () => this.bot.api.editMessageText(this.chatId, this.messageId, fullHtml, {
+              parse_mode: "HTML"
+            }),
+            { type: "other" }
+          );
+        } else {
+          const msg = await this.sendQueue.enqueue(
+            () => this.bot.api.sendMessage(this.chatId, fullHtml, {
+              message_thread_id: this.threadId,
+              parse_mode: "HTML",
+              disable_notification: true
+            }),
+            { type: "other" }
+          );
+          if (msg) this.messageId = msg.message_id;
+        }
+        return this.messageId;
+      } catch {
+      }
+    }
     const mdChunks = splitMessage(this.buffer);
     for (let i = 0; i < mdChunks.length; i++) {
       const html = markdownToTelegramHtml(mdChunks[i]);
@@ -2620,202 +2664,229 @@ function buildDeepLink(chatId, messageId) {
   return `https://t.me/c/${cleanId}/${messageId}`;
 }
 
-// src/adapters/telegram/commands.ts
+// src/adapters/telegram/commands/new-session.ts
+import { InlineKeyboard as InlineKeyboard2 } from "grammy";
+
+// src/adapters/telegram/commands/admin.ts
 import { InlineKeyboard } from "grammy";
-var log8 = createChildLogger({ module: "telegram-commands" });
-var pendingNewSessions = /* @__PURE__ */ new Map();
-var PENDING_TIMEOUT_MS = 5 * 60 * 1e3;
-function cleanupPending(userId) {
-  const pending = pendingNewSessions.get(userId);
-  if (pending) {
-    clearTimeout(pending.timer);
-    pendingNewSessions.delete(userId);
-  }
-}
-function setupCommands(bot, core, chatId, assistant) {
-  bot.command("new", (ctx) => handleNew(ctx, core, chatId, assistant));
-  bot.command("newchat", (ctx) => handleNewChat(ctx, core, chatId));
-  bot.command("cancel", (ctx) => handleCancel(ctx, core, assistant));
-  bot.command("status", (ctx) => handleStatus(ctx, core));
-  bot.command("sessions", (ctx) => handleTopics(ctx, core));
-  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));
-  bot.command("restart", (ctx) => handleRestart(ctx, core));
-  bot.command("update", (ctx) => handleUpdate(ctx, core));
-  bot.command("integrate", (ctx) => handleIntegrate(ctx, core));
-  bot.command("clear", (ctx) => handleClear(ctx, assistant));
-}
-function buildMenuKeyboard() {
-  return new InlineKeyboard().text("\u{1F195} New Session", "m:new").text("\u{1F4CB} Sessions", "m:topics").row().text("\u{1F4CA} Status", "m:status").text("\u{1F916} Agents", "m:agents").row().text("\u{1F517} Integrate", "m:integrate").text("\u2753 Help", "m:help").row().text("\u{1F504} Restart", "m:restart").text("\u2B06\uFE0F Update", "m:update");
+var log8 = createChildLogger({ module: "telegram-cmd-admin" });
+function buildDangerousModeKeyboard(sessionId, enabled) {
+  return new InlineKeyboard().text(
+    enabled ? "\u{1F510} Disable Dangerous Mode" : "\u2620\uFE0F Enable Dangerous Mode",
+    `d:${sessionId}`
+  );
 }
-function setupMenuCallbacks(bot, core, chatId, systemTopicIds) {
-  bot.callbackQuery(/^m:/, async (ctx) => {
-    const data = ctx.callbackQuery.data;
-    try {
-      await ctx.answerCallbackQuery();
-    } catch {
-    }
-    if (data.startsWith("m:new:agent:")) {
-      const agentName = data.replace("m:new:agent:", "");
-      const userId = ctx.from?.id;
-      if (userId) await startWorkspaceStep(ctx, core, chatId, userId, agentName);
-      return;
-    }
-    if (data === "m:new:ws:default") {
-      const userId = ctx.from?.id;
-      if (!userId) return;
-      const pending = pendingNewSessions.get(userId);
-      if (!pending?.agentName) return;
-      const workspace = core.configManager.get().workspace.baseDir;
-      await startConfirmStep(ctx, chatId, userId, pending.agentName, workspace);
-      return;
-    }
-    if (data === "m:new:ws:custom") {
-      const userId = ctx.from?.id;
-      if (!userId) return;
-      const pending = pendingNewSessions.get(userId);
-      if (!pending?.agentName) return;
-      try {
-        await ctx.api.editMessageText(
-          chatId,
-          pending.messageId,
-          `\u270F\uFE0F <b>Enter your project path:</b>
-
-Full path like <code>~/code/my-project</code>
-Or just the folder name like <code>my-project</code> (will use ${core.configManager.get().workspace.baseDir}/)`,
-          { parse_mode: "HTML" }
-        );
-      } catch {
-        await ctx.reply(
-          `\u270F\uFE0F <b>Enter your project path:</b>`,
-          { parse_mode: "HTML" }
-        );
-      }
-      clearTimeout(pending.timer);
-      pending.step = "workspace_input";
-      pending.timer = setTimeout(() => pendingNewSessions.delete(userId), PENDING_TIMEOUT_MS);
-      return;
-    }
-    if (data === "m:new:confirm") {
-      const userId = ctx.from?.id;
-      if (!userId) return;
-      const pending = pendingNewSessions.get(userId);
-      if (!pending?.agentName || !pending?.workspace) return;
-      cleanupPending(userId);
-      const confirmMsgId = pending.messageId;
+function setupDangerousModeCallbacks(bot, core) {
+  bot.callbackQuery(/^d:/, async (ctx) => {
+    const sessionId = ctx.callbackQuery.data.slice(2);
+    const session = core.sessionManager.getSession(sessionId);
+    if (session) {
+      session.dangerousMode = !session.dangerousMode;
+      log8.info({ sessionId, dangerousMode: session.dangerousMode }, "Dangerous mode toggled via button");
+      core.sessionManager.updateSessionDangerousMode(sessionId, session.dangerousMode).catch(() => {
+      });
+      const toastText2 = session.dangerousMode ? "\u2620\uFE0F Dangerous mode enabled \u2014 permissions auto-approved" : "\u{1F510} Dangerous mode disabled \u2014 permissions shown normally";
       try {
-        await ctx.api.editMessageText(chatId, confirmMsgId, `\u23F3 Creating session...`, { parse_mode: "HTML" });
+        await ctx.answerCallbackQuery({ text: toastText2 });
       } catch {
       }
-      const resultThreadId = await createSessionDirect(ctx, core, chatId, pending.agentName, pending.workspace);
       try {
-        if (resultThreadId) {
-          const link = buildDeepLink(chatId, resultThreadId);
-          await ctx.api.editMessageText(chatId, confirmMsgId, `\u2705 Session created \u2192 <a href="${link}">Open topic</a>`, { parse_mode: "HTML" });
-        } else {
-          await ctx.api.editMessageText(chatId, confirmMsgId, `\u274C Session creation failed.`, { parse_mode: "HTML" });
-        }
+        await ctx.editMessageReplyMarkup({
+          reply_markup: buildDangerousModeKeyboard(sessionId, session.dangerousMode)
+        });
       } catch {
       }
       return;
     }
-    if (data === "m:new:cancel") {
-      const userId = ctx.from?.id;
-      if (userId) cleanupPending(userId);
+    const record = core.sessionManager.getSessionRecord(sessionId);
+    if (!record || record.status === "cancelled" || record.status === "error") {
       try {
-        await ctx.editMessageText("\u274C Session creation cancelled.", { parse_mode: "HTML" });
+        await ctx.answerCallbackQuery({ text: "\u26A0\uFE0F Session not found or already ended." });
       } catch {
       }
       return;
     }
-    switch (data) {
-      case "m:new":
-        await handleNew(ctx, core, chatId);
-        break;
-      case "m:status":
-        await handleStatus(ctx, core);
-        break;
-      case "m:agents":
-        await handleAgents(ctx, core);
-        break;
-      case "m:help":
-        await handleHelp(ctx);
-        break;
-      case "m:restart":
-        await handleRestart(ctx, core);
-        break;
-      case "m:update":
-        await handleUpdate(ctx, core);
-        break;
-      case "m:integrate":
-        await handleIntegrate(ctx, core);
-        break;
-      case "m:topics":
-        await handleTopics(ctx, core);
-        break;
-      case "m:cleanup:finished":
-        await handleCleanup(ctx, core, chatId, ["finished"]);
-        break;
-      case "m:cleanup:errors":
-        await handleCleanup(ctx, core, chatId, ["error", "cancelled"]);
-        break;
-      case "m:cleanup:all":
-        await handleCleanup(ctx, core, chatId, ["finished", "error", "cancelled"]);
-        break;
-      case "m:cleanup:everything":
-        await handleCleanupEverything(ctx, core, chatId, systemTopicIds);
-        break;
-      case "m:cleanup:everything:confirm":
-        await handleCleanupEverythingConfirmed(ctx, core, chatId, systemTopicIds);
-        break;
+    const newDangerousMode = !(record.dangerousMode ?? false);
+    core.sessionManager.updateSessionDangerousMode(sessionId, newDangerousMode).catch(() => {
+    });
+    log8.info({ sessionId, dangerousMode: newDangerousMode }, "Dangerous mode toggled via button (store-only, session not in memory)");
+    const toastText = newDangerousMode ? "\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, newDangerousMode)
+      });
+    } catch {
     }
   });
 }
-async function handleMenu(ctx) {
-  await ctx.reply(`<b>OpenACP Menu</b>
-Choose an action:`, {
-    parse_mode: "HTML",
-    reply_markup: buildMenuKeyboard()
-  });
-}
-async function handleNew(ctx, core, chatId, assistant) {
-  const rawMatch = ctx.match;
-  const matchStr = typeof rawMatch === "string" ? rawMatch : "";
-  const args = matchStr.split(" ").filter(Boolean);
-  const agentName = args[0];
-  const workspace = args[1];
-  if (agentName && workspace) {
-    await createSessionDirect(ctx, core, chatId, agentName, workspace);
+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 currentThreadId = ctx.message?.message_thread_id;
-  if (assistant && currentThreadId === assistant.topicId) {
-    const assistantSession = assistant.getSession();
-    if (assistantSession) {
-      const prompt = agentName ? `User wants to create a new session with agent "${agentName}" but didn't specify a workspace. Ask them which project directory to use as workspace.` : `User wants to create a new session. Guide them through choosing an agent and workspace (project directory).`;
-      await assistantSession.enqueuePrompt(prompt);
+  const session = core.sessionManager.getSessionByThread("telegram", String(threadId));
+  if (session) {
+    if (session.dangerousMode) {
+      await ctx.reply("\u2620\uFE0F Dangerous mode is already enabled.", { parse_mode: "HTML" });
       return;
     }
+    session.dangerousMode = true;
+    core.sessionManager.updateSessionDangerousMode(session.id, true).catch(() => {
+    });
+  } else {
+    const record = core.sessionManager.getRecordByThread("telegram", String(threadId));
+    if (!record || record.status === "cancelled" || record.status === "error") {
+      await ctx.reply("\u26A0\uFE0F No active session in this topic.", { parse_mode: "HTML" });
+      return;
+    }
+    if (record.dangerousMode) {
+      await ctx.reply("\u2620\uFE0F Dangerous mode is already enabled.", { parse_mode: "HTML" });
+      return;
+    }
+    core.sessionManager.updateSessionDangerousMode(record.sessionId, true).catch(() => {
+    });
   }
-  const userId = ctx.from?.id;
-  if (!userId) return;
-  const agents = core.agentManager.getAvailableAgents();
-  const config = core.configManager.get();
-  if (agentName || agents.length === 1) {
-    const selectedAgent = agentName || config.defaultAgent;
-    await startWorkspaceStep(ctx, core, chatId, userId, selectedAgent);
-    return;
-  }
-  const keyboard = new InlineKeyboard();
-  for (const agent of agents) {
-    const label = agent.name === config.defaultAgent ? `${agent.name} (default)` : agent.name;
-    keyboard.text(label, `m:new:agent:${agent.name}`).row();
-  }
-  const msg = await ctx.reply(
-    `\u{1F916} <b>Choose an agent:</b>`,
+  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) {
+    if (!session.dangerousMode) {
+      await ctx.reply("\u{1F510} Dangerous mode is already disabled.", { parse_mode: "HTML" });
+      return;
+    }
+    session.dangerousMode = false;
+    core.sessionManager.updateSessionDangerousMode(session.id, false).catch(() => {
+    });
+  } else {
+    const record = core.sessionManager.getRecordByThread("telegram", String(threadId));
+    if (!record || record.status === "cancelled" || record.status === "error") {
+      await ctx.reply("\u26A0\uFE0F No active session in this topic.", { parse_mode: "HTML" });
+      return;
+    }
+    if (!record.dangerousMode) {
+      await ctx.reply("\u{1F510} Dangerous mode is already disabled.", { parse_mode: "HTML" });
+      return;
+    }
+    core.sessionManager.updateSessionDangerousMode(record.sessionId, false).catch(() => {
+    });
+  }
+  await ctx.reply("\u{1F510} <b>Dangerous mode disabled</b>\n\nPermission requests will be shown normally.", { parse_mode: "HTML" });
+}
+async function handleUpdate(ctx, core) {
+  if (!core.requestRestart) {
+    await ctx.reply("\u26A0\uFE0F Update is not available (no restart handler registered).", { parse_mode: "HTML" });
+    return;
+  }
+  const { getCurrentVersion, getLatestVersion, compareVersions, runUpdate } = await import("./version-VC5CPXBX.js");
+  const current = getCurrentVersion();
+  const statusMsg = await ctx.reply(`\u{1F50D} Checking for updates... (current: v${escapeHtml(current)})`, { parse_mode: "HTML" });
+  const latest = await getLatestVersion();
+  if (!latest) {
+    await ctx.api.editMessageText(ctx.chat.id, statusMsg.message_id, "\u274C Could not check for updates.", { parse_mode: "HTML" });
+    return;
+  }
+  if (compareVersions(current, latest) >= 0) {
+    await ctx.api.editMessageText(ctx.chat.id, statusMsg.message_id, `\u2705 Already up to date (v${escapeHtml(current)}).`, { parse_mode: "HTML" });
+    return;
+  }
+  await ctx.api.editMessageText(
+    ctx.chat.id,
+    statusMsg.message_id,
+    `\u2B07\uFE0F Updating v${escapeHtml(current)} \u2192 v${escapeHtml(latest)}...`,
+    { parse_mode: "HTML" }
+  );
+  const ok = await runUpdate();
+  if (!ok) {
+    await ctx.api.editMessageText(ctx.chat.id, statusMsg.message_id, "\u274C Update failed. Try manually: <code>npm install -g @openacp/cli@latest</code>", { parse_mode: "HTML" });
+    return;
+  }
+  await ctx.api.editMessageText(
+    ctx.chat.id,
+    statusMsg.message_id,
+    `\u2705 Updated to v${escapeHtml(latest)}. Restarting...`,
+    { parse_mode: "HTML" }
+  );
+  await new Promise((r) => setTimeout(r, 500));
+  await core.requestRestart();
+}
+async function handleRestart(ctx, core) {
+  if (!core.requestRestart) {
+    await ctx.reply("\u26A0\uFE0F Restart is not available (no restart handler registered).", { parse_mode: "HTML" });
+    return;
+  }
+  await ctx.reply("\u{1F504} <b>Restarting OpenACP...</b>\nRebuilding and restarting. Be back shortly.", { parse_mode: "HTML" });
+  await new Promise((r) => setTimeout(r, 500));
+  await core.requestRestart();
+}
+
+// src/adapters/telegram/commands/new-session.ts
+var log9 = createChildLogger({ module: "telegram-cmd-new-session" });
+var pendingNewSessions = /* @__PURE__ */ new Map();
+var PENDING_TIMEOUT_MS = 5 * 60 * 1e3;
+function cleanupPending(userId) {
+  const pending = pendingNewSessions.get(userId);
+  if (pending) {
+    clearTimeout(pending.timer);
+    pendingNewSessions.delete(userId);
+  }
+}
+function botFromCtx(ctx) {
+  return { api: ctx.api };
+}
+async function handleNew(ctx, core, chatId, assistant) {
+  const rawMatch = ctx.match;
+  const matchStr = typeof rawMatch === "string" ? rawMatch : "";
+  const args = matchStr.split(" ").filter(Boolean);
+  const agentName = args[0];
+  const workspace = args[1];
+  if (agentName && workspace) {
+    await createSessionDirect(ctx, core, chatId, agentName, workspace);
+    return;
+  }
+  const currentThreadId = ctx.message?.message_thread_id;
+  if (assistant && currentThreadId === assistant.topicId) {
+    const assistantSession = assistant.getSession();
+    if (assistantSession) {
+      const prompt = agentName ? `User wants to create a new session with agent "${agentName}" but didn't specify a workspace. Ask them which project directory to use as workspace.` : `User wants to create a new session. Guide them through choosing an agent and workspace (project directory).`;
+      await assistantSession.enqueuePrompt(prompt);
+      return;
+    }
+  }
+  const userId = ctx.from?.id;
+  if (!userId) return;
+  const agents = core.agentManager.getAvailableAgents();
+  const config = core.configManager.get();
+  if (agentName || agents.length === 1) {
+    const selectedAgent = agentName || config.defaultAgent;
+    await startWorkspaceStep(ctx, core, chatId, userId, selectedAgent);
+    return;
+  }
+  const keyboard = new InlineKeyboard2();
+  for (const agent of agents) {
+    const label = agent.name === config.defaultAgent ? `${agent.name} (default)` : agent.name;
+    keyboard.text(label, `m:new:agent:${agent.name}`).row();
+  }
+  keyboard.text("\u274C Cancel", "m:new:cancel");
+  const msg = await ctx.reply(
+    `\u{1F916} <b>Choose an agent:</b>`,
     { parse_mode: "HTML", reply_markup: keyboard }
   );
   cleanupPending(userId);
@@ -2829,7 +2900,7 @@ async function handleNew(ctx, core, chatId, assistant) {
 async function startWorkspaceStep(ctx, core, chatId, userId, agentName) {
   const config = core.configManager.get();
   const baseDir = config.workspace.baseDir;
-  const keyboard = new InlineKeyboard().text(`\u{1F4C1} Use ${baseDir}`, "m:new:ws:default").row().text("\u270F\uFE0F Enter project path", "m:new:ws:custom");
+  const keyboard = new InlineKeyboard2().text(`\u{1F4C1} Use ${baseDir}`, "m:new:ws:default").row().text("\u270F\uFE0F Enter project path", "m:new:ws:custom").row().text("\u274C Cancel", "m:new:cancel");
   const text = `\u{1F4C1} <b>Where should ${escapeHtml(agentName)} work?</b>
 
 Enter the path to your project folder \u2014 the agent will read, write, and run code there.
@@ -2860,7 +2931,7 @@ Or use the default directory below:`;
   });
 }
 async function startConfirmStep(ctx, chatId, userId, agentName, workspace) {
-  const keyboard = new InlineKeyboard().text("\u2705 Create", "m:new:confirm").text("\u274C Cancel", "m:new:cancel");
+  const keyboard = new InlineKeyboard2().text("\u2705 Create", "m:new:confirm").text("\u274C Cancel", "m:new:cancel");
   const text = `\u2705 <b>Ready to create session?</b>
 
 <b>Agent:</b> ${escapeHtml(agentName)}
@@ -2891,7 +2962,7 @@ async function startConfirmStep(ctx, chatId, userId, agentName, workspace) {
   });
 }
 async function createSessionDirect(ctx, core, chatId, agentName, workspace) {
-  log8.info({ userId: ctx.from?.id, agentName, workspace }, "New session command (direct)");
+  log9.info({ userId: ctx.from?.id, agentName, workspace }, "New session command (direct)");
   let threadId;
   try {
     const topicName = `\u{1F504} New Session`;
@@ -2921,99 +2992,262 @@ This is your coding session \u2014 chat here to work with the agent.`,
         reply_markup: buildDangerousModeKeyboard(session.id, false)
       }
     );
-    session.warmup().catch((err) => log8.error({ err }, "Warm-up error"));
+    session.warmup().catch((err) => log9.error({ err }, "Warm-up error"));
     return threadId ?? null;
   } catch (err) {
-    log8.error({ err }, "Session creation failed");
+    log9.error({ err }, "Session creation failed");
     if (threadId) {
       try {
         await ctx.api.deleteForumTopic(chatId, threadId);
       } catch {
       }
-    }
-    const message = err instanceof Error ? err.message : typeof err === "object" ? JSON.stringify(err) : String(err);
-    await ctx.reply(`\u274C ${escapeHtml(message)}`, { parse_mode: "HTML" });
-    return null;
-  }
-}
-async function handleNewChat(ctx, core, chatId) {
-  const threadId = ctx.message?.message_thread_id;
-  if (!threadId) {
-    await ctx.reply(
-      "Use /newchat inside a session topic to inherit its config.",
-      { parse_mode: "HTML" }
-    );
-    return;
-  }
-  const currentSession = core.sessionManager.getSessionByThread(
-    "telegram",
-    String(threadId)
-  );
-  let agentName;
-  let workspace;
-  if (currentSession) {
-    agentName = currentSession.agentName;
-    workspace = currentSession.workingDirectory;
-  } else {
-    const record = core.sessionManager.getRecordByThread("telegram", String(threadId));
-    if (!record || record.status === "cancelled" || record.status === "error") {
-      await ctx.reply("No active session in this topic.", {
-        parse_mode: "HTML"
-      });
+    }
+    const message = err instanceof Error ? err.message : typeof err === "object" ? JSON.stringify(err) : String(err);
+    await ctx.reply(`\u274C ${escapeHtml(message)}`, { parse_mode: "HTML" });
+    return null;
+  }
+}
+async function handleNewChat(ctx, core, chatId) {
+  const threadId = ctx.message?.message_thread_id;
+  if (!threadId) {
+    await ctx.reply(
+      "Use /newchat inside a session topic to inherit its config.",
+      { parse_mode: "HTML" }
+    );
+    return;
+  }
+  const currentSession = core.sessionManager.getSessionByThread(
+    "telegram",
+    String(threadId)
+  );
+  let agentName;
+  let workspace;
+  if (currentSession) {
+    agentName = currentSession.agentName;
+    workspace = currentSession.workingDirectory;
+  } else {
+    const record = core.sessionManager.getRecordByThread("telegram", String(threadId));
+    if (!record || record.status === "cancelled" || record.status === "error") {
+      await ctx.reply("No active session in this topic.", {
+        parse_mode: "HTML"
+      });
+      return;
+    }
+    agentName = record.agentName;
+    workspace = record.workingDir;
+  }
+  let newThreadId;
+  try {
+    const topicName = `\u{1F504} ${agentName} \u2014 New Chat`;
+    newThreadId = await createSessionTopic(
+      botFromCtx(ctx),
+      chatId,
+      topicName
+    );
+    const topicLink = buildDeepLink(chatId, newThreadId);
+    await ctx.reply(
+      `\u2705 New chat created \u2192 <a href="${topicLink}">Open topic</a>`,
+      { parse_mode: "HTML" }
+    );
+    await ctx.api.sendMessage(chatId, `\u23F3 Setting up session, please wait...`, {
+      message_thread_id: newThreadId,
+      parse_mode: "HTML"
+    });
+    const session = await core.handleNewSession(
+      "telegram",
+      agentName,
+      workspace
+    );
+    session.threadId = String(newThreadId);
+    await core.sessionManager.updateSessionPlatform(session.id, {
+      topicId: newThreadId
+    });
+    await ctx.api.sendMessage(
+      chatId,
+      `\u2705 New chat (same agent &amp; workspace)
+<b>Agent:</b> ${escapeHtml(session.agentName)}
+<b>Workspace:</b> <code>${escapeHtml(session.workingDirectory)}</code>`,
+      {
+        message_thread_id: newThreadId,
+        parse_mode: "HTML",
+        reply_markup: buildDangerousModeKeyboard(session.id, false)
+      }
+    );
+    session.warmup().catch((err) => log9.error({ err }, "Warm-up error"));
+  } catch (err) {
+    if (newThreadId) {
+      try {
+        await ctx.api.deleteForumTopic(chatId, newThreadId);
+      } catch {
+      }
+    }
+    const message = err instanceof Error ? err.message : String(err);
+    await ctx.reply(`\u274C ${escapeHtml(message)}`, { parse_mode: "HTML" });
+  }
+}
+async function executeNewSession(bot, core, chatId, agentName, workspace) {
+  const threadId = await createSessionTopic(bot, chatId, "\u{1F504} New Session");
+  const setupMsg = await bot.api.sendMessage(chatId, "\u23F3 Setting up session, please wait...", {
+    message_thread_id: threadId,
+    parse_mode: "HTML"
+  });
+  const firstMsgId = setupMsg.message_id;
+  try {
+    const session = await core.handleNewSession(
+      "telegram",
+      agentName,
+      workspace
+    );
+    session.threadId = String(threadId);
+    await core.sessionManager.updateSessionPlatform(session.id, {
+      topicId: threadId
+    });
+    const finalName = `\u{1F504} ${session.agentName} \u2014 New Session`;
+    await renameSessionTopic(bot, chatId, threadId, finalName);
+    session.warmup().catch((err) => log9.error({ err }, "Warm-up error"));
+    return { session, threadId, firstMsgId };
+  } catch (err) {
+    try {
+      await bot.api.deleteForumTopic(chatId, threadId);
+    } catch {
+    }
+    throw err;
+  }
+}
+async function handlePendingWorkspaceInput(ctx, core, chatId, assistantTopicId) {
+  const userId = ctx.from?.id;
+  if (!userId) return false;
+  const pending = pendingNewSessions.get(userId);
+  if (!pending || !ctx.message?.text) return false;
+  if (pending.step !== "workspace_input" && pending.step !== "workspace") return false;
+  const threadId = ctx.message.message_thread_id;
+  if (threadId && threadId !== assistantTopicId) return false;
+  let workspace = ctx.message.text.trim();
+  if (!workspace || !pending.agentName) {
+    await ctx.reply("\u26A0\uFE0F Please enter a valid directory path.", { parse_mode: "HTML" });
+    return true;
+  }
+  if (!workspace.startsWith("/") && !workspace.startsWith("~")) {
+    const baseDir = core.configManager.get().workspace.baseDir;
+    workspace = `${baseDir.replace(/\/$/, "")}/${workspace}`;
+  }
+  await startConfirmStep(ctx, chatId, userId, pending.agentName, workspace);
+  return true;
+}
+async function startInteractiveNewSession(ctx, core, chatId, agentName) {
+  const userId = ctx.from?.id;
+  if (!userId) return;
+  const agents = core.agentManager.getAvailableAgents();
+  const config = core.configManager.get();
+  if (agentName || agents.length === 1) {
+    const selectedAgent = agentName || config.defaultAgent;
+    await startWorkspaceStep(ctx, core, chatId, userId, selectedAgent);
+    return;
+  }
+  const keyboard = new InlineKeyboard2();
+  for (const agent of agents) {
+    const label = agent.name === config.defaultAgent ? `${agent.name} (default)` : agent.name;
+    keyboard.text(label, `m:new:agent:${agent.name}`).row();
+  }
+  keyboard.text("\u274C Cancel", "m:new:cancel");
+  const msg = await ctx.reply(
+    `\u{1F916} <b>Choose an agent:</b>`,
+    { parse_mode: "HTML", reply_markup: keyboard }
+  );
+  cleanupPending(userId);
+  pendingNewSessions.set(userId, {
+    step: "agent",
+    messageId: msg.message_id,
+    threadId: ctx.callbackQuery?.message?.message_thread_id,
+    timer: setTimeout(() => pendingNewSessions.delete(userId), PENDING_TIMEOUT_MS)
+  });
+}
+function setupNewSessionCallbacks(bot, core, chatId) {
+  bot.callbackQuery(/^m:new:/, async (ctx) => {
+    const data = ctx.callbackQuery.data;
+    try {
+      await ctx.answerCallbackQuery();
+    } catch {
+    }
+    if (data.startsWith("m:new:agent:")) {
+      const agentName = data.replace("m:new:agent:", "");
+      const userId = ctx.from?.id;
+      if (userId) await startWorkspaceStep(ctx, core, chatId, userId, agentName);
+      return;
+    }
+    if (data === "m:new:ws:default") {
+      const userId = ctx.from?.id;
+      if (!userId) return;
+      const pending = pendingNewSessions.get(userId);
+      if (!pending?.agentName) return;
+      const workspace = core.configManager.get().workspace.baseDir;
+      await startConfirmStep(ctx, chatId, userId, pending.agentName, workspace);
+      return;
+    }
+    if (data === "m:new:ws:custom") {
+      const userId = ctx.from?.id;
+      if (!userId) return;
+      const pending = pendingNewSessions.get(userId);
+      if (!pending?.agentName) return;
+      try {
+        await ctx.api.editMessageText(
+          chatId,
+          pending.messageId,
+          `\u270F\uFE0F <b>Enter your project path:</b>
+
+Full path like <code>~/code/my-project</code>
+Or just the folder name like <code>my-project</code> (will use ${core.configManager.get().workspace.baseDir}/)`,
+          { parse_mode: "HTML" }
+        );
+      } catch {
+        await ctx.reply(
+          `\u270F\uFE0F <b>Enter your project path:</b>`,
+          { parse_mode: "HTML" }
+        );
+      }
+      clearTimeout(pending.timer);
+      pending.step = "workspace_input";
+      pending.timer = setTimeout(() => pendingNewSessions.delete(userId), PENDING_TIMEOUT_MS);
+      return;
+    }
+    if (data === "m:new:confirm") {
+      const userId = ctx.from?.id;
+      if (!userId) return;
+      const pending = pendingNewSessions.get(userId);
+      if (!pending?.agentName || !pending?.workspace) return;
+      cleanupPending(userId);
+      const confirmMsgId = pending.messageId;
+      try {
+        await ctx.api.editMessageText(chatId, confirmMsgId, `\u23F3 Creating session...`, { parse_mode: "HTML" });
+      } catch {
+      }
+      const resultThreadId = await createSessionDirect(ctx, core, chatId, pending.agentName, pending.workspace);
+      try {
+        if (resultThreadId) {
+          const link = buildDeepLink(chatId, resultThreadId);
+          await ctx.api.editMessageText(chatId, confirmMsgId, `\u2705 Session created \u2192 <a href="${link}">Open topic</a>`, { parse_mode: "HTML" });
+        } else {
+          await ctx.api.editMessageText(chatId, confirmMsgId, `\u274C Session creation failed.`, { parse_mode: "HTML" });
+        }
+      } catch {
+      }
       return;
     }
-    agentName = record.agentName;
-    workspace = record.workingDir;
-  }
-  let newThreadId;
-  try {
-    const topicName = `\u{1F504} ${agentName} \u2014 New Chat`;
-    newThreadId = await createSessionTopic(
-      botFromCtx(ctx),
-      chatId,
-      topicName
-    );
-    const topicLink = buildDeepLink(chatId, newThreadId);
-    await ctx.reply(
-      `\u2705 New chat created \u2192 <a href="${topicLink}">Open topic</a>`,
-      { parse_mode: "HTML" }
-    );
-    await ctx.api.sendMessage(chatId, `\u23F3 Setting up session, please wait...`, {
-      message_thread_id: newThreadId,
-      parse_mode: "HTML"
-    });
-    const session = await core.handleNewSession(
-      "telegram",
-      agentName,
-      workspace
-    );
-    session.threadId = String(newThreadId);
-    await core.sessionManager.updateSessionPlatform(session.id, {
-      topicId: newThreadId
-    });
-    await ctx.api.sendMessage(
-      chatId,
-      `\u2705 New chat (same agent &amp; workspace)
-<b>Agent:</b> ${escapeHtml(session.agentName)}
-<b>Workspace:</b> <code>${escapeHtml(session.workingDirectory)}</code>`,
-      {
-        message_thread_id: newThreadId,
-        parse_mode: "HTML",
-        reply_markup: buildDangerousModeKeyboard(session.id, false)
-      }
-    );
-    session.warmup().catch((err) => log8.error({ err }, "Warm-up error"));
-  } catch (err) {
-    if (newThreadId) {
+    if (data === "m:new:cancel") {
+      const userId = ctx.from?.id;
+      if (userId) cleanupPending(userId);
       try {
-        await ctx.api.deleteForumTopic(chatId, newThreadId);
+        await ctx.editMessageText("\u274C Session creation cancelled.", { parse_mode: "HTML" });
       } catch {
       }
+      return;
     }
-    const message = err instanceof Error ? err.message : String(err);
-    await ctx.reply(`\u274C ${escapeHtml(message)}`, { parse_mode: "HTML" });
-  }
+  });
 }
+
+// src/adapters/telegram/commands/session.ts
+import { InlineKeyboard as InlineKeyboard3 } from "grammy";
+var log10 = createChildLogger({ module: "telegram-cmd-session" });
 async function handleCancel(ctx, core, assistant) {
   const threadId = ctx.message?.message_thread_id;
   if (!threadId) return;
@@ -3031,14 +3265,14 @@ async function handleCancel(ctx, core, assistant) {
     String(threadId)
   );
   if (session) {
-    log8.info({ sessionId: session.id }, "Cancel session command");
+    log10.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") {
-    log8.info({ sessionId: record.sessionId }, "Cancel session command (from store)");
+    log10.info({ sessionId: record.sessionId }, "Cancel session command (from store)");
     await core.sessionManager.cancelSession(record.sessionId);
     await ctx.reply("\u26D4 Session cancelled.", { parse_mode: "HTML" });
   }
@@ -3124,8 +3358,7 @@ async function handleTopics(ctx, core) {
 <i>...and ${records.length - MAX_DISPLAY} more</i>` : "";
     const finishedCount = records.filter((r) => r.status === "finished").length;
     const errorCount = records.filter((r) => r.status === "error" || r.status === "cancelled").length;
-    const activeCount = records.filter((r) => r.status === "active" || r.status === "initializing").length;
-    const keyboard = new InlineKeyboard();
+    const keyboard = new InlineKeyboard3();
     if (finishedCount > 0) {
       keyboard.text(`Cleanup finished (${finishedCount})`, "m:cleanup:finished").row();
     }
@@ -3144,7 +3377,7 @@ ${lines.join("\n")}${truncated}`,
       { parse_mode: "HTML", reply_markup: keyboard }
     );
   } catch (err) {
-    log8.error({ err }, "handleTopics error");
+    log10.error({ err }, "handleTopics error");
     await ctx.reply("\u274C Failed to list sessions.", { parse_mode: "HTML" }).catch(() => {
     });
   }
@@ -3168,13 +3401,13 @@ async function handleCleanup(ctx, core, chatId, statuses) {
         try {
           await ctx.api.deleteForumTopic(chatId, topicId);
         } catch (err) {
-          log8.warn({ err, sessionId: record.sessionId, topicId }, "Failed to delete forum topic during cleanup");
+          log10.warn({ err, sessionId: record.sessionId, topicId }, "Failed to delete forum topic during cleanup");
         }
       }
       await core.sessionManager.removeRecord(record.sessionId);
       deleted++;
     } catch (err) {
-      log8.error({ err, sessionId: record.sessionId }, "Failed to cleanup session");
+      log10.error({ err, sessionId: record.sessionId }, "Failed to cleanup session");
       failed++;
     }
   }
@@ -3211,7 +3444,7 @@ async function handleCleanupEverything(ctx, core, chatId, systemTopicIds) {
   const activeWarning = activeCount > 0 ? `
 
 \u26A0\uFE0F <b>${activeCount} active session(s) will be cancelled and their agents stopped!</b>` : "";
-  const keyboard = new InlineKeyboard().text("Yes, delete all", "m:cleanup:everything:confirm").text("Cancel", "m:topics");
+  const keyboard = new InlineKeyboard3().text("Yes, delete all", "m:cleanup:everything:confirm").text("Cancel", "m:topics");
   await ctx.reply(
     `<b>Delete ${cleanable.length} topics?</b>
 
@@ -3247,7 +3480,7 @@ async function handleCleanupEverythingConfirmed(ctx, core, chatId, systemTopicId
         try {
           await core.sessionManager.cancelSession(record.sessionId);
         } catch (err) {
-          log8.warn({ err, sessionId: record.sessionId }, "Failed to cancel session during cleanup");
+          log10.warn({ err, sessionId: record.sessionId }, "Failed to cancel session during cleanup");
         }
       }
       const topicId = record.platform?.topicId;
@@ -3255,13 +3488,13 @@ async function handleCleanupEverythingConfirmed(ctx, core, chatId, systemTopicId
         try {
           await ctx.api.deleteForumTopic(chatId, topicId);
         } catch (err) {
-          log8.warn({ err, sessionId: record.sessionId, topicId }, "Failed to delete forum topic during cleanup");
+          log10.warn({ err, sessionId: record.sessionId, topicId }, "Failed to delete forum topic during cleanup");
         }
       }
       await core.sessionManager.removeRecord(record.sessionId);
       deleted++;
     } catch (err) {
-      log8.error({ err, sessionId: record.sessionId }, "Failed to cleanup session");
+      log10.error({ err, sessionId: record.sessionId }, "Failed to cleanup session");
       failed++;
     }
   }
@@ -3270,238 +3503,115 @@ async function handleCleanupEverythingConfirmed(ctx, core, chatId, systemTopicId
     { parse_mode: "HTML" }
   );
 }
-async function handleAgents(ctx, core) {
-  const agents = core.agentManager.getAvailableAgents();
-  const defaultAgent = core.configManager.get().defaultAgent;
-  const lines = agents.map(
-    (a) => `\u2022 <b>${escapeHtml(a.name)}</b>${a.name === defaultAgent ? " (default)" : ""}
-  <code>${escapeHtml(a.command)} ${a.args.map((arg) => escapeHtml(arg)).join(" ")}</code>`
-  );
-  const text = lines.length > 0 ? `<b>Available Agents:</b>
-
-${lines.join("\n")}` : `<b>Available Agents:</b>
-
-No agents configured.`;
-  await ctx.reply(text, { parse_mode: "HTML" });
-}
-async function handleHelp(ctx) {
-  await ctx.reply(
-    `\u{1F4D6} <b>OpenACP Help</b>
-
-\u{1F680} <b>Getting Started</b>
-Tap \u{1F195} New Session to start coding with AI.
-Each session gets its own topic \u2014 chat there to work with the agent.
-
-\u{1F4A1} <b>Common Tasks</b>
-/new [agent] [workspace] \u2014 Create new session
-/cancel \u2014 Cancel session (in session topic)
-/status \u2014 Show session or system status
-/sessions \u2014 List all sessions
-/agents \u2014 List available agents
-
-\u2699\uFE0F <b>System</b>
-/restart \u2014 Restart OpenACP
-/update \u2014 Update to latest version
-/integrate \u2014 Manage agent integrations
-/menu \u2014 Show action menu
-
-\u{1F512} <b>Session Options</b>
-/enable_dangerous \u2014 Auto-approve permissions
-/disable_dangerous \u2014 Restore permission prompts
-/handoff \u2014 Continue session in terminal
-/clear \u2014 Clear assistant history
-
-\u{1F4AC} Need help? Just ask me in this topic!`,
-    { parse_mode: "HTML" }
-  );
-}
-async function handleClear(ctx, assistant) {
-  if (!assistant) {
-    await ctx.reply("\u26A0\uFE0F Assistant is not available.", { parse_mode: "HTML" });
-    return;
-  }
-  const threadId = ctx.message?.message_thread_id;
-  if (threadId !== assistant.topicId) {
-    await ctx.reply("\u2139\uFE0F /clear only works in the Assistant topic.", { parse_mode: "HTML" });
-    return;
-  }
-  await ctx.reply("\u{1F504} Clearing assistant history...", { parse_mode: "HTML" });
-  try {
-    await assistant.respawn();
-    await ctx.reply("\u2705 Assistant history cleared.", { parse_mode: "HTML" });
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    await ctx.reply(`\u274C Failed to clear: <code>${message}</code>`, { parse_mode: "HTML" });
-  }
-}
-function buildDangerousModeKeyboard(sessionId, enabled) {
-  return new InlineKeyboard().text(
-    enabled ? "\u{1F510} Disable Dangerous Mode" : "\u2620\uFE0F Enable Dangerous Mode",
-    `d:${sessionId}`
-  );
+async function executeCancelSession(core, excludeSessionId) {
+  const sessions = core.sessionManager.listSessions("telegram").filter((s) => s.status === "active" && s.id !== excludeSessionId).sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
+  const session = sessions[0];
+  if (!session) return null;
+  await session.cancel();
+  return session;
 }
-function setupDangerousModeCallbacks(bot, core) {
-  bot.callbackQuery(/^d:/, async (ctx) => {
-    const sessionId = ctx.callbackQuery.data.slice(2);
-    const session = core.sessionManager.getSession(sessionId);
-    if (session) {
-      session.dangerousMode = !session.dangerousMode;
-      log8.info({ sessionId, dangerousMode: session.dangerousMode }, "Dangerous mode toggled via button");
-      core.sessionManager.updateSessionDangerousMode(sessionId, session.dangerousMode).catch(() => {
-      });
-      const toastText2 = 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: toastText2 });
-      } catch {
-      }
-      try {
-        await ctx.editMessageReplyMarkup({
-          reply_markup: buildDangerousModeKeyboard(sessionId, session.dangerousMode)
-        });
-      } catch {
-      }
-      return;
-    }
-    const record = core.sessionManager.getSessionRecord(sessionId);
-    if (!record || record.status === "cancelled" || record.status === "error") {
-      try {
-        await ctx.answerCallbackQuery({ text: "\u26A0\uFE0F Session not found or already ended." });
-      } catch {
-      }
-      return;
-    }
-    const newDangerousMode = !(record.dangerousMode ?? false);
-    core.sessionManager.updateSessionDangerousMode(sessionId, newDangerousMode).catch(() => {
-    });
-    log8.info({ sessionId, dangerousMode: newDangerousMode }, "Dangerous mode toggled via button (store-only, session not in memory)");
-    const toastText = newDangerousMode ? "\u2620\uFE0F Dangerous mode enabled \u2014 permissions auto-approved" : "\u{1F510} Dangerous mode disabled \u2014 permissions shown normally";
+function setupSessionCallbacks(bot, core, chatId, systemTopicIds) {
+  bot.callbackQuery(/^m:cleanup/, async (ctx) => {
+    const data = ctx.callbackQuery.data;
     try {
-      await ctx.answerCallbackQuery({ text: toastText });
+      await ctx.answerCallbackQuery();
     } catch {
     }
-    try {
-      await ctx.editMessageReplyMarkup({
-        reply_markup: buildDangerousModeKeyboard(sessionId, newDangerousMode)
-      });
-    } catch {
+    switch (data) {
+      case "m:cleanup:finished":
+        await handleCleanup(ctx, core, chatId, ["finished"]);
+        break;
+      case "m:cleanup:errors":
+        await handleCleanup(ctx, core, chatId, ["error", "cancelled"]);
+        break;
+      case "m:cleanup:all":
+        await handleCleanup(ctx, core, chatId, ["finished", "error", "cancelled"]);
+        break;
+      case "m:cleanup:everything":
+        await handleCleanupEverything(ctx, core, chatId, systemTopicIds);
+        break;
+      case "m:cleanup:everything:confirm":
+        await handleCleanupEverythingConfirmed(ctx, core, chatId, systemTopicIds);
+        break;
     }
   });
 }
-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) {
-    if (session.dangerousMode) {
-      await ctx.reply("\u2620\uFE0F Dangerous mode is already enabled.", { parse_mode: "HTML" });
-      return;
-    }
-    session.dangerousMode = true;
-    core.sessionManager.updateSessionDangerousMode(session.id, true).catch(() => {
-    });
-  } else {
-    const record = core.sessionManager.getRecordByThread("telegram", String(threadId));
-    if (!record || record.status === "cancelled" || record.status === "error") {
-      await ctx.reply("\u26A0\uFE0F No active session in this topic.", { parse_mode: "HTML" });
-      return;
-    }
-    if (record.dangerousMode) {
-      await ctx.reply("\u2620\uFE0F Dangerous mode is already enabled.", { parse_mode: "HTML" });
-      return;
-    }
-    core.sessionManager.updateSessionDangerousMode(record.sessionId, true).catch(() => {
-    });
-  }
-  await ctx.reply(
-    `\u26A0\uFE0F <b>Dangerous mode enabled</b>
 
-All permission requests will be auto-approved. Claude can run arbitrary commands without asking.
+// src/adapters/telegram/commands/menu.ts
+import { InlineKeyboard as InlineKeyboard4 } from "grammy";
+function buildMenuKeyboard() {
+  return new InlineKeyboard4().text("\u{1F195} New Session", "m:new").text("\u{1F4CB} Sessions", "m:topics").row().text("\u{1F4CA} Status", "m:status").text("\u{1F916} Agents", "m:agents").row().text("\u{1F517} Integrate", "m:integrate").text("\u2753 Help", "m:help").row().text("\u{1F504} Restart", "m:restart").text("\u2B06\uFE0F Update", "m:update");
+}
+async function handleMenu(ctx) {
+  await ctx.reply(`<b>OpenACP Menu</b>
+Choose an action:`, {
+    parse_mode: "HTML",
+    reply_markup: buildMenuKeyboard()
+  });
+}
+async function handleAgents(ctx, core) {
+  const agents = core.agentManager.getAvailableAgents();
+  const defaultAgent = core.configManager.get().defaultAgent;
+  const lines = agents.map(
+    (a) => `\u2022 <b>${escapeHtml(a.name)}</b>${a.name === defaultAgent ? " (default)" : ""}
+  <code>${escapeHtml(a.command)} ${a.args.map((arg) => escapeHtml(arg)).join(" ")}</code>`
+  );
+  const text = lines.length > 0 ? `<b>Available Agents:</b>
+
+${lines.join("\n")}` : `<b>Available Agents:</b>
 
-Use /disable_dangerous to restore normal behaviour.`,
-    { parse_mode: "HTML" }
-  );
+No agents configured.`;
+  await ctx.reply(text, { parse_mode: "HTML" });
 }
-async function handleUpdate(ctx, core) {
-  if (!core.requestRestart) {
-    await ctx.reply("\u26A0\uFE0F Update is not available (no restart handler registered).", { parse_mode: "HTML" });
-    return;
-  }
-  const { getCurrentVersion, getLatestVersion, compareVersions, runUpdate } = await import("./version-VC5CPXBX.js");
-  const current = getCurrentVersion();
-  const statusMsg = await ctx.reply(`\u{1F50D} Checking for updates... (current: v${escapeHtml(current)})`, { parse_mode: "HTML" });
-  const latest = await getLatestVersion();
-  if (!latest) {
-    await ctx.api.editMessageText(ctx.chat.id, statusMsg.message_id, "\u274C Could not check for updates.", { parse_mode: "HTML" });
-    return;
-  }
-  if (compareVersions(current, latest) >= 0) {
-    await ctx.api.editMessageText(ctx.chat.id, statusMsg.message_id, `\u2705 Already up to date (v${escapeHtml(current)}).`, { parse_mode: "HTML" });
-    return;
-  }
-  await ctx.api.editMessageText(
-    ctx.chat.id,
-    statusMsg.message_id,
-    `\u2B07\uFE0F Updating v${escapeHtml(current)} \u2192 v${escapeHtml(latest)}...`,
-    { parse_mode: "HTML" }
-  );
-  const ok = await runUpdate();
-  if (!ok) {
-    await ctx.api.editMessageText(ctx.chat.id, statusMsg.message_id, "\u274C Update failed. Try manually: <code>npm install -g @openacp/cli@latest</code>", { parse_mode: "HTML" });
-    return;
-  }
-  await ctx.api.editMessageText(
-    ctx.chat.id,
-    statusMsg.message_id,
-    `\u2705 Updated to v${escapeHtml(latest)}. Restarting...`,
+async function handleHelp(ctx) {
+  await ctx.reply(
+    `\u{1F4D6} <b>OpenACP Help</b>
+
+\u{1F680} <b>Getting Started</b>
+Tap \u{1F195} New Session to start coding with AI.
+Each session gets its own topic \u2014 chat there to work with the agent.
+
+\u{1F4A1} <b>Common Tasks</b>
+/new [agent] [workspace] \u2014 Create new session
+/cancel \u2014 Cancel session (in session topic)
+/status \u2014 Show session or system status
+/sessions \u2014 List all sessions
+/agents \u2014 List available agents
+
+\u2699\uFE0F <b>System</b>
+/restart \u2014 Restart OpenACP
+/update \u2014 Update to latest version
+/integrate \u2014 Manage agent integrations
+/menu \u2014 Show action menu
+
+\u{1F512} <b>Session Options</b>
+/enable_dangerous \u2014 Auto-approve permissions
+/disable_dangerous \u2014 Restore permission prompts
+/handoff \u2014 Continue session in terminal
+/clear \u2014 Clear assistant history
+
+\u{1F4AC} Need help? Just ask me in this topic!`,
     { parse_mode: "HTML" }
   );
-  await new Promise((r) => setTimeout(r, 500));
-  await core.requestRestart();
 }
-async function handleRestart(ctx, core) {
-  if (!core.requestRestart) {
-    await ctx.reply("\u26A0\uFE0F Restart is not available (no restart handler registered).", { parse_mode: "HTML" });
+async function handleClear(ctx, assistant) {
+  if (!assistant) {
+    await ctx.reply("\u26A0\uFE0F Assistant is not available.", { parse_mode: "HTML" });
     return;
   }
-  await ctx.reply("\u{1F504} <b>Restarting OpenACP...</b>\nRebuilding and restarting. Be back shortly.", { parse_mode: "HTML" });
-  await new Promise((r) => setTimeout(r, 500));
-  await core.requestRestart();
-}
-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" });
+  if (threadId !== assistant.topicId) {
+    await ctx.reply("\u2139\uFE0F /clear only works in the Assistant topic.", { parse_mode: "HTML" });
     return;
   }
-  const session = core.sessionManager.getSessionByThread("telegram", String(threadId));
-  if (session) {
-    if (!session.dangerousMode) {
-      await ctx.reply("\u{1F510} Dangerous mode is already disabled.", { parse_mode: "HTML" });
-      return;
-    }
-    session.dangerousMode = false;
-    core.sessionManager.updateSessionDangerousMode(session.id, false).catch(() => {
-    });
-  } else {
-    const record = core.sessionManager.getRecordByThread("telegram", String(threadId));
-    if (!record || record.status === "cancelled" || record.status === "error") {
-      await ctx.reply("\u26A0\uFE0F No active session in this topic.", { parse_mode: "HTML" });
-      return;
-    }
-    if (!record.dangerousMode) {
-      await ctx.reply("\u{1F510} Dangerous mode is already disabled.", { parse_mode: "HTML" });
-      return;
-    }
-    core.sessionManager.updateSessionDangerousMode(record.sessionId, false).catch(() => {
-    });
+  await ctx.reply("\u{1F504} Clearing assistant history...", { parse_mode: "HTML" });
+  try {
+    await assistant.respawn();
+    await ctx.reply("\u2705 Assistant history cleared.", { parse_mode: "HTML" });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    await ctx.reply(`\u274C Failed to clear: <code>${message}</code>`, { parse_mode: "HTML" });
   }
-  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 };
 }
 var TELEGRAM_MSG_LIMIT = 4096;
 function buildSkillMessages(commands) {
@@ -3522,46 +3632,13 @@ function buildSkillMessages(commands) {
   if (current) messages.push(current);
   return messages;
 }
-async function executeNewSession(bot, core, chatId, agentName, workspace) {
-  const threadId = await createSessionTopic(bot, chatId, "\u{1F504} New Session");
-  const setupMsg = await bot.api.sendMessage(chatId, "\u23F3 Setting up session, please wait...", {
-    message_thread_id: threadId,
-    parse_mode: "HTML"
-  });
-  const firstMsgId = setupMsg.message_id;
-  try {
-    const session = await core.handleNewSession(
-      "telegram",
-      agentName,
-      workspace
-    );
-    session.threadId = String(threadId);
-    await core.sessionManager.updateSessionPlatform(session.id, {
-      topicId: threadId
-    });
-    const finalName = `\u{1F504} ${session.agentName} \u2014 New Session`;
-    await renameSessionTopic(bot, chatId, threadId, finalName);
-    session.warmup().catch((err) => log8.error({ err }, "Warm-up error"));
-    return { session, threadId, firstMsgId };
-  } catch (err) {
-    try {
-      await bot.api.deleteForumTopic(chatId, threadId);
-    } catch {
-    }
-    throw err;
-  }
-}
-async function executeCancelSession(core, excludeSessionId) {
-  const sessions = core.sessionManager.listSessions("telegram").filter((s) => s.status === "active" && s.id !== excludeSessionId).sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
-  const session = sessions[0];
-  if (!session) return null;
-  await session.cancel();
-  return session;
-}
+
+// src/adapters/telegram/commands/integrate.ts
+import { InlineKeyboard as InlineKeyboard5 } from "grammy";
 async function handleIntegrate(ctx, _core) {
   const { listIntegrations } = await import("./integrate-WUPLRJD3.js");
   const agents = listIntegrations();
-  const keyboard = new InlineKeyboard();
+  const keyboard = new InlineKeyboard5();
   for (const agent of agents) {
     keyboard.text(`\u{1F916} ${agent}`, `i:agent:${agent}`).row();
   }
@@ -3573,7 +3650,7 @@ Select an agent to manage its integrations.`,
   );
 }
 function buildAgentItemsKeyboard(agentName, items) {
-  const keyboard = new InlineKeyboard();
+  const keyboard = new InlineKeyboard5();
   for (const item of items) {
     const installed = item.isInstalled();
     keyboard.text(
@@ -3594,7 +3671,7 @@ function setupIntegrateCallbacks(bot, core) {
     if (data === "i:back") {
       const { listIntegrations } = await import("./integrate-WUPLRJD3.js");
       const agents = listIntegrations();
-      const keyboard2 = new InlineKeyboard();
+      const keyboard2 = new InlineKeyboard5();
       for (const agent of agents) {
         keyboard2.text(`\u{1F916} ${agent}`, `i:agent:${agent}`).row();
       }
@@ -3673,51 +3750,59 @@ ${resultText}`,
     }
   });
 }
-async function handlePendingWorkspaceInput(ctx, core, chatId, assistantTopicId) {
-  const userId = ctx.from?.id;
-  if (!userId) return false;
-  const pending = pendingNewSessions.get(userId);
-  if (!pending || !ctx.message?.text) return false;
-  if (pending.step !== "workspace_input" && pending.step !== "workspace") return false;
-  const threadId = ctx.message.message_thread_id;
-  if (threadId && threadId !== assistantTopicId) return false;
-  let workspace = ctx.message.text.trim();
-  if (!workspace || !pending.agentName) {
-    await ctx.reply("\u26A0\uFE0F Please enter a valid directory path.", { parse_mode: "HTML" });
-    return true;
-  }
-  if (!workspace.startsWith("/") && !workspace.startsWith("~")) {
-    const baseDir = core.configManager.get().workspace.baseDir;
-    workspace = `${baseDir.replace(/\/$/, "")}/${workspace}`;
-  }
-  await startConfirmStep(ctx, chatId, userId, pending.agentName, workspace);
-  return true;
+
+// src/adapters/telegram/commands/index.ts
+function setupCommands(bot, core, chatId, assistant) {
+  bot.command("new", (ctx) => handleNew(ctx, core, chatId, assistant));
+  bot.command("newchat", (ctx) => handleNewChat(ctx, core, chatId));
+  bot.command("cancel", (ctx) => handleCancel(ctx, core, assistant));
+  bot.command("status", (ctx) => handleStatus(ctx, core));
+  bot.command("sessions", (ctx) => handleTopics(ctx, core));
+  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));
+  bot.command("restart", (ctx) => handleRestart(ctx, core));
+  bot.command("update", (ctx) => handleUpdate(ctx, core));
+  bot.command("integrate", (ctx) => handleIntegrate(ctx, core));
+  bot.command("clear", (ctx) => handleClear(ctx, assistant));
 }
-async function startInteractiveNewSession(ctx, core, chatId, agentName) {
-  const userId = ctx.from?.id;
-  if (!userId) return;
-  const agents = core.agentManager.getAvailableAgents();
-  const config = core.configManager.get();
-  if (agentName || agents.length === 1) {
-    const selectedAgent = agentName || config.defaultAgent;
-    await startWorkspaceStep(ctx, core, chatId, userId, selectedAgent);
-    return;
-  }
-  const keyboard = new InlineKeyboard();
-  for (const agent of agents) {
-    const label = agent.name === config.defaultAgent ? `${agent.name} (default)` : agent.name;
-    keyboard.text(label, `m:new:agent:${agent.name}`).row();
-  }
-  const msg = await ctx.reply(
-    `\u{1F916} <b>Choose an agent:</b>`,
-    { parse_mode: "HTML", reply_markup: keyboard }
-  );
-  cleanupPending(userId);
-  pendingNewSessions.set(userId, {
-    step: "agent",
-    messageId: msg.message_id,
-    threadId: ctx.callbackQuery?.message?.message_thread_id,
-    timer: setTimeout(() => pendingNewSessions.delete(userId), PENDING_TIMEOUT_MS)
+function setupAllCallbacks(bot, core, chatId, systemTopicIds) {
+  setupNewSessionCallbacks(bot, core, chatId);
+  setupSessionCallbacks(bot, core, chatId, systemTopicIds);
+  bot.callbackQuery(/^m:/, async (ctx) => {
+    const data = ctx.callbackQuery.data;
+    try {
+      await ctx.answerCallbackQuery();
+    } catch {
+    }
+    switch (data) {
+      case "m:new":
+        await handleNew(ctx, core, chatId);
+        break;
+      case "m:status":
+        await handleStatus(ctx, core);
+        break;
+      case "m:agents":
+        await handleAgents(ctx, core);
+        break;
+      case "m:help":
+        await handleHelp(ctx);
+        break;
+      case "m:restart":
+        await handleRestart(ctx, core);
+        break;
+      case "m:update":
+        await handleUpdate(ctx, core);
+        break;
+      case "m:integrate":
+        await handleIntegrate(ctx, core);
+        break;
+      case "m:topics":
+        await handleTopics(ctx, core);
+        break;
+    }
   });
 }
 var STATIC_COMMANDS = [
@@ -3739,9 +3824,9 @@ var STATIC_COMMANDS = [
 ];
 
 // src/adapters/telegram/permissions.ts
-import { InlineKeyboard as InlineKeyboard2 } from "grammy";
+import { InlineKeyboard as InlineKeyboard6 } from "grammy";
 import { nanoid as nanoid2 } from "nanoid";
-var log9 = createChildLogger({ module: "telegram-permissions" });
+var log11 = createChildLogger({ module: "telegram-permissions" });
 var PermissionHandler = class {
   constructor(bot, chatId, getSession, sendNotification) {
     this.bot = bot;
@@ -3758,7 +3843,7 @@ var PermissionHandler = class {
       requestId: request.id,
       options: request.options.map((o) => ({ id: o.id, isAllow: o.isAllow }))
     });
-    const keyboard = new InlineKeyboard2();
+    const keyboard = new InlineKeyboard6();
     for (const option of request.options) {
       const emoji = option.isAllow ? "\u2705" : "\u274C";
       keyboard.text(`${emoji} ${option.label}`, `p:${callbackKey}:${option.id}`);
@@ -3801,7 +3886,7 @@ ${escapeHtml(request.description)}`,
       }
       const session = this.getSession(pending.sessionId);
       const isAllow = pending.options.find((o) => o.id === optionId)?.isAllow ?? false;
-      log9.info({ requestId: pending.requestId, optionId, isAllow }, "Permission responded");
+      log11.info({ requestId: pending.requestId, optionId, isAllow }, "Permission responded");
       if (session?.permissionGate.requestId === pending.requestId) {
         session.permissionGate.resolve(optionId);
       }
@@ -4183,10 +4268,10 @@ Session logs auto-cleanup: 30 days (configurable via \`logging.sessionLogRetenti
 `;
 
 // src/adapters/telegram/assistant.ts
-var log10 = createChildLogger({ module: "telegram-assistant" });
+var log12 = createChildLogger({ module: "telegram-assistant" });
 async function spawnAssistant(core, adapter, assistantTopicId) {
   const config = core.configManager.get();
-  log10.info({ agent: config.defaultAgent }, "Creating assistant session...");
+  log12.info({ agent: config.defaultAgent }, "Creating assistant session...");
   const session = await core.sessionManager.createSession(
     "telegram",
     config.defaultAgent,
@@ -4195,7 +4280,7 @@ async function spawnAssistant(core, adapter, assistantTopicId) {
   );
   session.threadId = String(assistantTopicId);
   session.name = "Assistant";
-  log10.info({ sessionId: session.id }, "Assistant agent spawned");
+  log12.info({ sessionId: session.id }, "Assistant agent spawned");
   core.wireSessionEvents(session, adapter);
   const allRecords = core.sessionManager.listRecords();
   const activeCount = allRecords.filter((r) => r.status === "active" || r.status === "initializing").length;
@@ -4212,9 +4297,9 @@ async function spawnAssistant(core, adapter, assistantTopicId) {
   };
   const systemPrompt = buildAssistantSystemPrompt(ctx);
   const ready = session.enqueuePrompt(systemPrompt).then(() => {
-    log10.info({ sessionId: session.id }, "Assistant system prompt completed");
+    log12.info({ sessionId: session.id }, "Assistant system prompt completed");
   }).catch((err) => {
-    log10.warn({ err }, "Assistant system prompt failed");
+    log12.warn({ err }, "Assistant system prompt failed");
   });
   return { session, ready };
 }
@@ -4347,7 +4432,7 @@ function redirectToAssistant(chatId, assistantTopicId) {
 }
 
 // src/adapters/telegram/activity.ts
-var log11 = createChildLogger({ module: "telegram:activity" });
+var log13 = createChildLogger({ module: "telegram:activity" });
 var THINKING_REFRESH_MS = 15e3;
 var THINKING_MAX_MS = 3 * 60 * 1e3;
 var ThinkingIndicator = class {
@@ -4379,7 +4464,7 @@ var ThinkingIndicator = class {
         this.startRefreshTimer();
       }
     } catch (err) {
-      log11.warn({ err }, "ThinkingIndicator.show() failed");
+      log13.warn({ err }, "ThinkingIndicator.show() failed");
     } finally {
       this.sending = false;
     }
@@ -4452,7 +4537,7 @@ var UsageMessage = class {
         if (result) this.msgId = result.message_id;
       }
     } catch (err) {
-      log11.warn({ err }, "UsageMessage.send() failed");
+      log13.warn({ err }, "UsageMessage.send() failed");
     }
   }
   getMsgId() {
@@ -4465,7 +4550,7 @@ var UsageMessage = class {
     try {
       await this.sendQueue.enqueue(() => this.api.deleteMessage(this.chatId, id));
     } catch (err) {
-      log11.warn({ err }, "UsageMessage.delete() failed");
+      log13.warn({ err }, "UsageMessage.delete() failed");
     }
   }
 };
@@ -4551,7 +4636,7 @@ var PlanCard = class {
         if (result) this.msgId = result.message_id;
       }
     } catch (err) {
-      log11.warn({ err }, "PlanCard flush failed");
+      log13.warn({ err }, "PlanCard flush failed");
     }
   }
 };
@@ -4614,7 +4699,7 @@ var ActivityTracker = class {
           })
         );
       } catch (err) {
-        log11.warn({ err }, "ActivityTracker.onComplete() Done send failed");
+        log13.warn({ err }, "ActivityTracker.onComplete() Done send failed");
       }
     }
   }
@@ -4697,7 +4782,7 @@ var TelegramSendQueue = class {
 
 // src/adapters/telegram/action-detect.ts
 import { nanoid as nanoid3 } from "nanoid";
-import { InlineKeyboard as InlineKeyboard3 } from "grammy";
+import { InlineKeyboard as InlineKeyboard7 } 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 = /(?:create|new)\s+session/i;
@@ -4744,7 +4829,7 @@ function removeAction(id) {
   actionMap.delete(id);
 }
 function buildActionKeyboard(actionId, action) {
-  const keyboard = new InlineKeyboard3();
+  const keyboard = new InlineKeyboard7();
   if (action.action === "new_session") {
     keyboard.text("\u2705 Create session", `a:${actionId}`);
     keyboard.text("\u274C Cancel", `a:dismiss:${actionId}`);
@@ -4852,7 +4937,7 @@ function setupActionCallbacks(bot, core, chatId, getAssistantSessionId) {
 }
 
 // src/adapters/telegram/adapter.ts
-var log12 = createChildLogger({ module: "telegram" });
+var log14 = createChildLogger({ module: "telegram" });
 function patchedFetch(input, init) {
   if (init?.signal && !(init.signal instanceof AbortSignal)) {
     const nativeController = new AbortController();
@@ -4903,7 +4988,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;
-      log12.error({ err: rootCause }, "Telegram bot error");
+      log14.error({ err: rootCause }, "Telegram bot error");
     });
     this.bot.api.config.use(async (prev, method, payload, signal) => {
       const maxRetries = 3;
@@ -4917,7 +5002,7 @@ var TelegramAdapter = class extends ChannelAdapter {
         if (rateLimitedMethods.includes(method)) {
           this.sendQueue.onRateLimited();
         }
-        log12.warn(
+        log14.warn(
           { method, retryAfter, attempt: attempt + 1 },
           "Rate limited by Telegram, retrying"
         );
@@ -4969,7 +5054,7 @@ var TelegramAdapter = class extends ChannelAdapter {
       () => this.assistantSession?.id
     );
     setupIntegrateCallbacks(this.bot, this.core);
-    setupMenuCallbacks(
+    setupAllCallbacks(
       this.bot,
       this.core,
       this.telegramConfig.chatId,
@@ -5042,7 +5127,7 @@ var TelegramAdapter = class extends ChannelAdapter {
     this.setupRoutes();
     this.bot.start({
       allowed_updates: ["message", "callback_query"],
-      onStart: () => log12.info(
+      onStart: () => log14.info(
         { chatId: this.telegramConfig.chatId },
         "Telegram bot started"
       )
@@ -5064,10 +5149,10 @@ var TelegramAdapter = class extends ChannelAdapter {
         reply_markup: buildMenuKeyboard()
       });
     } catch (err) {
-      log12.warn({ err }, "Failed to send welcome message");
+      log14.warn({ err }, "Failed to send welcome message");
     }
     try {
-      log12.info("Spawning assistant session...");
+      log14.info("Spawning assistant session...");
       const { session, ready } = await spawnAssistant(
         this.core,
         this,
@@ -5075,13 +5160,13 @@ var TelegramAdapter = class extends ChannelAdapter {
       );
       this.assistantSession = session;
       this.assistantInitializing = true;
-      log12.info({ sessionId: session.id }, "Assistant session ready, system prompt running in background");
+      log14.info({ sessionId: session.id }, "Assistant session ready, system prompt running in background");
       ready.then(() => {
         this.assistantInitializing = false;
-        log12.info({ sessionId: session.id }, "Assistant ready for user messages");
+        log14.info({ sessionId: session.id }, "Assistant ready for user messages");
       });
     } catch (err) {
-      log12.error({ err }, "Failed to spawn assistant");
+      log14.error({ err }, "Failed to spawn assistant");
       this.bot.api.sendMessage(
         this.telegramConfig.chatId,
         `\u26A0\uFE0F <b>Failed to start assistant session.</b>
@@ -5097,7 +5182,7 @@ var TelegramAdapter = class extends ChannelAdapter {
       await this.assistantSession.destroy();
     }
     await this.bot.stop();
-    log12.info("Telegram bot stopped");
+    log14.info("Telegram bot stopped");
   }
   setupRoutes() {
     this.bot.on("message:text", async (ctx) => {
@@ -5123,7 +5208,7 @@ var TelegramAdapter = class extends ChannelAdapter {
         ctx.replyWithChatAction("typing").catch(() => {
         });
         handleAssistantMessage(this.assistantSession, ctx.message.text).catch(
-          (err) => log12.error({ err }, "Assistant error")
+          (err) => log14.error({ err }, "Assistant error")
         );
         return;
       }
@@ -5140,7 +5225,7 @@ var TelegramAdapter = class extends ChannelAdapter {
         threadId: String(threadId),
         userId: String(ctx.from.id),
         text: ctx.message.text
-      }).catch((err) => log12.error({ err }, "handleMessage error"));
+      }).catch((err) => log14.error({ err }, "handleMessage error"));
     });
   }
   // --- ChannelAdapter implementations ---
@@ -5152,7 +5237,7 @@ var TelegramAdapter = class extends ChannelAdapter {
     if (!session) return;
     const threadId = Number(session.threadId);
     if (!threadId || isNaN(threadId)) {
-      log12.warn({ sessionId, threadId: session.threadId }, "Session has no valid threadId, skipping message");
+      log14.warn({ sessionId, threadId: session.threadId }, "Session has no valid threadId, skipping message");
       return;
     }
     switch (content.type) {
@@ -5224,16 +5309,16 @@ var TelegramAdapter = class extends ChannelAdapter {
         if (toolState) {
           if (meta.viewerLinks) {
             toolState.viewerLinks = meta.viewerLinks;
-            log12.debug({ toolId: meta.id, viewerLinks: meta.viewerLinks }, "Accumulated viewerLinks");
+            log14.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;
+          if (!isTerminal) break;
           await toolState.ready;
-          log12.debug(
+          log14.debug(
             { toolId: meta.id, status: meta.status, hasViewerLinks: !!toolState.viewerLinks, viewerLinks: toolState.viewerLinks, name: toolState.name, msgId: toolState.msgId },
             "Tool completed, preparing edit"
           );
@@ -5255,7 +5340,7 @@ var TelegramAdapter = class extends ChannelAdapter {
               )
             );
           } catch (err) {
-            log12.warn(
+            log14.warn(
               { err, msgId: toolState.msgId, textLen: formattedText.length, hasViewerLinks: !!merged.viewerLinks },
               "Tool update edit failed"
             );
@@ -5350,7 +5435,7 @@ Task completed.
     }
   }
   async sendPermissionRequest(sessionId, request) {
-    log12.info({ sessionId, requestId: request.id }, "Permission request sent");
+    log14.info({ sessionId, requestId: request.id }, "Permission request sent");
     const session = this.core.sessionManager.getSession(
       sessionId
     );
@@ -5358,7 +5443,7 @@ Task completed.
     if (request.description.includes("openacp")) {
       const allowOption = request.options.find((o) => o.isAllow);
       if (allowOption && session.permissionGate.requestId === request.id) {
-        log12.info({ sessionId, requestId: request.id }, "Auto-approving openacp command");
+        log14.info({ sessionId, requestId: request.id }, "Auto-approving openacp command");
         session.permissionGate.resolve(allowOption.id);
       }
       return;
@@ -5366,7 +5451,7 @@ Task completed.
     if (session.dangerousMode) {
       const allowOption = request.options.find((o) => o.isAllow);
       if (allowOption && session.permissionGate.requestId === request.id) {
-        log12.info({ sessionId, requestId: request.id, optionId: allowOption.id }, "Dangerous mode: auto-approving permission");
+        log14.info({ sessionId, requestId: request.id, optionId: allowOption.id }, "Dangerous mode: auto-approving permission");
         session.permissionGate.resolve(allowOption.id);
       }
       return;
@@ -5377,7 +5462,7 @@ Task completed.
   }
   async sendNotification(notification) {
     if (notification.sessionId === this.assistantSession?.id) return;
-    log12.info(
+    log14.info(
       { sessionId: notification.sessionId, type: notification.type },
       "Notification sent"
     );
@@ -5413,7 +5498,7 @@ Task completed.
     );
   }
   async createSessionThread(sessionId, name) {
-    log12.info({ sessionId, name }, "Session topic created");
+    log14.info({ sessionId, name }, "Session topic created");
     return String(
       await createSessionTopic(this.bot, this.telegramConfig.chatId, name)
     );
@@ -5442,7 +5527,7 @@ Task completed.
     try {
       await this.bot.api.deleteForumTopic(this.telegramConfig.chatId, topicId);
     } catch (err) {
-      log12.warn({ err, sessionId, topicId }, "Failed to delete forum topic (may already be deleted)");
+      log14.warn({ err, sessionId, topicId }, "Failed to delete forum topic (may already be deleted)");
     }
   }
   async sendSkillCommands(sessionId, commands) {
@@ -5515,7 +5600,7 @@ Task completed.
         { disable_notification: true }
       );
     } catch (err) {
-      log12.error({ err, sessionId }, "Failed to send skill commands");
+      log14.error({ err, sessionId }, "Failed to send skill commands");
     }
   }
   async cleanupSkillCommands(sessionId) {
@@ -5586,4 +5671,4 @@ export {
   TopicManager,
   TelegramAdapter
 };
-//# sourceMappingURL=chunk-45DFYWJT.js.map
+//# sourceMappingURL=chunk-KPI4HGJC.js.map