@openacp/cli 0.6.5 → 0.6.7

package/dist/{chunk-FW6HM4VU.js → chunk-5SXG7X5D.js}

@@ -1,10 +1,20 @@
 import {
   PRODUCT_GUIDE,
-  dispatchMessage
-} from "./chunk-FCLGYYTY.js";
+  STATUS_ICONS,
+  dispatchMessage,
+  evaluateNoise,
+  extractContentText,
+  formatTokens,
+  formatToolSummary,
+  formatToolTitle,
+  progressBar,
+  splitMessage,
+  stripCodeFences,
+  truncateContent
+} from "./chunk-JUYDFUSN.js";
 import {
   DoctorEngine
-} from "./chunk-PJVKOZTR.js";
+} from "./chunk-YEOY2PBJ.js";
 import {
   buildMenuKeyboard,
   buildSkillMessages,
@@ -12,15 +22,19 @@ import {
   handleHelp,
   handleMenu
 } from "./chunk-7QJS2XBD.js";
+import {
+  CheckpointReader,
+  DEFAULT_MAX_TOKENS
+} from "./chunk-LO4Y5WQ7.js";
 import {
   ChannelAdapter
-} from "./chunk-4GQ3I65A.js";
+} from "./chunk-LBIKITQT.js";
 import {
   getConfigValue,
   getSafeFields,
   isHotReloadable,
   resolveOptions
-} from "./chunk-F3AICYO4.js";
+} from "./chunk-JHYXKVV2.js";
 import {
   createChildLogger
 } from "./chunk-GAK6PIBW.js";
@@ -76,13 +90,16 @@ function escapeHtml(text) {
 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`;
-  });
+  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>`);
@@ -100,72 +117,32 @@ function markdownToTelegramHtml(md) {
   });
   return text;
 }
