@openacp/cli 0.5.2 → 0.6.0

package/dist/{chunk-65XE66HK.js → chunk-V2V767XI.js}

@@ -1,6 +1,10 @@
+import {
+  ChannelAdapter,
+  PRODUCT_GUIDE
+} from "./chunk-5NBWM7P6.js";
 import {
   DoctorEngine
-} from "./chunk-IRGYTNLP.js";
+} from "./chunk-SPX7CKWV.js";
 import {
   buildMenuKeyboard,
   buildSkillMessages,
@@ -488,9 +492,10 @@ ${stderr}`
   }
   async prompt(text, attachments) {
     const contentBlocks = [{ type: "text", text }];
+    const SUPPORTED_IMAGE_MIMES = /* @__PURE__ */ new Set(["image/jpeg", "image/png", "image/gif", "image/webp"]);
     for (const att of attachments ?? []) {
       const tooLarge = att.size > 10 * 1024 * 1024;
-      if (att.type === "image" && this.promptCapabilities?.image && !tooLarge) {
+      if (att.type === "image" && this.promptCapabilities?.image && !tooLarge && SUPPORTED_IMAGE_MIMES.has(att.mimeType)) {
         const data = await fs.promises.readFile(att.filePath);
         contentBlocks.push({ type: "image", data: data.toString("base64"), mimeType: att.mimeType });
       } else if (att.type === "audio" && this.promptCapabilities?.audio && !tooLarge) {
@@ -640,6 +645,7 @@ var PromptQueue = class {
   }
   queue = [];
   processing = false;
+  abortController = null;
   async enqueue(text, attachments) {
     if (this.processing) {
       return new Promise((resolve2) => {
@@ -650,11 +656,21 @@ var PromptQueue = class {
   }
   async process(text, attachments) {
     this.processing = true;
+    this.abortController = new AbortController();
+    const { signal } = this.abortController;
     try {
-      await this.processor(text, attachments);
+      await Promise.race([
+        this.processor(text, attachments),
+        new Promise((_, reject) => {
+          signal.addEventListener("abort", () => reject(new Error("Prompt aborted")), { once: true });
+        })
+      ]);
     } catch (err) {
-      this.onError?.(err);
+      if (!(err instanceof Error && err.message === "Prompt aborted")) {
+        this.onError?.(err);
+      }
     } finally {
+      this.abortController = null;
       this.processing = false;
       this.drainNext();
     }
@@ -666,6 +682,9 @@ var PromptQueue = class {
     }
   }
   clear() {
+    if (this.abortController) {
+      this.abortController.abort();
+    }
     for (const item of this.queue) {
       item.resolve();
     }
@@ -958,7 +977,7 @@ var SessionManager = class {
   getRecordByThread(channelId, threadId) {
     return this.store?.findByPlatform(
       channelId,
-      (p) => String(p.topicId) === threadId
+      (p) => String(p.topicId) === threadId || p.threadId === threadId
     );
   }
   registerSession(session) {
@@ -1701,9 +1720,10 @@ var OpenACPCore = class {
       "Incoming message"
     );
     if (config.security.allowedUserIds.length > 0) {
-      if (!config.security.allowedUserIds.includes(message.userId)) {
+      const userId = String(message.userId);
+      if (!config.security.allowedUserIds.includes(userId)) {
         log5.warn(
-          { userId: message.userId },
+          { userId },
           "Rejected message from unauthorized user"
         );
         return;
@@ -1779,12 +1799,32 @@ var OpenACPCore = class {
       const bridge = this.createBridge(session, adapter);
       bridge.connect();
     }
+    session.on("status_change", (_from, to) => {
+      if ((to === "finished" || to === "cancelled") && this._tunnelService) {
+        this._tunnelService.stopBySession(session.id).then((stopped) => {
+          for (const entry of stopped) {
+            this.notificationManager.notifyAll({
+              sessionId: session.id,
+              sessionName: session.name,
+              type: "completed",
+              summary: `Tunnel stopped: port ${entry.port}${entry.label ? ` (${entry.label})` : ""} \u2014 session ended`
+            }).catch(() => {
+            });
+          }
+        }).catch(() => {
+        });
+      }
+    });
     const existingRecord = this.sessionStore?.get(session.id);
     const platform = {
       ...existingRecord?.platform ?? {}
     };
     if (session.threadId) {
-      platform.topicId = Number(session.threadId);
+      if (params.channelId === "telegram") {
+        platform.topicId = Number(session.threadId);
+      } else {
+        platform.threadId = session.threadId;
+      }
     }
     await this.sessionManager.patchRecord(session.id, {
       sessionId: session.id,
@@ -1928,10 +1968,10 @@ var OpenACPCore = class {
       );
       return null;
     }
-    if (record.status === "cancelled" || record.status === "error") {
+    if (record.status === "error") {
       log5.debug(
         { threadId: message.threadId, sessionId: record.sessionId, status: record.status },
-        "Skipping resume of cancelled/error session"
+        "Skipping resume of error session"
       );
       return null;
     }
@@ -1989,26 +2029,12 @@ var OpenACPCore = class {
   }
 };
 
-// src/core/channel.ts
-var ChannelAdapter = class {
-  constructor(core, config) {
-    this.core = core;
-    this.config = config;
-  }
-  async deleteSessionThread(_sessionId) {
-  }
-  // Skill commands — override in adapters that support dynamic commands
-  async sendSkillCommands(_sessionId, _commands) {
-  }
-  async cleanupSkillCommands(_sessionId) {
-  }
-};
-
 // src/core/api-server.ts
 import * as http from "http";
 import * as fs4 from "fs";
 import * as path5 from "path";
 import * as os2 from "os";
+import * as crypto from "crypto";
 import { fileURLToPath } from "url";
 var log6 = createChildLogger({ module: "api-server" });
 var DEFAULT_PORT_FILE = path5.join(os2.homedir(), ".openacp", "api.port");
@@ -2041,17 +2067,21 @@ function redactDeep(obj) {
   }
 }
 var ApiServer = class {
-  constructor(core, config, portFilePath, topicManager) {
+  constructor(core, config, portFilePath, topicManager, secretFilePath) {
     this.core = core;
     this.config = config;
     this.topicManager = topicManager;
     this.portFilePath = portFilePath ?? DEFAULT_PORT_FILE;
+    this.secretFilePath = secretFilePath ?? path5.join(os2.homedir(), ".openacp", "api-secret");
   }
   server = null;
   actualPort = 0;
   portFilePath;
   startedAt = Date.now();
+  secret = "";
+  secretFilePath;
   async start() {
+    this.loadOrCreateSecret();
     this.server = http.createServer((req, res) => this.handleRequest(req, res));
     await new Promise((resolve2, reject) => {
       this.server.on("error", (err) => {
@@ -2097,9 +2127,42 @@ var ApiServer = class {
     } catch {
     }
   }
+  loadOrCreateSecret() {
+    const dir = path5.dirname(this.secretFilePath);
+    fs4.mkdirSync(dir, { recursive: true });
+    try {
+      this.secret = fs4.readFileSync(this.secretFilePath, "utf-8").trim();
+      if (this.secret) {
+        try {
+          const stat = fs4.statSync(this.secretFilePath);
+          const mode = stat.mode & 511;
+          if (mode & 63) {
+            log6.warn({ path: this.secretFilePath, mode: "0" + mode.toString(8) }, "API secret file has insecure permissions (should be 0600). Run: chmod 600 %s", this.secretFilePath);
+          }
+        } catch {
+        }
+        return;
+      }
+    } catch {
+    }
+    this.secret = crypto.randomBytes(32).toString("hex");
+    fs4.writeFileSync(this.secretFilePath, this.secret, { mode: 384 });
+  }
+  authenticate(req) {
+    const authHeader = req.headers.authorization;
+    if (!authHeader?.startsWith("Bearer ")) return false;
+    const token = authHeader.slice(7);
+    if (token.length !== this.secret.length) return false;
+    return crypto.timingSafeEqual(Buffer.from(token, "utf-8"), Buffer.from(this.secret, "utf-8"));
+  }
   async handleRequest(req, res) {
     const method = req.method?.toUpperCase();
     const url = req.url || "";
+    const isExempt = method === "GET" && (url === "/api/health" || url === "/api/version");
+    if (!isExempt && !this.authenticate(req)) {
+      this.sendJson(res, 401, { error: "Unauthorized" });
+      return;
+    }
     try {
       if (method === "POST" && url === "/api/sessions/adopt") {
         await this.handleAdoptSession(req, res);
@@ -2135,6 +2198,15 @@ var ApiServer = class {
         await this.handleListAdapters(res);
       } else if (method === "GET" && url === "/api/tunnel") {
         await this.handleTunnelStatus(res);
+      } else if (method === "GET" && url === "/api/tunnel/list") {
+        await this.handleTunnelList(res);
+      } else if (method === "POST" && url === "/api/tunnel") {
+        await this.handleTunnelAdd(req, res);
+      } else if (method === "DELETE" && url === "/api/tunnel") {
+        await this.handleTunnelStopAll(res);
+      } else if (method === "DELETE" && url.match(/^\/api\/tunnel\/(\d+)$/)) {
+        const port = parseInt(url.match(/^\/api\/tunnel\/(\d+)$/)[1], 10);
+        await this.handleTunnelStop(port, res);
       } else if (method === "POST" && url === "/api/notify") {
         await this.handleNotify(req, res);
       } else if (method === "POST" && url === "/api/restart") {
@@ -2361,7 +2433,7 @@ var ApiServer = class {
       return;
     }
     target[lastKey] = value;
-    const { ConfigSchema } = await import("./config-PCPIBPUA.js");
+    const { ConfigSchema } = await import("./config-KF2MQWAP.js");
     const result = ConfigSchema.safeParse(cloned);
     if (!result.success) {
       this.sendJson(res, 400, {
@@ -2401,6 +2473,60 @@ var ApiServer = class {
       this.sendJson(res, 200, { enabled: false });
     }
   }
+  async handleTunnelList(res) {
+    const tunnel = this.core.tunnelService;
+    if (!tunnel) {
+      this.sendJson(res, 200, []);
+      return;
+    }
+    this.sendJson(res, 200, tunnel.listTunnels());
+  }
+  async handleTunnelAdd(req, res) {
+    const tunnel = this.core.tunnelService;
+    if (!tunnel) {
+      this.sendJson(res, 400, { error: "Tunnel service is not enabled" });
+      return;
+    }
+    const body = await this.readBody(req);
+    if (!body) {
+      this.sendJson(res, 400, { error: "Missing request body" });
+      return;
+    }
+    try {
+      const { port, label, sessionId } = JSON.parse(body);
+      if (!port || typeof port !== "number") {
+        this.sendJson(res, 400, { error: "port is required and must be a number" });
+        return;
+      }
+      const entry = await tunnel.addTunnel(port, { label, sessionId });
+      this.sendJson(res, 200, entry);
+    } catch (err) {
+      this.sendJson(res, 400, { error: err.message });
+    }
+  }
+  async handleTunnelStop(port, res) {
+    const tunnel = this.core.tunnelService;
+    if (!tunnel) {
+      this.sendJson(res, 400, { error: "Tunnel service is not enabled" });
+      return;
+    }
+    try {
+      await tunnel.stopTunnel(port);
+      this.sendJson(res, 200, { ok: true });
+    } catch (err) {
+      this.sendJson(res, 400, { error: err.message });
+    }
+  }
+  async handleTunnelStopAll(res) {
+    const tunnel = this.core.tunnelService;
+    if (!tunnel) {
+      this.sendJson(res, 400, { error: "Tunnel service is not enabled" });
+      return;
+    }
+    const count = tunnel.listTunnels().length;
+    await tunnel.stopAllUser();
+    this.sendJson(res, 200, { ok: true, stopped: count });
+  }
   async handleNotify(req, res) {
     const body = await this.readBody(req);
     let message;
@@ -2955,7 +3081,7 @@ async function handleUpdate(ctx, core) {
     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 { getCurrentVersion, getLatestVersion, compareVersions, runUpdate } = await import("./version-ALWGGVKM.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();
@@ -3405,16 +3531,15 @@ async function handleCancel(ctx, core, assistant) {
     String(threadId)
   );
   if (session) {
-    log11.info({ sessionId: session.id }, "Cancel session command");
+    log11.info({ sessionId: session.id }, "Abort prompt command");
     await session.abortPrompt();
-    await ctx.reply("\u26D4 Session cancelled.", { parse_mode: "HTML" });
+    await ctx.reply("\u26D4 Prompt aborted. Session is still active \u2014 send a new message to continue.", { parse_mode: "HTML" });
     return;
   }
   const record = core.sessionManager.getRecordByThread("telegram", String(threadId));
-  if (record && record.status !== "cancelled" && record.status !== "error") {
-    log11.info({ sessionId: record.sessionId }, "Cancel session command (from store)");
-    await core.sessionManager.cancelSession(record.sessionId);
-    await ctx.reply("\u26D4 Session cancelled.", { parse_mode: "HTML" });
+  if (record && record.status !== "error") {
+    log11.info({ sessionId: record.sessionId, status: record.status }, "Cancel command \u2014 no active prompt to abort");
+    await ctx.reply("\u2139\uFE0F No active prompt to cancel. Send a new message to resume the session.", { parse_mode: "HTML" });
   }
 }
 async function handleStatus(ctx, core) {
@@ -3874,7 +3999,7 @@ Downloading... ${bar} ${percent}%`, { parse_mode: "HTML" });
     const { getAgentCapabilities: getAgentCapabilities2 } = await import("./agent-dependencies-QY5QSULV.js");
     const caps = getAgentCapabilities2(result.agentKey);
     if (caps.integration) {
-      const { installIntegration } = await import("./integrate-BLETI3UO.js");
+      const { installIntegration } = await import("./integrate-VOUYBPPZ.js");
       const intResult = await installIntegration(result.agentKey, caps.integration);
       if (intResult.success) {
         try {
@@ -3944,7 +4069,7 @@ function buildProgressBar(percent) {
 // src/adapters/telegram/commands/integrate.ts
 import { InlineKeyboard as InlineKeyboard5 } from "grammy";
 async function handleIntegrate(ctx, _core) {
-  const { listIntegrations } = await import("./integrate-BLETI3UO.js");
+  const { listIntegrations } = await import("./integrate-VOUYBPPZ.js");
   const agents = listIntegrations();
   const keyboard = new InlineKeyboard5();
   for (const agent of agents) {
@@ -3977,7 +4102,7 @@ function setupIntegrateCallbacks(bot, core) {
     } catch {
     }
     if (data === "i:back") {
-      const { listIntegrations } = await import("./integrate-BLETI3UO.js");
+      const { listIntegrations } = await import("./integrate-VOUYBPPZ.js");
       const agents = listIntegrations();
       const keyboard2 = new InlineKeyboard5();
       for (const agent of agents) {
@@ -3997,7 +4122,7 @@ Select an agent to manage its integrations.`,
     const agentMatch = data.match(/^i:agent:(.+)$/);
     if (agentMatch) {
       const agentName2 = agentMatch[1];
-      const { getIntegration: getIntegration2 } = await import("./integrate-BLETI3UO.js");
+      const { getIntegration: getIntegration2 } = await import("./integrate-VOUYBPPZ.js");
       const integration2 = getIntegration2(agentName2);
       if (!integration2) {
         await ctx.reply(`\u274C No integration available for '${escapeHtml(agentName2)}'.`, { parse_mode: "HTML" });
@@ -4024,7 +4149,7 @@ ${integration2.items.map((i) => `\u2022 <b>${escapeHtml(i.name)}</b> \u2014 ${es
     const action = actionMatch[1];
     const agentName = actionMatch[2];
     const itemId = actionMatch[3];
-    const { getIntegration } = await import("./integrate-BLETI3UO.js");
+    const { getIntegration } = await import("./integrate-VOUYBPPZ.js");
     const integration = getIntegration(agentName);
     if (!integration) return;
     const item = integration.items.find((i) => i.id === itemId);
@@ -4351,6 +4476,155 @@ function setupDoctorCallbacks(bot) {
   });
 }
 
+// src/adapters/telegram/commands/tunnel.ts
+import { InlineKeyboard as InlineKeyboard8 } from "grammy";
+var log14 = createChildLogger({ module: "telegram-cmd-tunnel" });
+async function handleTunnel(ctx, core) {
+  if (!core.tunnelService) {
+    await ctx.reply("\u274C Tunnel service is not enabled.", { parse_mode: "HTML" });
+    return;
+  }
+  const match = ctx.match?.trim() ?? "";
+  if (match.startsWith("stop ")) {
+    const portStr = match.slice(5).trim();
+    const port = parseInt(portStr, 10);
+    if (isNaN(port)) {
+      await ctx.reply("\u274C Invalid port number.", { parse_mode: "HTML" });
+      return;
+    }
+    try {
+      await core.tunnelService.stopTunnel(port);
+      await ctx.reply(`\u{1F50C} Tunnel stopped: port ${port}`, { parse_mode: "HTML" });
+    } catch (err) {
+      await ctx.reply(`\u274C ${escapeHtml(err.message)}`, { parse_mode: "HTML" });
+    }
+    return;
+  }
+  if (match) {
+    const parts = match.split(/\s+/);
+    const port = parseInt(parts[0], 10);
+    if (isNaN(port)) {
+      await ctx.reply("\u274C Invalid port number. Usage: <code>/tunnel 3000 [label]</code>", { parse_mode: "HTML" });
+      return;
+    }
+    const label = parts.slice(1).join(" ") || void 0;
+    const threadId = ctx.message?.message_thread_id;
+    let sessionId;
+    if (threadId) {
+      const session = core.sessionManager.getSessionByThread("telegram", String(threadId));
+      if (session) sessionId = session.id;
+    }
+    try {
+      await ctx.reply(`\u23F3 Starting tunnel for port ${port}...`, { parse_mode: "HTML" });
+      const entry = await core.tunnelService.addTunnel(port, { label, sessionId });
+      await ctx.reply(
+        `\u{1F517} <b>Tunnel active</b>
+
+Port ${port}${label ? ` (${escapeHtml(label)})` : ""}
+\u2192 <a href="${escapeHtml(entry.publicUrl || "")}">${escapeHtml(entry.publicUrl || "")}</a>`,
+        { parse_mode: "HTML" }
+      );
+    } catch (err) {
+      await ctx.reply(`\u274C ${escapeHtml(err.message)}`, { parse_mode: "HTML" });
+    }
+    return;
+  }
+  await ctx.reply(
+    `<b>Tunnel commands:</b>
+
+<code>/tunnel &lt;port&gt; [label]</code> \u2014 Create tunnel
+<code>/tunnel stop &lt;port&gt;</code> \u2014 Stop tunnel
+<code>/tunnels</code> \u2014 List active tunnels`,
+    { parse_mode: "HTML" }
+  );
+}
+async function handleTunnels(ctx, core) {
+  if (!core.tunnelService) {
+    await ctx.reply("\u274C Tunnel service is not enabled.", { parse_mode: "HTML" });
+    return;
+  }
+  const entries = core.tunnelService.listTunnels();
+  if (entries.length === 0) {
+    await ctx.reply(
+      "No active tunnels.\n\nUse <code>/tunnel &lt;port&gt;</code> to create one.",
+      { parse_mode: "HTML" }
+    );
+    return;
+  }
+  const lines = entries.map((e) => {
+    const status = e.status === "active" ? "\u2705" : e.status === "starting" ? "\u23F3" : "\u274C";
+    const label = e.label ? ` (${escapeHtml(e.label)})` : "";
+    const url = e.publicUrl ? `
+  \u2192 <a href="${escapeHtml(e.publicUrl)}">${escapeHtml(e.publicUrl)}</a>` : "";
+    return `${status} Port <b>${e.port}</b>${label}${url}`;
+  });
+  const keyboard = new InlineKeyboard8();
+  for (const e of entries) {
+    keyboard.text(`\u{1F50C} Stop ${e.port}${e.label ? ` (${e.label})` : ""}`, `tn:stop:${e.port}`).row();
+  }
+  if (entries.length > 1) {
+    keyboard.text("\u{1F50C} Stop all", "tn:stop-all").row();
+  }
+  await ctx.reply(
+    `<b>Active tunnels:</b>
+
+${lines.join("\n\n")}`,
+    { parse_mode: "HTML", reply_markup: keyboard }
+  );
+}
+function setupTunnelCallbacks(bot, core) {
+  bot.callbackQuery(/^tn:/, async (ctx) => {
+    const data = ctx.callbackQuery.data;
+    if (!core.tunnelService) {
+      await ctx.answerCallbackQuery({ text: "Tunnel not enabled" });
+      return;
+    }
+    try {
+      if (data === "tn:stop-all") {
+        const entries = core.tunnelService.listTunnels();
+        for (const e of entries) {
+          try {
+            await core.tunnelService.stopTunnel(e.port);
+          } catch {
+          }
+        }
+        await ctx.answerCallbackQuery({ text: "All tunnels stopped" });
+        await ctx.editMessageText("\u{1F50C} All tunnels stopped.", { parse_mode: "HTML" });
+      } else if (data.startsWith("tn:stop:")) {
+        const port = parseInt(data.replace("tn:stop:", ""), 10);
+        await core.tunnelService.stopTunnel(port);
+        await ctx.answerCallbackQuery({ text: `Port ${port} stopped` });
+        const remaining = core.tunnelService.listTunnels();
+        if (remaining.length === 0) {
+          await ctx.editMessageText("\u{1F50C} All tunnels stopped.", { parse_mode: "HTML" });
+        } else {
+          const kb = new InlineKeyboard8();
+          for (const e of remaining) {
+            kb.text(`\u{1F50C} Stop ${e.port}${e.label ? ` (${e.label})` : ""}`, `tn:stop:${e.port}`).row();
+          }
+          if (remaining.length > 1) {
+            kb.text("\u{1F50C} Stop all", "tn:stop-all").row();
+          }
+          await ctx.editMessageText(
+            `<b>Active tunnels:</b>
+
+` + remaining.map((e) => {
+              const status = e.status === "active" ? "\u2705" : "\u23F3";
+              const label = e.label ? ` (${escapeHtml(e.label)})` : "";
+              const url = e.publicUrl ? `
+  \u2192 <a href="${escapeHtml(e.publicUrl)}">${escapeHtml(e.publicUrl)}</a>` : "";
+              return `${status} Port <b>${e.port}</b>${label}${url}`;
+            }).join("\n\n"),
+            { parse_mode: "HTML", reply_markup: kb }
+          );
+        }
+      }
+    } catch (err) {
+      await ctx.answerCallbackQuery({ text: err.message });
+    }
+  });
+}
+
 // src/adapters/telegram/commands/index.ts
 function setupCommands(bot, core, chatId, assistant) {
   bot.command("new", (ctx) => handleNew(ctx, core, chatId, assistant));
@@ -4369,12 +4643,15 @@ function setupCommands(bot, core, chatId, assistant) {
   bot.command("integrate", (ctx) => handleIntegrate(ctx, core));
   bot.command("clear", (ctx) => handleClear(ctx, assistant));
   bot.command("doctor", (ctx) => handleDoctor(ctx));
+  bot.command("tunnel", (ctx) => handleTunnel(ctx, core));
+  bot.command("tunnels", (ctx) => handleTunnels(ctx, core));
 }
 function setupAllCallbacks(bot, core, chatId, systemTopicIds, getAssistantSession) {
   setupNewSessionCallbacks(bot, core, chatId);
   setupSessionCallbacks(bot, core, chatId, systemTopicIds);
   setupSettingsCallbacks(bot, core, getAssistantSession ?? (() => void 0));
   setupDoctorCallbacks(bot);
+  setupTunnelCallbacks(bot, core);
   bot.callbackQuery(/^ag:/, (ctx) => handleAgentCallback(ctx, core));
   bot.callbackQuery(/^na:/, async (ctx) => {
     const agentKey = ctx.callbackQuery.data.replace("na:", "");
@@ -4435,13 +4712,15 @@ var STATIC_COMMANDS = [
   { command: "clear", description: "Clear assistant history" },
   { command: "restart", description: "Restart OpenACP" },
   { command: "update", description: "Update to latest version and restart" },
-  { command: "doctor", description: "Run system diagnostics" }
+  { command: "doctor", description: "Run system diagnostics" },
+  { command: "tunnel", description: "Create/stop tunnel for a local port" },
+  { command: "tunnels", description: "List active tunnels" }
 ];
 
 // src/adapters/telegram/permissions.ts
-import { InlineKeyboard as InlineKeyboard8 } from "grammy";
+import { InlineKeyboard as InlineKeyboard9 } from "grammy";
 import { nanoid as nanoid2 } from "nanoid";
-var log14 = createChildLogger({ module: "telegram-permissions" });
+var log15 = createChildLogger({ module: "telegram-permissions" });
 var PermissionHandler = class {
   constructor(bot, chatId, getSession, sendNotification) {
     this.bot = bot;
@@ -4458,7 +4737,7 @@ var PermissionHandler = class {
       requestId: request.id,
       options: request.options.map((o) => ({ id: o.id, isAllow: o.isAllow }))
     });
-    const keyboard = new InlineKeyboard8();
+    const keyboard = new InlineKeyboard9();
     for (const option of request.options) {
       const emoji = option.isAllow ? "\u2705" : "\u274C";
       keyboard.text(`${emoji} ${option.label}`, `p:${callbackKey}:${option.id}`);
@@ -4501,7 +4780,7 @@ ${escapeHtml(request.description)}`,
       }
       const session = this.getSession(pending.sessionId);
       const isAllow = pending.options.find((o) => o.id === optionId)?.isAllow ?? false;
-      log14.info({ requestId: pending.requestId, optionId, isAllow }, "Permission responded");
+      log15.info({ requestId: pending.requestId, optionId, isAllow }, "Permission responded");
       if (session?.permissionGate.requestId === pending.requestId) {
         session.permissionGate.resolve(optionId);
       }
@@ -4518,408 +4797,11 @@ ${escapeHtml(request.description)}`,
   }
 };
 
-// src/product-guide.ts
-var PRODUCT_GUIDE = `
-# OpenACP \u2014 Product Guide
-
-OpenACP lets you chat with AI coding agents (like Claude Code) through Telegram.
-You type messages in Telegram, the agent reads/writes/runs code in your project folder, and results stream back in real time.
-
----
-
-## Quick Start
-
-1. Start OpenACP: \`openacp\` (or \`openacp start\` for background daemon)
-2. Open your Telegram group \u2014 you'll see the Assistant topic
-3. Tap \u{1F195} New Session or type /new
-4. Pick an agent and a project folder
-5. Chat in the session topic \u2014 the agent works on your code
-
----
-
-## Core Concepts
-
-### Sessions
-A session = one conversation with one AI agent working in one project folder.
-Each session gets its own Telegram topic. Chat there to give instructions to the agent.
-
-### Agents
-An agent is an AI coding tool (e.g., Claude Code, Gemini, Cursor, Codex, etc.).
-OpenACP supports 28+ agents from the official ACP Registry (agentclientprotocol.com).
-You can install multiple agents and choose which one to use per session.
-The default agent is used when you don't specify one.
-
-### Agent Management
-- Browse agents: \`/agents\` in Telegram or \`openacp agents\` in CLI
-- Install: tap the install button in /agents, or \`openacp agents install <name>\`
-- Uninstall: \`openacp agents uninstall <name>\`
-- Setup/login: \`openacp agents run <name> -- <args>\` (e.g., \`openacp agents run gemini -- auth login\`)
-- Details: \`openacp agents info <name>\` shows version, dependencies, and setup steps
-
-Some agents need additional setup before they can be used:
-- Claude: requires \`claude login\`
-- Gemini: requires \`openacp agents run gemini -- auth login\`
-- Codex: requires setting \`OPENAI_API_KEY\` environment variable
-- GitHub Copilot: requires \`openacp agents run copilot -- auth login\`
-
-Agents are installed in three ways depending on the agent:
-- **npx** \u2014 Node.js agents, downloaded automatically on first use
-- **uvx** \u2014 Python agents, downloaded automatically on first use
-- **binary** \u2014 Platform-specific binaries, downloaded to \`~/.openacp/agents/\`
-
-### Project Folder (Workspace)
-The directory where the agent reads, writes, and runs code.
-When creating a session, you choose which folder the agent works in.
-You can type a full path like \`~/code/my-project\` or just a name like \`my-project\` (it becomes \`<base-dir>/my-project\`).
-
-### System Topics
-- **Assistant** \u2014 Always-on helper that can answer questions, create sessions, check status, troubleshoot
-- **Notifications** \u2014 System alerts (permission requests, session errors, completions)
-
----
-
-## Creating Sessions
-
-### From menu
-Tap \u{1F195} New Session \u2192 choose agent (if multiple) \u2192 choose project folder \u2192 confirm
-
-### From command
-- \`/new\` \u2014 Interactive flow (asks agent + folder)
-- \`/new claude ~/code/my-project\` \u2014 Create directly with specific agent and folder
-
-### From Assistant topic
-Just ask: "Create a session for my-project with claude" \u2014 the assistant handles it
-
-### Quick new chat
-\`/newchat\` in a session topic \u2014 creates new session with same agent and folder as current one
-
----
-
-## Working with Sessions
-
-### Chat
-Type messages in the session topic. The agent responds with code changes, explanations, tool outputs.
-
-### What you see while the agent works
-- **\u{1F4AD} Thinking indicator** \u2014 Shows when the agent is reasoning, with elapsed time
-- **Text responses** \u2014 Streamed in real time, updated every few seconds
-- **Tool calls** \u2014 When the agent runs commands or edits files, you see tool name, input, status, and output
-- **\u{1F4CB} Plan card** \u2014 Visual task progress with completed/in-progress/pending items and progress bar
-- **"View File" / "View Diff" buttons** \u2014 Opens in browser with Monaco editor (requires tunnel)
-
-### Session lifecycle
-1. **Creating** \u2014 Topic created, agent spawning
-2. **Warming up** \u2014 Agent primes its cache (happens automatically, invisible to you)
-3. **Active** \u2014 Ready for your messages
-4. **Auto-naming** \u2014 After your first message, the session gets a descriptive name (agent summarizes in ~5 words). The topic title updates automatically.
-5. **Finished/Error** \u2014 Session completed or hit an error
-
-### Agent skills
-Some agents provide slash commands (e.g., /compact, /review). Available skills are pinned in the session topic.
-
-### Permission requests
-When the agent wants to run a command, it asks for permission.
-You see buttons: \u2705 Allow, \u274C Reject (and sometimes "Always Allow").
-A notification also appears in the Notifications topic with a link to the request.
-
-### Dangerous mode
-Auto-approves ALL permission requests \u2014 the agent runs any command without asking.
-- Enable: \`/enable_dangerous\` or tap the \u2620\uFE0F button in the session
-- Disable: \`/disable_dangerous\` or tap the \u{1F510} button
-- \u26A0\uFE0F Use with caution \u2014 the agent can execute anything
-
-### Session timeout
-Idle sessions are automatically cancelled after a configurable timeout (default: 60 minutes).
-Configure via \`security.sessionTimeoutMinutes\` in config.
-
----
-
-## Session Transfer (Handoff)
-
-### Telegram \u2192 Terminal
-1. Type \`/handoff\` in a session topic
-2. You get a command like \`claude --resume <SESSION_ID>\`
-3. Copy and run it in your terminal \u2014 the session continues there with full conversation history
-
-### Terminal \u2192 Telegram
-1. First time: run \`openacp integrate claude\` to install the handoff skill (one-time setup)
-2. In Claude Code, use the /openacp:handoff slash command
-3. The session appears as a new topic in Telegram and you can continue chatting there
-
-### How it works
-- The agent session ID is shared between platforms
-- Conversation history is preserved \u2014 pick up where you left off
-- The agent that supports resume (e.g., Claude with \`--resume\`) handles the actual transfer
-
----
-
-## Managing Sessions
-
-### Status
-- \`/status\` \u2014 Shows active sessions count and details
-- Ask the Assistant: "What sessions are running?"
-
-### List all sessions
-- \`/sessions\` \u2014 Shows all sessions with status (active, finished, error)
-
-### Cancel
-- \`/cancel\` in a session topic \u2014 cancels that session
-- Ask the Assistant: "Cancel the stuck session"
-
-### Cleanup
-- From \`/sessions\` \u2192 tap cleanup buttons (finished, errors, all)
-- Ask the Assistant: "Clean up old sessions"
-
----
-
-## Assistant Topic
-
-The Assistant is an always-on AI helper in its own topic. It can:
-- Answer questions about OpenACP
-- Create sessions for you
-- Check status and health
-- Cancel sessions
-- Clean up old sessions
-- Troubleshoot issues
-- Manage configuration
-
-Just chat naturally: "How do I create a session?", "What's the status?", "Something is stuck"
-
-### Clear history
-\`/clear\` in the Assistant topic \u2014 resets the conversation
-
----
-
-## System Commands
-
-| Command | Where | What it does |
-|---------|-------|-------------|
-| \`/new [agent] [path]\` | Anywhere | Create new session |
-| \`/newchat\` | Session topic | New session, same agent + folder |
-| \`/cancel\` | Session topic | Cancel current session |
-| \`/status\` | Anywhere | Show status |
-| \`/sessions\` | Anywhere | List all sessions |
-| \`/agents\` | Anywhere | Browse & install agents from ACP Registry |
-| \`/install <name>\` | Anywhere | Install an agent |
-| \`/enable_dangerous\` | Session topic | Auto-approve all permissions |
-| \`/disable_dangerous\` | Session topic | Restore permission prompts |
-| \`/handoff\` | Session topic | Transfer session to terminal |
-| \`/clear\` | Assistant topic | Clear assistant history |
-| \`/menu\` | Anywhere | Show action menu |
-| \`/help\` | Anywhere | Show help |
-| \`/restart\` | Anywhere | Restart OpenACP |
-| \`/update\` | Anywhere | Update to latest version |
-| \`/integrate\` | Anywhere | Manage agent integrations |
-
----
-
-## Menu Buttons
-
-| Button | Action |
-|--------|--------|
-| \u{1F195} New Session | Create new session (interactive) |
-| \u{1F4CB} Sessions | List all sessions with cleanup options |
-| \u{1F4CA} Status | Show active/total session count |
-| \u{1F916} Agents | List available agents |
-| \u{1F517} Integrate | Manage agent integrations |
-| \u2753 Help | Show help text |
-| \u{1F504} Restart | Restart OpenACP |
-| \u2B06\uFE0F Update | Check and install updates |
-
----
-
-## CLI Commands
-
-### Server
-- \`openacp\` \u2014 Start (uses configured mode: foreground or daemon)
-- \`openacp start\` \u2014 Start as background daemon
-- \`openacp stop\` \u2014 Stop daemon
-- \`openacp status\` \u2014 Show daemon status
-- \`openacp logs\` \u2014 Tail daemon logs
-- \`openacp --foreground\` \u2014 Force foreground mode (useful for debugging or containers)
-
-### Auto-start (run on boot)
-- macOS: installs a LaunchAgent in \`~/Library/LaunchAgents/\`
-- Linux: installs a systemd user service in \`~/.config/systemd/user/\`
-- Enabled automatically when you start the daemon. Remove with \`openacp stop\`.
-
-### Configuration
-- \`openacp config\` \u2014 Interactive config editor
-- \`openacp reset\` \u2014 Delete all data and start fresh
-
-### Agent Management (CLI)
-- \`openacp agents\` \u2014 List all agents (installed + available from ACP Registry)
-- \`openacp agents install <name>\` \u2014 Install an agent
-- \`openacp agents uninstall <name>\` \u2014 Remove an agent
-- \`openacp agents info <name>\` \u2014 Show details, dependencies, and setup guide
-- \`openacp agents run <name> [-- args]\` \u2014 Run agent CLI directly (for login, config, etc.)
-- \`openacp agents refresh\` \u2014 Force-refresh registry cache
-
-### Plugins
-- \`openacp install <package>\` \u2014 Install adapter plugin (e.g., \`@openacp/adapter-discord\`)
-- \`openacp uninstall <package>\` \u2014 Remove adapter plugin
-- \`openacp plugins\` \u2014 List installed plugins
-
-### Integration
-- \`openacp integrate <agent>\` \u2014 Install agent integration (e.g., Claude handoff skill)
-- \`openacp integrate <agent> --uninstall\` \u2014 Remove integration
-
-### API (requires running daemon)
-\`openacp api <command>\` \u2014 Interact with running daemon:
-
-| Command | Description |
-|---------|-------------|
-| \`status\` | List active sessions |
-| \`session <id>\` | Session details |
-| \`new <agent> <path>\` | Create session |
-| \`send <id> "text"\` | Send prompt |
-| \`cancel <id>\` | Cancel session |
-| \`dangerous <id> on/off\` | Toggle dangerous mode |
-| \`topics [--status x,y]\` | List topics |
-| \`delete-topic <id> [--force]\` | Delete topic |
-| \`cleanup [--status x,y]\` | Cleanup old topics |
-| \`agents\` | List agents |
-| \`health\` | System health |
-| \`config\` | Show config |
-| \`config set <key> <value>\` | Update config |
-| \`adapters\` | List adapters |
-| \`tunnel\` | Tunnel status |
-| \`notify "message"\` | Send notification |
-| \`version\` | Daemon version |
-| \`restart\` | Restart daemon |
-
----
-
-## File Viewer (Tunnel)
-
-When tunnel is enabled, file edits and diffs get "View" buttons that open in your browser:
-- **Monaco Editor** \u2014 Full VS Code editor with syntax highlighting
-- **Diff viewer** \u2014 Side-by-side or inline comparison
-- **Line highlighting** \u2014 Click lines to highlight
-- Dark/light theme toggle
-
-### Setup
-Enable in config: set \`tunnel.enabled\` to \`true\`.
-Providers: Cloudflare (default, free), ngrok, bore, Tailscale Funnel.
-
----
-
-## Configuration
-
-Config file: \`~/.openacp/config.json\`
-
-### Telegram
-- **telegram.botToken** \u2014 Your Telegram bot token
-- **telegram.chatId** \u2014 Your Telegram supergroup ID
-
-### Agents
-- **defaultAgent** \u2014 Which agent to use by default
-- Agents are managed via \`/agents\` (Telegram) or \`openacp agents\` (CLI)
-- Installed agents are stored in \`~/.openacp/agents.json\`
-- Agent list is fetched from the ACP Registry CDN and cached locally (24h)
-
-### Workspace
-- **workspace.baseDir** \u2014 Base directory for project folders (default: \`~/openacp-workspace\`)
-
-### Security
-- **security.allowedUserIds** \u2014 Restrict who can use the bot (empty = everyone)
-- **security.maxConcurrentSessions** \u2014 Max parallel sessions (default: 5)
-- **security.sessionTimeoutMinutes** \u2014 Auto-cancel idle sessions (default: 60)
-
-### Tunnel / File Viewer
-- **tunnel.enabled** \u2014 Enable file viewer tunnel
-- **tunnel.provider** \u2014 Tunnel provider: cloudflare (default, free), ngrok, bore, tailscale
-- **tunnel.port** \u2014 Local port for tunnel server (default: 3100)
-- **tunnel.auth.enabled** \u2014 Enable authentication for tunnel URLs
-- **tunnel.auth.token** \u2014 Auth token for tunnel access
-- **tunnel.storeTtlMinutes** \u2014 How long viewer links stay cached (default: 60)
-
-### Logging
-- **logging.level** \u2014 Log level: silent, debug, info, warn, error, fatal (default: info)
-- **logging.logDir** \u2014 Log directory (default: \`~/.openacp/logs\`)
-- **logging.maxFileSize** \u2014 Max log file size before rotation
-- **logging.maxFiles** \u2014 Max number of rotated log files
-- **logging.sessionLogRetentionDays** \u2014 Auto-delete old session logs (default: 30)
-
-### Data Retention
-- **sessionStore.ttlDays** \u2014 How long session records persist (default: 30). Old records are cleaned up automatically.
-
-### Environment variables
-Override config with env vars:
-- \`OPENACP_TELEGRAM_BOT_TOKEN\`
-- \`OPENACP_TELEGRAM_CHAT_ID\`
-- \`OPENACP_DEFAULT_AGENT\`
-- \`OPENACP_RUN_MODE\` \u2014 foreground or daemon
-- \`OPENACP_API_PORT\` \u2014 API server port (default: 21420)
-- \`OPENACP_TUNNEL_ENABLED\`
-- \`OPENACP_TUNNEL_PORT\`
-- \`OPENACP_TUNNEL_PROVIDER\`
-- \`OPENACP_LOG_LEVEL\`
-- \`OPENACP_LOG_DIR\`
-- \`OPENACP_DEBUG\` \u2014 Sets log level to debug
-
----
-
-## Troubleshooting
-
-### Session stuck / not responding
-- Check status: ask Assistant "Is anything stuck?"
-- Cancel and create new: \`/cancel\` then \`/new\`
-- Check system health: Assistant can run health check
-
-### Agent not found
-- Check available agents: \`/agents\` or \`openacp agents\`
-- Install missing agent: \`openacp agents install <name>\`
-- Some agents need login first: \`openacp agents info <name>\` to see setup steps
-- Run agent CLI for setup: \`openacp agents run <name> -- <args>\`
-
-### Permission request not showing
-- Check Notifications topic for the alert
-- Try \`/enable_dangerous\` to auto-approve (if you trust the agent)
-
-### Session disappeared after restart
-- Sessions persist across restarts
-- Send a message in the old topic \u2014 it auto-resumes
-- If topic was deleted, the session record may still exist in status
-
-### Bot not responding at all
-- Check daemon: \`openacp status\`
-- Check logs: \`openacp logs\`
-- Restart: \`openacp start\` or \`/restart\`
-
-### Messages going to wrong topic
-- Each session is bound to a specific Telegram topic
-- If you see messages appearing in the Assistant topic instead of the session topic, try creating a new session
-
-### Viewing logs
-- Session-specific logs: \`~/.openacp/logs/sessions/\`
-- System logs: \`openacp logs\` to tail live
-- Set \`OPENACP_DEBUG=true\` for verbose output
-
----
-
-## Data & Storage
-
-All data is stored in \`~/.openacp/\`:
-- \`config.json\` \u2014 Configuration
-- \`agents.json\` \u2014 Installed agents (managed by AgentCatalog)
-- \`registry-cache.json\` \u2014 Cached ACP Registry data (refreshes every 24h)
-- \`agents/\` \u2014 Downloaded binary agents
-- \`sessions/\` \u2014 Session records and state
-- \`topics/\` \u2014 Topic-to-session mappings
-- \`logs/\` \u2014 System and session logs
-- \`plugins/\` \u2014 Installed adapter plugins
-- \`openacp.pid\` \u2014 Daemon PID file
-
-Session records auto-cleanup: 30 days (configurable via \`sessionStore.ttlDays\`).
-Session logs auto-cleanup: 30 days (configurable via \`logging.sessionLogRetentionDays\`).
-`;
-
 // src/adapters/telegram/assistant.ts
-var log15 = createChildLogger({ module: "telegram-assistant" });
+var log16 = createChildLogger({ module: "telegram-assistant" });
 async function spawnAssistant(core, adapter, assistantTopicId) {
   const config = core.configManager.get();
-  log15.info({ agent: config.defaultAgent }, "Creating assistant session...");
+  log16.info({ agent: config.defaultAgent }, "Creating assistant session...");
   const session = await core.createSession({
     channelId: "telegram",
     agentName: config.defaultAgent,
@@ -4928,7 +4810,7 @@ async function spawnAssistant(core, adapter, assistantTopicId) {
     // Prevent auto-naming from triggering after system prompt
   });
   session.threadId = String(assistantTopicId);
-  log15.info({ sessionId: session.id }, "Assistant agent spawned");
+  log16.info({ sessionId: session.id }, "Assistant agent spawned");
   const allRecords = core.sessionManager.listRecords();
   const activeCount = allRecords.filter((r) => r.status === "active" || r.status === "initializing").length;
   const statusCounts = /* @__PURE__ */ new Map();
@@ -4949,9 +4831,9 @@ async function spawnAssistant(core, adapter, assistantTopicId) {
   };
   const systemPrompt = buildAssistantSystemPrompt(ctx);
   const ready = session.enqueuePrompt(systemPrompt).then(() => {
-    log15.info({ sessionId: session.id }, "Assistant system prompt completed");
+    log16.info({ sessionId: session.id }, "Assistant system prompt completed");
   }).catch((err) => {
-    log15.warn({ err }, "Assistant system prompt failed");
+    log16.warn({ err }, "Assistant system prompt failed");
   });
   return { session, ready };
 }
@@ -5106,7 +4988,7 @@ function redirectToAssistant(chatId, assistantTopicId) {
 }
 
 // src/adapters/telegram/activity.ts
-var log16 = createChildLogger({ module: "telegram:activity" });
+var log17 = createChildLogger({ module: "telegram:activity" });
 var THINKING_REFRESH_MS = 15e3;
 var THINKING_MAX_MS = 3 * 60 * 1e3;
 var ThinkingIndicator = class {
@@ -5138,7 +5020,7 @@ var ThinkingIndicator = class {
         this.startRefreshTimer();
       }
     } catch (err) {
-      log16.warn({ err }, "ThinkingIndicator.show() failed");
+      log17.warn({ err }, "ThinkingIndicator.show() failed");
     } finally {
       this.sending = false;
     }
@@ -5211,7 +5093,7 @@ var UsageMessage = class {
         if (result) this.msgId = result.message_id;
       }
     } catch (err) {
-      log16.warn({ err }, "UsageMessage.send() failed");
+      log17.warn({ err }, "UsageMessage.send() failed");
     }
   }
   getMsgId() {
@@ -5224,7 +5106,7 @@ var UsageMessage = class {
     try {
       await this.sendQueue.enqueue(() => this.api.deleteMessage(this.chatId, id));
     } catch (err) {
-      log16.warn({ err }, "UsageMessage.delete() failed");
+      log17.warn({ err }, "UsageMessage.delete() failed");
     }
   }
 };
@@ -5310,7 +5192,7 @@ var PlanCard = class {
         if (result) this.msgId = result.message_id;
       }
     } catch (err) {
-      log16.warn({ err }, "PlanCard flush failed");
+      log17.warn({ err }, "PlanCard flush failed");
     }
   }
 };
@@ -5373,7 +5255,7 @@ var ActivityTracker = class {
           })
         );
       } catch (err) {
-        log16.warn({ err }, "ActivityTracker.onComplete() Done send failed");
+        log17.warn({ err }, "ActivityTracker.onComplete() Done send failed");
       }
     }
   }
@@ -5456,7 +5338,7 @@ var TelegramSendQueue = class {
 
 // src/adapters/telegram/action-detect.ts
 import { nanoid as nanoid3 } from "nanoid";
-import { InlineKeyboard as InlineKeyboard9 } from "grammy";
+import { InlineKeyboard as InlineKeyboard10 } 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;
@@ -5503,7 +5385,7 @@ function removeAction(id) {
   actionMap.delete(id);
 }
 function buildActionKeyboard(actionId, action) {
-  const keyboard = new InlineKeyboard9();
+  const keyboard = new InlineKeyboard10();
   if (action.action === "new_session") {
     keyboard.text("\u2705 Create session", `a:${actionId}`);
     keyboard.text("\u274C Cancel", `a:dismiss:${actionId}`);
@@ -5611,7 +5493,7 @@ function setupActionCallbacks(bot, core, chatId, getAssistantSessionId) {
 }
 
 // src/adapters/telegram/tool-call-tracker.ts
-var log17 = createChildLogger({ module: "tool-call-tracker" });
+var log18 = createChildLogger({ module: "tool-call-tracker" });
 var ToolCallTracker = class {
   constructor(bot, chatId, sendQueue) {
     this.bot = bot;
@@ -5655,7 +5537,7 @@ var ToolCallTracker = class {
     if (!toolState) return;
     if (meta.viewerLinks) {
       toolState.viewerLinks = meta.viewerLinks;
-      log17.debug({ toolId: meta.id, viewerLinks: meta.viewerLinks }, "Accumulated viewerLinks");
+      log18.debug({ toolId: meta.id, viewerLinks: meta.viewerLinks }, "Accumulated viewerLinks");
     }
     if (meta.viewerFilePath) toolState.viewerFilePath = meta.viewerFilePath;
     if (meta.name) toolState.name = meta.name;
@@ -5663,7 +5545,7 @@ var ToolCallTracker = class {
     const isTerminal = meta.status === "completed" || meta.status === "failed";
     if (!isTerminal) return;
     await toolState.ready;
-    log17.debug(
+    log18.debug(
       {
         toolId: meta.id,
         status: meta.status,
@@ -5692,7 +5574,7 @@ var ToolCallTracker = class {
         )
       );
     } catch (err) {
-      log17.warn(
+      log18.warn(
         {
           err,
           msgId: toolState.msgId,
@@ -5942,7 +5824,7 @@ var DraftManager = class {
 };
 
 // src/adapters/telegram/skill-command-manager.ts
-var log18 = createChildLogger({ module: "skill-commands" });
+var log19 = createChildLogger({ module: "skill-commands" });
 var SkillCommandManager = class {
   // sessionId → pinned msgId
   constructor(bot, chatId, sendQueue, sessionManager) {
@@ -6008,7 +5890,7 @@ var SkillCommandManager = class {
         disable_notification: true
       });
     } catch (err) {
-      log18.error({ err, sessionId }, "Failed to send skill commands");
+      log19.error({ err, sessionId }, "Failed to send skill commands");
     }
   }
   async cleanup(sessionId) {
@@ -6034,7 +5916,7 @@ var SkillCommandManager = class {
 };
 
 // src/adapters/telegram/adapter.ts
-var log19 = createChildLogger({ module: "telegram" });
+var log20 = createChildLogger({ module: "telegram" });
 function patchedFetch(input, init) {
   if (init?.signal && !(init.signal instanceof AbortSignal)) {
     const nativeController = new AbortController();
@@ -6093,7 +5975,7 @@ var TelegramAdapter = class extends ChannelAdapter {
     );
     this.bot.catch((err) => {
       const rootCause = err.error instanceof Error ? err.error : err;
-      log19.error({ err: rootCause }, "Telegram bot error");
+      log20.error({ err: rootCause }, "Telegram bot error");
     });
     this.bot.api.config.use(async (prev, method, payload, signal) => {
       const maxRetries = 3;
@@ -6107,7 +5989,7 @@ var TelegramAdapter = class extends ChannelAdapter {
         if (rateLimitedMethods.includes(method)) {
           this.sendQueue.onRateLimited();
         }
-        log19.warn(
+        log20.warn(
           { method, retryAfter, attempt: attempt + 1 },
           "Rate limited by Telegram, retrying"
         );
@@ -6239,7 +6121,7 @@ var TelegramAdapter = class extends ChannelAdapter {
     this.setupRoutes();
     this.bot.start({
       allowed_updates: ["message", "callback_query"],
-      onStart: () => log19.info(
+      onStart: () => log20.info(
         { chatId: this.telegramConfig.chatId },
         "Telegram bot started"
       )
@@ -6261,10 +6143,10 @@ var TelegramAdapter = class extends ChannelAdapter {
         reply_markup: buildMenuKeyboard()
       });
     } catch (err) {
-      log19.warn({ err }, "Failed to send welcome message");
+      log20.warn({ err }, "Failed to send welcome message");
     }
     try {
-      log19.info("Spawning assistant session...");
+      log20.info("Spawning assistant session...");
       const { session, ready } = await spawnAssistant(
         this.core,
         this,
@@ -6272,13 +6154,13 @@ var TelegramAdapter = class extends ChannelAdapter {
       );
       this.assistantSession = session;
       this.assistantInitializing = true;
-      log19.info({ sessionId: session.id }, "Assistant session ready, system prompt running in background");
+      log20.info({ sessionId: session.id }, "Assistant session ready, system prompt running in background");
       ready.then(() => {
         this.assistantInitializing = false;
-        log19.info({ sessionId: session.id }, "Assistant ready for user messages");
+        log20.info({ sessionId: session.id }, "Assistant ready for user messages");
       });
     } catch (err) {
-      log19.error({ err }, "Failed to spawn assistant");
+      log20.error({ err }, "Failed to spawn assistant");
       this.bot.api.sendMessage(
         this.telegramConfig.chatId,
         `\u26A0\uFE0F <b>Failed to start assistant session.</b>
@@ -6294,11 +6176,12 @@ var TelegramAdapter = class extends ChannelAdapter {
       await this.assistantSession.destroy();
     }
     await this.bot.stop();
-    log19.info("Telegram bot stopped");
+    log20.info("Telegram bot stopped");
   }
   setupRoutes() {
     this.bot.on("message:text", async (ctx) => {
       const threadId = ctx.message.message_thread_id;
+      const text = ctx.message.text;
       if (await handlePendingWorkspaceInput(ctx, this.core, this.telegramConfig.chatId, this.assistantTopicId)) {
         return;
       }
@@ -6311,6 +6194,7 @@ var TelegramAdapter = class extends ChannelAdapter {
         return;
       }
       if (threadId === this.notificationTopicId) return;
+      const forwardText = text.startsWith("/") ? text.slice(1) : text;
       if (threadId === this.assistantTopicId) {
         if (!this.assistantSession) {
           await ctx.reply("\u26A0\uFE0F Assistant is not available yet. Please try again shortly.", { parse_mode: "HTML" });
@@ -6319,8 +6203,8 @@ var TelegramAdapter = class extends ChannelAdapter {
         await this.draftManager.finalize(this.assistantSession.id, this.assistantSession.id);
         ctx.replyWithChatAction("typing").catch(() => {
         });
-        handleAssistantMessage(this.assistantSession, ctx.message.text).catch(
-          (err) => log19.error({ err }, "Assistant error")
+        handleAssistantMessage(this.assistantSession, forwardText).catch(
+          (err) => log20.error({ err }, "Assistant error")
         );
         return;
       }
@@ -6336,8 +6220,8 @@ var TelegramAdapter = class extends ChannelAdapter {
         channelId: "telegram",
         threadId: String(threadId),
         userId: String(ctx.from.id),
-        text: ctx.message.text
-      }).catch((err) => log19.error({ err }, "handleMessage error"));
+        text: forwardText
+      }).catch((err) => log20.error({ err }, "handleMessage error"));
     });
     this.bot.on("message:photo", async (ctx) => {
       const threadId = ctx.message.message_thread_id;
@@ -6414,7 +6298,7 @@ var TelegramAdapter = class extends ChannelAdapter {
     if (!session) return;
     const threadId = Number(session.threadId);
     if (!threadId || isNaN(threadId)) {
-      log19.warn({ sessionId, threadId: session.threadId }, "Session has no valid threadId, skipping message");
+      log20.warn({ sessionId, threadId: session.threadId }, "Session has no valid threadId, skipping message");
       return;
     }
     switch (content.type) {
@@ -6496,7 +6380,7 @@ Task completed.
         if (!content.attachment) break;
         const { attachment } = content;
         if (attachment.size > 50 * 1024 * 1024) {
-          log19.warn({ sessionId, fileName: attachment.fileName, size: attachment.size }, "File too large for Telegram (>50MB)");
+          log20.warn({ sessionId, fileName: attachment.fileName, size: attachment.size }, "File too large for Telegram (>50MB)");
           await this.sendQueue.enqueue(
             () => this.bot.api.sendMessage(
               this.telegramConfig.chatId,
@@ -6528,7 +6412,7 @@ Task completed.
             );
           }
         } catch (err) {
-          log19.error({ err, sessionId, fileName: attachment.fileName }, "Failed to send attachment");
+          log20.error({ err, sessionId, fileName: attachment.fileName }, "Failed to send attachment");
         }
         break;
       }
@@ -6580,13 +6464,13 @@ Task completed.
     }
   }
   async sendPermissionRequest(sessionId, request) {
-    log19.info({ sessionId, requestId: request.id }, "Permission request sent");
+    log20.info({ sessionId, requestId: request.id }, "Permission request sent");
     const session = this.core.sessionManager.getSession(sessionId);
     if (!session) return;
     if (request.description.includes("openacp")) {
       const allowOption = request.options.find((o) => o.isAllow);
       if (allowOption && session.permissionGate.requestId === request.id) {
-        log19.info({ sessionId, requestId: request.id }, "Auto-approving openacp command");
+        log20.info({ sessionId, requestId: request.id }, "Auto-approving openacp command");
         session.permissionGate.resolve(allowOption.id);
       }
       return;
@@ -6594,7 +6478,7 @@ Task completed.
     if (session.dangerousMode) {
       const allowOption = request.options.find((o) => o.isAllow);
       if (allowOption && session.permissionGate.requestId === request.id) {
-        log19.info({ sessionId, requestId: request.id, optionId: allowOption.id }, "Dangerous mode: auto-approving permission");
+        log20.info({ sessionId, requestId: request.id, optionId: allowOption.id }, "Dangerous mode: auto-approving permission");
         session.permissionGate.resolve(allowOption.id);
       }
       return;
@@ -6605,7 +6489,7 @@ Task completed.
   }
   async sendNotification(notification) {
     if (notification.sessionId === this.assistantSession?.id) return;
-    log19.info(
+    log20.info(
       { sessionId: notification.sessionId, type: notification.type },
       "Notification sent"
     );
@@ -6641,7 +6525,7 @@ Task completed.
     );
   }
   async createSessionThread(sessionId, name) {
-    log19.info({ sessionId, name }, "Session topic created");
+    log20.info({ sessionId, name }, "Session topic created");
     return String(
       await createSessionTopic(this.bot, this.telegramConfig.chatId, name)
     );
@@ -6665,7 +6549,7 @@ Task completed.
     try {
       await this.bot.api.deleteForumTopic(this.telegramConfig.chatId, topicId);
     } catch (err) {
-      log19.warn({ err, sessionId, topicId }, "Failed to delete forum topic (may already be deleted)");
+      log20.warn({ err, sessionId, topicId }, "Failed to delete forum topic (may already be deleted)");
     }
   }
   async sendSkillCommands(sessionId, commands) {
@@ -6689,7 +6573,7 @@ Task completed.
       const buffer = Buffer.from(await response.arrayBuffer());
       return { buffer, filePath: file.file_path };
     } catch (err) {
-      log19.error({ err }, "Failed to download file from Telegram");
+      log20.error({ err }, "Failed to download file from Telegram");
       return null;
     }
   }
@@ -6701,14 +6585,15 @@ Task completed.
       try {
         buffer = await this.fileService.convertOggToWav(buffer);
       } catch (err) {
-        log19.warn({ err }, "OGG\u2192WAV conversion failed, saving original OGG");
+        log20.warn({ err }, "OGG\u2192WAV conversion failed, saving original OGG");
         fileName = "voice.ogg";
         mimeType = "audio/ogg";
       }
     }
     const sessionId = this.resolveSessionId(threadId) || "unknown";
     const att = await this.fileService.saveFile(sessionId, fileName, buffer, mimeType);
-    const text = caption || `[${att.type === "image" ? "Photo" : att.type === "audio" ? "Audio" : "File"}: ${att.fileName}]`;
+    const rawText = caption || `[${att.type === "image" ? "Photo" : att.type === "audio" ? "Audio" : "File"}: ${att.fileName}]`;
+    const text = rawText.startsWith("/") ? rawText.slice(1) : rawText;
     if (threadId === this.assistantTopicId) {
       if (this.assistantSession) {
         await this.assistantSession.enqueuePrompt(text, [att]);
@@ -6723,7 +6608,7 @@ Task completed.
       userId: String(userId),
       text,
       attachments: [att]
-    }).catch((err) => log19.error({ err }, "handleMessage error"));
+    }).catch((err) => log20.error({ err }, "handleMessage error"));
   }
   async cleanupSkillCommands(sessionId) {
     await this.skillManager.cleanup(sessionId);
@@ -6746,9 +6631,8 @@ export {
   NotificationManager,
   MessageTransformer,
   OpenACPCore,
-  ChannelAdapter,
   ApiServer,
   TopicManager,
   TelegramAdapter
 };
-//# sourceMappingURL=chunk-65XE66HK.js.map
+//# sourceMappingURL=chunk-V2V767XI.js.map