@openacp/cli 0.4.6 → 0.4.8

package/README.md

@@ -109,24 +109,24 @@ Once OpenACP is running, control it from Telegram:
 
 Each session gets its own forum topic. The agent streams responses in real time, shows tool calls, and asks for permission when needed.
 
-### Session Handoff
+### Session Transfer
 
-Transfer sessions between Claude CLI and Telegram:
+Move sessions between your terminal and Telegram:
 
-**CLI → Telegram:**
+**Terminal → Telegram:**
 ```bash
-# Install Claude CLI integration (one-time)
+# Install integration (one-time)
 openacp integrate claude
 
-# In Claude CLI, type /openacp:handoff to transfer current session
+# In Claude CLI, type /openacp:handoff to transfer the current session
 # Or manually:
 openacp adopt claude <session_id> --cwd /path/to/project
 ```
 
-**Telegram → CLI:**
-Type `/handoff` in any session topic. The bot will reply with the `claude --resume` command to paste in your terminal.
+**Telegram → Terminal:**
+Type `/handoff` in any session topic. The bot replies with a command you can paste in your terminal to continue.
 
-Sessions are not locked after handoff — you can continue from either side.
+Sessions are not locked after transfer — you can continue from either side.
 
 ## Roadmap
 

package/dist/{chunk-IUPHAXGA.js → chunk-6MJLVZXV.js}

@@ -1,10 +1,10 @@
 import {
   validateBotToken,
   validateChatId
-} from "./chunk-ARWC4S35.js";
+} from "./chunk-UAUTLC4E.js";
 import {
   expandHome
-} from "./chunk-WF5XDN4D.js";
+} from "./chunk-ZRFBLD3W.js";
 import {
   installAutoStart,
   isAutoStartInstalled,
@@ -524,4 +524,4 @@ ${c.cyan}${c.bold}OpenACP Config Editor${c.reset}`);
 export {
   runConfigEditor
 };
-//# sourceMappingURL=chunk-IUPHAXGA.js.map
+//# sourceMappingURL=chunk-6MJLVZXV.js.map

package/dist/{chunk-2M4O7AFI.js → chunk-BBPWAWE3.js}

@@ -830,6 +830,7 @@ var SessionManager = class {
         createdAt: session.createdAt.toISOString(),
         lastActiveAt: (/* @__PURE__ */ new Date()).toISOString(),
         name: session.name,
+        dangerousMode: false,
         platform: {}
       });
     }
@@ -2016,7 +2017,7 @@ var ApiServer = class {
       return;
     }
     target[lastKey] = value;
-    const { ConfigSchema } = await import("./config-J5YQOMDU.js");
+    const { ConfigSchema } = await import("./config-H2DSEHNW.js");
     const result = ConfigSchema.safeParse(cloned);
     if (!result.success) {
       this.sendJson(res, 400, {
@@ -2418,7 +2419,7 @@ function formatUsage(usage) {
   return `${emoji} ${formatTokens(tokensUsed)} / ${formatTokens(contextSize)} tokens
 ${bar} ${pct}%`;
 }
-function splitMessage(text, maxLength = 4096) {
+function splitMessage(text, maxLength = 3800) {
   if (text.length <= maxLength) return [text];
   const chunks = [];
   let remaining = text;
@@ -2428,14 +2429,23 @@ function splitMessage(text, maxLength = 4096) {
       break;
     }
     let splitAt = remaining.lastIndexOf("\n\n", maxLength);
-    if (splitAt === -1 || splitAt < maxLength * 0.5) {
+    if (splitAt === -1 || splitAt < maxLength * 0.2) {
       splitAt = remaining.lastIndexOf("\n", maxLength);
     }
-    if (splitAt === -1 || splitAt < maxLength * 0.5) {
+    if (splitAt === -1 || splitAt < maxLength * 0.2) {
       splitAt = maxLength;
     }
+    const candidate = remaining.slice(0, splitAt);
+    const fences = candidate.match(/```/g);
+    if (fences && fences.length % 2 !== 0) {
+      const closingFence = remaining.indexOf("```", splitAt);
+      if (closingFence !== -1) {
+        const afterFence = remaining.indexOf("\n", closingFence + 3);
+        splitAt = afterFence !== -1 ? afterFence + 1 : closingFence + 3;
+      }
+    }
     chunks.push(remaining.slice(0, splitAt));