-var STATUS_ICON = {
-  pending: "\u23F3",
-  in_progress: "\u{1F504}",
-  completed: "\u2705",
-  failed: "\u274C"
-};
-var KIND_ICON = {
-  read: "\u{1F4D6}",
-  edit: "\u270F\uFE0F",
-  delete: "\u{1F5D1}\uFE0F",
-  execute: "\u25B6\uFE0F",
-  search: "\u{1F50D}",
-  fetch: "\u{1F310}",
-  think: "\u{1F9E0}",
-  move: "\u{1F4E6}",
-  other: "\u{1F6E0}\uFE0F"
-};
-function extractContentText(content, depth = 0) {
-  if (!content || depth > 5) return "";
-  if (typeof content === "string") return content;
-  if (Array.isArray(content)) {
-    return content.map((c) => extractContentText(c, depth + 1)).filter(Boolean).join("\n");
-  }
-  if (typeof content === "object" && content !== null) {
-    const c = content;
-    if (c.type === "text" && typeof c.text === "string") return c.text;
-    if (typeof c.text === "string") return c.text;
-    if (typeof c.content === "string") return c.content;
-    if (c.content && typeof c.content === "object") return extractContentText(c.content, depth + 1);
-    if (c.input) return extractContentText(c.input, depth + 1);
-    if (c.output) return extractContentText(c.output, depth + 1);
-    const keys = Object.keys(c).filter((k) => k !== "type");
-    if (keys.length === 0) return "";
-    return JSON.stringify(c, null, 2);
-  }
-  return String(content);
-}
-function truncateContent(text, maxLen = 3800) {
-  if (text.length <= maxLen) return text;
-  return text.slice(0, maxLen) + "\n\u2026 (truncated)";
-}
-function formatToolCall(tool) {
-  const si = STATUS_ICON[tool.status || ""] || "\u{1F527}";
-  const ki = KIND_ICON[tool.kind || ""] || "\u{1F6E0}\uFE0F";
-  let text = `${si} ${ki} <b>${escapeHtml(tool.name || "Tool")}</b>`;
+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 (!tool.viewerLinks) {
-    const details = extractContentText(tool.content);
+  if (verbosity === "high" || verbosity === "medium" && !tool.viewerLinks) {
+    const details = stripCodeFences(extractContentText(tool.content));
     if (details) {
       text += `
-<pre>${escapeHtml(truncateContent(details))}</pre>`;
+<pre>${escapeHtml(truncateContent(details, 3800))}</pre>`;
     }
   }
   return text;
 }
-function formatToolUpdate(update) {
-  const si = STATUS_ICON[update.status] || "\u{1F527}";
-  const ki = KIND_ICON[update.kind || ""] || "\u{1F6E0}\uFE0F";
+function formatToolUpdate(update, verbosity = "medium") {
+  const si = STATUS_ICONS[update.status] || "\u{1F527}";
   const name = update.name || "Tool";
-  let text = `${si} ${ki} <b>${escapeHtml(name)}</b>`;
+  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 (!update.viewerLinks) {
-    const details = extractContentText(update.content);
+  if (verbosity === "high" || verbosity === "medium" && !update.viewerLinks) {
+    const details = stripCodeFences(extractContentText(update.content));
     if (details) {
       text += `
-<pre>${escapeHtml(truncateContent(details))}</pre>`;
+<pre>${escapeHtml(truncateContent(details, 3800))}</pre>`;
     }
   }
   return text;
@@ -174,19 +151,14 @@ function formatViewerLinks(links, filePath) {
   if (!links) return "";
   const fileName = filePath ? filePath.split("/").pop() || filePath : "";
   let text = "\n";
-  if (links.file) text += `
+  if (links.file)
+    text += `
 \u{1F4C4} <a href="${escapeHtml(links.file)}">View ${escapeHtml(fileName || "file")}</a>`;
-  if (links.diff) text += `
+  if (links.diff)
+    text += `
 \u{1F4DD} <a href="${escapeHtml(links.diff)}">View diff${fileName ? ` \u2014 ${escapeHtml(fileName)}` : ""}</a>`;
   return text;
 }
-function formatTokens(n) {
-  return n >= 1e3 ? `${Math.round(n / 1e3)}k` : String(n);
-}
-function progressBar(ratio) {
-  const filled = Math.round(Math.min(ratio, 1) * 10);
-  return "\u2593".repeat(filled) + "\u2591".repeat(10 - filled);
-}
 function formatUsage(usage) {
   const { tokensUsed, contextSize } = usage;
   if (tokensUsed == null) return "\u{1F4CA} Usage data unavailable";
@@ -213,49 +185,30 @@ function formatUsageReport(summaries, budgetStatus) {
   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(
+      `\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(
+        `Budget: ${formatCost(budgetStatus.used)} / ${formatCost(budgetStatus.budget)} (${budgetStatus.percent}%)`
+      );
       lines.push(`${bar} ${budgetStatus.percent}%`);
     }
   }
   return lines.join("\n");
 }
-function splitMessage(text, maxLength = 3800) {
-  if (text.length <= maxLength) return [text];
-  const chunks = [];
-  let remaining = text;
-  while (remaining.length > 0) {
-    if (remaining.length <= maxLength) {
-      chunks.push(remaining);
-      break;
-    }
-    const wouldLeaveSmall = remaining.length < maxLength * 1.3;
-    const searchLimit = wouldLeaveSmall ? Math.floor(remaining.length / 2) + 300 : maxLength;
-    let splitAt = remaining.lastIndexOf("\n\n", searchLimit);
-    if (splitAt === -1 || splitAt < searchLimit * 0.2) {
-      splitAt = remaining.lastIndexOf("\n", searchLimit);
-    }
-    if (splitAt === -1 || splitAt < searchLimit * 0.2) {
-      splitAt = searchLimit;
-    }
-    const candidate = remaining.slice(0, splitAt);
-    const fences = candidate.match(/```/g);
-    if (fences && fences.length % 2 !== 0) {
-      const closingFence = remaining.indexOf("```", splitAt);
-      if (closingFence !== -1) {
-        const afterFence = remaining.indexOf("\n", closingFence + 3);
-        splitAt = afterFence !== -1 ? afterFence + 1 : closingFence + 3;
-      }
-    }
-    chunks.push(remaining.slice(0, splitAt));
-    remaining = remaining.slice(splitAt).replace(/^\n+/, "");
-  }
-  return chunks;
+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
@@ -267,7 +220,10 @@ function setupDangerousModeCallbacks(bot, core) {
     const session = core.sessionManager.getSession(sessionId);
     if (session) {
       session.dangerousMode = !session.dangerousMode;
-      log.info({ sessionId, dangerousMode: session.dangerousMode }, "Dangerous mode toggled via button");
+      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";
@@ -277,7 +233,11 @@ function setupDangerousModeCallbacks(bot, core) {
       }
       try {
         await ctx.editMessageReplyMarkup({
-          reply_markup: buildSessionControlKeyboard(sessionId, session.dangerousMode, session.voiceMode === "on")
+          reply_markup: buildSessionControlKeyboard(
+            sessionId,
+            session.dangerousMode,
+            session.voiceMode === "on"
+          )
         });
       } catch {
       }
@@ -286,7 +246,9 @@ function setupDangerousModeCallbacks(bot, core) {
     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." });
+        await ctx.answerCallbackQuery({
+          text: "\u26A0\uFE0F Session not found or already ended."
+        });
       } catch {
       }
       return;
@@ -294,7 +256,10 @@ function setupDangerousModeCallbacks(bot, core) {
     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)");
+    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 });
@@ -302,7 +267,11 @@ function setupDangerousModeCallbacks(bot, core) {
     }
     try {
       await ctx.editMessageReplyMarkup({
-        reply_markup: buildSessionControlKeyboard(sessionId, newDangerousMode, false)
+        reply_markup: buildSessionControlKeyboard(
+          sessionId,
+          newDangerousMode,
+          false
+        )
       });
     } catch {
     }
@@ -311,26 +280,40 @@ function setupDangerousModeCallbacks(bot, core) {
 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" });
+    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));
+  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" });
+      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));
+    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" });
+      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" });
+      await ctx.reply("\u2620\uFE0F Dangerous mode is already enabled.", {
+        parse_mode: "HTML"
+      });
       return;
     }
     core.sessionManager.patchRecord(record.sessionId, { dangerousMode: true }).catch(() => {
@@ -348,32 +331,49 @@ Use /disable_dangerous to restore normal behaviour.`,
 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" });
+    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));
+  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" });
+      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));
+    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" });
+      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" });
+      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" });
+  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(
@@ -390,7 +390,9 @@ function setupTTSCallbacks(bot, core) {
     const session = core.sessionManager.getSession(sessionId);
     if (!session) {
       try {
-        await ctx.answerCallbackQuery({ text: "\u26A0\uFE0F Session not found or not active." });
+        await ctx.answerCallbackQuery({
+          text: "\u26A0\uFE0F Session not found or not active."
+        });
       } catch {
       }
       return;
@@ -404,7 +406,11 @@ function setupTTSCallbacks(bot, core) {
     }
     try {
       await ctx.editMessageReplyMarkup({
-        reply_markup: buildSessionControlKeyboard(sessionId, session.dangerousMode, newMode === "on")
+        reply_markup: buildSessionControlKeyboard(
+          sessionId,
+          session.dangerousMode,
+          newMode === "on"
+        )
       });
     } catch {
     }
@@ -413,42 +419,113 @@ function setupTTSCallbacks(bot, core) {
 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" });
+    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" });
+    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" });
+    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" });
+    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" });
+    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-AXXV6IV2.js");
   const current = getCurrentVersion();
-  const statusMsg = await ctx.reply(`\u{1F50D} Checking for updates... (current: v${escapeHtml(current)})`, { parse_mode: "HTML" });
+  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" });
+    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" });
+    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(
@@ -459,7 +536,12 @@ async function handleUpdate(ctx, core) {
   );
   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" });
+    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(
@@ -473,10 +555,16 @@ async function handleUpdate(ctx, core) {
 }
 async function handleRestart(ctx, core) {
   if (!core.requestRestart) {
-    await ctx.reply("\u26A0\uFE0F Restart is not available (no restart handler registered).", { parse_mode: "HTML" });
+    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 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();
 }
@@ -1179,26 +1267,13 @@ async function handleArchive(ctx, core) {
   const threadId = ctx.message?.message_thread_id;
   if (!threadId) return;
   const session = core.sessionManager.getSessionByThread("telegram", String(threadId));
-  if (!session) {
-    await ctx.reply(
-      "\u2139\uFE0F <b>/archive</b> works in session topics \u2014 it recreates the topic with a clean chat view while keeping your agent session alive.\n\nGo to the session topic you want to archive and type /archive there.",
-      { parse_mode: "HTML" }
-    );
-    return;
-  }
-  if (session.status === "initializing") {
-    await ctx.reply("\u23F3 Please wait for session to be ready.", { parse_mode: "HTML" });
-    return;
-  }
-  if (session.status !== "active") {
-    await ctx.reply(`\u26A0\uFE0F Cannot archive \u2014 session is ${session.status}.`, { parse_mode: "HTML" });
-    return;
-  }
+  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 topic?</b>\n\nThis will permanently delete all messages in this topic and create a fresh one.\nYour agent session will continue \u2014 only the chat view is reset.\n\n<i>Note: links to messages in this topic will stop working.</i>",
+    "\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:${session.id}`).text("\u274C Cancel", `ar:no:${session.id}`)
+      reply_markup: new InlineKeyboard3().text("\u{1F5D1} Yes, archive", `ar:yes:${identifier}`).text("\u274C Cancel", `ar:no:${identifier}`)
     }
   );
 }
