@openacp/cli 0.6.9 → 2026.41.1

package/dist/chunk-H5P2C6H4.js

@@ -1,4740 +0,0 @@
-import {
-  PRODUCT_GUIDE,
-  STATUS_ICONS,
-  dispatchMessage,
-  evaluateNoise,
-  extractContentText,
-  formatTokens,
-  formatToolSummary,
-  formatToolTitle,
-  progressBar,
-  splitMessage,
-  stripCodeFences,
-  truncateContent
-} from "./chunk-JUYDFUSN.js";
-import {
-  CheckpointReader,
-  DEFAULT_MAX_TOKENS
-} from "./chunk-LGP2YGRL.js";
-import {
-  ChannelAdapter
-} from "./chunk-LBIKITQT.js";
-import {
-  DoctorEngine
-} from "./chunk-NVPG6JCL.js";
-import {
-  buildMenuKeyboard,
-  buildSkillMessages,
-  handleClear,
-  handleHelp,
-  handleMenu
-} from "./chunk-7QJS2XBD.js";
-import {
-  getConfigValue,
-  getSafeFields,
-  isHotReloadable,
-  resolveOptions
-} from "./chunk-JHYXKVV2.js";
-import {
-  createChildLogger
-} from "./chunk-GAK6PIBW.js";
-
-// src/adapters/telegram/adapter.ts
-import { Bot, InputFile } from "grammy";
-
-// src/adapters/telegram/topics.ts
-async function ensureTopics(bot, chatId, config, saveConfig) {
-  let notificationTopicId = config.notificationTopicId;
-  let assistantTopicId = config.assistantTopicId;
-  if (notificationTopicId === null) {
-    const topic = await bot.api.createForumTopic(chatId, "\u{1F4CB} Notifications");
-    notificationTopicId = topic.message_thread_id;
-    await saveConfig({ notificationTopicId });
-  }
-  if (assistantTopicId === null) {
-    const topic = await bot.api.createForumTopic(chatId, "\u{1F916} Assistant");
-    assistantTopicId = topic.message_thread_id;
-    await saveConfig({ assistantTopicId });
-  }
-  return { notificationTopicId, assistantTopicId };
-}
-async function createSessionTopic(bot, chatId, name) {
-  const topic = await bot.api.createForumTopic(chatId, name);
-  return topic.message_thread_id;
-}
-async function renameSessionTopic(bot, chatId, threadId, name) {
-  try {
-    await bot.api.editForumTopic(chatId, threadId, { name });
-  } catch {
-  }
-}
-async function deleteSessionTopic(bot, chatId, threadId) {
-  await bot.api.deleteForumTopic(chatId, threadId);
-}
-function buildDeepLink(chatId, threadId, messageId) {
-  const cleanId = String(chatId).replace("-100", "");
-  if (messageId && messageId !== threadId) {
-    return `https://t.me/c/${cleanId}/${threadId}/${messageId}`;
-  }
-  return `https://t.me/c/${cleanId}/${threadId}`;
-}
-
-// src/adapters/telegram/commands/new-session.ts
-import { InlineKeyboard as InlineKeyboard2 } from "grammy";
-
-// src/adapters/telegram/formatting.ts
-function escapeHtml(text) {
-  if (!text) return "";
-  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
-}
-function markdownToTelegramHtml(md) {
-  const codeBlocks = [];
-  const inlineCodes = [];
-  let text = md.replace(
-    /```(\w*)\n?([\s\S]*?)```/g,
-    (_match, lang, code) => {
-      const index = codeBlocks.length;
-      const escapedCode = escapeHtml(code);
-      const langAttr = lang ? ` class="language-${escapeHtml(lang)}"` : "";
-      codeBlocks.push(`<pre><code${langAttr}>${escapedCode}</code></pre>`);
-      return `\0CODE_BLOCK_${index}\0`;
-    }
-  );
-  text = text.replace(/`([^`]+)`/g, (_match, code) => {
-    const index = inlineCodes.length;
-    inlineCodes.push(`<code>${escapeHtml(code)}</code>`);
-    return `\0INLINE_CODE_${index}\0`;
-  });
-  text = escapeHtml(text);
-  text = text.replace(/\*\*(.+?)\*\*/g, "<b>$1</b>");
-  text = text.replace(/(?<!\*)\*(?!\*)(.+?)(?<!\*)\*(?!\*)/g, "<i>$1</i>");
-  text = text.replace(/\[([^\]]+)\]\(([^)]+)\)/g, '<a href="$2">$1</a>');
-  text = text.replace(/\x00CODE_BLOCK_(\d+)\x00/g, (_match, idx) => {
-    return codeBlocks[parseInt(idx, 10)];
-  });
-  text = text.replace(/\x00INLINE_CODE_(\d+)\x00/g, (_match, idx) => {
-    return inlineCodes[parseInt(idx, 10)];
-  });
-  return text;
-}
-function formatToolCall(tool, verbosity = "medium") {
-  const si = STATUS_ICONS[tool.status || ""] || "\u{1F527}";
-  const name = tool.name || "Tool";
-  const label = verbosity === "low" ? formatToolTitle(name, tool.rawInput) : formatToolSummary(name, tool.rawInput);
-  let text = `${si} <b>${escapeHtml(label)}</b>`;
-  text += formatViewerLinks(tool.viewerLinks, tool.viewerFilePath);
-  if (verbosity === "high" || verbosity === "medium" && !tool.viewerLinks) {
-    const details = stripCodeFences(extractContentText(tool.content));
-    if (details) {
-      text += `
-<pre>${escapeHtml(truncateContent(details, 3800))}</pre>`;
-    }
-  }
-  return text;
-}
-function formatToolUpdate(update, verbosity = "medium") {
-  const si = STATUS_ICONS[update.status] || "\u{1F527}";
-  const name = update.name || "Tool";
-  const label = verbosity === "low" ? formatToolTitle(name, update.rawInput) : formatToolSummary(name, update.rawInput);
-  let text = `${si} <b>${escapeHtml(label)}</b>`;
-  text += formatViewerLinks(update.viewerLinks, update.viewerFilePath);
-  if (verbosity === "high" || verbosity === "medium" && !update.viewerLinks) {
-    const details = stripCodeFences(extractContentText(update.content));
-    if (details) {
-      text += `
-<pre>${escapeHtml(truncateContent(details, 3800))}</pre>`;
-    }
-  }
-  return text;
-}
-function formatViewerLinks(links, filePath) {
-  if (!links) return "";
-  const fileName = filePath ? filePath.split("/").pop() || filePath : "";
-  let text = "\n";
-  if (links.file)
-    text += `
-\u{1F4C4} <a href="${escapeHtml(links.file)}">View ${escapeHtml(fileName || "file")}</a>`;
-  if (links.diff)
-    text += `
-\u{1F4DD} <a href="${escapeHtml(links.diff)}">View diff${fileName ? ` \u2014 ${escapeHtml(fileName)}` : ""}</a>`;
-  return text;
-}
-function formatUsage(usage) {
-  const { tokensUsed, contextSize } = usage;
-  if (tokensUsed == null) return "\u{1F4CA} Usage data unavailable";
-  if (contextSize == null) return `\u{1F4CA} ${formatTokens(tokensUsed)} tokens`;
-  const ratio = tokensUsed / contextSize;
-  const pct = Math.round(ratio * 100);
-  const bar = progressBar(ratio);
-  const emoji = pct >= 85 ? "\u26A0\uFE0F" : "\u{1F4CA}";
-  return `${emoji} ${formatTokens(tokensUsed)} / ${formatTokens(contextSize)} tokens
-${bar} ${pct}%`;
-}
-var PERIOD_LABEL = {
-  today: "Today",
-  week: "This Week",
-  month: "This Month",
-  all: "All Time"
-};
-function formatUsageReport(summaries, budgetStatus) {
-  const hasData = summaries.some((s) => s.recordCount > 0);
-  if (!hasData) {
-    return "\u{1F4CA} <b>Usage Report</b>\n\nNo usage data yet.";
-  }
-  const formatCost = (n) => `$${n.toFixed(2)}`;
-  const lines = ["\u{1F4CA} <b>Usage Report</b>"];
-  for (const summary of summaries) {
-    lines.push("");
-    lines.push(
-      `\u2500\u2500 <b>${PERIOD_LABEL[summary.period] ?? summary.period}</b> \u2500\u2500`
-    );
-    lines.push(
-      `\u{1F4B0} ${formatCost(summary.totalCost)} \xB7 \u{1F524} ${formatTokens(summary.totalTokens)} tokens \xB7 \u{1F4CB} ${summary.sessionCount} sessions`
-    );
-    if (summary.period === "month" && budgetStatus.budget > 0) {
-      const bar = progressBar(budgetStatus.used / budgetStatus.budget);
-      lines.push(
-        `Budget: ${formatCost(budgetStatus.used)} / ${formatCost(budgetStatus.budget)} (${budgetStatus.percent}%)`
-      );
-      lines.push(`${bar} ${budgetStatus.percent}%`);
-    }
-  }
-  return lines.join("\n");
-}
-function formatSummary(summary, sessionName) {
-  const header = sessionName ? `\u{1F4CB} <b>Summary \u2014 ${escapeHtml(sessionName)}</b>` : "\u{1F4CB} <b>Session Summary</b>";
-  return `${header}
-
-${escapeHtml(summary)}`;
-}
-function splitMessage2(text, maxLength = 3800) {
-  return splitMessage(text, maxLength);
-}
-
-// src/adapters/telegram/commands/admin.ts
-import { InlineKeyboard } from "grammy";
-var log = createChildLogger({ module: "telegram-cmd-admin" });
-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;
-      log.info(
-        { sessionId, dangerousMode: session.dangerousMode },
-        "Dangerous mode toggled via button"
-      );
-      core.sessionManager.patchRecord(sessionId, { dangerousMode: 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: buildSessionControlKeyboard(
-            sessionId,
-            session.dangerousMode,
-            session.voiceMode === "on"
-          )
-        });
-      } 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.patchRecord(sessionId, { dangerousMode: newDangerousMode }).catch(() => {
-    });
-    log.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: buildSessionControlKeyboard(
-          sessionId,
-          newDangerousMode,
-          false
-        )
-      });
-    } catch {
-    }
-  });
-}
-async function handleEnableDangerous(ctx, core) {
-  const threadId = ctx.message?.message_thread_id;
-  if (!threadId) {
-    await ctx.reply("\u26A0\uFE0F This command only works inside a session topic.", {
-      parse_mode: "HTML"
-    });
-    return;
-  }
-  const session = core.sessionManager.getSessionByThread(
-    "telegram",
-    String(threadId)
-  );
-  if (session) {
-    if (session.dangerousMode) {
-      await ctx.reply("\u2620\uFE0F Dangerous mode is already enabled.", {
-        parse_mode: "HTML"
-      });
-      return;
-    }
-    session.dangerousMode = true;
-    core.sessionManager.patchRecord(session.id, { dangerousMode: 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.patchRecord(record.sessionId, { dangerousMode: 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.
-
-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.patchRecord(session.id, { dangerousMode: 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.patchRecord(record.sessionId, { dangerousMode: false }).catch(() => {
-    });
-  }
-  await ctx.reply(
-    "\u{1F510} <b>Dangerous mode disabled</b>\n\nPermission requests will be shown normally.",
-    { parse_mode: "HTML" }
-  );
-}
-function buildSessionControlKeyboard(sessionId, dangerousMode, voiceMode) {
-  return new InlineKeyboard().text(
-    dangerousMode ? "\u{1F510} Disable Dangerous Mode" : "\u2620\uFE0F Enable Dangerous Mode",
-    `d:${sessionId}`
-  ).row().text(
-    voiceMode ? "\u{1F50A} Text to Speech" : "\u{1F507} Text to Speech",
-    `v:${sessionId}`
-  );
-}
-function setupTTSCallbacks(bot, core) {
-  bot.callbackQuery(/^v:/, async (ctx) => {
-    const sessionId = ctx.callbackQuery.data.slice(2);
-    const session = core.sessionManager.getSession(sessionId);
-    if (!session) {
-      try {
-        await ctx.answerCallbackQuery({
-          text: "\u26A0\uFE0F Session not found or not active."
-        });
-      } catch {
-      }
-      return;
-    }
-    const newMode = session.voiceMode === "on" ? "off" : "on";
-    session.setVoiceMode(newMode);
-    const toastText = newMode === "on" ? "\u{1F50A} Text to Speech enabled" : "\u{1F507} Text to Speech disabled";
-    try {
-      await ctx.answerCallbackQuery({ text: toastText });
-    } catch {
-    }
-    try {
-      await ctx.editMessageReplyMarkup({
-        reply_markup: buildSessionControlKeyboard(
-          sessionId,
-          session.dangerousMode,
-          newMode === "on"
-        )
-      });
-    } catch {
-    }
-  });
-}
-async function handleTTS(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 = await core.getOrResumeSession("telegram", String(threadId));
-  if (!session) {
-    await ctx.reply("\u26A0\uFE0F No active session in this topic.", {
-      parse_mode: "HTML"
-    });
-    return;
-  }
-  const args = ctx.message?.text?.split(/\s+/).slice(1) ?? [];
-  const arg = args[0]?.toLowerCase();
-  if (arg === "on") {
-    session.setVoiceMode("on");
-    await ctx.reply("\u{1F50A} Text to Speech enabled for this session.", {
-      parse_mode: "HTML"
-    });
-  } else if (arg === "off") {
-    session.setVoiceMode("off");
-    await ctx.reply("\u{1F507} Text to Speech disabled.", { parse_mode: "HTML" });
-  } else {
-    session.setVoiceMode("next");
-    await ctx.reply("\u{1F50A} Text to Speech enabled for the next message.", {
-      parse_mode: "HTML"
-    });
-  }
-}
-var VERBOSITY_LABELS = {
-  low: "\u{1F507} Low",
-  medium: "\u{1F4CA} Medium",
-  high: "\u{1F4D6} High"
-};
-async function handleVerbosity(ctx, core) {
-  const args = ctx.message?.text?.split(/\s+/).slice(1) ?? [];
-  const arg = args[0]?.toLowerCase();
-  if (arg === "low" || arg === "medium" || arg === "high") {
-    await core.configManager.save(
-      { channels: { telegram: { displayVerbosity: arg } } },
-      "channels.telegram.displayVerbosity"
-    );
-    await ctx.reply(
-      `${VERBOSITY_LABELS[arg]} Display verbosity set to <b>${arg}</b>.`,
-      { parse_mode: "HTML" }
-    );
-  } else {
-    const current = core.configManager.get().channels?.telegram?.displayVerbosity ?? "medium";
-    await ctx.reply(
-      `\u{1F4CA} Current verbosity: <b>${current}</b>
-
-Usage: <code>/verbosity low|medium|high</code>
-
-\u2022 <b>low</b> \u2014 minimal output, title only
-\u2022 <b>medium</b> \u2014 balanced (default)
-\u2022 <b>high</b> \u2014 full detail with content`,
-      { parse_mode: "HTML" }
-    );
-  }
-}
-function setupVerbosityCallbacks(bot, core) {
-  bot.callbackQuery(/^vb:/, async (ctx) => {
-    const level = ctx.callbackQuery.data.slice(3);
-    if (level !== "low" && level !== "medium" && level !== "high") return;
-    await core.configManager.save(
-      { channels: { telegram: { displayVerbosity: level } } },
-      "channels.telegram.displayVerbosity"
-    );
-    try {
-      await ctx.answerCallbackQuery({
-        text: `${VERBOSITY_LABELS[level]} Verbosity: ${level}`
-      });
-    } catch {
-    }
-  });
-}
-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-NQZBM5M7.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 log2 = 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;
-    }
-  }
-  await showAgentPicker(ctx, core, chatId, agentName);
-}
-async function startWorkspaceStep(ctx, core, chatId, userId, agentName) {
-  const config = core.configManager.get();
-  const baseDir = config.workspace.baseDir;
-  const keyboard = new InlineKeyboard2().text(`\u{1F4C1} Use ${baseDir}`, "m:new:ws:default").row().text("\u270F\uFE0F Enter project path", "m:new:ws:custom");
-  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.
-
-Or use the default directory below:`;
-  let msg;
-  try {
-    const pending = pendingNewSessions.get(userId);
-    if (pending?.messageId) {
-      await ctx.api.editMessageText(chatId, pending.messageId, text, {
-        parse_mode: "HTML",
-        reply_markup: keyboard
-      });
-      msg = { message_id: pending.messageId };
-    } else {
-      msg = await ctx.reply(text, { parse_mode: "HTML", reply_markup: keyboard });
-    }
-  } catch {
-    msg = await ctx.reply(text, { parse_mode: "HTML", reply_markup: keyboard });
-  }
-  cleanupPending(userId);
-  pendingNewSessions.set(userId, {
-    agentName,
-    step: "workspace",
-    messageId: msg.message_id,
-    threadId: ctx.message?.message_thread_id ?? ctx.callbackQuery?.message?.message_thread_id,
-    timer: setTimeout(() => pendingNewSessions.delete(userId), PENDING_TIMEOUT_MS)
-  });
-}
-async function startConfirmStep(ctx, chatId, userId, agentName, workspace) {
-  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)}
-<b>Project:</b> <code>${escapeHtml(workspace)}</code>`;
-  let msg;
-  try {
-    const pending = pendingNewSessions.get(userId);
-    if (pending?.messageId) {
-      await ctx.api.editMessageText(chatId, pending.messageId, text, {
-        parse_mode: "HTML",
-        reply_markup: keyboard
-      });
-      msg = { message_id: pending.messageId };
-    } else {
-      msg = await ctx.reply(text, { parse_mode: "HTML", reply_markup: keyboard });
-    }
-  } catch {
-    msg = await ctx.reply(text, { parse_mode: "HTML", reply_markup: keyboard });
-  }
-  cleanupPending(userId);
-  pendingNewSessions.set(userId, {
-    agentName,
-    workspace,
-    step: "confirm",
-    messageId: msg.message_id,
-    threadId: ctx.message?.message_thread_id ?? ctx.callbackQuery?.message?.message_thread_id,
-    timer: setTimeout(() => pendingNewSessions.delete(userId), PENDING_TIMEOUT_MS)
-  });
-}
-async function createSessionDirect(ctx, core, chatId, agentName, workspace) {
-  log2.info({ userId: ctx.from?.id, agentName, workspace }, "New session command (direct)");
-  let threadId;
-  try {
-    const topicName = `\u{1F504} New Session`;
-    threadId = await createSessionTopic(botFromCtx(ctx), chatId, topicName);
-    await ctx.api.sendMessage(chatId, `\u23F3 Setting up session, please wait...`, {
-      message_thread_id: threadId,
-      parse_mode: "HTML"
-    });
-    const session = await core.handleNewSession("telegram", agentName, workspace);
-    session.threadId = String(threadId);
-    await core.sessionManager.patchRecord(session.id, { platform: { topicId: threadId } });
-    const finalName = `\u{1F504} ${session.agentName} \u2014 New Session`;
-    try {
-      await ctx.api.editForumTopic(chatId, threadId, { name: finalName });
-    } catch {
-    }
-    await ctx.api.sendMessage(
-      chatId,
-      `\u2705 <b>Session started</b>
-<b>Agent:</b> ${escapeHtml(session.agentName)}
-<b>Workspace:</b> <code>${escapeHtml(session.workingDirectory)}</code>
-
-This is your coding session \u2014 chat here to work with the agent.`,
-      {
-        message_thread_id: threadId,
-        parse_mode: "HTML",
-        reply_markup: buildSessionControlKeyboard(session.id, false, false)
-      }
-    );
-    session.warmup().catch((err) => log2.error({ err }, "Warm-up error"));
-    return threadId ?? null;
-  } catch (err) {
-    log2.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"
-      });
-      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.patchRecord(session.id, { platform: {
-      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: buildSessionControlKeyboard(session.id, false, false)
-      }
-    );
-    session.warmup().catch((err) => log2.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.patchRecord(session.id, { platform: {
-      topicId: threadId
-    } });
-    const finalName = `\u{1F504} ${session.agentName} \u2014 New Session`;
-    await renameSessionTopic(bot, chatId, threadId, finalName);
-    session.warmup().catch((err) => log2.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) {
-  await showAgentPicker(ctx, core, chatId, agentName);
-}
-async function showAgentPicker(ctx, core, chatId, agentName) {
-  const userId = ctx.from?.id;
-  if (!userId) return;
-  const installedEntries = core.agentCatalog.getInstalledEntries();
-  const agentKeys = Object.keys(installedEntries);
-  const config = core.configManager.get();
-  if (agentName || agentKeys.length === 1) {
-    const selectedAgent = agentName || config.defaultAgent;
-    await startWorkspaceStep(ctx, core, chatId, userId, selectedAgent);
-    return;
-  }
-  const keyboard = new InlineKeyboard2();
-  for (const key of agentKeys) {
-    const agent = installedEntries[key];
-    const label = key === config.defaultAgent ? `${agent.name} (default)` : agent.name;
-    keyboard.text(label, `m:new:agent:${key}`).row();
-  }
-  const msg = await ctx.reply(
-    `\u{1F916} <b>Choose an agent:</b>`,
-    { parse_mode: "HTML", reply_markup: keyboard }
-  );
-  cleanupPending(userId);
-  const threadId = ctx.message?.message_thread_id ?? ctx.callbackQuery?.message?.message_thread_id;
-  pendingNewSessions.set(userId, {
-    step: "agent",
-    messageId: msg.message_id,
-    threadId,
-    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;
-    }
-    if (data === "m:new:cancel") {
-      const userId = ctx.from?.id;
-      if (userId) cleanupPending(userId);
-      try {
-        await ctx.editMessageText("\u274C Session creation cancelled.", { parse_mode: "HTML" });
-      } catch {
-      }
-      return;
-    }
-  });
-}
-
-// src/adapters/telegram/commands/session.ts
-import { InlineKeyboard as InlineKeyboard3 } from "grammy";
-var log3 = createChildLogger({ module: "telegram-cmd-session" });
-async function handleCancel(ctx, core, assistant) {
-  const threadId = ctx.message?.message_thread_id;
-  if (!threadId) return;
-  if (assistant && threadId === assistant.topicId) {
-    const assistantSession = assistant.getSession();
-    if (assistantSession) {
-      await assistantSession.enqueuePrompt(
-        "User wants to cancel a session. Confirm which session to cancel."
-      );
-      return;
-    }
-  }
-  const session = core.sessionManager.getSessionByThread(
-    "telegram",
-    String(threadId)
-  );
-  if (session) {
-    log3.info({ sessionId: session.id }, "Abort prompt command");
-    await session.abortPrompt();
-    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 !== "error") {
-    log3.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) {
-  const threadId = ctx.message?.message_thread_id;
-  if (threadId) {
-    const session = core.sessionManager.getSessionByThread(
-      "telegram",
-      String(threadId)
-    );
-    if (session) {
-      await ctx.reply(
-        `<b>Session:</b> ${escapeHtml(session.name || session.id)}
-<b>Agent:</b> ${escapeHtml(session.agentName)}
-<b>Status:</b> ${escapeHtml(session.status)}
-<b>Workspace:</b> <code>${escapeHtml(session.workingDirectory)}</code>
-<b>Queue:</b> ${session.queueDepth} pending`,
-        { parse_mode: "HTML" }
-      );
-    } else {
-      const record = core.sessionManager.getRecordByThread("telegram", String(threadId));
-      if (record) {
-        await ctx.reply(
-          `<b>Session:</b> ${escapeHtml(record.name || record.sessionId)}
-<b>Agent:</b> ${escapeHtml(record.agentName)}
-<b>Status:</b> ${escapeHtml(record.status)} (not loaded)
-<b>Workspace:</b> <code>${escapeHtml(record.workingDir)}</code>`,
-          { parse_mode: "HTML" }
-        );
-      } else {
-        await ctx.reply("No active session in this topic.", {
-          parse_mode: "HTML"
-        });
-      }
-    }
-  } else {
-    const sessions = core.sessionManager.listSessions("telegram");
-    const active = sessions.filter(
-      (s) => s.status === "active" || s.status === "initializing"
-    );
-    await ctx.reply(
-      `<b>OpenACP Status</b>
-Active sessions: ${active.length}
-Total sessions: ${sessions.length}`,
-      { parse_mode: "HTML" }
-    );
-  }
-}
-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 = allRecords.filter((r) => r.status === "finished").length;
-    const errorCount = allRecords.filter((r) => r.status === "error" || r.status === "cancelled").length;
-    const keyboard = new InlineKeyboard3();
-    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 (${allRecords.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) {
-    log3.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) => 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) {
-          log3.warn({ err, sessionId: record.sessionId, topicId }, "Failed to delete forum topic during cleanup");
-        }
-      }
-      await core.sessionManager.removeRecord(record.sessionId);
-      deleted++;
-    } catch (err) {
-      log3.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 (systemTopicIds && platform?.topicId && (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 InlineKeyboard3().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 (systemTopicIds && platform?.topicId && (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) {
-          log3.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) {
-          log3.warn({ err, sessionId: record.sessionId, topicId }, "Failed to delete forum topic during cleanup");
-        }
-      }
-      await core.sessionManager.removeRecord(record.sessionId);
-      deleted++;
-    } catch (err) {
-      log3.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 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.abortPrompt();
-  return session;
-}
-function setupSessionCallbacks(bot, core, chatId, systemTopicIds) {
-  bot.callbackQuery(/^m:cleanup/, async (ctx) => {
-    const data = ctx.callbackQuery.data;
-    try {
-      await ctx.answerCallbackQuery();
-    } 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 handleUsage(ctx, core) {
-  if (!core.usageStore) {
-    await ctx.reply("\u{1F4CA} Usage tracking is disabled.", { parse_mode: "HTML" });
-    return;
-  }
-  const rawMatch = ctx.match;
-  const period = typeof rawMatch === "string" ? rawMatch.trim().toLowerCase() : "";
-  let summaries;
-  if (period === "today" || period === "week" || period === "month") {
-    summaries = [core.usageStore.query(period)];
-  } else {
-    summaries = [
-      core.usageStore.query("month"),
-      core.usageStore.query("week"),
-      core.usageStore.query("today")
-    ];
-  }
-  const budgetStatus = core.usageBudget ? core.usageBudget.getStatus() : { status: "ok", used: 0, budget: 0, percent: 0 };
-  const text = formatUsageReport(summaries, budgetStatus);
-  await ctx.reply(text, { parse_mode: "HTML" });
-}
-async function handleArchive(ctx, core) {
-  const threadId = ctx.message?.message_thread_id;
-  if (!threadId) return;
-  const session = core.sessionManager.getSessionByThread("telegram", String(threadId));
-  const record = !session ? core.sessionManager.getRecordByThread("telegram", String(threadId)) : void 0;
-  const identifier = session?.id ?? record?.sessionId ?? `topic:${threadId}`;
-  await ctx.reply(
-    "\u26A0\uFE0F <b>Archive this session?</b>\n\nThis will:\n\u2022 Delete this topic and all messages\n\u2022 Stop the agent session (if running)\n\u2022 Remove the session record\n\n<i>This action cannot be undone.</i>",
-    {
-      parse_mode: "HTML",
-      reply_markup: new InlineKeyboard3().text("\u{1F5D1} Yes, archive", `ar:yes:${identifier}`).text("\u274C Cancel", `ar:no:${identifier}`)
-    }
-  );
-}
-async function handleArchiveConfirm(ctx, core, chatId) {
-  const data = ctx.callbackQuery?.data;
-  if (!data) return;
-  try {
-    await ctx.answerCallbackQuery();
-  } catch {
-  }
-  const [, action, ...rest] = data.split(":");
-  const identifier = rest.join(":");
-  if (action === "no") {
-    await ctx.editMessageText("Archive cancelled.", { parse_mode: "HTML" });
-    return;
-  }
-  await ctx.editMessageText("\u{1F504} Archiving...", { parse_mode: "HTML" });
-  if (identifier.startsWith("topic:")) {
-    const topicId = Number(identifier.slice("topic:".length));
-    try {
-      await ctx.api.deleteForumTopic(chatId, topicId);
-      core.notificationManager.notifyAll({
-        sessionId: "system",
-        sessionName: `Orphan topic #${topicId}`,
-        type: "completed",
-        summary: `Orphan topic #${topicId} archived and deleted.`
-      });
-    } catch (err) {
-      core.notificationManager.notifyAll({
-        sessionId: "system",
-        sessionName: `Orphan topic #${topicId}`,
-        type: "error",
-        summary: `Failed to delete orphan topic #${topicId}: ${err.message}`
-      });
-    }
-    return;
-  }
-  const result = await core.archiveSession(identifier);
-  if (result.ok) {
-    core.notificationManager.notifyAll({
-      sessionId: identifier,
-      type: "completed",
-      summary: `Session archived and deleted.`
-    });
-  } else {
-    try {
-      await ctx.editMessageText(`\u274C Failed to archive: <code>${escapeHtml(result.error)}</code>`, { parse_mode: "HTML" });
-    } catch {
-      core.notificationManager.notifyAll({
-        sessionId: identifier,
-        type: "error",
-        summary: `Failed to archive session "${identifier}": ${result.error}`
-      });
-    }
-  }
-}
-async function handleSummary(ctx, core) {
-  const threadId = ctx.message?.message_thread_id;
-  if (!threadId) return;
-  const session = core.sessionManager.getSessionByThread("telegram", String(threadId));
-  const record = !session ? core.sessionManager.getRecordByThread("telegram", String(threadId)) : void 0;
-  const sessionId = session?.id ?? record?.sessionId;
-  if (!sessionId) {
-    await ctx.reply(
-      "\u2139\uFE0F <b>/summary</b> works in session topics \u2014 it asks the agent to summarize the session.\n\nGo to a session topic and type /summary there.",
-      { parse_mode: "HTML" }
-    );
-    return;
-  }
-  await ctx.replyWithChatAction("typing");
-  const result = await core.summarizeSession(sessionId);
-  if (result.ok) {
-    await ctx.reply(formatSummary(result.summary, session?.name ?? record?.name), { parse_mode: "HTML" });
-  } else {
-    await ctx.reply(`\u26A0\uFE0F ${escapeHtml(result.error)}`, { parse_mode: "HTML" });
-  }
-}
-async function handleSummaryCallback(ctx, core, chatId) {
-  const data = ctx.callbackQuery?.data;
-  if (!data) return;
-  const sessionId = data.replace("sm:summary:", "");
-  try {
-    await ctx.answerCallbackQuery();
-  } catch {
-  }
-  const session = core.sessionManager.getSession(sessionId);
-  const record = !session ? core.sessionManager.getSessionRecord(sessionId) : void 0;
-  const threadId = session ? Number(session.threadId) : record?.platform?.topicId ?? 0;
-  if (!threadId) return;
-  await ctx.api.sendMessage(chatId, "\u{1F4CB} Generating summary...", {
-    message_thread_id: threadId,
-    parse_mode: "HTML"
-  });
-  const result = await core.summarizeSession(sessionId);
-  const sessionName = session?.name ?? record?.name;
-  if (result.ok) {
-    await ctx.api.sendMessage(chatId, formatSummary(result.summary, sessionName), {
-      message_thread_id: threadId,
-      parse_mode: "HTML"
-    });
-  } else {
-    await ctx.api.sendMessage(chatId, `\u26A0\uFE0F ${escapeHtml(result.error)}`, {
-      message_thread_id: threadId,
-      parse_mode: "HTML"
-    });
-  }
-}
-
-// src/adapters/telegram/commands/agents.ts
-import { InlineKeyboard as InlineKeyboard4 } from "grammy";
-var AGENTS_PER_PAGE = 6;
-async function handleAgents(ctx, core, page = 0) {
-  const catalog = core.agentCatalog;
-  const items = catalog.getAvailable();
-  const installed = items.filter((i) => i.installed);
-  const available = items.filter((i) => !i.installed);
-  let text = "<b>\u{1F916} Agents</b>\n\n";
-  if (installed.length > 0) {
-    text += "<b>Installed:</b>\n";
-    for (const item of installed) {
-      text += `\u2705 <b>${escapeHtml(item.name)}</b>`;
-      if (item.description) {
-        text += ` \u2014 <i>${escapeHtml(truncate(item.description, 50))}</i>`;
-      }
-      text += "\n";
-    }
-    text += "\n";
-  }
-  if (available.length > 0) {
-    const totalPages = Math.ceil(available.length / AGENTS_PER_PAGE);
-    const safePage = Math.max(0, Math.min(page, totalPages - 1));
-    const pageItems = available.slice(safePage * AGENTS_PER_PAGE, (safePage + 1) * AGENTS_PER_PAGE);
-    text += `<b>Available to install:</b>`;
-    if (totalPages > 1) {
-      text += ` (${safePage + 1}/${totalPages})`;
-    }
-    text += "\n";
-    for (const item of pageItems) {
-      if (item.available) {
-        text += `\u2B07\uFE0F <b>${escapeHtml(item.name)}</b>`;
-      } else {
-        const deps = item.missingDeps?.join(", ") ?? "requirements not met";
-        text += `\u26A0\uFE0F <b>${escapeHtml(item.name)}</b> <i>(needs: ${escapeHtml(deps)})</i>`;
-      }
-      if (item.description) {
-        text += `
-    <i>${escapeHtml(truncate(item.description, 60))}</i>`;
-      }
-      text += "\n";
-    }
-    const keyboard = new InlineKeyboard4();
-    const installable = pageItems.filter((i) => i.available);
-    for (let i = 0; i < installable.length; i += 2) {
-      const row = installable.slice(i, i + 2);
-      for (const item of row) {
-        keyboard.text(`\u2B07\uFE0F ${item.name}`, `ag:install:${item.key}`);
-      }
-      keyboard.row();
-    }
-    if (totalPages > 1) {
-      if (safePage > 0) {
-        keyboard.text("\u25C0\uFE0F Prev", `ag:page:${safePage - 1}`);
-      }
-      if (safePage < totalPages - 1) {
-        keyboard.text("Next \u25B6\uFE0F", `ag:page:${safePage + 1}`);
-      }
-      keyboard.row();
-    }
-    if (available.some((i) => !i.available)) {
-      text += "\n\u{1F4A1} <i>Agents marked \u26A0\uFE0F need additional setup. Use</i> <code>openacp agents info &lt;name&gt;</code> <i>for details.</i>\n";
-    }
-    await ctx.reply(text, { parse_mode: "HTML", reply_markup: keyboard });
-  } else {
-    text += "<i>All agents are already installed!</i>";
-    await ctx.reply(text, { parse_mode: "HTML" });
-  }
-}
-async function handleInstall(ctx, core) {
-  const text = (ctx.message?.text ?? "").trim();
-  const parts = text.split(/\s+/);
-  const nameOrId = parts[1];
-  if (!nameOrId) {
-    await ctx.reply(
-      "\u{1F4E6} <b>Install an agent</b>\n\nUsage: <code>/install &lt;agent-name&gt;</code>\nExample: <code>/install gemini</code>\n\nUse /agents to browse available agents.",
-      { parse_mode: "HTML" }
-    );
-    return;
-  }
-  await installAgentWithProgress(ctx, core, nameOrId);
-}
-async function handleAgentCallback(ctx, core) {
-  const data = ctx.callbackQuery?.data ?? "";
-  await ctx.answerCallbackQuery();
-  if (data.startsWith("ag:install:")) {
-    const nameOrId = data.replace("ag:install:", "");
-    await installAgentWithProgress(ctx, core, nameOrId);
-    return;
-  }
-  if (data.startsWith("ag:page:")) {
-    const page = parseInt(data.replace("ag:page:", ""), 10);
-    try {
-      const catalog = core.agentCatalog;
-      const items = catalog.getAvailable();
-      const installed = items.filter((i) => i.installed);
-      const available = items.filter((i) => !i.installed);
-      let text = "<b>\u{1F916} Agents</b>\n\n";
-      if (installed.length > 0) {
-        text += "<b>Installed:</b>\n";
-        for (const item of installed) {
-          text += `\u2705 <b>${escapeHtml(item.name)}</b>`;
-          if (item.description) {
-            text += ` \u2014 <i>${escapeHtml(truncate(item.description, 50))}</i>`;
-          }
-          text += "\n";
-        }
-        text += "\n";
-      }
-      const totalPages = Math.ceil(available.length / AGENTS_PER_PAGE);
-      const safePage = Math.max(0, Math.min(page, totalPages - 1));
-      const pageItems = available.slice(safePage * AGENTS_PER_PAGE, (safePage + 1) * AGENTS_PER_PAGE);
-      text += `<b>Available to install:</b>`;
-      if (totalPages > 1) {
-        text += ` (${safePage + 1}/${totalPages})`;
-      }
-      text += "\n";
-      for (const item of pageItems) {
-        if (item.available) {
-          text += `\u2B07\uFE0F <b>${escapeHtml(item.name)}</b>`;
-        } else {
-          const deps = item.missingDeps?.join(", ") ?? "requirements not met";
-          text += `\u26A0\uFE0F <b>${escapeHtml(item.name)}</b> <i>(needs: ${escapeHtml(deps)})</i>`;
-        }
-        if (item.description) {
-          text += `
-    <i>${escapeHtml(truncate(item.description, 60))}</i>`;
-        }
-        text += "\n";
-      }
-      const keyboard = new InlineKeyboard4();
-      const installable = pageItems.filter((i) => i.available);
-      for (let i = 0; i < installable.length; i += 2) {
-        const row = installable.slice(i, i + 2);
-        for (const item of row) {
-          keyboard.text(`\u2B07\uFE0F ${item.name}`, `ag:install:${item.key}`);
-        }
-        keyboard.row();
-      }
-      if (totalPages > 1) {
-        if (safePage > 0) {
-          keyboard.text("\u25C0\uFE0F Prev", `ag:page:${safePage - 1}`);
-        }
-        if (safePage < totalPages - 1) {
-          keyboard.text("Next \u25B6\uFE0F", `ag:page:${safePage + 1}`);
-        }
-        keyboard.row();
-      }
-      await ctx.editMessageText(text, { parse_mode: "HTML", reply_markup: keyboard });
-    } catch {
-    }
-  }
-}
-async function installAgentWithProgress(ctx, core, nameOrId) {
-  const catalog = core.agentCatalog;
-  const msg = await ctx.reply(`\u23F3 Installing <b>${escapeHtml(nameOrId)}</b>...`, { parse_mode: "HTML" });
-  let lastEdit = 0;
-  const EDIT_THROTTLE_MS = 1500;
-  const progress = {
-    onStart(_id, _name) {
-    },
-    async onStep(step) {
-      const now = Date.now();
-      if (now - lastEdit > EDIT_THROTTLE_MS) {
-        lastEdit = now;
-        try {
-          await ctx.api.editMessageText(msg.chat.id, msg.message_id, `\u23F3 <b>${escapeHtml(nameOrId)}</b>: ${escapeHtml(step)}`, { parse_mode: "HTML" });
-        } catch {
-        }
-      }
-    },
-    async onDownloadProgress(percent) {
-      const now = Date.now();
-      if (now - lastEdit > EDIT_THROTTLE_MS) {
-        lastEdit = now;
-        try {
-          const bar = buildProgressBar(percent);
-          await ctx.api.editMessageText(msg.chat.id, msg.message_id, `\u23F3 <b>${escapeHtml(nameOrId)}</b>
-Downloading... ${bar} ${percent}%`, { parse_mode: "HTML" });
-        } catch {
-        }
-      }
-    },
-    async onSuccess(name) {
-      try {
-        const keyboard = new InlineKeyboard4().text(`\u{1F680} Start session with ${name}`, `na:${nameOrId}`);
-        await ctx.api.editMessageText(msg.chat.id, msg.message_id, `\u2705 <b>${escapeHtml(name)}</b> installed!`, { parse_mode: "HTML", reply_markup: keyboard });
-      } catch {
-      }
-    },
-    async onError(error) {
-      try {
-        await ctx.api.editMessageText(msg.chat.id, msg.message_id, `\u274C ${escapeHtml(error)}`, { parse_mode: "HTML" });
-      } catch {
-      }
-    }
-  };
-  const result = await catalog.install(nameOrId, progress);
-  if (result.ok) {
-    const { getAgentCapabilities } = await import("./agent-dependencies-4OWBMZWZ.js");
-    const caps = getAgentCapabilities(result.agentKey);
-    if (caps.integration) {
-      const { installIntegration } = await import("./integrate-PNEHRY2I.js");
-      const intResult = await installIntegration(result.agentKey, caps.integration);
-      if (intResult.success) {
-        try {
-          await ctx.reply(`\u{1F517} Handoff integration installed for <b>${escapeHtml(result.agentKey)}</b>`, { parse_mode: "HTML" });
-        } catch {
-        }
-      }
-    }
-  }
-  if (result.ok && result.setupSteps?.length) {
-    let setupText = `\u{1F4CB} <b>Setup for ${escapeHtml(result.agentKey)}:</b>
-
-`;
-    for (const step of result.setupSteps) {
-      setupText += `\u2192 ${formatSetupStep(step)}
-`;
-    }
-    setupText += `
-\u{1F4A1} <i>Tap any command to copy it</i>`;
-    try {
-      await ctx.reply(setupText, { parse_mode: "HTML" });
-    } catch {
-    }
-  }
-}
-function formatSetupStep(step) {
-  const colonIdx = step.indexOf(": ");
-  if (colonIdx === -1) return escapeHtml(step);
-  const label = step.slice(0, colonIdx);
-  const rest = step.slice(colonIdx + 2);
-  const cmdPrefixes = [
-    "npm ",
-    "npx ",
-    "pip ",
-    "uvx ",
-    "export ",
-    "claude ",
-    "codex ",
-    "openacp ",
-    "goose ",
-    "gemini ",
-    "cursor ",
-    "gh "
-  ];
-  const looksLikeCommand = cmdPrefixes.some((p) => rest.startsWith(p));
-  if (looksLikeCommand) {
-    const parenIdx = rest.indexOf(" (");
-    if (parenIdx !== -1) {
-      const cmd = rest.slice(0, parenIdx);
-      const explanation = rest.slice(parenIdx);
-      return `${escapeHtml(label)}: <code>${escapeHtml(cmd)}</code> ${escapeHtml(explanation)}`;
-    }
-    return `${escapeHtml(label)}: <code>${escapeHtml(rest)}</code>`;
-  }
-  return escapeHtml(step);
-}
-function truncate(text, maxLen) {
-  if (text.length <= maxLen) return text;
-  return text.slice(0, maxLen - 1) + "\u2026";
-}
-function buildProgressBar(percent) {
-  const filled = Math.round(percent / 10);
-  const empty = 10 - filled;
-  return "\u2588".repeat(filled) + "\u2591".repeat(empty);
-}
-
-// src/adapters/telegram/commands/integrate.ts
-import { InlineKeyboard as InlineKeyboard5 } from "grammy";
-async function handleIntegrate(ctx, _core) {
-  const { listIntegrations } = await import("./integrate-PNEHRY2I.js");
-  const agents = listIntegrations();
-  const keyboard = new InlineKeyboard5();
-  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 InlineKeyboard5();
-  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-PNEHRY2I.js");
-      const agents = listIntegrations();
-      const keyboard2 = new InlineKeyboard5();
-      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-PNEHRY2I.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-PNEHRY2I.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" });
-    }
-  });
-}
-
-// src/adapters/telegram/commands/resume.ts
-import * as fs from "fs";
-import * as path from "path";
-import * as os from "os";
-import { InlineKeyboard as InlineKeyboard6 } from "grammy";
-var log4 = createChildLogger({ module: "telegram-cmd-resume" });
-var PENDING_TIMEOUT_MS2 = 5 * 60 * 1e3;
-function botFromCtx2(ctx) {
-  return { api: ctx.api };
-}
-var pendingResumes = /* @__PURE__ */ new Map();
-function cleanupPending2(userId) {
-  const pending = pendingResumes.get(userId);
-  if (pending) {
-    clearTimeout(pending.timer);
-    pendingResumes.delete(userId);
-  }
-}
-function parseResumeArgs(matchStr) {
-  const args = matchStr.split(" ").filter(Boolean);
-  if (args.length === 0) return { query: { type: "latest", value: "5" } };
-  const first = args[0];
-  if (first === "pr") return args[1] ? { query: { type: "pr", value: args[1] } } : null;
-  if (first === "branch") return args[1] ? { query: { type: "branch", value: args[1] } } : null;
-  if (first === "commit") return args[1] ? { query: { type: "commit", value: args[1] } } : null;
-  if (CheckpointReader.isCheckpointId(first)) return { query: { type: "checkpoint", value: first } };
-  if (CheckpointReader.isSessionId(first)) return { query: { type: "session", value: first } };
-  if (first.includes("/pull/")) {
-    const prMatch = first.match(/\/pull\/(\d+)/);
-    return prMatch ? { query: { type: "pr", value: prMatch[1] } } : null;
-  }
-  const ghCommitMatch = first.match(/github\.com\/[^/]+\/[^/]+\/commit\/([0-9a-f]+)/);
-  if (ghCommitMatch) return { query: { type: "commit", value: ghCommitMatch[1] } };
-  const ghBranchMatch = first.match(/github\.com\/[^/]+\/[^/]+\/tree\/(.+?)(?:\?|#|$)/);
-  if (ghBranchMatch) return { query: { type: "branch", value: ghBranchMatch[1] } };
-  const ghCompareMatch = first.match(/github\.com\/[^/]+\/[^/]+\/compare\/(?:[^.]+\.{2,3})(.+?)(?:\?|#|$)/);
-  if (ghCompareMatch) return { query: { type: "branch", value: ghCompareMatch[1] } };
-  if (first.match(/github\.com\/[^/]+\/[^/]+\/?$/) && !first.includes("/tree/") && !first.includes("/pull/") && !first.includes("/commit/") && !first.includes("/compare/")) {
-    return { query: { type: "latest", value: "5" } };
-  }
-  const entireCheckpointMatch = first.match(/entire\.io\/gh\/[^/]+\/[^/]+\/checkpoints\/[^/]+\/([0-9a-f]{12})/);
-  if (entireCheckpointMatch) return { query: { type: "checkpoint", value: entireCheckpointMatch[1] } };
-  const entireCommitMatch = first.match(/entire\.io\/gh\/[^/]+\/[^/]+\/commit\/([0-9a-f]+)/);
-  if (entireCommitMatch) return { query: { type: "commit", value: entireCommitMatch[1] } };
-  return { query: { type: "latest", value: "5" } };
-}
-function looksLikePath(text) {
-  return text.startsWith("/") || text.startsWith("~") || text.startsWith(".");
-}
-function listWorkspaceDirs(baseDir, maxItems = 10) {
-  const resolved = baseDir.replace(/^~/, os.homedir());
-  try {
-    if (!fs.existsSync(resolved)) return [];
-    return fs.readdirSync(resolved, { withFileTypes: true }).filter((d) => d.isDirectory() && !d.name.startsWith(".")).map((d) => d.name).sort().slice(0, maxItems);
-  } catch {
-    return [];
-  }
-}
-async function showWorkspacePicker(ctx, core, chatId, userId, query) {
-  const config = core.configManager.get();
-  const baseDir = config.workspace.baseDir;
-  const resolvedBase = baseDir.replace(/^~/, os.homedir());
-  const subdirs = listWorkspaceDirs(baseDir);
-  const keyboard = new InlineKeyboard6();
-  for (const dir of subdirs) {
-    const fullPath = path.join(resolvedBase, dir);
-    keyboard.text(`\u{1F4C1} ${dir}`, `m:resume:ws:${dir}`).row();
-  }
-  keyboard.text(`\u{1F4C1} Use ${baseDir}`, "m:resume:ws:default").row();
-  keyboard.text("\u270F\uFE0F Enter project path", "m:resume:ws:custom");
-  const queryLabel = query.type === "latest" ? "latest sessions" : `${query.type}: ${query.value}`;
-  const text = `\u{1F4C1} <b>Select project directory for resume</b>
-
-Query: <code>${escapeHtml(queryLabel)}</code>
-
-Choose the repo that has Entire checkpoints enabled:`;
-  const msg = await ctx.reply(text, { parse_mode: "HTML", reply_markup: keyboard });
-  cleanupPending2(userId);
-  pendingResumes.set(userId, {
-    query,
-    step: "workspace",
-    messageId: msg.message_id,
-    threadId: ctx.message?.message_thread_id,
-    timer: setTimeout(() => pendingResumes.delete(userId), PENDING_TIMEOUT_MS2)
-  });
-}
-async function executeResume(ctx, core, chatId, query, repoPath) {
-  const provider = await core.contextManager.getProvider(repoPath);
-  if (!provider) {
-    await ctx.reply(
-      `\u26A0\uFE0F <b>Entire not enabled in <code>${escapeHtml(repoPath)}</code></b>
-
-To enable conversation history tracking:
-<code>cd ${escapeHtml(repoPath)} && npx entire enable</code>
-
-Learn more: https://docs.entire.io/getting-started`,
-      { parse_mode: "HTML" }
-    );
-    return;
-  }
-  const fullQuery = { ...query, repoPath };
-  await ctx.reply(`\u{1F50D} Scanning ${query.type === "latest" ? "latest sessions" : `${query.type}: ${escapeHtml(query.value)}`}...`, { parse_mode: "HTML" });
-  const listResult = await core.contextManager.listSessions(fullQuery);
-  if (!listResult || listResult.sessions.length === 0) {
-    await ctx.reply(
-      `\u{1F50D} <b>No sessions found</b>
-
-Query: <code>${escapeHtml(query.type)}: ${escapeHtml(query.value)}</code>
-Repo: <code>${escapeHtml(repoPath)}</code>`,
-      { parse_mode: "HTML" }
-    );
-    return;
-  }
-  const config = core.configManager.get();
-  const agentName = config.defaultAgent;
-  let threadId;
-  try {
-    const queryLabel = query.type === "latest" ? "latest" : `${query.type}: ${query.value.slice(0, 20)}`;
-    const topicName = `\u{1F4DC} Resume \u2014 ${queryLabel}`;
-    threadId = await createSessionTopic(botFromCtx2(ctx), chatId, topicName);
-    await ctx.api.sendMessage(chatId, `\u23F3 Loading context and starting session...`, {
-      message_thread_id: threadId,
-      parse_mode: "HTML"
-    });
-    const { session, contextResult } = await core.createSessionWithContext({
-      channelId: "telegram",
-      agentName,
-      workingDirectory: repoPath,
-      contextQuery: fullQuery,
-      contextOptions: { maxTokens: DEFAULT_MAX_TOKENS }
-    });
-    session.threadId = String(threadId);
-    await core.sessionManager.patchRecord(session.id, { platform: { topicId: threadId } });
-    const sessionCount = contextResult?.sessionCount ?? listResult.sessions.length;
-    const mode = contextResult?.mode ?? "full";
-    const tokens = contextResult?.tokenEstimate ?? listResult.estimatedTokens;
-    const topicLink = buildDeepLink(chatId, threadId);
-    const replyTarget = ctx.message?.message_thread_id;
-    if (replyTarget !== threadId) {
-      await ctx.reply(
-        `\u2705 Session resumed \u2192 <a href="${topicLink}">Open topic</a>`,
-        { parse_mode: "HTML" }
-      );
-    }
-    await ctx.api.sendMessage(
-      chatId,
-      `\u2705 <b>Session resumed with context</b>
-<b>Agent:</b> ${escapeHtml(session.agentName)}
-<b>Workspace:</b> <code>${escapeHtml(session.workingDirectory)}</code>
-<b>Sessions loaded:</b> ${sessionCount}
-<b>Mode:</b> ${escapeHtml(mode)}
-<b>~Tokens:</b> ${tokens.toLocaleString()}
-
-Context is ready \u2014 chat here to continue working with the agent.`,
-      {
-        message_thread_id: threadId,
-        parse_mode: "HTML",
-        reply_markup: buildSessionControlKeyboard(session.id, false, false)
-      }
-    );
-    session.warmup().catch((err) => log4.error({ err }, "Warm-up error"));
-  } catch (err) {
-    log4.error({ err }, "Resume 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" });
-  }
-}
-async function handleResume(ctx, core, chatId, assistant) {
-  const rawMatch = ctx.match;
-  const matchStr = typeof rawMatch === "string" ? rawMatch : "";
-  const parsed = parseResumeArgs(matchStr);
-  if (!parsed) {
-    await ctx.reply(
-      `\u274C <b>Invalid arguments.</b>
-
-Usage examples:
-\u2022 <code>/resume</code> \u2014 latest 5 sessions
-\u2022 <code>/resume pr 19</code>
-\u2022 <code>/resume branch main</code>
-\u2022 <code>/resume commit e0dd2fa4</code>
-\u2022 <code>/resume f634acf05138</code> \u2014 checkpoint ID
-\u2022 <code>/resume https://entire.io/gh/.../checkpoints/.../2e884e2c402a</code>
-\u2022 <code>/resume https://entire.io/gh/.../commit/e0dd2fa4...</code>`,
-      { parse_mode: "HTML" }
-    );
-    return;
-  }
-  const { query } = parsed;
-  const userId = ctx.from?.id;
-  if (!userId) return;
-  await showWorkspacePicker(ctx, core, chatId, userId, query);
-}
-async function handlePendingResumeInput(ctx, core, chatId, assistantTopicId) {
-  const userId = ctx.from?.id;
-  if (!userId) return false;
-  const pending = pendingResumes.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;
-  if (pending.step === "workspace" && !looksLikePath(ctx.message.text.trim())) return false;
-  let workspace = ctx.message.text.trim();
-  if (!workspace) {
-    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}`;
-  }
-  const resolved = core.configManager.resolveWorkspace(workspace);
-  cleanupPending2(userId);
-  await executeResume(ctx, core, chatId, pending.query, resolved);
-  return true;
-}
-function setupResumeCallbacks(bot, core, chatId) {
-  bot.callbackQuery(/^m:resume:/, async (ctx) => {
-    const data = ctx.callbackQuery.data;
-    const userId = ctx.from?.id;
-    if (!userId) return;
-    try {
-      await ctx.answerCallbackQuery();
-    } catch {
-    }
-    const pending = pendingResumes.get(userId);
-    if (!pending) return;
-    if (data === "m:resume:ws:default") {
-      const baseDir = core.configManager.get().workspace.baseDir;
-      const resolved = core.configManager.resolveWorkspace(baseDir);
-      cleanupPending2(userId);
-      try {
-        await ctx.api.editMessageText(chatId, pending.messageId, `\u23F3 Using <code>${escapeHtml(resolved)}</code>...`, { parse_mode: "HTML" });
-      } catch {
-      }
-      await executeResume(ctx, core, chatId, pending.query, resolved);
-      return;
-    }
-    if (data === "m:resume:ws:custom") {
-      try {
-        await ctx.api.editMessageText(
-          chatId,
-          pending.messageId,
-          `\u270F\uFE0F <b>Enter project path:</b>
-
-Full path like <code>~/code/my-project</code>
-Or just the folder name (will use workspace baseDir)`,
-          { parse_mode: "HTML" }
-        );
-      } catch {
-        await ctx.reply(`\u270F\uFE0F <b>Enter project path:</b>`, { parse_mode: "HTML" });
-      }
-      clearTimeout(pending.timer);
-      pending.step = "workspace_input";
-      pending.timer = setTimeout(() => pendingResumes.delete(userId), PENDING_TIMEOUT_MS2);
-      return;
-    }
-    if (data.startsWith("m:resume:ws:")) {
-      const dirName = data.replace("m:resume:ws:", "");
-      const baseDir = core.configManager.get().workspace.baseDir;
-      const resolved = core.configManager.resolveWorkspace(path.join(baseDir.replace(/^~/, os.homedir()), dirName));
-      cleanupPending2(userId);
-      try {
-        await ctx.api.editMessageText(chatId, pending.messageId, `\u23F3 Using <code>${escapeHtml(resolved)}</code>...`, { parse_mode: "HTML" });
-      } catch {
-      }
-      await executeResume(ctx, core, chatId, pending.query, resolved);
-      return;
-    }
-  });
-}
-
-// src/adapters/telegram/commands/settings.ts
-import { InlineKeyboard as InlineKeyboard7 } from "grammy";
-var log5 = createChildLogger({ module: "telegram-settings" });
-function buildSettingsKeyboard(core) {
-  const config = core.configManager.get();
-  const fields = getSafeFields();
-  const kb = new InlineKeyboard7();
-  for (const field of fields) {
-    const value = getConfigValue(config, field.path);
-    const label = formatFieldLabel(field, value);
-    if (field.type === "toggle") {
-      kb.text(`${label}`, `s:toggle:${field.path}`).row();
-    } else if (field.type === "select") {
-      kb.text(`${label}`, `s:select:${field.path}`).row();
-    } else {
-      kb.text(`${label}`, `s:input:${field.path}`).row();
-    }
-  }
-  kb.text("\u25C0\uFE0F Back to Menu", "s:back");
-  return kb;
-}
-function formatFieldLabel(field, value) {
-  const icons = {
-    agent: "\u{1F916}",
-    logging: "\u{1F4DD}",
-    tunnel: "\u{1F517}",
-    security: "\u{1F512}",
-    workspace: "\u{1F4C1}",
-    storage: "\u{1F4BE}",
-    speech: "\u{1F3A4}"
-  };
-  const icon = icons[field.group] ?? "\u2699\uFE0F";
-  if (field.type === "toggle") {
-    return `${icon} ${field.displayName}: ${value ? "ON" : "OFF"}`;
-  }
-  const displayValue = value === null || value === void 0 ? "Not set" : String(value);
-  return `${icon} ${field.displayName}: ${displayValue}`;
-}
-async function handleSettings(ctx, core) {
-  const kb = buildSettingsKeyboard(core);
-  await ctx.reply(`<b>\u2699\uFE0F Settings</b>
-Tap to change:`, {
-    parse_mode: "HTML",
-    reply_markup: kb
-  });
-}
-function setupSettingsCallbacks(bot, core, getAssistantSession) {
-  bot.callbackQuery(/^s:toggle:/, async (ctx) => {
-    const fieldPath = ctx.callbackQuery.data.replace("s:toggle:", "");
-    const config = core.configManager.get();
-    const currentValue = getConfigValue(config, fieldPath);
-    const newValue = !currentValue;
-    try {
-      const updates = buildNestedUpdate(fieldPath, newValue);
-      await core.configManager.save(updates, fieldPath);
-      const toast = isHotReloadable(fieldPath) ? `\u2705 ${fieldPath} = ${newValue}` : `\u2705 ${fieldPath} = ${newValue} (restart needed)`;
-      try {
-        await ctx.answerCallbackQuery({ text: toast });
-      } catch {
-      }
-      try {
-        await ctx.editMessageReplyMarkup({ reply_markup: buildSettingsKeyboard(core) });
-      } catch {
-      }
-    } catch (err) {
-      log5.error({ err, fieldPath }, "Failed to toggle config");
-      try {
-        await ctx.answerCallbackQuery({ text: "\u274C Failed to update" });
-      } catch {
-      }
-    }
-  });
-  bot.callbackQuery(/^s:select:/, async (ctx) => {
-    const fieldPath = ctx.callbackQuery.data.replace("s:select:", "");
-    const config = core.configManager.get();
-    const fieldDef = getSafeFields().find((f) => f.path === fieldPath);
-    if (!fieldDef) return;
-    const options = resolveOptions(fieldDef, config) ?? [];
-    const currentValue = getConfigValue(config, fieldPath);
-    const kb = new InlineKeyboard7();
-    for (const opt of options) {
-      const marker = opt === String(currentValue) ? " \u2713" : "";
-      kb.text(`${opt}${marker}`, `s:pick:${fieldPath}:${opt}`).row();
-    }
-    kb.text("\u25C0\uFE0F Back", "s:back:refresh");
-    try {
-      await ctx.answerCallbackQuery();
-    } catch {
-    }
-    try {
-      await ctx.editMessageText(`<b>\u2699\uFE0F ${fieldDef.displayName}</b>
-Select a value:`, {
-        parse_mode: "HTML",
-        reply_markup: kb
-      });
-    } catch {
-    }
-  });
-  bot.callbackQuery(/^s:pick:/, async (ctx) => {
-    const parts = ctx.callbackQuery.data.replace("s:pick:", "").split(":");
-    const fieldPath = parts.slice(0, -1).join(":");
-    const newValue = parts[parts.length - 1];
-    try {
-      if (fieldPath === "speech.stt.provider") {
-        const config = core.configManager.get();
-        const providerConfig = config.speech?.stt?.providers?.[newValue];
-        if (!providerConfig?.apiKey) {
-          const assistant = getAssistantSession();
-          if (assistant) {
-            try {
-              await ctx.answerCallbackQuery({ text: `\u{1F511} API key needed \u2014 check Assistant topic` });
-            } catch {
-            }
-            const prompt = `User wants to enable ${newValue} as Speech-to-Text provider, but no API key is configured yet. Guide them to get a ${newValue} API key and set it up. After they provide the key, run both commands: \`openacp config set speech.stt.providers.${newValue}.apiKey <key>\` and \`openacp config set speech.stt.provider ${newValue}\``;
-            await assistant.enqueuePrompt(prompt);
-            return;
-          }
-          try {
-            await ctx.answerCallbackQuery({ text: `\u26A0\uFE0F Set API key first: openacp config set speech.stt.providers.${newValue}.apiKey <key>` });
-          } catch {
-          }
-          return;
-        }
-      }
-      const updates = buildNestedUpdate(fieldPath, newValue);
-      await core.configManager.save(updates, fieldPath);
-      try {
-        await ctx.answerCallbackQuery({ text: `\u2705 ${fieldPath} = ${newValue}` });
-      } catch {
-      }
-      try {
-        await ctx.editMessageText(`<b>\u2699\uFE0F Settings</b>
-Tap to change:`, {
-          parse_mode: "HTML",
-          reply_markup: buildSettingsKeyboard(core)
-        });
-      } catch {
-      }
-    } catch (err) {
-      log5.error({ err, fieldPath }, "Failed to set config");
-      try {
-        await ctx.answerCallbackQuery({ text: "\u274C Failed to update" });
-      } catch {
-      }
-    }
-  });
-  bot.callbackQuery(/^s:input:/, async (ctx) => {
-    const fieldPath = ctx.callbackQuery.data.replace("s:input:", "");
-    const config = core.configManager.get();
-    const fieldDef = getSafeFields().find((f) => f.path === fieldPath);
-    if (!fieldDef) return;
-    const currentValue = getConfigValue(config, fieldPath);
-    const assistant = getAssistantSession();
-    if (!assistant) {
-      try {
-        await ctx.answerCallbackQuery({ text: "\u26A0\uFE0F Start the assistant first (/assistant)" });
-      } catch {
-      }
-      return;
-    }
-    try {
-      await ctx.answerCallbackQuery({ text: `Delegating to assistant...` });
-    } catch {
-    }
-    const prompt = `User wants to change ${fieldDef.displayName} (config path: ${fieldPath}). Current value: ${JSON.stringify(currentValue)}. Ask them for the new value and apply it using: openacp config set ${fieldPath} <value>`;
-    await assistant.enqueuePrompt(prompt);
-  });
-  bot.callbackQuery("s:back", async (ctx) => {
-    try {
-      await ctx.answerCallbackQuery();
-    } catch {
-    }
-    const { buildMenuKeyboard: buildMenuKeyboard3 } = await import("./menu-YY5MKHEK.js");
-    try {
-      await ctx.editMessageText(`<b>OpenACP Menu</b>
-Choose an action:`, {
-        parse_mode: "HTML",
-        reply_markup: buildMenuKeyboard3()
-      });
-    } catch {
-    }
-  });
-  bot.callbackQuery("s:back:refresh", async (ctx) => {
-    try {
-      await ctx.answerCallbackQuery();
-    } catch {
-    }
-    try {
-      await ctx.editMessageText(`<b>\u2699\uFE0F Settings</b>
-Tap to change:`, {
-        parse_mode: "HTML",
-        reply_markup: buildSettingsKeyboard(core)
-      });
-    } catch {
-    }
-  });
-}
-function buildNestedUpdate(dotPath, value) {
-  const parts = dotPath.split(".");
-  const result = {};
-  let target = result;
-  for (let i = 0; i < parts.length - 1; i++) {
-    target[parts[i]] = {};
-    target = target[parts[i]];
-  }
-  target[parts[parts.length - 1]] = value;
-  return result;
-}
-
-// src/adapters/telegram/commands/doctor.ts
-import { InlineKeyboard as InlineKeyboard8 } from "grammy";
-var log6 = createChildLogger({ module: "telegram-cmd-doctor" });
-var pendingFixesStore = /* @__PURE__ */ new Map();
-function renderReport(report) {
-  const icons = { pass: "\u2705", warn: "\u26A0\uFE0F", fail: "\u274C" };
-  const lines = ["\u{1FA7A} <b>OpenACP Doctor</b>\n"];
-  for (const category of report.categories) {
-    lines.push(`<b>${category.name}</b>`);
-    for (const result of category.results) {
-      lines.push(`  ${icons[result.status]} ${escapeHtml2(result.message)}`);
-    }
-    lines.push("");
-  }
-  const { passed, warnings, failed, fixed } = report.summary;
-  const fixedStr = fixed > 0 ? `, ${fixed} fixed` : "";
-  lines.push(`<b>Result:</b> ${passed} passed, ${warnings} warnings, ${failed} failed${fixedStr}`);
-  let keyboard;
-  if (report.pendingFixes.length > 0) {
-    keyboard = new InlineKeyboard8();
-    for (let i = 0; i < report.pendingFixes.length; i++) {
-      const label = `\u{1F527} Fix: ${report.pendingFixes[i].message.slice(0, 30)}`;
-      keyboard.text(label, `m:doctor:fix:${i}`).row();
-    }
-  }
-  return { text: lines.join("\n"), keyboard };
-}
-function escapeHtml2(text) {
-  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
-}
-async function handleDoctor(ctx) {
-  const statusMsg = await ctx.reply("\u{1FA7A} Running diagnostics...", { parse_mode: "HTML" });
-  try {
-    const engine = new DoctorEngine();
-    const report = await engine.runAll();
-    const { text, keyboard } = renderReport(report);
-    const storeKey = `${ctx.chat.id}:${statusMsg.message_id}`;
-    if (report.pendingFixes.length > 0) {
-      pendingFixesStore.set(storeKey, report.pendingFixes);
-    }
-    await ctx.api.editMessageText(ctx.chat.id, statusMsg.message_id, text, {
-      parse_mode: "HTML",
-      reply_markup: keyboard
-    });
-  } catch (err) {
-    log6.error({ err }, "Doctor command failed");
-    await ctx.api.editMessageText(
-      ctx.chat.id,
-      statusMsg.message_id,
-      `\u274C Doctor failed: ${err instanceof Error ? err.message : String(err)}`,
-      { parse_mode: "HTML" }
-    );
-  }
-}
-function setupDoctorCallbacks(bot) {
-  bot.callbackQuery(/^m:doctor:fix:/, async (ctx) => {
-    const data = ctx.callbackQuery.data;
-    const index = parseInt(data.replace("m:doctor:fix:", ""), 10);
-    const chatId = ctx.callbackQuery.message?.chat.id;
-    const messageId = ctx.callbackQuery.message?.message_id;
-    try {
-      await ctx.answerCallbackQuery({ text: "Applying fix..." });
-    } catch {
-    }
-    if (chatId === void 0 || messageId === void 0) return;
-    const storeKey = `${chatId}:${messageId}`;
-    const fixes = pendingFixesStore.get(storeKey);
-    if (!fixes || index < 0 || index >= fixes.length) {
-      try {
-        await ctx.answerCallbackQuery({ text: "Fix no longer available" });
-      } catch {
-      }
-      return;
-    }
-    const pending = fixes[index];
-    try {
-      const result = await pending.fix();
-      if (result.success) {
-        const engine = new DoctorEngine();
-        const report = await engine.runAll();
-        const { text, keyboard } = renderReport(report);
-        if (report.pendingFixes.length > 0) {
-          pendingFixesStore.set(storeKey, report.pendingFixes);
-        } else {
-          pendingFixesStore.delete(storeKey);
-        }
-        await ctx.editMessageText(text, { parse_mode: "HTML", reply_markup: keyboard });
-      } else {
-        try {
-          await ctx.answerCallbackQuery({ text: `Fix failed: ${result.message}` });
-        } catch {
-        }
-      }
-    } catch (err) {
-      log6.error({ err, index }, "Doctor fix callback failed");
-    }
-  });
-  bot.callbackQuery("m:doctor", async (ctx) => {
-    try {
-      await ctx.answerCallbackQuery();
-    } catch {
-    }
-    await handleDoctor(ctx);
-  });
-}
-
-// src/adapters/telegram/commands/tunnel.ts
-import { InlineKeyboard as InlineKeyboard9 } from "grammy";
-var log7 = 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 threadId = ctx.message?.message_thread_id;
-  let entries = core.tunnelService.listTunnels();
-  let sessionScoped = false;
-  if (threadId) {
-    const session = core.sessionManager.getSessionByThread("telegram", String(threadId));
-    if (session) {
-      entries = entries.filter((e) => e.sessionId === session.id);
-      sessionScoped = true;
-    }
-  }
-  if (entries.length === 0) {
-    const hint = sessionScoped ? "No tunnels for this session.\n\nUse <code>/tunnel &lt;port&gt;</code> to create one." : "No active tunnels.\n\nUse <code>/tunnel &lt;port&gt;</code> to create one.";
-    await ctx.reply(hint, { 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 InlineKeyboard9();
-  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 InlineKeyboard9();
-          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));
-  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("install", (ctx) => handleInstall(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));
-  bot.command("doctor", (ctx) => handleDoctor(ctx));
-  bot.command("usage", (ctx) => handleUsage(ctx, core));
-  bot.command("tunnel", (ctx) => handleTunnel(ctx, core));
-  bot.command("tunnels", (ctx) => handleTunnels(ctx, core));
-  bot.command("archive", (ctx) => handleArchive(ctx, core));
-  bot.command("summary", (ctx) => handleSummary(ctx, core));
-  bot.command("text_to_speech", (ctx) => handleTTS(ctx, core));
-  bot.command("verbosity", (ctx) => handleVerbosity(ctx, core));
-  bot.command("resume", (ctx) => handleResume(ctx, core, chatId, assistant));
-}
-function setupAllCallbacks(bot, core, chatId, systemTopicIds, getAssistantSession) {
-  setupNewSessionCallbacks(bot, core, chatId);
-  setupResumeCallbacks(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:", "");
-    await ctx.answerCallbackQuery();
-    await createSessionDirect(
-      ctx,
-      core,
-      chatId,
-      agentKey,
-      core.configManager.get().workspace.baseDir
-    );
-  });
-  bot.callbackQuery(/^ar:/, (ctx) => handleArchiveConfirm(ctx, core, chatId));
-  bot.callbackQuery(/^sm:/, (ctx) => handleSummaryCallback(ctx, core, chatId));
-  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;
-      case "m:settings":
-        await handleSettings(ctx, core);
-        break;
-    }
-  });
-}
-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: "install", description: "Install a new agent" },
-  { 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: "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: "usage", description: "View token usage and cost report" },
-  { command: "tunnel", description: "Create/stop tunnel for a local port" },
-  { command: "tunnels", description: "List active tunnels" },
-  { command: "archive", description: "Archive session topic (recreate with clean history)" },
-  { command: "summary", description: "Get AI summary of current session" },
-  { command: "text_to_speech", description: "Toggle Text to Speech (/text_to_speech on, /text_to_speech off)" },
-  { command: "verbosity", description: "Set display verbosity (/verbosity low|medium|high)" },
-  { command: "resume", description: "Resume with conversation history from Entire checkpoints" }
-];
-
-// src/adapters/telegram/permissions.ts
-import { InlineKeyboard as InlineKeyboard10 } from "grammy";
-import { nanoid } from "nanoid";
-var log8 = createChildLogger({ module: "telegram-permissions" });
-var PermissionHandler = class {
-  constructor(bot, chatId, getSession, sendNotification) {
-    this.bot = bot;
-    this.chatId = chatId;
-    this.getSession = getSession;
-    this.sendNotification = sendNotification;
-  }
-  pending = /* @__PURE__ */ new Map();
-  async sendPermissionRequest(session, request) {
-    const threadId = Number(session.threadId);
-    const callbackKey = nanoid(8);
-    this.pending.set(callbackKey, {
-      sessionId: session.id,
-      requestId: request.id,
-      options: request.options.map((o) => ({ id: o.id, isAllow: o.isAllow }))
-    });
-    const keyboard = new InlineKeyboard10();
-    for (const option of request.options) {
-      const emoji = option.isAllow ? "\u2705" : "\u274C";
-      keyboard.text(`${emoji} ${option.label}`, `p:${callbackKey}:${option.id}`);
-    }
-    const msg = await this.bot.api.sendMessage(
-      this.chatId,
-      `\u{1F510} <b>Permission request:</b>
-
-${escapeHtml(request.description)}`,
-      {
-        message_thread_id: threadId,
-        parse_mode: "HTML",
-        reply_markup: keyboard,
-        disable_notification: false
-      }
-    );
-    const deepLink = buildDeepLink(this.chatId, threadId, msg.message_id);
-    void this.sendNotification({
-      sessionId: session.id,
-      sessionName: session.name,
-      type: "permission",
-      summary: request.description,
-      deepLink
-    });
-  }
-  setupCallbackHandler() {
-    this.bot.on("callback_query:data", async (ctx) => {
-      const data = ctx.callbackQuery.data;
-      if (!data.startsWith("p:")) return;
-      const parts = data.split(":");
-      if (parts.length < 3) return;
-      const [, callbackKey, optionId] = parts;
-      const pending = this.pending.get(callbackKey);
-      if (!pending) {
-        try {
-          await ctx.answerCallbackQuery({ text: "\u274C Expired" });
-        } catch {
-        }
-        return;
-      }
-      const session = this.getSession(pending.sessionId);
-      const isAllow = pending.options.find((o) => o.id === optionId)?.isAllow ?? false;
-      log8.info({ requestId: pending.requestId, optionId, isAllow }, "Permission responded");
-      if (session?.permissionGate.requestId === pending.requestId) {
-        session.permissionGate.resolve(optionId);
-      }
-      this.pending.delete(callbackKey);
-      try {
-        await ctx.answerCallbackQuery({ text: "\u2705 Responded" });
-      } catch {
-      }
-      try {
-        await ctx.editMessageReplyMarkup({ reply_markup: void 0 });
-      } catch {
-      }
-    });
-  }
-};
-
-// src/adapters/telegram/assistant.ts
-var log9 = createChildLogger({ module: "telegram-assistant" });
-async function spawnAssistant(core, adapter, assistantTopicId) {
-  const config = core.configManager.get();
-  log9.info({ agent: config.defaultAgent }, "Creating assistant session...");
-  const session = await core.createSession({
-    channelId: "telegram",
-    agentName: config.defaultAgent,
-    workingDirectory: core.configManager.resolveWorkspace(),
-    initialName: "Assistant"
-    // Prevent auto-naming from triggering after system prompt
-  });
-  session.threadId = String(assistantTopicId);
-  log9.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();
-  for (const r of allRecords) {
-    statusCounts.set(r.status, (statusCounts.get(r.status) ?? 0) + 1);
-  }
-  const topicSummary = Array.from(statusCounts.entries()).map(([status, count]) => ({ status, count }));
-  const installedAgents = Object.keys(core.agentCatalog.getInstalledEntries());
-  const availableItems = core.agentCatalog.getAvailable();
-  const availableAgentCount = availableItems.filter((i) => !i.installed).length;
-  const ctx = {
-    config,
-    activeSessionCount: activeCount,
-    totalSessionCount: allRecords.length,
-    topicSummary,
-    installedAgents,
-    availableAgentCount
-  };
-  const systemPrompt = buildAssistantSystemPrompt(ctx);
-  const ready = session.enqueuePrompt(systemPrompt).then(() => {
-    log9.info({ sessionId: session.id }, "Assistant system prompt completed");
-  }).catch((err) => {
-    log9.warn({ err }, "Assistant system prompt failed");
-  });
-  return { session, ready };
-}
-function buildWelcomeMessage(ctx) {
-  const { activeCount, errorCount, totalCount, agents, defaultAgent } = ctx;
-  const agentList = agents.map((a) => `${a}${a === defaultAgent ? " (default)" : ""}`).join(", ");
-  if (totalCount === 0) {
-    return `\u{1F44B} <b>OpenACP is ready!</b>
-
-No sessions yet. Tap \u{1F195} New Session to start, or ask me anything!`;
-  }
-  if (errorCount > 0) {
-    return `\u{1F44B} <b>OpenACP is ready!</b>
-
-\u{1F4CA} ${activeCount} active, ${errorCount} errors / ${totalCount} total
-\u26A0\uFE0F ${errorCount} session${errorCount > 1 ? "s have" : " has"} errors \u2014 ask me to check if you'd like.
-
-Agents: ${agentList}`;
-  }
-  return `\u{1F44B} <b>OpenACP is ready!</b>
-
-\u{1F4CA} ${activeCount} active / ${totalCount} total
-Agents: ${agentList}`;
-}
-function buildAssistantSystemPrompt(ctx) {
-  const { config, activeSessionCount, totalSessionCount, topicSummary, installedAgents, availableAgentCount } = ctx;
-  const agentNames = installedAgents?.length ? installedAgents.join(", ") : Object.keys(config.agents).join(", ");
-  const topicBreakdown = topicSummary.map((s) => `${s.status}: ${s.count}`).join(", ") || "none";
-  return `You are the OpenACP Assistant \u2014 a helpful guide for managing AI coding sessions.
-
-## Current State
-- Active sessions: ${activeSessionCount} / ${totalSessionCount} total
-- Topics by status: ${topicBreakdown}
-- Installed agents: ${agentNames}
-- Available in ACP Registry: ${availableAgentCount ?? "28+"}  more agents (use /agents to browse)
-- Default agent: ${config.defaultAgent}
-- Workspace base directory: ${config.workspace.baseDir}
-- STT: ${config.speech?.stt?.provider ? `${config.speech.stt.provider} \u2705` : "Not configured"}
-
-## Action Playbook
-
-### Create Session
-- The workspace is the project directory where the agent will work (read, write, execute code). It is NOT the base directory \u2014 it should be a specific project folder like \`~/code/my-project\` or \`${config.workspace.baseDir}/my-app\`.
-- Ask which agent to use (if multiple are installed). Show installed: ${agentNames}
-- Ask which project directory to use as workspace. Suggest \`${config.workspace.baseDir}\` as the base, but explain the user can provide any path.
-- Confirm before creating: show agent name + full workspace path.
-- Create via: \`openacp api new <agent> <workspace>\`
-
-### Browse & Install Agents
-- Guide users to /agents command to see all available agents (installed + from ACP Registry)
-- The /agents list is paginated with install buttons \u2014 users can tap to install directly
-- For CLI users: \`openacp agents install <name>\`
-- Some agents need login/setup after install \u2014 guide users to \`openacp agents info <name>\` for setup steps
-- To run agent CLI for login: \`openacp agents run <name> -- <args>\`
-- Common setup examples:
-  - Gemini: \`openacp agents run gemini -- auth login\`
-  - GitHub Copilot: \`openacp agents run copilot -- auth login\`
-  - Codex: needs OPENAI_API_KEY environment variable
-
-### Check Status / List Sessions
-- Run \`openacp api status\` for active sessions overview
-- Run \`openacp api topics\` for full list with statuses
-- Format the output nicely for the user
-
-### Cancel Session
-- Run \`openacp api status\` to see what's active
-- If 1 active session \u2192 ask user to confirm \u2192 \`openacp api cancel <id>\`
-- If multiple \u2192 list them, ask user which one to cancel
-
-### Troubleshoot (Session Stuck, Errors)
-- Run \`openacp api health\` + \`openacp api status\` to diagnose
-- Small issue (stuck session) \u2192 suggest cancel + create new
-- Big issue (system-level) \u2192 suggest restart, ask for confirmation first
-
-### Cleanup Old Sessions
-- Run \`openacp api topics --status finished,error\` to see what can be cleaned
-- Report the count, ask user to confirm
-- Execute: \`openacp api cleanup --status <statuses>\`
-
-### Configuration
-- View: \`openacp config\` (or \`openacp api config\` \u2014 deprecated)
-- Update: \`openacp config set <key> <value>\`
-- When user asks about "settings" or "config", use \`openacp config set\` directly
-- When receiving a delegated request from the Settings menu, ask user for the new value, then apply with \`openacp config set <path> <value>\`
-
-### Voice / Speech-to-Text
-- OpenACP can transcribe voice messages to text using STT providers (Groq Whisper, OpenAI Whisper)
-- Current STT provider: ${config.speech?.stt?.provider ?? "Not configured"}
-- To enable: user needs an API key from the STT provider
-  - Groq (recommended, free tier ~8h/day): Get key at console.groq.com \u2192 API Keys
-  - Set via: \`openacp config set speech.stt.provider groq\` then \`openacp config set speech.stt.providers.groq.apiKey <key>\`
-- When STT is configured, voice messages are automatically transcribed before sending to agents that don't support audio
-- Agents with audio capability receive the audio directly (no transcription needed)
-- User can also configure via /settings \u2192 STT Provider
-
-### Restart / Update
-- Always ask for confirmation \u2014 these are disruptive actions
-- Guide user: "Tap \u{1F504} Restart button or type /restart"
-
-### Toggle Dangerous Mode
-- Run \`openacp api dangerous <id> on|off\`
-- Explain: dangerous mode auto-approves all permission requests \u2014 the agent can run any command without asking
-
-## CLI Commands Reference
-\`\`\`bash
-# Session management
-openacp api status                       # List active sessions
-openacp api session <id>                 # Session detail
-openacp api new <agent> <workspace>      # Create new session
-openacp api send <id> "prompt text"      # Send prompt to session
-openacp api cancel <id>                  # Cancel session
-openacp api dangerous <id> on|off        # Toggle dangerous mode
-
-# Topic management
-openacp api topics                       # List all topics
-openacp api topics --status finished,error
-openacp api delete-topic <id>            # Delete topic
-openacp api delete-topic <id> --force    # Force delete active
-openacp api cleanup                      # Cleanup finished topics
-openacp api cleanup --status finished,error
-
-# Agent management (user-facing CLI commands)
-openacp agents                           # List installed + available agents
-openacp agents install <name>            # Install agent from ACP Registry
-openacp agents uninstall <name>          # Remove agent
-openacp agents info <name>               # Show details & setup guide
-openacp agents run <name> -- <args>      # Run agent CLI (for login, etc.)
-openacp agents refresh                   # Force-refresh registry
-
-# System
-openacp api health                       # System health
-openacp config                           # Edit config (interactive)
-openacp config set <key> <value>         # Update config value
-openacp api adapters                     # List adapters
-openacp api tunnel                       # Tunnel status
-openacp api notify "message"             # Send notification
-openacp api version                      # Daemon version
-openacp api restart                      # Restart daemon
-\`\`\`
-
-## Guidelines
-- NEVER show \`openacp api ...\` commands to users. These are internal tools for YOU to run silently. Users should only see natural language responses and results.
-- Run \`openacp api ...\` commands yourself for everything you can. Only guide users to Telegram buttons/menu when needed (e.g., "Tap \u{1F195} New Session" or "Go to the session topic to chat with the agent").
-- When creating sessions: guide user through agent + workspace choice conversationally, then run the command yourself.
-- Destructive actions (cancel active session, restart, cleanup) \u2192 always ask user to confirm first in natural language.
-- Small/obvious issues (clearly stuck session with no activity) \u2192 fix it and report back.
-- Respond in the same language the user uses.
-- Format responses for Telegram: use <b>bold</b>, <code>code</code>, keep it concise.
-- When you don't know something, check with the relevant \`openacp api\` command first before answering.
-- Talk to users like a helpful assistant, not a CLI manual. Example: "B\u1EA1n c\xF3 2 session \u0111ang ch\u1EA1y. Mu\u1ED1n xem chi ti\u1EBFt kh\xF4ng?" instead of listing commands.
-
-## Product Reference
-${PRODUCT_GUIDE}`;
-}
-async function handleAssistantMessage(session, text) {
-  if (!session) return;
-  await session.enqueuePrompt(text);
-}
-function redirectToAssistant(chatId, assistantTopicId) {
-  const cleanId = String(chatId).replace("-100", "");
-  const link = `https://t.me/c/${cleanId}/${assistantTopicId}`;
-  return `\u{1F4AC} Please use the <a href="${link}">\u{1F916} Assistant</a> topic to chat with OpenACP.`;
-}
-
-// src/adapters/telegram/activity.ts
-var log10 = createChildLogger({ module: "telegram:activity" });
-var THINKING_REFRESH_MS = 15e3;
-var THINKING_MAX_MS = 3 * 60 * 1e3;
-var ThinkingIndicator = class {
-  constructor(api, chatId, threadId, sendQueue) {
-    this.api = api;
-    this.chatId = chatId;
-    this.threadId = threadId;
-    this.sendQueue = sendQueue;
-  }
-  msgId;
-  sending = false;
-  dismissed = false;
-  refreshTimer;
-  showTime = 0;
-  async show() {
-    if (this.msgId || this.sending || this.dismissed) return;
-    this.sending = true;
-    this.showTime = Date.now();
-    try {
-      const result = await this.sendQueue.enqueue(
-        () => this.api.sendMessage(this.chatId, "\u{1F4AD} <i>Thinking...</i>", {
-          message_thread_id: this.threadId,
-          parse_mode: "HTML",
-          disable_notification: true
-        })
-      );
-      if (result && !this.dismissed) {
-        this.msgId = result.message_id;
-        this.startRefreshTimer();
-      }
-    } catch (err) {
-      log10.warn({ err }, "ThinkingIndicator.show() failed");
-    } finally {
-      this.sending = false;
-    }
-  }
-  /** Clear state — stops refresh timer, no Telegram API call */
-  dismiss() {
-    this.dismissed = true;
-    this.msgId = void 0;
-    this.stopRefreshTimer();
-  }
-  /** Reset for a new prompt cycle */
-  reset() {
-    this.dismissed = false;
-  }
-  startRefreshTimer() {
-    this.stopRefreshTimer();
-    this.refreshTimer = setInterval(() => {
-      if (this.dismissed || !this.msgId || Date.now() - this.showTime >= THINKING_MAX_MS) {
-        this.stopRefreshTimer();
-        return;
-      }
-      const elapsed = Math.round((Date.now() - this.showTime) / 1e3);
-      this.sendQueue.enqueue(() => {
-        if (this.dismissed) return Promise.resolve(void 0);
-        return this.api.sendMessage(this.chatId, `\u{1F4AD} <i>Still thinking... (${elapsed}s)</i>`, {
-          message_thread_id: this.threadId,
-          parse_mode: "HTML",
-          disable_notification: true
-        });
-      }).then((result) => {
-        if (result && !this.dismissed) {
-          this.msgId = result.message_id;
-        }
-      }).catch(() => {
-      });
-    }, THINKING_REFRESH_MS);
-  }
-  stopRefreshTimer() {
-    if (this.refreshTimer) {
-      clearInterval(this.refreshTimer);
-      this.refreshTimer = void 0;
-    }
-  }
-};
-var UsageMessage = class {
-  constructor(api, chatId, threadId, sendQueue) {
-    this.api = api;
-    this.chatId = chatId;
-    this.threadId = threadId;
-    this.sendQueue = sendQueue;
-  }
-  msgId;
-  async send(usage) {
-    const text = formatUsage(usage);
-    try {
-      if (this.msgId) {
-        await this.sendQueue.enqueue(
-          () => this.api.editMessageText(this.chatId, this.msgId, text, {
-            parse_mode: "HTML"
-          })
-        );
-      } else {
-        const result = await this.sendQueue.enqueue(
-          () => this.api.sendMessage(this.chatId, text, {
-            message_thread_id: this.threadId,
-            parse_mode: "HTML",
-            disable_notification: true
-          })
-        );
-        if (result) this.msgId = result.message_id;
-      }
-    } catch (err) {
-      log10.warn({ err }, "UsageMessage.send() failed");
-    }
-  }
-  getMsgId() {
-    return this.msgId;
-  }
-  async delete() {
-    if (!this.msgId) return;
-    const id = this.msgId;
-    this.msgId = void 0;
-    try {
-      await this.sendQueue.enqueue(() => this.api.deleteMessage(this.chatId, id));
-    } catch (err) {
-      log10.warn({ err }, "UsageMessage.delete() failed");
-    }
-  }
-};
-function formatPlanCard(entries) {
-  const statusIcon = {
-    completed: "\u2705",
-    in_progress: "\u{1F504}",
-    pending: "\u2B1C",
-    failed: "\u274C"
-  };
-  const total = entries.length;
-  const done = entries.filter((e) => e.status === "completed").length;
-  const ratio = total > 0 ? done / total : 0;
-  const filled = Math.round(ratio * 10);
-  const bar = "\u2593".repeat(filled) + "\u2591".repeat(10 - filled);
-  const pct = Math.round(ratio * 100);
-  const header = `\u{1F4CB} <b>Plan</b>
-${bar} ${pct}% \xB7 ${done}/${total}`;
-  const lines = entries.map((e, i) => {
-    const icon = statusIcon[e.status] ?? "\u2B1C";
-    return `${icon} ${i + 1}. ${e.content}`;
-  });
-  return [header, ...lines].join("\n");
-}
-var PlanCard = class {
-  constructor(api, chatId, threadId, sendQueue) {
-    this.api = api;
-    this.chatId = chatId;
-    this.threadId = threadId;
-    this.sendQueue = sendQueue;
-  }
-  msgId;
-  flushPromise = Promise.resolve();
-  latestEntries;
-  lastSentText;
-  flushTimer;
-  update(entries) {
-    this.latestEntries = entries;
-    if (this.flushTimer) clearTimeout(this.flushTimer);
-    this.flushTimer = setTimeout(() => {
-      this.flushTimer = void 0;
-      this.flushPromise = this.flushPromise.then(() => this._flush()).catch(() => {
-      });
-    }, 3500);
-  }
-  async finalize() {
-    if (!this.latestEntries) return;
-    if (this.flushTimer) {
-      clearTimeout(this.flushTimer);
-      this.flushTimer = void 0;
-    }
-    await this.flushPromise;
-    this.flushPromise = this.flushPromise.then(() => this._flush()).catch(() => {
-    });
-    await this.flushPromise;
-  }
-  destroy() {
-    if (this.flushTimer) {
-      clearTimeout(this.flushTimer);
-      this.flushTimer = void 0;
-    }
-  }
-  async _flush() {
-    if (!this.latestEntries) return;
-    const text = formatPlanCard(this.latestEntries);
-    if (this.msgId && text === this.lastSentText) return;
-    this.lastSentText = text;
-    try {
-      if (this.msgId) {
-        await this.sendQueue.enqueue(
-          () => this.api.editMessageText(this.chatId, this.msgId, text, {
-            parse_mode: "HTML"
-          })
-        );
-      } else {
-        const result = await this.sendQueue.enqueue(
-          () => this.api.sendMessage(this.chatId, text, {
-            message_thread_id: this.threadId,
-            parse_mode: "HTML",
-            disable_notification: true
-          })
-        );
-        if (result) this.msgId = result.message_id;
-      }
-    } catch (err) {
-      log10.warn({ err }, "PlanCard flush failed");
-    }
-  }
-};
-var ActivityTracker = class {
-  constructor(api, chatId, threadId, sendQueue) {
-    this.api = api;
-    this.chatId = chatId;
-    this.threadId = threadId;
-    this.sendQueue = sendQueue;
-    this.thinking = new ThinkingIndicator(api, chatId, threadId, sendQueue);
-    this.planCard = new PlanCard(api, chatId, threadId, sendQueue);
-    this.usage = new UsageMessage(api, chatId, threadId, sendQueue);
-  }
-  isFirstEvent = true;
-  hasPlanCard = false;
-  thinking;
-  planCard;
-  usage;
-  async onNewPrompt() {
-    this.isFirstEvent = true;
-    this.hasPlanCard = false;
-    this.thinking.dismiss();
-    this.thinking.reset();
-  }
-  async onThought() {
-    await this._firstEventGuard();
-    await this.thinking.show();
-  }
-  async onPlan(entries) {
-    await this._firstEventGuard();
-    this.thinking.dismiss();
-    this.hasPlanCard = true;
-    this.planCard.update(entries);
-  }
-  async onToolCall() {
-    await this._firstEventGuard();
-    this.thinking.dismiss();
-    this.thinking.reset();
-  }
-  async onTextStart() {
-    await this._firstEventGuard();
-    this.thinking.dismiss();
-  }
-  async sendUsage(data) {
-    await this.usage.send(data);
-  }
-  getUsageMsgId() {
-    return this.usage.getMsgId();
-  }
-  async onComplete() {
-    if (this.hasPlanCard) {
-      await this.planCard.finalize();
-    } else {
-      try {
-        await this.sendQueue.enqueue(
-          () => this.api.sendMessage(this.chatId, "\u2705 <b>Done</b>", {
-            message_thread_id: this.threadId,
-            parse_mode: "HTML",
-            disable_notification: true
-          })
-        );
-      } catch (err) {
-        log10.warn({ err }, "ActivityTracker.onComplete() Done send failed");
-      }
-    }
-  }
-  destroy() {
-    this.thinking.dismiss();
-    this.planCard.destroy();
-  }
-  async _firstEventGuard() {
-    if (!this.isFirstEvent) return;
-    this.isFirstEvent = false;
-    await this.usage.delete();
-  }
-};
-
-// src/adapters/telegram/send-queue.ts
-var TelegramSendQueue = class {
-  items = [];
-  processing = false;
-  lastExec = 0;
-  minInterval;
-  constructor(minInterval = 3e3) {
-    this.minInterval = minInterval;
-  }
-  enqueue(fn, opts) {
-    const type = opts?.type ?? "other";
-    const key = opts?.key;
-    return new Promise((resolve, reject) => {
-      if (type === "text" && key) {
-        const idx = this.items.findIndex(
-          (item) => item.type === "text" && item.key === key
-        );
-        if (idx !== -1) {
-          this.items[idx].resolve(void 0);
-          this.items[idx] = { fn, type, key, resolve, reject };
-          this.scheduleProcess();
-          return;
-        }
-      }
-      this.items.push({ fn, type, key, resolve, reject });
-      this.scheduleProcess();
-    });
-  }
-  onRateLimited() {
-    const remaining = [];
-    for (const item of this.items) {
-      if (item.type === "text") {
-        item.resolve(void 0);
-      } else {
-        remaining.push(item);
-      }
-    }
-    this.items = remaining;
-  }
-  scheduleProcess() {
-    if (this.processing) return;
-    if (this.items.length === 0) return;
-    const elapsed = Date.now() - this.lastExec;
-    const delay = Math.max(0, this.minInterval - elapsed);
-    this.processing = true;
-    setTimeout(() => void this.processNext(), delay);
-  }
-  async processNext() {
-    const item = this.items.shift();
-    if (!item) {
-      this.processing = false;
-      return;
-    }
-    try {
-      const result = await item.fn();
-      item.resolve(result);
-    } catch (err) {
-      item.reject(err);
-    } finally {
-      this.lastExec = Date.now();
-      this.processing = false;
-      this.scheduleProcess();
-    }
-  }
-};
-
-// src/adapters/telegram/action-detect.ts
-import { nanoid as nanoid2 } from "nanoid";
-import { InlineKeyboard as InlineKeyboard11 } 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;
-var KW_CANCEL_RE = /(?:cancel|stop)\s+session/i;
-function detectAction(text) {
-  if (!text) return null;
-  const cancelCmd = CMD_CANCEL_RE.exec(text);
-  if (cancelCmd) return { action: "cancel_session" };
-  const newCmd = CMD_NEW_RE.exec(text);
-  if (newCmd) {
-    return {
-      action: "new_session",
-      agent: newCmd[1] || void 0,
-      workspace: newCmd[2] || void 0
-    };
-  }
-  if (KW_CANCEL_RE.test(text)) return { action: "cancel_session" };
-  if (KW_NEW_RE.test(text))
-    return { action: "new_session", agent: void 0, workspace: void 0 };
-  return null;
-}
-var ACTION_TTL_MS = 5 * 60 * 1e3;
-var actionMap = /* @__PURE__ */ new Map();
-function storeAction(action) {
-  const id = nanoid2(10);
-  actionMap.set(id, { action, createdAt: Date.now() });
-  for (const [key, entry] of actionMap) {
-    if (Date.now() - entry.createdAt > ACTION_TTL_MS) {
-      actionMap.delete(key);
-    }
-  }
-  return id;
-}
-function getAction(id) {
-  const entry = actionMap.get(id);
-  if (!entry) return void 0;
-  if (Date.now() - entry.createdAt > ACTION_TTL_MS) {
-    actionMap.delete(id);
-    return void 0;
-  }
-  return entry.action;
-}
-function removeAction(id) {
-  actionMap.delete(id);
-}
-function buildActionKeyboard(actionId, action) {
-  const keyboard = new InlineKeyboard11();
-  if (action.action === "new_session") {
-    keyboard.text("\u2705 Create session", `a:${actionId}`);
-    keyboard.text("\u274C Cancel", `a:dismiss:${actionId}`);
-  } else {
-    keyboard.text("\u26D4 Cancel session", `a:${actionId}`);
-    keyboard.text("\u274C No", `a:dismiss:${actionId}`);
-  }
-  return keyboard;
-}
-function setupActionCallbacks(bot, core, chatId, getAssistantSessionId) {
-  bot.callbackQuery(/^a:dismiss:/, async (ctx) => {
-    const actionId = ctx.callbackQuery.data.replace("a:dismiss:", "");
-    removeAction(actionId);
-    try {
-      await ctx.editMessageReplyMarkup({
-        reply_markup: { inline_keyboard: [] }
-      });
-    } catch {
-    }
-    await ctx.answerCallbackQuery({ text: "Dismissed" });
-  });
-  bot.callbackQuery(/^a:(?!dismiss)/, async (ctx) => {
-    const actionId = ctx.callbackQuery.data.replace("a:", "");
-    const action = getAction(actionId);
-    if (!action) {
-      await ctx.answerCallbackQuery({ text: "Action expired" });
-      return;
-    }
-    removeAction(actionId);
-    try {
-      if (action.action === "new_session") {
-        if (action.agent && action.workspace) {
-          await ctx.answerCallbackQuery({ text: "\u23F3 Creating session..." });
-          const { threadId, firstMsgId } = await executeNewSession(
-            bot,
-            core,
-            chatId,
-            action.agent,
-            action.workspace
-          );
-          const cleanId = String(chatId).replace("-100", "");
-          const topicLink = firstMsgId ? `https://t.me/c/${cleanId}/${threadId}/${firstMsgId}` : `https://t.me/c/${cleanId}/${threadId}`;
-          const originalText = ctx.callbackQuery.message?.text ?? "";
-          try {
-            await ctx.editMessageText(
-              originalText + `
-
-\u2705 Session created \u2192 <a href="${topicLink}">Go to topic</a>`,
-              { parse_mode: "HTML" }
-            );
-          } catch {
-            await ctx.editMessageReplyMarkup({
-              reply_markup: { inline_keyboard: [] }
-            });
-          }
-        } else {
-          await ctx.answerCallbackQuery();
-          try {
-            await ctx.editMessageReplyMarkup({
-              reply_markup: { inline_keyboard: [] }
-            });
-          } catch {
-          }
-          await startInteractiveNewSession(ctx, core, chatId, action.agent);
-        }
-      } else if (action.action === "cancel_session") {
-        const assistantId = getAssistantSessionId();
-        const cancelled = await executeCancelSession(core, assistantId);
-        if (cancelled) {
-          await ctx.answerCallbackQuery({ text: "\u26D4 Session cancelled" });
-          const originalText = ctx.callbackQuery.message?.text ?? "";
-          try {
-            await ctx.editMessageText(
-              originalText + `
-
-\u26D4 Session "${cancelled.name ?? cancelled.id}" cancelled`,
-              { parse_mode: "HTML" }
-            );
-          } catch {
-            await ctx.editMessageReplyMarkup({
-              reply_markup: { inline_keyboard: [] }
-            });
-          }
-        } else {
-          await ctx.answerCallbackQuery({
-            text: "No active session"
-          });
-          try {
-            await ctx.editMessageReplyMarkup({
-              reply_markup: { inline_keyboard: [] }
-            });
-          } catch {
-          }
-        }
-      }
-    } catch {
-      await ctx.answerCallbackQuery({ text: "\u274C Error, try again later" });
-      try {
-        await ctx.editMessageReplyMarkup({
-          reply_markup: { inline_keyboard: [] }
-        });
-      } catch {
-      }
-    }
-  });
-}
-
-// src/adapters/telegram/tool-call-tracker.ts
-var log11 = createChildLogger({ module: "tool-call-tracker" });
-var ToolCallTracker = class {
-  constructor(bot, chatId, sendQueue) {
-    this.bot = bot;
-    this.chatId = chatId;
-    this.sendQueue = sendQueue;
-  }
-  sessions = /* @__PURE__ */ new Map();
-  async trackNewCall(sessionId, threadId, meta, verbosity = "medium") {
-    if (!this.sessions.has(sessionId)) {
-      this.sessions.set(sessionId, /* @__PURE__ */ new Map());
-    }
-    let resolveReady;
-    const ready = new Promise((r) => {
-      resolveReady = r;
-    });
-    this.sessions.get(sessionId).set(meta.id, {
-      msgId: 0,
-      name: meta.name,
-      kind: meta.kind,
-      rawInput: meta.rawInput,
-      viewerLinks: meta.viewerLinks,
-      viewerFilePath: meta.viewerFilePath,
-      ready
-    });
-    try {
-      const msg = await this.sendQueue.enqueue(
-        () => this.bot.api.sendMessage(this.chatId, formatToolCall(meta, verbosity), {
-          message_thread_id: threadId,
-          parse_mode: "HTML",
-          disable_notification: true
-        })
-      );
-      const toolEntry = this.sessions.get(sessionId).get(meta.id);
-      toolEntry.msgId = msg.message_id;
-    } finally {
-      resolveReady();
-    }
-  }
-  async updateCall(sessionId, meta, verbosity = "medium") {
-    const toolState = this.sessions.get(sessionId)?.get(meta.id);
-    if (!toolState) return;
-    if (meta.viewerLinks) {
-      toolState.viewerLinks = meta.viewerLinks;
-      log11.debug(
-        { toolId: meta.id, viewerLinks: meta.viewerLinks },
-        "Accumulated viewerLinks"
-      );
-    }
-    if (meta.viewerFilePath) toolState.viewerFilePath = meta.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) return;
-    await toolState.ready;
-    log11.debug(
-      {
-        toolId: meta.id,
-        status: meta.status,
-        hasViewerLinks: !!toolState.viewerLinks,
-        viewerLinks: toolState.viewerLinks,
-        name: toolState.name,
-        msgId: toolState.msgId
-      },
-      "Tool completed, preparing edit"
-    );
-    const merged = {
-      ...meta,
-      name: toolState.name,
-      kind: toolState.kind,
-      rawInput: toolState.rawInput,
-      viewerLinks: toolState.viewerLinks,
-      viewerFilePath: toolState.viewerFilePath
-    };
-    const formattedText = formatToolUpdate(merged, verbosity);
-    try {
-      await this.sendQueue.enqueue(
-        () => this.bot.api.editMessageText(
-          this.chatId,
-          toolState.msgId,
-          formattedText,
-          { parse_mode: "HTML" }
-        )
-      );
-    } catch (err) {
-      log11.warn(
-        {
-          err,
-          msgId: toolState.msgId,
-          textLen: formattedText.length,
-          hasViewerLinks: !!merged.viewerLinks
-        },
-        "Tool update edit failed"
-      );
-    }
-  }
-  cleanup(sessionId) {
-    this.sessions.delete(sessionId);
-  }
-};
-
-// src/adapters/telegram/streaming.ts
-var FLUSH_INTERVAL = 5e3;
-var MessageDraft = class {
-  constructor(bot, chatId, threadId, sendQueue, sessionId) {
-    this.bot = bot;
-    this.chatId = chatId;
-    this.threadId = threadId;
-    this.sendQueue = sendQueue;
-    this.sessionId = sessionId;
-  }
-  buffer = "";
-  messageId;
-  firstFlushPending = false;
-  flushTimer;
-  flushPromise = Promise.resolve();
-  lastSentBuffer = "";
-  displayTruncated = false;
-  append(text) {
-    if (!text) return;
-    this.buffer += text;
-    this.scheduleFlush();
-  }
-  scheduleFlush() {
-    if (this.flushTimer) return;
-    this.flushTimer = setTimeout(() => {
-      this.flushTimer = void 0;
-      this.flushPromise = this.flushPromise.then(() => this.flush()).catch(() => {
-      });
-    }, FLUSH_INTERVAL);
-  }
-  async flush() {
-    if (!this.buffer) return;
-    if (this.firstFlushPending) return;
-    const snapshot = this.buffer;
-    let html = markdownToTelegramHtml(snapshot);
-    if (!html) return;
-    let truncated = false;
-    if (html.length > 4096) {
-      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;
-      try {
-        const result = await this.sendQueue.enqueue(
-          () => this.bot.api.sendMessage(this.chatId, html, {
-            message_thread_id: this.threadId,
-            parse_mode: "HTML",
-            disable_notification: true
-          }),
-          { type: "other" }
-        );
-        if (result) {
-          this.messageId = result.message_id;
-          if (!truncated) {
-            this.lastSentBuffer = snapshot;
-            this.displayTruncated = false;
-          } else {
-            this.displayTruncated = true;
-          }
-        }
-      } catch {
-      } finally {
-        this.firstFlushPending = false;
-      }
-    } else {
-      try {
-        const result = await this.sendQueue.enqueue(
-          () => this.bot.api.editMessageText(this.chatId, this.messageId, html, {
-            parse_mode: "HTML"
-          }),
-          { type: "text", key: this.sessionId }
-        );
-        if (result !== void 0) {
-          if (!truncated) {
-            this.lastSentBuffer = snapshot;
-            this.displayTruncated = false;
-          } else {
-            this.displayTruncated = true;
-          }
-        }
-      } catch {
-      }
-    }
-  }
-  async finalize() {
-    if (this.flushTimer) {
-      clearTimeout(this.flushTimer);
-      this.flushTimer = void 0;
-    }
-    await this.flushPromise;
-    if (!this.buffer) return this.messageId;
-    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 = splitMessage2(this.buffer);
-    const chunkPromises = [];
-    for (let i = 0; i < mdChunks.length; i++) {
-      const html = markdownToTelegramHtml(mdChunks[i]);
-      const isEdit = i === 0 && !!this.messageId;
-      const chunkMd = mdChunks[i];
-      const fn = isEdit ? () => this.bot.api.editMessageText(this.chatId, this.messageId, html, { parse_mode: "HTML" }) : () => this.bot.api.sendMessage(this.chatId, html, {
-        message_thread_id: this.threadId,
-        parse_mode: "HTML",
-        disable_notification: true
-      });
-      const promise = this.sendQueue.enqueue(fn, { type: "other" }).then((result) => {
-        if (!isEdit && result && typeof result === "object" && "message_id" in result) {
-          this.messageId = result.message_id;
-        }
-      }).catch(() => {
-        const fallbackFn = isEdit ? () => this.bot.api.editMessageText(this.chatId, this.messageId, chunkMd.slice(0, 4096)) : () => this.bot.api.sendMessage(this.chatId, chunkMd.slice(0, 4096), {
-          message_thread_id: this.threadId,
-          disable_notification: true
-        });
-        return this.sendQueue.enqueue(fallbackFn, { type: "other" }).then((result) => {
-          if (!isEdit && result && typeof result === "object" && "message_id" in result) {
-            this.messageId = result.message_id;
-          }
-        }).catch(() => {
-        });
-      });
-      chunkPromises.push(promise);
-    }
-    await Promise.all(chunkPromises);
-    return this.messageId;
-  }
-  getMessageId() {
-    return this.messageId;
-  }
-  async stripPattern(pattern) {
-    if (!this.messageId || !this.buffer) return;
-    const stripped = this.buffer.replace(pattern, "").trim();
-    if (stripped === this.buffer.trim()) return;
-    this.buffer = stripped;
-    this.lastSentBuffer = stripped;
-    const html = markdownToTelegramHtml(stripped);
-    if (!html) return;
-    try {
-      await this.sendQueue.enqueue(
-        () => this.bot.api.editMessageText(this.chatId, this.messageId, html, {
-          parse_mode: "HTML"
-        }),
-        { type: "other" }
-      );
-    } catch {
-    }
-  }
-};
-
-// src/adapters/telegram/draft-manager.ts
-var DraftManager = class {
-  constructor(bot, chatId, sendQueue) {
-    this.bot = bot;
-    this.chatId = chatId;
-    this.sendQueue = sendQueue;
-  }
-  drafts = /* @__PURE__ */ new Map();
-  textBuffers = /* @__PURE__ */ new Map();
-  getOrCreate(sessionId, threadId) {
-    let draft = this.drafts.get(sessionId);
-    if (!draft) {
-      draft = new MessageDraft(
-        this.bot,
-        this.chatId,
-        threadId,
-        this.sendQueue,
-        sessionId
-      );
-      this.drafts.set(sessionId, draft);
-    }
-    return draft;
-  }
-  hasDraft(sessionId) {
-    return this.drafts.has(sessionId);
-  }
-  getDraft(sessionId) {
-    return this.drafts.get(sessionId);
-  }
-  appendText(sessionId, text) {
-    this.textBuffers.set(
-      sessionId,
-      (this.textBuffers.get(sessionId) ?? "") + text
-    );
-  }
-  /**
-   * Finalize the current draft and return the message ID.
-   * Optionally detects actions in assistant responses.
-   */
-  async finalize(sessionId, assistantSessionId) {
-    const draft = this.drafts.get(sessionId);
-    if (!draft) return;
-    this.drafts.delete(sessionId);
-    const finalMsgId = await draft.finalize();
-    if (assistantSessionId && sessionId === assistantSessionId) {
-      const fullText = this.textBuffers.get(sessionId);
-      this.textBuffers.delete(sessionId);
-      if (fullText && finalMsgId) {
-        const detected = detectAction(fullText);
-        if (detected) {
-          const actionId = storeAction(detected);
-          const keyboard = buildActionKeyboard(actionId, detected);
-          try {
-            await this.bot.api.editMessageReplyMarkup(
-              this.chatId,
-              finalMsgId,
-              { reply_markup: keyboard }
-            );
-          } catch {
-          }
-        }
-      }
-    } else {
-      this.textBuffers.delete(sessionId);
-    }
-  }
-  cleanup(sessionId) {
-    this.drafts.delete(sessionId);
-    this.textBuffers.delete(sessionId);
-  }
-};
-
-// src/adapters/telegram/skill-command-manager.ts
-var log12 = createChildLogger({ module: "skill-commands" });
-var SkillCommandManager = class {
-  // sessionId → pinned msgId
-  constructor(bot, chatId, sendQueue, sessionManager) {
-    this.bot = bot;
-    this.chatId = chatId;
-    this.sendQueue = sendQueue;
-    this.sessionManager = sessionManager;
-  }
-  messages = /* @__PURE__ */ new Map();
-  async send(sessionId, threadId, commands) {
-    if (!this.messages.has(sessionId)) {
-      const record = this.sessionManager.getSessionRecord(sessionId);
-      const platform = record?.platform;
-      if (platform?.skillMsgId) {
-        this.messages.set(sessionId, platform.skillMsgId);
-      }
-    }
-    if (commands.length === 0) {
-      await this.cleanup(sessionId);
-      return;
-    }
-    const messages = buildSkillMessages(commands);
-    const existingMsgId = this.messages.get(sessionId);
-    if (existingMsgId) {
-      try {
-        await this.bot.api.editMessageText(
-          this.chatId,
-          existingMsgId,
-          messages[0],
-          { parse_mode: "HTML" }
-        );
-        return;
-      } catch (err) {
-        const msg = err instanceof Error ? err.message : "";
-        if (msg.includes("message is not modified")) return;
-        try {
-          await this.bot.api.deleteMessage(this.chatId, existingMsgId);
-        } catch {
-        }
-        this.messages.delete(sessionId);
-      }
-    }
-    try {
-      let firstMsgId;
-      for (const text of messages) {
-        const msg = await this.sendQueue.enqueue(
-          () => this.bot.api.sendMessage(this.chatId, text, {
-            message_thread_id: threadId,
-            parse_mode: "HTML",
-            disable_notification: true
-          })
-        );
-        if (!firstMsgId) firstMsgId = msg.message_id;
-      }
-      this.messages.set(sessionId, firstMsgId);
-      const record = this.sessionManager.getSessionRecord(sessionId);
-      if (record) {
-        await this.sessionManager.patchRecord(sessionId, {
-          platform: { ...record.platform, skillMsgId: firstMsgId }
-        });
-      }
-      await this.bot.api.pinChatMessage(this.chatId, firstMsgId, {
-        disable_notification: true
-      });
-    } catch (err) {
-      log12.error({ err, sessionId }, "Failed to send skill commands");
-    }
-  }
-  async cleanup(sessionId) {
-    const msgId = this.messages.get(sessionId);
-    if (!msgId) return;
-    try {
-      await this.bot.api.editMessageText(
-        this.chatId,
-        msgId,
-        "\u{1F6E0} <i>Session ended</i>",
-        { parse_mode: "HTML" }
-      );
-      await this.bot.api.unpinChatMessage(this.chatId, msgId);
-    } catch {
-    }
-    this.messages.delete(sessionId);
-    const record = this.sessionManager.getSessionRecord(sessionId);
-    if (record) {
-      const platform = record.platform;
-      if (platform && typeof platform === "object" && "topicId" in platform) {
-        const { skillMsgId: _removed, ...rest } = platform;
-        await this.sessionManager.patchRecord(sessionId, { platform: rest });
-      }
-    }
-  }
-};
-
-// src/adapters/telegram/adapter.ts
-var log13 = createChildLogger({ module: "telegram" });
-function patchedFetch(input, init) {
-  if (init?.signal && !(init.signal instanceof AbortSignal)) {
-    const nativeController = new AbortController();
-    const polyfillSignal = init.signal;
-    if (polyfillSignal.aborted) {
-      nativeController.abort();
-    } else {
-      polyfillSignal.addEventListener("abort", () => nativeController.abort());
-    }
-    init = { ...init, signal: nativeController.signal };
-  }
-  return fetch(input, init);
-}
-var TelegramAdapter = class extends ChannelAdapter {
-  bot;
-  telegramConfig;
-  permissionHandler;
-  assistantSession = null;
-  assistantInitializing = false;
-  notificationTopicId;
-  assistantTopicId;
-  sendQueue = new TelegramSendQueue(3e3);
-  // Extracted managers
-  toolTracker;
-  draftManager;
-  skillManager;
-  fileService;
-  sessionTrackers = /* @__PURE__ */ new Map();
-  get verbosity() {
-    const live = this.core.configManager.get().channels?.telegram;
-    const v = live?.displayVerbosity ?? this.telegramConfig.displayVerbosity;
-    if (v === "low" || v === "high") return v;
-    return "medium";
-  }
-  getOrCreateTracker(sessionId, threadId) {
-    let tracker = this.sessionTrackers.get(sessionId);
-    if (!tracker) {
-      tracker = new ActivityTracker(
-        this.bot.api,
-        this.telegramConfig.chatId,
-        threadId,
-        this.sendQueue
-      );
-      this.sessionTrackers.set(sessionId, tracker);
-    }
-    return tracker;
-  }
-  constructor(core, config) {
-    super(core, config);
-    this.telegramConfig = config;
-  }
-  async start() {
-    this.bot = new Bot(this.telegramConfig.botToken, {
-      client: {
-        baseFetchConfig: { duplex: "half" },
-        fetch: patchedFetch
-      }
-    });
-    this.fileService = this.core.fileService;
-    this.toolTracker = new ToolCallTracker(
-      this.bot,
-      this.telegramConfig.chatId,
-      this.sendQueue
-    );
-    this.draftManager = new DraftManager(
-      this.bot,
-      this.telegramConfig.chatId,
-      this.sendQueue
-    );
-    this.skillManager = new SkillCommandManager(
-      this.bot,
-      this.telegramConfig.chatId,
-      this.sendQueue,
-      this.core.sessionManager
-    );
-    this.bot.catch((err) => {
-      const rootCause = err.error instanceof Error ? err.error : err;
-      log13.error({ err: rootCause }, "Telegram bot error");
-    });
-    this.bot.api.config.use(async (prev, method, payload, signal) => {
-      const maxRetries = 3;
-      for (let attempt = 0; attempt <= maxRetries; attempt++) {
-        const result = await prev(method, payload, signal);
-        if (result.ok || result.error_code !== 429 || attempt === maxRetries) {
-          return result;
-        }
-        const retryAfter = (result.parameters?.retry_after ?? 5) + 1;
-        const rateLimitedMethods = [
-          "sendMessage",
-          "editMessageText",
-          "editMessageReplyMarkup"
-        ];
-        if (rateLimitedMethods.includes(method)) {
-          this.sendQueue.onRateLimited();
-        }
-        log13.warn(
-          { method, retryAfter, attempt: attempt + 1 },
-          "Rate limited by Telegram, retrying"
-        );
-        await new Promise((r) => setTimeout(r, retryAfter * 1e3));
-      }
-      return prev(method, payload, signal);
-    });
-    this.bot.api.config.use((prev, method, payload, signal) => {
-      if (method === "getUpdates") {
-        const p = payload;
-        p.allowed_updates = p.allowed_updates ?? [
-          "message",
-          "callback_query"
-        ];
-      }
-      return prev(method, payload, signal);
-    });
-    await this.bot.api.setMyCommands(STATIC_COMMANDS, {
-      scope: { type: "chat", chat_id: this.telegramConfig.chatId }
-    });
-    this.bot.use((ctx, next) => {
-      const chatId = ctx.chat?.id ?? ctx.callbackQuery?.message?.chat?.id;
-      if (chatId !== this.telegramConfig.chatId) return;
-      return next();
-    });
-    const topics = await ensureTopics(
-      this.bot,
-      this.telegramConfig.chatId,
-      this.telegramConfig,
-      async (updates) => {
-        await this.core.configManager.save({
-          channels: { telegram: updates }
-        });
-      }
-    );
-    this.notificationTopicId = topics.notificationTopicId;
-    this.assistantTopicId = topics.assistantTopicId;
-    this.permissionHandler = new PermissionHandler(
-      this.bot,
-      this.telegramConfig.chatId,
-      (sessionId) => this.core.sessionManager.getSession(sessionId),
-      (notification) => this.sendNotification(notification)
-    );
-    setupDangerousModeCallbacks(this.bot, this.core);
-    setupTTSCallbacks(this.bot, this.core);
-    setupVerbosityCallbacks(this.bot, this.core);
-    setupActionCallbacks(
-      this.bot,
-      this.core,
-      this.telegramConfig.chatId,
-      () => this.assistantSession?.id
-    );
-    setupIntegrateCallbacks(this.bot, this.core);
-    setupAllCallbacks(
-      this.bot,
-      this.core,
-      this.telegramConfig.chatId,
-      {
-        notificationTopicId: this.notificationTopicId,
-        assistantTopicId: this.assistantTopicId
-      },
-      () => {
-        if (!this.assistantSession) return void 0;
-        return {
-          topicId: this.assistantTopicId,
-          enqueuePrompt: (p) => this.assistantSession.enqueuePrompt(p)
-        };
-      }
-    );
-    setupCommands(
-      this.bot,
-      this.core,
-      this.telegramConfig.chatId,
-      {
-        topicId: this.assistantTopicId,
-        getSession: () => this.assistantSession,
-        respawn: async () => {
-          if (this.assistantSession) {
-            await this.assistantSession.destroy();
-            this.assistantSession = null;
-          }
-          const { session, ready } = await spawnAssistant(
-            this.core,
-            this,
-            this.assistantTopicId
-          );
-          this.assistantSession = session;
-          this.assistantInitializing = true;
-          ready.then(() => {
-            this.assistantInitializing = false;
-          });
-        }
-      }
-    );
-    this.permissionHandler.setupCallbackHandler();
-    this.bot.command("handoff", async (ctx) => {
-      const threadId = ctx.message?.message_thread_id;
-      if (!threadId) return;
-      if (threadId === this.notificationTopicId || threadId === this.assistantTopicId) {
-        await ctx.reply("This command only works in session topics.", {
-          message_thread_id: threadId
-        });
-        return;
-      }
-      const session = this.core.sessionManager.getSessionByThread(
-        "telegram",
-        String(threadId)
-      );
-      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 } = await import("./agent-registry-WT4NXPYG.js");
-      const caps = getAgentCapabilities(agentName);
-      if (!caps.supportsResume || !caps.resumeCommand) {
-        await ctx.reply("This agent does not support session transfer.", {
-          message_thread_id: threadId
-        });
-        return;
-      }
-      const command = caps.resumeCommand(agentSessionId);
-      await ctx.reply(
-        `Run this in your terminal to continue the session:
-
-<code>${command}</code>`,
-        {
-          message_thread_id: threadId,
-          parse_mode: "HTML"
-        }
-      );
-    });
-    this.setupRoutes();
-    this.bot.start({
-      allowed_updates: ["message", "callback_query"],
-      onStart: () => log13.info(
-        { chatId: this.telegramConfig.chatId },
-        "Telegram bot started"
-      )
-    });
-    try {
-      const config = this.core.configManager.get();
-      const agents = this.core.agentManager.getAvailableAgents();
-      const allRecords = this.core.sessionManager.listRecords();
-      const welcomeText = buildWelcomeMessage({
-        activeCount: allRecords.filter(
-          (r) => r.status === "active" || r.status === "initializing"
-        ).length,
-        errorCount: allRecords.filter((r) => r.status === "error").length,
-        totalCount: allRecords.length,
-        agents: agents.map((a) => a.name),
-        defaultAgent: config.defaultAgent
-      });
-      await this.bot.api.sendMessage(this.telegramConfig.chatId, welcomeText, {
-        message_thread_id: this.assistantTopicId,
-        parse_mode: "HTML",
-        reply_markup: buildMenuKeyboard()
-      });
-    } catch (err) {
-      log13.warn({ err }, "Failed to send welcome message");
-    }
-    try {
-      log13.info("Spawning assistant session...");
-      const { session, ready } = await spawnAssistant(
-        this.core,
-        this,
-        this.assistantTopicId
-      );
-      this.assistantSession = session;
-      this.assistantInitializing = true;
-      log13.info(
-        { sessionId: session.id },
-        "Assistant session ready, system prompt running in background"
-      );
-      ready.then(() => {
-        this.assistantInitializing = false;
-        log13.info(
-          { sessionId: session.id },
-          "Assistant ready for user messages"
-        );
-      });
-    } catch (err) {
-      log13.error({ err }, "Failed to spawn assistant");
-      this.bot.api.sendMessage(
-        this.telegramConfig.chatId,
-        `\u26A0\uFE0F <b>Failed to start assistant session.</b>
-
-<code>${err instanceof Error ? err.message : String(err)}</code>`,
-        { message_thread_id: this.assistantTopicId, parse_mode: "HTML" }
-      ).catch(() => {
-      });
-    }
-  }
-  async stop() {
-    if (this.assistantSession) {
-      await this.assistantSession.destroy();
-    }
-    await this.bot.stop();
-    log13.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;
-      }
-      if (await handlePendingResumeInput(
-        ctx,
-        this.core,
-        this.telegramConfig.chatId,
-        this.assistantTopicId
-      )) {
-        return;
-      }
-      if (!threadId) {
-        const html = redirectToAssistant(
-          this.telegramConfig.chatId,
-          this.assistantTopicId
-        );
-        await ctx.reply(html, { parse_mode: "HTML" });
-        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" }
-          );
-          return;
-        }
-        await this.draftManager.finalize(
-          this.assistantSession.id,
-          this.assistantSession.id
-        );
-        ctx.replyWithChatAction("typing").catch(() => {
-        });
-        handleAssistantMessage(this.assistantSession, forwardText).catch(
-          (err) => log13.error({ err }, "Assistant error")
-        );
-        return;
-      }
-      const sessionId = this.core.sessionManager.getSessionByThread(
-        "telegram",
-        String(threadId)
-      )?.id;
-      if (sessionId)
-        await this.draftManager.finalize(sessionId, this.assistantSession?.id);
-      if (sessionId) {
-        const tracker = this.sessionTrackers.get(sessionId);
-        if (tracker) await tracker.onNewPrompt();
-      }
-      ctx.replyWithChatAction("typing").catch(() => {
-      });
-      this.core.handleMessage({
-        channelId: "telegram",
-        threadId: String(threadId),
-        userId: String(ctx.from.id),
-        text: forwardText
-      }).catch((err) => log13.error({ err }, "handleMessage error"));
-    });
-    this.bot.on("message:photo", async (ctx) => {
-      const threadId = ctx.message.message_thread_id;
-      if (!threadId || threadId === this.notificationTopicId) return;
-      const photos = ctx.message.photo;
-      const largest = photos[photos.length - 1];
-      const ext = ".jpg";
-      await this.handleIncomingMedia(
-        threadId,
-        ctx.from.id,
-        largest.file_id,
-        `photo${ext}`,
-        "image/jpeg",
-        ctx.message.caption || void 0
-      );
-    });
-    this.bot.on("message:document", async (ctx) => {
-      const threadId = ctx.message.message_thread_id;
-      if (!threadId || threadId === this.notificationTopicId) return;
-      const doc = ctx.message.document;
-      await this.handleIncomingMedia(
-        threadId,
-        ctx.from.id,
-        doc.file_id,
-        doc.file_name || "document",
-        doc.mime_type || "application/octet-stream",
-        ctx.message.caption || void 0
-      );
-    });
-    this.bot.on("message:voice", async (ctx) => {
-      const threadId = ctx.message.message_thread_id;
-      if (!threadId || threadId === this.notificationTopicId) return;
-      const voice = ctx.message.voice;
-      await this.handleIncomingMedia(
-        threadId,
-        ctx.from.id,
-        voice.file_id,
-        "voice.wav",
-        "audio/wav",
-        void 0,
-        true
-      );
-    });
-    this.bot.on("message:audio", async (ctx) => {
-      const threadId = ctx.message.message_thread_id;
-      if (!threadId || threadId === this.notificationTopicId) return;
-      const audio = ctx.message.audio;
-      await this.handleIncomingMedia(
-        threadId,
-        ctx.from.id,
-        audio.file_id,
-        audio.file_name || "audio.mp3",
-        audio.mime_type || "audio/mpeg",
-        ctx.message.caption || void 0
-      );
-    });
-    this.bot.on("message:video_note", async (ctx) => {
-      const threadId = ctx.message.message_thread_id;
-      if (!threadId || threadId === this.notificationTopicId) return;
-      const videoNote = ctx.message.video_note;
-      await this.handleIncomingMedia(
-        threadId,
-        ctx.from.id,
-        videoNote.file_id,
-        "video_note.mp4",
-        "video/mp4"
-      );
-    });
-  }
-  // --- MessageHandlers for dispatchMessage ---
-  messageHandlers = {
-    onThought: async (ctx, _content) => {
-      const tracker = this.getOrCreateTracker(ctx.sessionId, ctx.threadId);
-      await tracker.onThought();
-    },
-    onText: async (ctx, content) => {
-      if (!this.draftManager.hasDraft(ctx.sessionId)) {
-        const tracker = this.getOrCreateTracker(ctx.sessionId, ctx.threadId);
-        tracker.onTextStart().catch(() => {
-        });
-      }
-      const draft = this.draftManager.getOrCreate(ctx.sessionId, ctx.threadId);
-      draft.append(content.text);
-      this.draftManager.appendText(ctx.sessionId, content.text);
-    },
-    onToolCall: async (ctx, content) => {
-      const meta = content.metadata ?? {};
-      const toolName = meta.name ?? content.text ?? "Tool";
-      const toolKind = String(meta.kind ?? "other");
-      const noiseAction = evaluateNoise(toolName, toolKind, meta.rawInput);
-      if (noiseAction === "hide" && this.verbosity !== "high") return;
-      if (noiseAction === "collapse" && this.verbosity === "low") return;
-      const tracker = this.getOrCreateTracker(ctx.sessionId, ctx.threadId);
-      await tracker.onToolCall();
-      await this.draftManager.finalize(
-        ctx.sessionId,
-        this.assistantSession?.id
-      );
-      await this.toolTracker.trackNewCall(
-        ctx.sessionId,
-        ctx.threadId,
-        {
-          id: meta.id ?? "",
-          name: meta.name ?? content.text ?? "Tool",
-          kind: meta.kind,
-          status: meta.status,
-          content: meta.content,
-          rawInput: meta.rawInput,
-          viewerLinks: meta.viewerLinks,
-          viewerFilePath: meta.viewerFilePath
-        },
-        this.verbosity
-      );
-    },
-    onToolUpdate: async (ctx, content) => {
-      const meta = content.metadata ?? {};
-      await this.toolTracker.updateCall(
-        ctx.sessionId,
-        {
-          id: meta.id ?? "",
-          name: meta.name ?? content.text ?? "",
-          kind: meta.kind,
-          status: meta.status ?? "completed",
-          content: meta.content,
-          rawInput: meta.rawInput,
-          viewerLinks: meta.viewerLinks,
-          viewerFilePath: meta.viewerFilePath
-        },
-        this.verbosity
-      );
-    },
-    onPlan: async (ctx, content) => {
-      const meta = content.metadata ?? {};
-      const entries = meta.entries ?? [];
-      const tracker = this.getOrCreateTracker(ctx.sessionId, ctx.threadId);
-      await tracker.onPlan(
-        entries.map((e) => ({
-          content: e.content,
-          status: e.status,
-          priority: e.priority ?? "medium"
-        }))
-      );
-    },
-    onUsage: async (ctx, content) => {
-      const meta = content.metadata;
-      await this.draftManager.finalize(
-        ctx.sessionId,
-        this.assistantSession?.id
-      );
-      const tracker = this.getOrCreateTracker(ctx.sessionId, ctx.threadId);
-      await tracker.sendUsage(meta ?? {});
-      if (this.notificationTopicId && ctx.sessionId !== this.assistantSession?.id) {
-        const sess = this.core.sessionManager.getSession(ctx.sessionId);
-        const sessionName = sess?.name || "Session";
-        const chatIdStr = String(this.telegramConfig.chatId);
-        const numericId = chatIdStr.startsWith("-100") ? chatIdStr.slice(4) : chatIdStr.replace("-", "");
-        const usageMsgId = tracker.getUsageMsgId();
-        const deepLink = usageMsgId ? `https://t.me/c/${numericId}/${ctx.threadId}/${usageMsgId}` : `https://t.me/c/${numericId}/${ctx.threadId}`;
-        const text = `\u2705 <b>${escapeHtml(sessionName)}</b>
-Task completed.
-
-<a href="${deepLink}">\u2192 Go to topic</a>`;
-        this.sendQueue.enqueue(
-          () => this.bot.api.sendMessage(this.telegramConfig.chatId, text, {
-            message_thread_id: this.notificationTopicId,
-            parse_mode: "HTML",
-            disable_notification: false
-          })
-        ).catch(() => {
-        });
-      }
-    },
-    onAttachment: async (ctx, content) => {
-      if (!content.attachment) return;
-      const { attachment } = content;
-      if (attachment.size > 50 * 1024 * 1024) {
-        log13.warn(
-          {
-            sessionId: ctx.sessionId,
-            fileName: attachment.fileName,
-            size: attachment.size
-          },
-          "File too large for Telegram (>50MB)"
-        );
-        await this.sendQueue.enqueue(
-          () => this.bot.api.sendMessage(
-            this.telegramConfig.chatId,
-            `\u26A0\uFE0F File too large to send (${Math.round(attachment.size / 1024 / 1024)}MB): ${escapeHtml(attachment.fileName)}`,
-            { message_thread_id: ctx.threadId, parse_mode: "HTML" }
-          )
-        );
-        return;
-      }
-      try {
-        const inputFile = new InputFile(attachment.filePath);
-        if (attachment.type === "image") {
-          await this.sendQueue.enqueue(
-            () => this.bot.api.sendPhoto(this.telegramConfig.chatId, inputFile, {
-              message_thread_id: ctx.threadId
-            })
-          );
-        } else if (attachment.type === "audio") {
-          await this.sendQueue.enqueue(
-            () => this.bot.api.sendVoice(this.telegramConfig.chatId, inputFile, {
-              message_thread_id: ctx.threadId
-            })
-          );
-          const draft = this.draftManager.getDraft(ctx.sessionId);
-          if (draft) {
-            draft.stripPattern(/\[TTS\][\s\S]*?\[\/TTS\]/g).catch(() => {
-            });
-          }
-        } else {
-          await this.sendQueue.enqueue(
-            () => this.bot.api.sendDocument(this.telegramConfig.chatId, inputFile, {
-              message_thread_id: ctx.threadId
-            })
-          );
-        }
-      } catch (err) {
-        log13.error(
-          { err, sessionId: ctx.sessionId, fileName: attachment.fileName },
-          "Failed to send attachment"
-        );
-      }
-    },
-    onSessionEnd: async (ctx, _content) => {
-      await this.draftManager.finalize(
-        ctx.sessionId,
-        this.assistantSession?.id
-      );
-      this.draftManager.cleanup(ctx.sessionId);
-      this.toolTracker.cleanup(ctx.sessionId);
-      await this.skillManager.cleanup(ctx.sessionId);
-      const tracker = this.sessionTrackers.get(ctx.sessionId);
-      if (tracker) {
-        await tracker.onComplete();
-        tracker.destroy();
-        this.sessionTrackers.delete(ctx.sessionId);
-      } else {
-        await this.sendQueue.enqueue(
-          () => this.bot.api.sendMessage(
-            this.telegramConfig.chatId,
-            `\u2705 <b>Done</b>`,
-            {
-              message_thread_id: ctx.threadId,
-              parse_mode: "HTML",
-              disable_notification: true
-            }
-          )
-        );
-      }
-    },
-    onError: async (ctx, content) => {
-      await this.draftManager.finalize(
-        ctx.sessionId,
-        this.assistantSession?.id
-      );
-      const tracker = this.sessionTrackers.get(ctx.sessionId);
-      if (tracker) {
-        tracker.destroy();
-        this.sessionTrackers.delete(ctx.sessionId);
-      }
-      await this.sendQueue.enqueue(
-        () => this.bot.api.sendMessage(
-          this.telegramConfig.chatId,
-          `\u274C <b>Error:</b> ${escapeHtml(content.text)}`,
-          {
-            message_thread_id: ctx.threadId,
-            parse_mode: "HTML",
-            disable_notification: true
-          }
-        )
-      );
-    },
-    onSystemMessage: async (ctx, content) => {
-      await this.sendQueue.enqueue(
-        () => this.bot.api.sendMessage(
-          this.telegramConfig.chatId,
-          escapeHtml(content.text),
-          {
-            message_thread_id: ctx.threadId,
-            parse_mode: "HTML",
-            disable_notification: true
-          }
-        )
-      );
-    }
-  };
-  // --- ChannelAdapter implementations ---
-  async sendMessage(sessionId, content) {
-    if (this.assistantInitializing && sessionId === this.assistantSession?.id)
-      return;
-    const session = this.core.sessionManager.getSession(sessionId);
-    if (!session) return;
-    if (session.archiving) return;
-    const threadId = Number(session.threadId);
-    if (!threadId || isNaN(threadId)) {
-      log13.warn(
-        { sessionId, threadId: session.threadId },
-        "Session has no valid threadId, skipping message"
-      );
-      return;
-    }
-    const ctx = { sessionId, threadId };
-    await dispatchMessage(this.messageHandlers, ctx, content, this.verbosity);
-  }
-  async sendPermissionRequest(sessionId, request) {
-    log13.info({ sessionId, requestId: request.id }, "Permission request sent");
-    const session = this.core.sessionManager.getSession(sessionId);
-    if (!session) return;
-    await this.sendQueue.enqueue(
-      () => this.permissionHandler.sendPermissionRequest(session, request)
-    );
-  }
-  async sendNotification(notification) {
-    if (notification.sessionId === this.assistantSession?.id) return;
-    log13.info(
-      { sessionId: notification.sessionId, type: notification.type },
-      "Notification sent"
-    );
-    if (!this.notificationTopicId) return;
-    const emoji = {
-      completed: "\u2705",
-      error: "\u274C",
-      permission: "\u{1F510}",
-      input_required: "\u{1F4AC}"
-    };
-    let text = `${emoji[notification.type] || "\u2139\uFE0F"} <b>${escapeHtml(notification.sessionName || "New session")}</b>
-`;
-    text += escapeHtml(notification.summary);
-    const deepLink = notification.deepLink ?? (() => {
-      const session = this.core.sessionManager.getSession(
-        notification.sessionId
-      );
-      const threadId = session?.threadId;
-      if (!threadId) return void 0;
-      const chatIdStr = String(this.telegramConfig.chatId);
-      const numericId = chatIdStr.startsWith("-100") ? chatIdStr.slice(4) : chatIdStr.replace("-", "");
-      return `https://t.me/c/${numericId}/${threadId}`;
-    })();
-    if (deepLink) {
-      text += `
-
-<a href="${deepLink}">\u2192 Go to topic</a>`;
-    }
-    const replyMarkup = notification.type === "completed" ? { inline_keyboard: [[{ text: "\u{1F4CB} Summary", callback_data: `sm:summary:${notification.sessionId}` }]] } : void 0;
-    await this.sendQueue.enqueue(
-      () => this.bot.api.sendMessage(this.telegramConfig.chatId, text, {
-        message_thread_id: this.notificationTopicId,
-        parse_mode: "HTML",
-        disable_notification: false,
-        reply_markup: replyMarkup
-      })
-    );
-  }
-  async createSessionThread(sessionId, name) {
-    log13.info({ sessionId, name }, "Session topic created");
-    return String(
-      await createSessionTopic(this.bot, this.telegramConfig.chatId, name)
-    );
-  }
-  async renameSessionThread(sessionId, newName) {
-    const session = this.core.sessionManager.getSession(sessionId);
-    if (!session) return;
-    await renameSessionTopic(
-      this.bot,
-      this.telegramConfig.chatId,
-      Number(session.threadId),
-      newName
-    );
-    await this.core.sessionManager.patchRecord(sessionId, { name: newName });
-  }
-  async deleteSessionThread(sessionId) {
-    const record = this.core.sessionManager.getSessionRecord(sessionId);
-    const platform = record?.platform;
-    const topicId = platform?.topicId;
-    if (!topicId) return;
-    try {
-      await this.bot.api.deleteForumTopic(this.telegramConfig.chatId, topicId);
-    } catch (err) {
-      log13.warn(
-        { err, sessionId, topicId },
-        "Failed to delete forum topic (may already be deleted)"
-      );
-    }
-  }
-  async sendSkillCommands(sessionId, commands) {
-    if (sessionId === this.assistantSession?.id) return;
-    const session = this.core.sessionManager.getSession(sessionId);
-    if (!session) return;
-    const threadId = Number(session.threadId);
-    if (!threadId) return;
-    await this.skillManager.send(sessionId, threadId, commands);
-  }
-  resolveSessionId(threadId) {
-    return this.core.sessionManager.getSessionByThread(
-      "telegram",
-      String(threadId)
-    )?.id;
-  }
-  async downloadTelegramFile(fileId) {
-    try {
-      const file = await this.bot.api.getFile(fileId);
-      if (!file.file_path) return null;
-      const url = `https://api.telegram.org/file/bot${this.telegramConfig.botToken}/${file.file_path}`;
-      const response = await fetch(url);
-      if (!response.ok) return null;
-      const buffer = Buffer.from(await response.arrayBuffer());
-      return { buffer, filePath: file.file_path };
-    } catch (err) {
-      log13.error({ err }, "Failed to download file from Telegram");
-      return null;
-    }
-  }
-  async handleIncomingMedia(threadId, userId, fileId, fileName, mimeType, caption, convertOggToWav) {
-    const downloaded = await this.downloadTelegramFile(fileId);
-    if (!downloaded) return;
-    let buffer = downloaded.buffer;
-    let originalFilePath;
-    const sessionId = this.resolveSessionId(threadId) || "unknown";
-    if (convertOggToWav) {
-      const oggAtt = await this.fileService.saveFile(
-        sessionId,
-        "voice.ogg",
-        downloaded.buffer,
-        "audio/ogg"
-      );
-      originalFilePath = oggAtt.filePath;
-      try {
-        buffer = await this.fileService.convertOggToWav(buffer);
-      } catch (err) {
-        log13.warn({ err }, "OGG\u2192WAV conversion failed, saving original OGG");
-        fileName = "voice.ogg";
-        mimeType = "audio/ogg";
-        originalFilePath = void 0;
-      }
-    }
-    const att = await this.fileService.saveFile(
-      sessionId,
-      fileName,
-      buffer,
-      mimeType
-    );
-    if (originalFilePath) {
-      att.originalFilePath = originalFilePath;
-    }
-    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]);
-      }
-      return;
-    }
-    const sid = this.resolveSessionId(threadId);
-    if (sid) await this.draftManager.finalize(sid, this.assistantSession?.id);
-    this.core.handleMessage({
-      channelId: "telegram",
-      threadId: String(threadId),
-      userId: String(userId),
-      text,
-      attachments: [att]
-    }).catch((err) => log13.error({ err }, "handleMessage error"));
-  }
-  async cleanupSkillCommands(sessionId) {
-    await this.skillManager.cleanup(sessionId);
-  }
-  async archiveSessionTopic(sessionId) {
-    const core = this.core;
-    const session = core.sessionManager.getSession(sessionId);
-    if (!session) return;
-    const chatId = this.telegramConfig.chatId;
-    const oldTopicId = Number(session.threadId);
-    session.archiving = true;
-    await this.draftManager.finalize(session.id, this.assistantSession?.id);
-    this.draftManager.cleanup(session.id);
-    this.toolTracker.cleanup(session.id);
-    await this.skillManager.cleanup(session.id);
-    const tracker = this.sessionTrackers.get(session.id);
-    if (tracker) {
-      tracker.destroy();
-      this.sessionTrackers.delete(session.id);
-    }
-    await deleteSessionTopic(this.bot, chatId, oldTopicId);
-  }
-};
-
-export {
-  TelegramAdapter
-};
-//# sourceMappingURL=chunk-H5P2C6H4.js.map