-    remaining = remaining.slice(splitAt).trimStart();
+    remaining = remaining.slice(splitAt).replace(/^\n+/, "");
   }
   return chunks;
 }
@@ -2472,14 +2482,22 @@ var MessageDraft = class {
   async flush() {
     if (!this.buffer) return;
     if (this.firstFlushPending) return;
-    const html = markdownToTelegramHtml(this.buffer);
-    const truncated = html.length > 4096 ? html.slice(0, 4090) + "\n..." : html;
-    if (!truncated) 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);
+    if (!html) return;
+    if (html.length > 4096) {
+      html = html.slice(0, 4090) + "\n\u2026";
+    }
     if (!this.messageId) {
       this.firstFlushPending = true;
       try {
         const result = await this.sendQueue.enqueue(
-          () => this.bot.api.sendMessage(this.chatId, truncated, {
+          () => this.bot.api.sendMessage(this.chatId, html, {
             message_thread_id: this.threadId,
             parse_mode: "HTML",
             disable_notification: true
@@ -2497,7 +2515,7 @@ var MessageDraft = class {
     } else {
       try {
         await this.sendQueue.enqueue(
-          () => this.bot.api.editMessageText(this.chatId, this.messageId, truncated, {
+          () => this.bot.api.editMessageText(this.chatId, this.messageId, html, {
             parse_mode: "HTML"
           }),
           { type: "text", key: this.sessionId }
@@ -2517,21 +2535,20 @@ var MessageDraft = class {
     if (this.messageId && this.buffer === this.lastSentBuffer) {
       return this.messageId;
     }
-    const html = markdownToTelegramHtml(this.buffer);
-    const chunks = splitMessage(html);
-    try {
-      for (let i = 0; i < chunks.length; i++) {
-        const chunk = chunks[i];
+    const mdChunks = splitMessage(this.buffer);
+    for (let i = 0; i < mdChunks.length; i++) {
+      const html = markdownToTelegramHtml(mdChunks[i]);
+      try {
         if (i === 0 && this.messageId) {
           await this.sendQueue.enqueue(
-            () => this.bot.api.editMessageText(this.chatId, this.messageId, chunk, {
+            () => this.bot.api.editMessageText(this.chatId, this.messageId, html, {
               parse_mode: "HTML"
             }),
             { type: "other" }
           );
         } else {
           const msg = await this.sendQueue.enqueue(
-            () => this.bot.api.sendMessage(this.chatId, chunk, {
+            () => this.bot.api.sendMessage(this.chatId, html, {
               message_thread_id: this.threadId,
               parse_mode: "HTML",
               disable_notification: true
@@ -2542,17 +2559,25 @@ var MessageDraft = class {
             this.messageId = msg.message_id;
           }
         }
-      }
-    } catch {
-      if (this.buffer !== this.lastSentBuffer) {
+      } catch {
         try {
-          await this.sendQueue.enqueue(
-            () => this.bot.api.sendMessage(this.chatId, this.buffer.slice(0, 4096), {
-              message_thread_id: this.threadId,
-              disable_notification: true
-            }),
-            { type: "other" }
-          );
+          if (i === 0 && this.messageId) {
+            await this.sendQueue.enqueue(
+              () => this.bot.api.editMessageText(this.chatId, this.messageId, mdChunks[i].slice(0, 4096)),
+              { type: "other" }
+            );
+          } else {
+            const msg = await this.sendQueue.enqueue(
+              () => this.bot.api.sendMessage(this.chatId, mdChunks[i].slice(0, 4096), {
+                message_thread_id: this.threadId,
+                disable_notification: true
+              }),
+              { type: "other" }
+            );
+            if (msg) {
+              this.messageId = msg.message_id;
+            }
+          }
         } catch {
         }
       }
@@ -2603,6 +2628,7 @@ function setupCommands(bot, 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));
@@ -2610,11 +2636,12 @@ function setupCommands(bot, core, chatId, assistant) {
   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));
 }
 function buildMenuKeyboard() {
-  return new InlineKeyboard().text("\u{1F195} New Session", "m:new").text("\u{1F4AC} New Chat", "m:newchat").row().text("\u26D4 Cancel", "m:cancel").text("\u{1F4CA} Status", "m:status").row().text("\u{1F916} Agents", "m:agents").text("\u2753 Help", "m:help").row().text("\u{1F504} Restart", "m:restart").text("\u2B06\uFE0F Update", "m:update");
+  return new InlineKeyboard().text("\u{1F195} New Session", "m:new").text("\u{1F4AC} New Chat", "m:newchat").row().text("\u26D4 Cancel", "m:cancel").text("\u{1F4CA} Status", "m:status").row().text("\u{1F4CB} Sessions", "m:topics").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");
 }
-function setupMenuCallbacks(bot, core, chatId) {
+function setupMenuCallbacks(bot, core, chatId, systemTopicIds) {
   bot.callbackQuery(/^m:/, async (ctx) => {
     const data = ctx.callbackQuery.data;
     try {
@@ -2646,6 +2673,27 @@ function setupMenuCallbacks(bot, core, chatId) {
       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;
     }
   });
 }
@@ -2870,6 +2918,188 @@ Total sessions: ${sessions.length}`,
     );
   }
 }
+async function handleTopics(ctx, core) {
+  try {
+    const allRecords = core.sessionManager.listRecords();
+    const records = allRecords.filter((r) => {
+      const platform = r.platform;
+      return !!platform?.topicId;
+    });
+    const headlessCount = allRecords.length - records.length;
+    if (records.length === 0) {
+      const extra = headlessCount > 0 ? ` (${headlessCount} headless hidden)` : "";
+      await ctx.reply(`No sessions with topics found.${extra}`, { parse_mode: "HTML" });
+      return;
+    }
+    const statusEmoji = {
+      active: "\u{1F7E2}",
+      initializing: "\u{1F7E1}",
+      finished: "\u2705",
+      error: "\u274C",
+      cancelled: "\u26D4"
+    };
+    const statusOrder = { active: 0, initializing: 1, error: 2, finished: 3, cancelled: 4 };
+    records.sort((a, b) => (statusOrder[a.status] ?? 5) - (statusOrder[b.status] ?? 5));
+    const MAX_DISPLAY = 30;
+    const displayed = records.slice(0, MAX_DISPLAY);
+    const lines = displayed.map((r) => {
+      const emoji = statusEmoji[r.status] || "\u26AA";
+      const name = r.name?.trim();
+      const label = name ? escapeHtml(name) : `<i>${escapeHtml(r.agentName)} session</i>`;
+      return `${emoji} ${label}  <code>[${r.status}]</code>`;
+    });
+    const header = `<b>Sessions: ${records.length}</b>` + (headlessCount > 0 ? ` (${headlessCount} headless hidden)` : "");
+    const truncated = records.length > MAX_DISPLAY ? `
+
+<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();
+    if (finishedCount > 0) {
+      keyboard.text(`Cleanup finished (${finishedCount})`, "m:cleanup:finished").row();
+    }
+    if (errorCount > 0) {
+      keyboard.text(`Cleanup errors (${errorCount})`, "m:cleanup:errors").row();
+    }
+    if (finishedCount + errorCount > 0) {
+      keyboard.text(`Cleanup all non-active (${finishedCount + errorCount})`, "m:cleanup:all").row();
+    }
+    keyboard.text(`\u26A0\uFE0F Cleanup ALL (${records.length})`, "m:cleanup:everything").row();
+    keyboard.text("Refresh", "m:topics");
+    await ctx.reply(
+      `${header}
+
+${lines.join("\n")}${truncated}`,
+      { parse_mode: "HTML", reply_markup: keyboard }
+    );
+  } catch (err) {
+    log8.error({ err }, "handleTopics error");
+    await ctx.reply("\u274C Failed to list sessions.", { parse_mode: "HTML" }).catch(() => {
+    });
+  }
+}
+async function handleCleanup(ctx, core, chatId, statuses) {
+  const allRecords = core.sessionManager.listRecords();
+  const cleanable = allRecords.filter((r) => {
+    const platform = r.platform;
+    return !!platform?.topicId && statuses.includes(r.status);
+  });
+  if (cleanable.length === 0) {
+    await ctx.reply("Nothing to clean up.", { parse_mode: "HTML" });
+    return;
+  }
+  let deleted = 0;
+  let failed = 0;
+  for (const record of cleanable) {
+    try {
+      const topicId = record.platform?.topicId;
+      if (topicId) {
+        try {
+          await ctx.api.deleteForumTopic(chatId, topicId);
+        } catch (err) {
+          log8.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");
+      failed++;
+    }
+  }
+  await ctx.reply(
+    `\u{1F5D1} Cleaned up <b>${deleted}</b> sessions${failed > 0 ? ` (${failed} failed)` : ""}.`,
+    { parse_mode: "HTML" }
+  );
+}
+async function handleCleanupEverything(ctx, core, chatId, systemTopicIds) {
+  const allRecords = core.sessionManager.listRecords();
+  const cleanable = allRecords.filter((r) => {
+    const platform = r.platform;
+    if (!platform?.topicId) return false;
+    if (systemTopicIds && (platform.topicId === systemTopicIds.notificationTopicId || platform.topicId === systemTopicIds.assistantTopicId)) return false;
+    return true;
+  });
+  if (cleanable.length === 0) {
+    await ctx.reply("Nothing to clean up.", { parse_mode: "HTML" });
+    return;
+  }
+  const statusCounts = /* @__PURE__ */ new Map();
+  for (const r of cleanable) {
+    statusCounts.set(r.status, (statusCounts.get(r.status) ?? 0) + 1);
+  }
+  const statusEmoji = {
+    active: "\u{1F7E2}",
+    initializing: "\u{1F7E1}",
+    finished: "\u2705",
+    error: "\u274C",
+    cancelled: "\u26D4"
+  };
+  const breakdown = Array.from(statusCounts.entries()).map(([status, count]) => `${statusEmoji[status] ?? "\u26AA"} ${status}: ${count}`).join("\n");
+  const activeCount = (statusCounts.get("active") ?? 0) + (statusCounts.get("initializing") ?? 0);
+  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");
+  await ctx.reply(
+    `<b>Delete ${cleanable.length} topics?</b>
+
+This will:
+\u2022 Delete all session topics from this group
+\u2022 Cancel any running agent sessions
+\u2022 Remove all session records
+
+<b>Breakdown:</b>
+${breakdown}${activeWarning}
+
+<i>Notifications and Assistant topics will NOT be deleted.</i>`,
+    { parse_mode: "HTML", reply_markup: keyboard }
+  );
+}
+async function handleCleanupEverythingConfirmed(ctx, core, chatId, systemTopicIds) {
+  const allRecords = core.sessionManager.listRecords();
+  const cleanable = allRecords.filter((r) => {
+    const platform = r.platform;
+    if (!platform?.topicId) return false;
+    if (systemTopicIds && (platform.topicId === systemTopicIds.notificationTopicId || platform.topicId === systemTopicIds.assistantTopicId)) return false;
+    return true;
+  });
+  if (cleanable.length === 0) {
+    await ctx.reply("Nothing to clean up.", { parse_mode: "HTML" });
+    return;
+  }
+  let deleted = 0;
+  let failed = 0;
+  for (const record of cleanable) {
+    try {
+      if (record.status === "active" || record.status === "initializing") {
+        try {
+          await core.sessionManager.cancelSession(record.sessionId);
+        } catch (err) {
+          log8.warn({ err, sessionId: record.sessionId }, "Failed to cancel session during cleanup");
+        }
+      }
+      const topicId = record.platform?.topicId;
+      if (topicId) {
+        try {
+          await ctx.api.deleteForumTopic(chatId, topicId);
+        } catch (err) {
+          log8.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");
+      failed++;
+    }
+  }
+  await ctx.reply(
+    `\u{1F5D1} Cleaned up <b>${deleted}</b> sessions${failed > 0 ? ` (${failed} failed)` : ""}.`,
+    { parse_mode: "HTML" }
+  );
+}
 async function handleAgents(ctx, core) {
   const agents = core.agentManager.getAvailableAgents();
   const defaultAgent = core.configManager.get().defaultAgent;
@@ -3126,16 +3356,134 @@ async function executeCancelSession(core, excludeSessionId) {
   await session.cancel();
   return session;
 }
+async function handleIntegrate(ctx, _core) {
+  const { listIntegrations } = await import("./integrate-WUPLRJD3.js");
+  const agents = listIntegrations();
+  const keyboard = new InlineKeyboard();
+  for (const agent of agents) {
+    keyboard.text(`\u{1F916} ${agent}`, `i:agent:${agent}`).row();
+  }
+  await ctx.reply(
+    `<b>\u{1F517} Integrations</b>
+
+Select an agent to manage its integrations.`,
+    { parse_mode: "HTML", reply_markup: keyboard }
+  );
+}
+function buildAgentItemsKeyboard(agentName, items) {
+  const keyboard = new InlineKeyboard();
+  for (const item of items) {
+    const installed = item.isInstalled();
+    keyboard.text(
+      installed ? `\u2705 ${item.name} \u2014 Uninstall` : `\u{1F4E6} ${item.name} \u2014 Install`,
+      installed ? `i:uninstall:${agentName}:${item.id}` : `i:install:${agentName}:${item.id}`
+    ).row();
+  }
+  keyboard.text("\u2190 Back", "i:back").row();
+  return keyboard;
+}
+function setupIntegrateCallbacks(bot, core) {
+  bot.callbackQuery(/^i:/, async (ctx) => {
+    const data = ctx.callbackQuery.data;
+    try {
+      await ctx.answerCallbackQuery();
+    } catch {
+    }
+    if (data === "i:back") {
+      const { listIntegrations } = await import("./integrate-WUPLRJD3.js");
+      const agents = listIntegrations();
+      const keyboard2 = new InlineKeyboard();
+      for (const agent of agents) {
+        keyboard2.text(`\u{1F916} ${agent}`, `i:agent:${agent}`).row();
+      }
+      try {
+        await ctx.editMessageText(
+          `<b>\u{1F517} Integrations</b>
+
+Select an agent to manage its integrations.`,
+          { parse_mode: "HTML", reply_markup: keyboard2 }
+        );
+      } catch {
+      }
+      return;
+    }
+    const agentMatch = data.match(/^i:agent:(.+)$/);
+    if (agentMatch) {
+      const agentName2 = agentMatch[1];
+      const { getIntegration: getIntegration2 } = await import("./integrate-WUPLRJD3.js");
+      const integration2 = getIntegration2(agentName2);
+      if (!integration2) {
+        await ctx.reply(`\u274C No integration available for '${escapeHtml(agentName2)}'.`, { parse_mode: "HTML" });
+        return;
+      }
+      const keyboard2 = buildAgentItemsKeyboard(agentName2, integration2.items);
+      try {
+        await ctx.editMessageText(
+          `<b>\u{1F517} ${escapeHtml(agentName2)} Integrations</b>
+
+${integration2.items.map((i) => `\u2022 <b>${escapeHtml(i.name)}</b> \u2014 ${escapeHtml(i.description)}`).join("\n")}`,
+          { parse_mode: "HTML", reply_markup: keyboard2 }
+        );
+      } catch {
+        await ctx.reply(
+          `<b>\u{1F517} ${escapeHtml(agentName2)} Integrations</b>`,
+          { parse_mode: "HTML", reply_markup: keyboard2 }
+        );
+      }
+      return;
+    }
+    const actionMatch = data.match(/^i:(install|uninstall):([^:]+):(.+)$/);
+    if (!actionMatch) return;
+    const action = actionMatch[1];
+    const agentName = actionMatch[2];
+    const itemId = actionMatch[3];
+    const { getIntegration } = await import("./integrate-WUPLRJD3.js");
+    const integration = getIntegration(agentName);
+    if (!integration) return;
+    const item = integration.items.find((i) => i.id === itemId);
+    if (!item) return;
+    const result = action === "install" ? await item.install() : await item.uninstall();
+    const installed = action === "install" && result.success;
+    await core.configManager.save({
+      integrations: {
+        [agentName]: {
+          installed,
+          installedAt: installed ? (/* @__PURE__ */ new Date()).toISOString() : void 0
+        }
+      }
+    });
+    const statusEmoji = result.success ? "\u2705" : "\u274C";
+    const actionLabel = action === "install" ? "installed" : "uninstalled";
+    const logsText = result.logs.map((l) => `<code>${escapeHtml(l)}</code>`).join("\n");
+    const resultText = `${statusEmoji} <b>${escapeHtml(item.name)}</b> ${actionLabel}.
+
+${logsText}`;
+    const keyboard = buildAgentItemsKeyboard(agentName, integration.items);
+    try {
+      await ctx.editMessageText(
+        `<b>\u{1F517} ${escapeHtml(agentName)} Integrations</b>
+
+${resultText}`,
+        { parse_mode: "HTML", reply_markup: keyboard }
+      );
+    } catch {
+      await ctx.reply(resultText, { parse_mode: "HTML" });
+    }
+  });
+}
 var STATIC_COMMANDS = [
   { command: "new", description: "Create new session" },
   { command: "newchat", description: "New chat, same agent & workspace" },
   { command: "cancel", description: "Cancel current session" },
   { command: "status", description: "Show status" },
+  { command: "sessions", description: "List all sessions" },
   { command: "agents", description: "List available agents" },
   { command: "help", description: "Help" },
   { 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)" },
+  { command: "integrate", description: "Manage agent integrations" },
+  { command: "handoff", description: "Continue this session in your terminal" },
   { command: "restart", description: "Restart OpenACP" },
   { command: "update", description: "Update to latest version and restart" }
 ];
@@ -3942,10 +4290,12 @@ var TelegramAdapter = class extends ChannelAdapter {
       this.telegramConfig.chatId,
       () => this.assistantSession?.id
     );
+    setupIntegrateCallbacks(this.bot, this.core);
     setupMenuCallbacks(
       this.bot,
       this.core,
-      this.telegramConfig.chatId
+      this.telegramConfig.chatId,
+      { notificationTopicId: this.notificationTopicId, assistantTopicId: this.assistantTopicId }
     );
     setupCommands(
       this.bot,
@@ -3967,24 +4317,26 @@ var TelegramAdapter = class extends ChannelAdapter {
         return;
       }
       const session = this.core.sessionManager.getSessionByThread("telegram", String(threadId));
-      if (!session) {
-        await ctx.reply("No active session in this topic.", {
+      const record = session ? void 0 : this.core.sessionManager.getRecordByThread("telegram", String(threadId));
+      const agentName = session?.agentName ?? record?.agentName;
+      const agentSessionId = session?.agentSessionId ?? record?.agentSessionId;
+      if (!agentName || !agentSessionId) {
+        await ctx.reply("No session found for this topic.", {
           message_thread_id: threadId
         });
         return;
       }
       const { getAgentCapabilities: getAgentCapabilities2 } = await import("./agent-registry-7HC6D4CH.js");
-      const caps = getAgentCapabilities2(session.agentName);
+      const caps = getAgentCapabilities2(agentName);
       if (!caps.supportsResume || !caps.resumeCommand) {
-        await ctx.reply("This agent does not support CLI handoff.", {
+        await ctx.reply("This agent does not support session transfer.", {
           message_thread_id: threadId
         });
         return;
       }
-      const agentSessionId = session.agentSessionId;
       const command = caps.resumeCommand(agentSessionId);
       await ctx.reply(
-        `Resume this session on CLI:
+        `Run this in your terminal to continue the session:
 
 <code>${command}</code>`,
         {
@@ -4006,10 +4358,13 @@ var TelegramAdapter = class extends ChannelAdapter {
       const agents = this.core.agentManager.getAvailableAgents();
       const agentList = agents.map((a) => `${escapeHtml(a.name)}${a.name === config.defaultAgent ? " (default)" : ""}`).join(", ");
       const workspace = escapeHtml(config.workspace.baseDir);
+      const allRecords = this.core.sessionManager.listRecords();
+      const activeCount = allRecords.filter((r) => r.status === "active" || r.status === "initializing").length;
       const welcomeText = `\u{1F44B} <b>OpenACP Assistant</b> is online.
 
 Available agents: ${agentList}
 Workspace: <code>${workspace}</code>
+Sessions: ${activeCount} active / ${allRecords.length} total
 
 <b>Select an action:</b>`;
       await this.bot.api.sendMessage(this.telegramConfig.chatId, welcomeText, {
@@ -4533,4 +4888,4 @@ export {
   TopicManager,
   TelegramAdapter
 };
-//# sourceMappingURL=chunk-2M4O7AFI.js.map
+//# sourceMappingURL=chunk-BBPWAWE3.js.map