@@ -1209,31 +1284,103 @@ async function handleArchiveConfirm(ctx, core, chatId) {
     await ctx.answerCallbackQuery();
   } catch {
   }
-  const [, action, sessionId] = data.split(":");
+  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 topic...", { parse_mode: "HTML" });
-  const result = await core.archiveSession(sessionId);
+  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) {
-    const newTopicId = Number(result.newThreadId);
-    await ctx.api.sendMessage(chatId, "\u2705 Topic archived. Session continues.", {
-      message_thread_id: newTopicId,
-      parse_mode: "HTML"
+    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,
+        sessionId: identifier,
         type: "error",
-        summary: `Failed to recreate topic for session "${sessionId}": ${result.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";
@@ -1622,13 +1769,290 @@ ${resultText}`,
   });
 }
 
-// src/adapters/telegram/commands/settings.ts
+// 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-settings" });
+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 InlineKeyboard6();
+  const kb = new InlineKeyboard7();
   for (const field of fields) {
     const value = getConfigValue(config, field.path);
     const label = formatFieldLabel(field, value);
@@ -1687,7 +2111,7 @@ function setupSettingsCallbacks(bot, core, getAssistantSession) {
       } catch {
       }
     } catch (err) {
-      log4.error({ err, fieldPath }, "Failed to toggle config");
+      log5.error({ err, fieldPath }, "Failed to toggle config");
       try {
         await ctx.answerCallbackQuery({ text: "\u274C Failed to update" });
       } catch {
@@ -1701,7 +2125,7 @@ function setupSettingsCallbacks(bot, core, getAssistantSession) {
     if (!fieldDef) return;
     const options = resolveOptions(fieldDef, config) ?? [];
     const currentValue = getConfigValue(config, fieldPath);
-    const kb = new InlineKeyboard6();
+    const kb = new InlineKeyboard7();
     for (const opt of options) {
       const marker = opt === String(currentValue) ? " \u2713" : "";
       kb.text(`${opt}${marker}`, `s:pick:${fieldPath}:${opt}`).row();
@@ -1761,7 +2185,7 @@ Tap to change:`, {
       } catch {
       }
     } catch (err) {
-      log4.error({ err, fieldPath }, "Failed to set config");
+      log5.error({ err, fieldPath }, "Failed to set config");
       try {
         await ctx.answerCallbackQuery({ text: "\u274C Failed to update" });
       } catch {
@@ -1832,8 +2256,8 @@ function buildNestedUpdate(dotPath, value) {
 }
 
 // src/adapters/telegram/commands/doctor.ts
-import { InlineKeyboard as InlineKeyboard7 } from "grammy";
-var log5 = createChildLogger({ module: "telegram-cmd-doctor" });
+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" };
@@ -1850,7 +2274,7 @@ function renderReport(report) {
   lines.push(`<b>Result:</b> ${passed} passed, ${warnings} warnings, ${failed} failed${fixedStr}`);
   let keyboard;
   if (report.pendingFixes.length > 0) {
-    keyboard = new InlineKeyboard7();
+    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();
@@ -1876,7 +2300,7 @@ async function handleDoctor(ctx) {
       reply_markup: keyboard
     });
   } catch (err) {
-    log5.error({ err }, "Doctor command failed");
+    log6.error({ err }, "Doctor command failed");
     await ctx.api.editMessageText(
       ctx.chat.id,
       statusMsg.message_id,
@@ -1925,7 +2349,7 @@ function setupDoctorCallbacks(bot) {
         }
       }
     } catch (err) {
-      log5.error({ err, index }, "Doctor fix callback failed");
+      log6.error({ err, index }, "Doctor fix callback failed");
     }
   });
   bot.callbackQuery("m:doctor", async (ctx) => {
@@ -1938,8 +2362,8 @@ function setupDoctorCallbacks(bot) {
 }
 
 // src/adapters/telegram/commands/tunnel.ts
-import { InlineKeyboard as InlineKeyboard8 } from "grammy";
-var log6 = createChildLogger({ module: "telegram-cmd-tunnel" });
+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" });
@@ -2026,7 +2450,7 @@ async function handleTunnels(ctx, core) {
   \u2192 <a href="${escapeHtml(e.publicUrl)}">${escapeHtml(e.publicUrl)}</a>` : "";
     return `${status} Port <b>${e.port}</b>${label}${url}`;
   });
-  const keyboard = new InlineKeyboard8();
+  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();
   }
@@ -2066,7 +2490,7 @@ function setupTunnelCallbacks(bot, core) {
         if (remaining.length === 0) {
           await ctx.editMessageText("\u{1F50C} All tunnels stopped.", { parse_mode: "HTML" });
         } else {
-          const kb = new InlineKeyboard8();
+          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();
           }
@@ -2115,10 +2539,14 @@ function setupCommands(bot, core, chatId, assistant) {
   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);
@@ -2127,9 +2555,16 @@ function setupAllCallbacks(bot, core, chatId, systemTopicIds, getAssistantSessio
   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);
+    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 {
@@ -2177,8 +2612,14 @@ var STATIC_COMMANDS = [
   { 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: "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" },
@@ -2189,13 +2630,16 @@ var STATIC_COMMANDS = [
   { 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: "text_to_speech", description: "Toggle Text to Speech (/text_to_speech on, /text_to_speech off)" }
+  { 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 InlineKeyboard9 } from "grammy";
+import { InlineKeyboard as InlineKeyboard10 } from "grammy";
 import { nanoid } from "nanoid";
-var log7 = createChildLogger({ module: "telegram-permissions" });
+var log8 = createChildLogger({ module: "telegram-permissions" });
 var PermissionHandler = class {
   constructor(bot, chatId, getSession, sendNotification) {
     this.bot = bot;
@@ -2212,7 +2656,7 @@ var PermissionHandler = class {
       requestId: request.id,
       options: request.options.map((o) => ({ id: o.id, isAllow: o.isAllow }))
     });
-    const keyboard = new InlineKeyboard9();
+    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}`);
@@ -2255,7 +2699,7 @@ ${escapeHtml(request.description)}`,
       }
       const session = this.getSession(pending.sessionId);
       const isAllow = pending.options.find((o) => o.id === optionId)?.isAllow ?? false;
-      log7.info({ requestId: pending.requestId, optionId, isAllow }, "Permission responded");
+      log8.info({ requestId: pending.requestId, optionId, isAllow }, "Permission responded");
       if (session?.permissionGate.requestId === pending.requestId) {
         session.permissionGate.resolve(optionId);
       }
@@ -2273,10 +2717,10 @@ ${escapeHtml(request.description)}`,
 };
 
 // src/adapters/telegram/assistant.ts
-var log8 = createChildLogger({ module: "telegram-assistant" });
+var log9 = createChildLogger({ module: "telegram-assistant" });
 async function spawnAssistant(core, adapter, assistantTopicId) {
   const config = core.configManager.get();
-  log8.info({ agent: config.defaultAgent }, "Creating assistant session...");
+  log9.info({ agent: config.defaultAgent }, "Creating assistant session...");
   const session = await core.createSession({
     channelId: "telegram",
     agentName: config.defaultAgent,
@@ -2285,7 +2729,7 @@ async function spawnAssistant(core, adapter, assistantTopicId) {
     // Prevent auto-naming from triggering after system prompt
   });
   session.threadId = String(assistantTopicId);
-  log8.info({ sessionId: session.id }, "Assistant agent spawned");
+  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();
@@ -2306,9 +2750,9 @@ async function spawnAssistant(core, adapter, assistantTopicId) {
   };
   const systemPrompt = buildAssistantSystemPrompt(ctx);
   const ready = session.enqueuePrompt(systemPrompt).then(() => {
-    log8.info({ sessionId: session.id }, "Assistant system prompt completed");
+    log9.info({ sessionId: session.id }, "Assistant system prompt completed");
   }).catch((err) => {
-    log8.warn({ err }, "Assistant system prompt failed");
+    log9.warn({ err }, "Assistant system prompt failed");
   });
   return { session, ready };
 }
@@ -2474,7 +2918,7 @@ function redirectToAssistant(chatId, assistantTopicId) {
 }
 
 // src/adapters/telegram/activity.ts
-var log9 = createChildLogger({ module: "telegram:activity" });
+var log10 = createChildLogger({ module: "telegram:activity" });
 var THINKING_REFRESH_MS = 15e3;
 var THINKING_MAX_MS = 3 * 60 * 1e3;
 var ThinkingIndicator = class {
@@ -2506,7 +2950,7 @@ var ThinkingIndicator = class {
         this.startRefreshTimer();
       }
     } catch (err) {
-      log9.warn({ err }, "ThinkingIndicator.show() failed");
+      log10.warn({ err }, "ThinkingIndicator.show() failed");
     } finally {
       this.sending = false;
     }
@@ -2579,7 +3023,7 @@ var UsageMessage = class {
         if (result) this.msgId = result.message_id;
       }
     } catch (err) {
-      log9.warn({ err }, "UsageMessage.send() failed");
+      log10.warn({ err }, "UsageMessage.send() failed");
     }
   }
   getMsgId() {
@@ -2592,7 +3036,7 @@ var UsageMessage = class {
     try {
       await this.sendQueue.enqueue(() => this.api.deleteMessage(this.chatId, id));
     } catch (err) {
-      log9.warn({ err }, "UsageMessage.delete() failed");
+      log10.warn({ err }, "UsageMessage.delete() failed");
     }
   }
 };
@@ -2678,7 +3122,7 @@ var PlanCard = class {
         if (result) this.msgId = result.message_id;
       }
     } catch (err) {
-      log9.warn({ err }, "PlanCard flush failed");
+      log10.warn({ err }, "PlanCard flush failed");
     }
   }
 };
@@ -2741,7 +3185,7 @@ var ActivityTracker = class {
           })
         );
       } catch (err) {
-        log9.warn({ err }, "ActivityTracker.onComplete() Done send failed");
+        log10.warn({ err }, "ActivityTracker.onComplete() Done send failed");
       }
     }
   }
@@ -2824,7 +3268,7 @@ var TelegramSendQueue = class {
 
 // src/adapters/telegram/action-detect.ts
 import { nanoid as nanoid2 } from "nanoid";
-import { InlineKeyboard as InlineKeyboard10 } from "grammy";
+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;
@@ -2871,7 +3315,7 @@ function removeAction(id) {
   actionMap.delete(id);
 }
 function buildActionKeyboard(actionId, action) {
-  const keyboard = new InlineKeyboard10();
+  const keyboard = new InlineKeyboard11();
   if (action.action === "new_session") {
     keyboard.text("\u2705 Create session", `a:${actionId}`);
     keyboard.text("\u274C Cancel", `a:dismiss:${actionId}`);
@@ -2980,7 +3424,7 @@ function setupActionCallbacks(bot, core, chatId, getAssistantSessionId) {
 }
 
 // src/adapters/telegram/tool-call-tracker.ts
-var log10 = createChildLogger({ module: "tool-call-tracker" });
+var log11 = createChildLogger({ module: "tool-call-tracker" });
 var ToolCallTracker = class {
   constructor(bot, chatId, sendQueue) {
     this.bot = bot;
@@ -2988,7 +3432,7 @@ var ToolCallTracker = class {
     this.sendQueue = sendQueue;
   }
   sessions = /* @__PURE__ */ new Map();
-  async trackNewCall(sessionId, threadId, meta) {
+  async trackNewCall(sessionId, threadId, meta, verbosity = "medium") {
     if (!this.sessions.has(sessionId)) {
       this.sessions.set(sessionId, /* @__PURE__ */ new Map());
     }
@@ -3000,31 +3444,34 @@ var ToolCallTracker = class {
       msgId: 0,
       name: meta.name,
       kind: meta.kind,
+      rawInput: meta.rawInput,
       viewerLinks: meta.viewerLinks,
       viewerFilePath: meta.viewerFilePath,
       ready
     });
-    const msg = await this.sendQueue.enqueue(
-      () => this.bot.api.sendMessage(
-        this.chatId,
-        formatToolCall(meta),
-        {
+    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;
-    resolveReady();
+        })
+      );
+      const toolEntry = this.sessions.get(sessionId).get(meta.id);
+      toolEntry.msgId = msg.message_id;
+    } finally {
+      resolveReady();
+    }
   }
-  async updateCall(sessionId, meta) {
+  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;
-      log10.debug({ toolId: meta.id, viewerLinks: meta.viewerLinks }, "Accumulated 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;
@@ -3032,7 +3479,7 @@ var ToolCallTracker = class {
     const isTerminal = meta.status === "completed" || meta.status === "failed";
     if (!isTerminal) return;
     await toolState.ready;
-    log10.debug(
+    log11.debug(
       {
         toolId: meta.id,
         status: meta.status,
@@ -3047,10 +3494,11 @@ var ToolCallTracker = class {
       ...meta,
       name: toolState.name,
       kind: toolState.kind,
+      rawInput: toolState.rawInput,
       viewerLinks: toolState.viewerLinks,
       viewerFilePath: toolState.viewerFilePath
     };
-    const formattedText = formatToolUpdate(merged);
+    const formattedText = formatToolUpdate(merged, verbosity);
     try {
       await this.sendQueue.enqueue(
         () => this.bot.api.editMessageText(
@@ -3061,7 +3509,7 @@ var ToolCallTracker = class {
         )
       );
     } catch (err) {
-      log10.warn(
+      log11.warn(
         {
           err,
           msgId: toolState.msgId,
@@ -3204,7 +3652,7 @@ var MessageDraft = class {
       } catch {
       }
     }
-    const mdChunks = splitMessage(this.buffer);
+    const mdChunks = splitMessage2(this.buffer);
     const chunkPromises = [];
     for (let i = 0; i < mdChunks.length; i++) {
       const html = markdownToTelegramHtml(mdChunks[i]);
@@ -3332,7 +3780,7 @@ var DraftManager = class {
 };
 
 // src/adapters/telegram/skill-command-manager.ts
-var log11 = createChildLogger({ module: "skill-commands" });
+var log12 = createChildLogger({ module: "skill-commands" });
 var SkillCommandManager = class {
   // sessionId → pinned msgId
   constructor(bot, chatId, sendQueue, sessionManager) {
@@ -3398,7 +3846,7 @@ var SkillCommandManager = class {
         disable_notification: true
       });
     } catch (err) {
-      log11.error({ err, sessionId }, "Failed to send skill commands");
+      log12.error({ err, sessionId }, "Failed to send skill commands");
     }
   }
   async cleanup(sessionId) {
@@ -3427,7 +3875,7 @@ var SkillCommandManager = class {
 };
 
 // src/adapters/telegram/adapter.ts
-var log12 = createChildLogger({ module: "telegram" });
+var log13 = createChildLogger({ module: "telegram" });
 function patchedFetch(input, init) {
   if (init?.signal && !(init.signal instanceof AbortSignal)) {
     const nativeController = new AbortController();
@@ -3456,6 +3904,12 @@ var TelegramAdapter = class extends ChannelAdapter {
   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) {
@@ -3481,8 +3935,16 @@ var TelegramAdapter = class extends ChannelAdapter {
       }
     });
     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.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,
@@ -3491,7 +3953,7 @@ var TelegramAdapter = class extends ChannelAdapter {
     );
     this.bot.catch((err) => {
       const rootCause = err.error instanceof Error ? err.error : err;
-      log12.error({ err: rootCause }, "Telegram bot error");
+      log13.error({ err: rootCause }, "Telegram bot error");
     });
     this.bot.api.config.use(async (prev, method, payload, signal) => {
       const maxRetries = 3;
@@ -3501,11 +3963,15 @@ var TelegramAdapter = class extends ChannelAdapter {
           return result;
         }
         const retryAfter = (result.parameters?.retry_after ?? 5) + 1;
-        const rateLimitedMethods = ["sendMessage", "editMessageText", "editMessageReplyMarkup"];
+        const rateLimitedMethods = [
+          "sendMessage",
+          "editMessageText",
+          "editMessageReplyMarkup"
+        ];
         if (rateLimitedMethods.includes(method)) {
           this.sendQueue.onRateLimited();
         }
-        log12.warn(
+        log13.warn(
           { method, retryAfter, attempt: attempt + 1 },
           "Rate limited by Telegram, retrying"
         );
@@ -3551,6 +4017,7 @@ var TelegramAdapter = class extends ChannelAdapter {
     );
     setupDangerousModeCallbacks(this.bot, this.core);
     setupTTSCallbacks(this.bot, this.core);
+    setupVerbosityCallbacks(this.bot, this.core);
     setupActionCallbacks(
       this.bot,
       this.core,
@@ -3562,7 +4029,10 @@ var TelegramAdapter = class extends ChannelAdapter {
       this.bot,
       this.core,
       this.telegramConfig.chatId,
-      { notificationTopicId: this.notificationTopicId, assistantTopicId: this.assistantTopicId },
+      {
+        notificationTopicId: this.notificationTopicId,
+        assistantTopicId: this.assistantTopicId
+      },
       () => {
         if (!this.assistantSession) return void 0;
         return {
@@ -3606,8 +4076,14 @@ var TelegramAdapter = class extends ChannelAdapter {
         });
         return;
       }
-      const session = this.core.sessionManager.getSessionByThread("telegram", String(threadId));
-      const record = session ? void 0 : this.core.sessionManager.getRecordByThread("telegram", String(threadId));
+      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) {
@@ -3638,7 +4114,7 @@ var TelegramAdapter = class extends ChannelAdapter {
     this.setupRoutes();
     this.bot.start({
       allowed_updates: ["message", "callback_query"],
-      onStart: () => log12.info(
+      onStart: () => log13.info(
         { chatId: this.telegramConfig.chatId },
         "Telegram bot started"
       )
@@ -3648,7 +4124,9 @@ var TelegramAdapter = class extends ChannelAdapter {
       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,
+        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),
@@ -3660,10 +4138,10 @@ var TelegramAdapter = class extends ChannelAdapter {
         reply_markup: buildMenuKeyboard()
       });
     } catch (err) {
-      log12.warn({ err }, "Failed to send welcome message");
+      log13.warn({ err }, "Failed to send welcome message");
     }
     try {
-      log12.info("Spawning assistant session...");
+      log13.info("Spawning assistant session...");
       const { session, ready } = await spawnAssistant(
         this.core,
         this,
@@ -3671,13 +4149,19 @@ var TelegramAdapter = class extends ChannelAdapter {
       );
       this.assistantSession = session;
       this.assistantInitializing = true;
-      log12.info({ sessionId: session.id }, "Assistant session ready, system prompt running in background");
+      log13.info(
+        { sessionId: session.id },
+        "Assistant session ready, system prompt running in background"
+      );
       ready.then(() => {
         this.assistantInitializing = false;
-        log12.info({ sessionId: session.id }, "Assistant ready for user messages");
+        log13.info(
+          { sessionId: session.id },
+          "Assistant ready for user messages"
+        );
       });
     } catch (err) {
-      log12.error({ err }, "Failed to spawn assistant");
+      log13.error({ err }, "Failed to spawn assistant");
       this.bot.api.sendMessage(
         this.telegramConfig.chatId,
         `\u26A0\uFE0F <b>Failed to start assistant session.</b>
@@ -3693,13 +4177,26 @@ var TelegramAdapter = class extends ChannelAdapter {
       await this.assistantSession.destroy();
     }
     await this.bot.stop();
-    log12.info("Telegram bot stopped");
+    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)) {
+      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) {
@@ -3714,19 +4211,29 @@ var TelegramAdapter = class extends ChannelAdapter {
       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" });
+          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);
+        await this.draftManager.finalize(
+          this.assistantSession.id,
+          this.assistantSession.id
+        );
         ctx.replyWithChatAction("typing").catch(() => {
         });
         handleAssistantMessage(this.assistantSession, forwardText).catch(
-          (err) => log12.error({ err }, "Assistant error")
+          (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);
+      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();
@@ -3738,7 +4245,7 @@ var TelegramAdapter = class extends ChannelAdapter {
         threadId: String(threadId),
         userId: String(ctx.from.id),
         text: forwardText
-      }).catch((err) => log12.error({ err }, "handleMessage error"));
+      }).catch((err) => log13.error({ err }, "handleMessage error"));
     });
     this.bot.on("message:photo", async (ctx) => {
       const threadId = ctx.message.message_thread_id;
@@ -3825,25 +4332,57 @@ var TelegramAdapter = class extends ChannelAdapter {
       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);
-      const meta = content.metadata;
-      await this.toolTracker.trackNewCall(ctx.sessionId, ctx.threadId, {
-        ...meta
-      });
+      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, {
-        ...meta
-      });
+      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 meta = content.metadata ?? {};
+      const entries = meta.entries ?? [];
       const tracker = this.getOrCreateTracker(ctx.sessionId, ctx.threadId);
       await tracker.onPlan(
-        meta.entries.map((e) => ({
+        entries.map((e) => ({
           content: e.content,
           status: e.status,
           priority: e.priority ?? "medium"
@@ -3852,7 +4391,10 @@ var TelegramAdapter = class extends ChannelAdapter {
     },
     onUsage: async (ctx, content) => {
       const meta = content.metadata;
-      await this.draftManager.finalize(ctx.sessionId, this.assistantSession?.id);
+      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) {
@@ -3880,7 +4422,14 @@ Task completed.
       if (!content.attachment) return;
       const { attachment } = content;
       if (attachment.size > 50 * 1024 * 1024) {
-        log12.warn({ sessionId: ctx.sessionId, fileName: attachment.fileName, size: attachment.size }, "File too large for Telegram (>50MB)");
+        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,
@@ -3917,11 +4466,17 @@ Task completed.
           );
         }
       } catch (err) {
-        log12.error({ err, sessionId: ctx.sessionId, fileName: attachment.fileName }, "Failed to send attachment");
+        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);
+      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);
@@ -3945,7 +4500,10 @@ Task completed.
       }
     },
     onError: async (ctx, content) => {
-      await this.draftManager.finalize(ctx.sessionId, this.assistantSession?.id);
+      await this.draftManager.finalize(
+        ctx.sessionId,
+        this.assistantSession?.id
+      );
       const tracker = this.sessionTrackers.get(ctx.sessionId);
       if (tracker) {
         tracker.destroy();
@@ -3979,20 +4537,24 @@ Task completed.
   };
   // --- ChannelAdapter implementations ---
   async sendMessage(sessionId, content) {
-    if (this.assistantInitializing && sessionId === this.assistantSession?.id) return;
+    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)) {
-      log12.warn({ sessionId, threadId: session.threadId }, "Session has no valid threadId, skipping message");
+      log13.warn(
+        { sessionId, threadId: session.threadId },
+        "Session has no valid threadId, skipping message"
+      );
       return;
     }
     const ctx = { sessionId, threadId };
-    await dispatchMessage(this.messageHandlers, ctx, content);
+    await dispatchMessage(this.messageHandlers, ctx, content, this.verbosity);
   }
   async sendPermissionRequest(sessionId, request) {
-    log12.info({ sessionId, requestId: request.id }, "Permission request sent");
+    log13.info({ sessionId, requestId: request.id }, "Permission request sent");
     const session = this.core.sessionManager.getSession(sessionId);
     if (!session) return;
     await this.sendQueue.enqueue(
@@ -4001,7 +4563,7 @@ Task completed.
   }
   async sendNotification(notification) {
     if (notification.sessionId === this.assistantSession?.id) return;
-    log12.info(
+    log13.info(
       { sessionId: notification.sessionId, type: notification.type },
       "Notification sent"
     );
@@ -4016,7 +4578,9 @@ Task completed.
 `;
     text += escapeHtml(notification.summary);
     const deepLink = notification.deepLink ?? (() => {
-      const session = this.core.sessionManager.getSession(notification.sessionId);
+      const session = this.core.sessionManager.getSession(
+        notification.sessionId
+      );
       const threadId = session?.threadId;
       if (!threadId) return void 0;
       const chatIdStr = String(this.telegramConfig.chatId);
@@ -4028,16 +4592,18 @@ Task completed.
 
 <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
+        disable_notification: false,
+        reply_markup: replyMarkup
       })
     );
   }
   async createSessionThread(sessionId, name) {
-    log12.info({ sessionId, name }, "Session topic created");
+    log13.info({ sessionId, name }, "Session topic created");
     return String(
       await createSessionTopic(this.bot, this.telegramConfig.chatId, name)
     );
@@ -4061,7 +4627,10 @@ Task completed.
     try {
       await this.bot.api.deleteForumTopic(this.telegramConfig.chatId, topicId);
     } catch (err) {
-      log12.warn({ err, sessionId, topicId }, "Failed to delete forum topic (may already be deleted)");
+      log13.warn(
+        { err, sessionId, topicId },
+        "Failed to delete forum topic (may already be deleted)"
+      );
     }
   }
   async sendSkillCommands(sessionId, commands) {
@@ -4073,7 +4642,10 @@ Task completed.
     await this.skillManager.send(sessionId, threadId, commands);
   }
   resolveSessionId(threadId) {
-    return this.core.sessionManager.getSessionByThread("telegram", String(threadId))?.id;
+    return this.core.sessionManager.getSessionByThread(
+      "telegram",
+      String(threadId)
+    )?.id;
   }
   async downloadTelegramFile(fileId) {
     try {
@@ -4085,7 +4657,7 @@ Task completed.
       const buffer = Buffer.from(await response.arrayBuffer());
       return { buffer, filePath: file.file_path };
     } catch (err) {
-      log12.error({ err }, "Failed to download file from Telegram");
+      log13.error({ err }, "Failed to download file from Telegram");
       return null;
     }
   }
@@ -4096,18 +4668,28 @@ Task completed.
     let originalFilePath;
     const sessionId = this.resolveSessionId(threadId) || "unknown";
     if (convertOggToWav) {
-      const oggAtt = await this.fileService.saveFile(sessionId, "voice.ogg", downloaded.buffer, "audio/ogg");
+      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) {
-        log12.warn({ err }, "OGG\u2192WAV conversion failed, saving original OGG");
+        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);
+    const att = await this.fileService.saveFile(
+      sessionId,
+      fileName,
+      buffer,
+      mimeType
+    );
     if (originalFilePath) {
       att.originalFilePath = originalFilePath;
     }
@@ -4127,7 +4709,7 @@ Task completed.
       userId: String(userId),
       text,
       attachments: [att]
-    }).catch((err) => log12.error({ err }, "handleMessage error"));
+    }).catch((err) => log13.error({ err }, "handleMessage error"));
   }
   async cleanupSkillCommands(sessionId) {
     await this.skillManager.cleanup(sessionId);
@@ -4135,10 +4717,9 @@ Task completed.
   async archiveSessionTopic(sessionId) {
     const core = this.core;
     const session = core.sessionManager.getSession(sessionId);
-    if (!session) return null;
+    if (!session) return;
     const chatId = this.telegramConfig.chatId;
     const oldTopicId = Number(session.threadId);
-    const rawName = (session.name || `Session ${session.id.slice(0, 6)}`).replace(/^🔄\s*/, "");
     session.archiving = true;
     await this.draftManager.finalize(session.id, this.assistantSession?.id);
     this.draftManager.cleanup(session.id);
@@ -4150,32 +4731,10 @@ Task completed.
       this.sessionTrackers.delete(session.id);
     }
     await deleteSessionTopic(this.bot, chatId, oldTopicId);
-    let newTopicId;
-    try {
-      newTopicId = await createSessionTopic(this.bot, chatId, `\u{1F504} ${rawName}`);
-    } catch (createErr) {
-      session.archiving = false;
-      core.notificationManager.notifyAll({
-        sessionId: session.id,
-        sessionName: session.name,
-        type: "error",
-        summary: `Topic recreation failed for session "${rawName}". Session is orphaned. Error: ${createErr.message}`
-      });
-      throw createErr;
-    }
-    session.threadId = String(newTopicId);
-    const existingRecord = core.sessionManager.getSessionRecord(session.id);
-    const existingPlatform = { ...existingRecord?.platform ?? {} };
-    delete existingPlatform.skillMsgId;
-    await core.sessionManager.patchRecord(session.id, {
-      platform: { ...existingPlatform, topicId: newTopicId }
-    });
-    session.archiving = false;
-    return { newThreadId: String(newTopicId) };
   }
 };
 
 export {
   TelegramAdapter
 };
-//# sourceMappingURL=chunk-FW6HM4VU.js.map
+//# sourceMappingURL=chunk-5SXG7X5D.js.map