@grinev/opencode-telegram-bot 0.18.0 → 0.19.1

package/dist/scheduled-task/executor.js

@@ -1,12 +1,30 @@
 import { config } from "../config.js";
+import { t } from "../i18n/index.js";
 import { opencodeClient } from "../opencode/client.js";
 import { logger } from "../utils/logger.js";
-const SCHEDULED_TASK_AGENT = "build";
+export const SCHEDULED_TASK_AGENT = "build";
 const SCHEDULED_TASK_SESSION_TITLE = "Scheduled task run";
 const EXECUTION_POLL_INTERVAL_MS = 2000;
 const MAX_IDLE_POLLS_WITHOUT_RESULT = 3;
+const COMPLETED_EMPTY_RESULT_RECHECK_INTERVAL_MS = 500;
+const MAX_COMPLETED_EMPTY_RESULT_RECHECKS = 3;
 const MODELS_DOCS_URL = "https://opencode.ai/docs/config/#models";
 const EXECUTION_TIMEOUT_ERROR_PREFIX = "Scheduled task exceeded bot execution timeout";
+const INTERACTIVE_PERMISSION_REJECT_MESSAGE = "Scheduled task cannot continue because it requires interactive permission.";
+class ScheduledTaskEmptyAssistantResponseError extends Error {
+    constructor() {
+        super("Scheduled task returned an empty assistant response");
+        this.name = "ScheduledTaskEmptyAssistantResponseError";
+    }
+}
+class ScheduledTaskInteractiveRequestError extends Error {
+    constructor(kind) {
+        super(t(kind === "question"
+            ? "task.run.error.interactive_question"
+            : "task.run.error.interactive_permission"));
+        this.name = "ScheduledTaskInteractiveRequestError";
+    }
+}
 function collectResponseText(parts) {
     return parts
         .filter((part) => part.type === "text" && typeof part.text === "string" && !part.ignored)
@@ -69,7 +87,7 @@ function sleep(ms) {
 function findLatestAssistantMessage(messages) {
     for (let index = messages.length - 1; index >= 0; index -= 1) {
         const message = messages[index];
-        if (message?.info.role === "assistant") {
+        if (message?.info.role === "assistant" && !message.info.summary) {
             return message;
         }
     }
@@ -77,7 +95,7 @@ function findLatestAssistantMessage(messages) {
 }
 function extractAssistantResult(message) {
     if (!message) {
-        return { resultText: null, errorMessage: null, completed: false };
+        return { resultText: null, errorMessage: null, completed: false, message: null };
     }
     const errorMessage = extractErrorMessage(message.info.error);
     if (errorMessage) {
@@ -85,6 +103,7 @@ function extractAssistantResult(message) {
             resultText: null,
             errorMessage: normalizeScheduledTaskErrorMessage(errorMessage),
             completed: true,
+            message,
         };
     }
     const resultText = collectResponseText(message.parts);
@@ -92,8 +111,116 @@ function extractAssistantResult(message) {
         resultText,
         errorMessage: null,
         completed: Boolean(message.info.time?.completed),
+        message,
     };
 }
+function summarizeAssistantParts(parts) {
+    return parts.map((part) => ({
+        id: part.id,
+        type: part.type,
+        ignored: part.ignored,
+        ...(typeof part.text === "string" ? { textLength: part.text.length } : {}),
+        ...(part.tool ? { tool: part.tool } : {}),
+        ...(part.state?.status ? { status: part.state.status } : {}),
+    }));
+}
+function logEmptyAssistantResponseDiagnostics(taskId, sessionId, directory, message, readCount) {
+    logger.warn("[ScheduledTaskExecutor] Empty completed assistant response diagnostics", {
+        taskId,
+        sessionId,
+        directory,
+        readCount,
+        assistantMessage: message
+            ? {
+                id: message.info.id,
+                completed: Boolean(message.info.time?.completed),
+                summary: Boolean(message.info.summary),
+                errorMessage: extractErrorMessage(message.info.error),
+                parts: summarizeAssistantParts(message.parts),
+            }
+            : null,
+    });
+}
+async function loadPendingInteractiveRequest(sessionId, directory) {
+    const [questionsResult, permissionsResult] = await Promise.all([
+        opencodeClient.question.list({ directory }),
+        opencodeClient.permission.list({ directory }),
+    ]);
+    if (questionsResult.error) {
+        logger.warn(`[ScheduledTaskExecutor] Failed to list pending questions: sessionId=${sessionId}`, questionsResult.error);
+    }
+    const question = questionsResult.data?.find((request) => request.sessionID === sessionId);
+    if (question) {
+        return { kind: "question", request: question };
+    }
+    if (permissionsResult.error) {
+        logger.warn(`[ScheduledTaskExecutor] Failed to list pending permissions: sessionId=${sessionId}`, permissionsResult.error);
+    }
+    const permission = permissionsResult.data?.find((request) => request.sessionID === sessionId);
+    if (permission) {
+        return { kind: "permission", request: permission };
+    }
+    return null;
+}
+async function rejectInteractiveRequest(request, directory) {
+    try {
+        if (request.kind === "question") {
+            const { error } = await opencodeClient.question.reject({
+                requestID: request.request.id,
+                directory,
+            });
+            if (error) {
+                logger.warn(`[ScheduledTaskExecutor] Failed to reject pending question: requestId=${request.request.id}`, error);
+            }
+            return;
+        }
+        const { error } = await opencodeClient.permission.reply({
+            requestID: request.request.id,
+            directory,
+            reply: "reject",
+            message: INTERACTIVE_PERMISSION_REJECT_MESSAGE,
+        });
+        if (error) {
+            logger.warn(`[ScheduledTaskExecutor] Failed to reject pending permission: requestId=${request.request.id}`, error);
+        }
+    }
+    catch (error) {
+        logger.warn(`[ScheduledTaskExecutor] Failed to reject pending interactive request: requestId=${request.request.id}`, error);
+    }
+}
+async function abortScheduledTaskSession(sessionId, directory) {
+    try {
+        const { error } = await opencodeClient.session.abort({ sessionID: sessionId, directory });
+        if (error) {
+            logger.warn(`[ScheduledTaskExecutor] Failed to abort interactive scheduled task session: sessionId=${sessionId}`, error);
+        }
+    }
+    catch (error) {
+        logger.warn(`[ScheduledTaskExecutor] Failed to abort interactive scheduled task session: sessionId=${sessionId}`, error);
+    }
+}
+async function failIfInteractiveRequest(taskId, sessionId, directory) {
+    const interactiveRequest = await loadPendingInteractiveRequest(sessionId, directory);
+    if (!interactiveRequest) {
+        return;
+    }
+    logger.warn("[ScheduledTaskExecutor] Scheduled task requested interactive action", {
+        taskId,
+        sessionId,
+        directory,
+        kind: interactiveRequest.kind,
+        requestId: interactiveRequest.request.id,
+        ...(interactiveRequest.kind === "question"
+            ? { questionCount: interactiveRequest.request.questions?.length ?? 0 }
+            : {
+                permission: interactiveRequest.request.permission,
+                patterns: interactiveRequest.request.patterns,
+            }),
+    });
+    await rejectInteractiveRequest(interactiveRequest, directory);
+    await abortScheduledTaskSession(sessionId, directory);
+    throw new ScheduledTaskInteractiveRequestError(interactiveRequest.kind);
+}
 async function loadAssistantResult(sessionId, directory) {
     const { data: messages, error: messagesError } = await opencodeClient.session.messages({
         sessionID: sessionId,
@@ -104,14 +231,16 @@ async function loadAssistantResult(sessionId, directory) {
     }
     return extractAssistantResult(findLatestAssistantMessage(messages));
 }
-async function waitForScheduledTaskResult(sessionId, directory) {
+async function waitForScheduledTaskResult(taskId, sessionId, directory) {
     const startedAtMs = Date.now();
     const executionTimeoutMs = getExecutionTimeoutMs();
     let idlePollsWithoutResult = 0;
+    let completedEmptyResultReadCount = 0;
     while (true) {
         if (Date.now() - startedAtMs >= executionTimeoutMs) {
             throw new Error(createExecutionTimeoutMessage());
         }
+        await failIfInteractiveRequest(taskId, sessionId, directory);
         const assistantResult = await loadAssistantResult(sessionId, directory);
         if (assistantResult.errorMessage) {
             throw new Error(assistantResult.errorMessage);
@@ -120,8 +249,15 @@ async function waitForScheduledTaskResult(sessionId, directory) {
             if (assistantResult.resultText) {
                 return assistantResult.resultText;
             }
-            throw new Error("Scheduled task returned an empty assistant response");
+            completedEmptyResultReadCount += 1;
+            if (completedEmptyResultReadCount > MAX_COMPLETED_EMPTY_RESULT_RECHECKS) {
+                logEmptyAssistantResponseDiagnostics(taskId, sessionId, directory, assistantResult.message, completedEmptyResultReadCount);
+                throw new ScheduledTaskEmptyAssistantResponseError();
+            }
+            await sleep(COMPLETED_EMPTY_RESULT_RECHECK_INTERVAL_MS);
+            continue;
         }
+        completedEmptyResultReadCount = 0;
         const { data: statuses, error: statusError } = await opencodeClient.session.status({
             directory,
         });
@@ -138,7 +274,13 @@ async function waitForScheduledTaskResult(sessionId, directory) {
                 if (confirmedAssistantResult.resultText) {
                     return confirmedAssistantResult.resultText;
                 }
-                throw new Error("Scheduled task returned an empty assistant response");
+                completedEmptyResultReadCount += 1;
+                if (completedEmptyResultReadCount > MAX_COMPLETED_EMPTY_RESULT_RECHECKS) {
+                    logEmptyAssistantResponseDiagnostics(taskId, sessionId, directory, confirmedAssistantResult.message, completedEmptyResultReadCount);
+                    throw new ScheduledTaskEmptyAssistantResponseError();
+                }
+                await sleep(COMPLETED_EMPTY_RESULT_RECHECK_INTERVAL_MS);
+                continue;
             }
             idlePollsWithoutResult += 1;
             if (idlePollsWithoutResult >= MAX_IDLE_POLLS_WITHOUT_RESULT) {
@@ -154,6 +296,7 @@ async function waitForScheduledTaskResult(sessionId, directory) {
 export async function executeScheduledTask(task) {
     const startedAt = new Date().toISOString();
     let sessionId = null;
+    let deleteTemporarySession = true;
     try {
         const { data: session, error: createError } = await opencodeClient.session.create({
             directory: task.projectWorktree,
@@ -182,7 +325,7 @@ export async function executeScheduledTask(task) {
         if (promptError) {
             throw promptError || new Error("Scheduled task prompt execution failed");
         }
-        const resultText = await waitForScheduledTaskResult(session.id, session.directory);
+        const resultText = await waitForScheduledTaskResult(task.id, session.id, session.directory);
         return {
             taskId: task.id,
             status: "success",
@@ -194,6 +337,10 @@ export async function executeScheduledTask(task) {
     }
     catch (error) {
         const errorMessage = toErrorMessage(error);
+        if (error instanceof ScheduledTaskEmptyAssistantResponseError && sessionId) {
+            deleteTemporarySession = false;
+            logger.warn(`[ScheduledTaskExecutor] Keeping temporary session for inspection: id=${task.id}, sessionId=${sessionId}`);
+        }
         logger.warn(`[ScheduledTaskExecutor] Task execution failed: id=${task.id}, message=${errorMessage}`);
         return {
             taskId: task.id,
@@ -205,7 +352,7 @@ export async function executeScheduledTask(task) {
         };
     }
     finally {
-        if (sessionId) {
+        if (sessionId && deleteTemporarySession) {
             try {
                 await opencodeClient.session.delete({ sessionID: sessionId });
             }

package/dist/scheduled-task/runtime.js

@@ -4,7 +4,8 @@ import { t } from "../i18n/index.js";
 import { logger } from "../utils/logger.js";
 import { safeBackgroundTask } from "../utils/safe-background-task.js";
 import { sendBotText } from "../bot/utils/telegram-text.js";
-import { executeScheduledTask } from "./executor.js";
+import { formatAssistantRunFooter } from "../bot/utils/assistant-run-footer.js";
+import { executeScheduledTask, SCHEDULED_TASK_AGENT } from "./executor.js";
 import { foregroundSessionState } from "./foreground-state.js";
 import { computeNextRunAt, isTaskDue } from "./next-run.js";
 import { getScheduledTask, listScheduledTasks, removeScheduledTask, replaceScheduledTasks, updateScheduledTask, } from "./store.js";
@@ -40,7 +41,15 @@ function normalizeTaskPrompt(prompt) {
     }
     return `${normalized.slice(0, TASK_DESCRIPTION_PREVIEW_LENGTH)}...`;
 }
-function buildSuccessDelivery(task, runAt, resultText) {
+function calculateElapsedMs(startedAt, finishedAt) {
+    const startedAtMs = Date.parse(startedAt);
+    const finishedAtMs = Date.parse(finishedAt);
+    if (Number.isNaN(startedAtMs) || Number.isNaN(finishedAtMs)) {
+        return 0;
+    }
+    return finishedAtMs - startedAtMs;
+}
+function buildSuccessDelivery(task, startedAt, runAt, resultText) {
     return {
         taskId: task.id,
         scheduleSummary: task.scheduleSummary,
@@ -51,6 +60,12 @@ function buildSuccessDelivery(task, runAt, resultText) {
             description: normalizeTaskPrompt(task.prompt),
         }),
         resultText,
+        footerText: formatAssistantRunFooter({
+            agent: SCHEDULED_TASK_AGENT,
+            providerID: task.model.providerID,
+            modelID: task.model.modelID,
+            elapsedMs: calculateElapsedMs(startedAt, runAt),
+        }),
     };
 }
 function buildErrorDelivery(task, runAt, errorMessage) {
@@ -280,7 +295,7 @@ export class ScheduledTaskRuntime {
         try {
             const result = await executeScheduledTask(runningTask);
             if (result.status === "success") {
-                await this.handleSuccessfulExecution(runningTask, result.finishedAt, result.resultText || "");
+                await this.handleSuccessfulExecution(runningTask, result.startedAt, result.finishedAt, result.resultText || "");
             }
             else {
                 await this.handleFailedExecution(runningTask, result.finishedAt, result.errorMessage || "Unknown error");
@@ -290,8 +305,8 @@ export class ScheduledTaskRuntime {
             this.runningTaskIds.delete(taskId);
         }
     }
-    async handleSuccessfulExecution(task, finishedAt, resultText) {
-        const delivery = buildSuccessDelivery(task, finishedAt, resultText);
+    async handleSuccessfulExecution(task, startedAt, finishedAt, resultText) {
+        const delivery = buildSuccessDelivery(task, startedAt, finishedAt, resultText);
         if (task.kind === "once") {
             await removeScheduledTask(task.id);
             this.removeTask(task.id);
@@ -357,12 +372,22 @@ export class ScheduledTaskRuntime {
                 ? buildScheduledTaskSuccessMessageParts(delivery)
                 : [delivery.notificationText];
             const format = delivery.status === "success" ? getScheduledTaskDeliveryFormat() : "raw";
+            const suppressResultNotification = delivery.status === "success" && Boolean(delivery.footerText);
             for (const part of messageParts) {
                 await sendBotText({
                     api: this.botApi,
                     chatId: this.chatId,
                     text: part,
                     format,
+                    ...(suppressResultNotification ? { options: { disable_notification: true } } : {}),
+                });
+            }
+            if (delivery.status === "success" && delivery.footerText) {
+                await sendBotText({
+                    api: this.botApi,
+                    chatId: this.chatId,
+                    text: delivery.footerText,
+                    format: "raw",
                 });
             }
             return true;

package/dist/session/cache-manager.js

@@ -136,9 +136,8 @@ function upsertDirectory(worktree, lastUpdated) {
     dedupeAndTrimDirectories(cacheData);
     return true;
 }
-function buildListParams() {
-    const hasWatermark = cacheData.lastSyncedUpdatedAt > 0;
-    if (!hasWatermark) {
+function buildListParams(options) {
+    if (options?.force || cacheData.lastSyncedUpdatedAt === 0) {
         return { limit: INITIAL_WARMUP_LIMIT };
     }
     return {
@@ -194,24 +193,38 @@ function isServerUnavailableError(error) {
     }
     return false;
 }
-async function runSync() {
+async function runSync(options) {
     await ensureCacheLoaded();
-    const params = buildListParams();
+    const shouldPrune = options?.force || cacheData.lastSyncedUpdatedAt === 0;
+    const params = buildListParams(options);
     const { data: sessions, error } = await opencodeClient.session.list(params);
     if (error || !sessions) {
         throw error || new Error("No session list received from server");
     }
     let changed = false;
     let maxUpdated = cacheData.lastSyncedUpdatedAt;
+    const seenDirectories = new Set();
     for (const session of sessions) {
         const updatedAt = session.time?.updated ?? Date.now();
         if (upsertDirectory(session.directory, updatedAt)) {
             changed = true;
         }
+        if (session.directory && isValidWorktree(session.directory)) {
+            seenDirectories.add(worktreeKey(session.directory.trim()));
+        }
         if (updatedAt > maxUpdated) {
             maxUpdated = updatedAt;
         }
     }
+    const responseIsTruncated = sessions.length >= INITIAL_WARMUP_LIMIT;
+    if (shouldPrune && !responseIsTruncated) {
+        const before = cacheData.directories.length;
+        cacheData.directories = cacheData.directories.filter((d) => seenDirectories.has(worktreeKey(d.worktree)));
+        if (cacheData.directories.length !== before) {
+            changed = true;
+            logger.info(`[SessionCache] Pruned ${before - cacheData.directories.length} stale directories from cache`);
+        }
+    }
     if (maxUpdated !== cacheData.lastSyncedUpdatedAt) {
         cacheData.lastSyncedUpdatedAt = maxUpdated;
         changed = true;
@@ -397,7 +410,7 @@ export async function syncSessionDirectoryCache(options) {
     if (syncInFlight) {
         return syncInFlight;
     }
-    syncInFlight = runSync()
+    syncInFlight = runSync(options)
         .then(() => {
         lastSyncAttemptAt = Date.now();
     })

package/dist/summary/aggregator.js

@@ -24,6 +24,17 @@ function countDiffChangesFromText(text) {
     }
     return { additions, deletions };
 }
+function normalizeSnapshotValue(value) {
+    if (Array.isArray(value)) {
+        return value.map((item) => normalizeSnapshotValue(item));
+    }
+    if (value && typeof value === "object") {
+        return Object.fromEntries(Object.entries(value)
+            .sort(([left], [right]) => left.localeCompare(right))
+            .map(([key, entryValue]) => [key, normalizeSnapshotValue(entryValue)]));
+    }
+    return value;
+}
 class SummaryAggregator {
     currentSessionId = null;
     textMessageStates = new Map();
@@ -65,6 +76,7 @@ class SummaryAggregator {
     pendingSubagentCardIdsByParent = new Map();
     pendingChildSessionIdsByParent = new Map();
     fallbackSubagentCardIdsByParent = new Map();
+    lastSubagentSnapshot = "";
     setBotAndChatId(bot, chatId) {
         this.bot = bot;
         this.chatId = chatId;
@@ -239,6 +251,7 @@ class SummaryAggregator {
         this.pendingSubagentCardIdsByParent.clear();
         this.pendingChildSessionIdsByParent.clear();
         this.fallbackSubagentCardIdsByParent.clear();
+        this.lastSubagentSnapshot = "";
         this.messageCount = 0;
         this.lastUpdated = 0;
         if (this.onClearedCallback) {
@@ -312,6 +325,28 @@ class SummaryAggregator {
             terminalMessage: state.terminalMessage,
             updatedAt: state.updatedAt,
         }));
+        const snapshot = JSON.stringify(subagents.map((subagent) => ({
+            cardId: subagent.cardId,
+            sessionId: subagent.sessionId,
+            parentSessionId: subagent.parentSessionId,
+            agent: subagent.agent,
+            description: subagent.description,
+            prompt: subagent.prompt,
+            command: subagent.command,
+            status: subagent.status,
+            providerID: subagent.providerID,
+            modelID: subagent.modelID,
+            tokens: subagent.tokens,
+            cost: subagent.cost,
+            currentTool: subagent.currentTool,
+            currentToolInput: normalizeSnapshotValue(subagent.currentToolInput),
+            currentToolTitle: subagent.currentToolTitle,
+            terminalMessage: subagent.terminalMessage,
+        })));
+        if (snapshot === this.lastSubagentSnapshot) {
+            return;
+        }
+        this.lastSubagentSnapshot = snapshot;
         this.onSubagentCallback(this.currentSessionId, subagents);
     }
     createSubagentState(parentSessionId, sessionId, cardId = `subagent-${parentSessionId}-${Date.now()}-${this.subagentOrder.length}`) {

package/dist/summary/formatter.js

@@ -1,9 +1,9 @@
 import * as path from "path";
-import { convert } from "telegram-markdown-v2";
 import { config } from "../config.js";
 import { logger } from "../utils/logger.js";
 import { t } from "../i18n/index.js";
 import { getCurrentProject } from "../settings/manager.js";
+import { convertToTelegramMarkdownV2 } from "./markdown-to-telegram-v2.js";
 import { normalizeMarkdownForTelegramRendering } from "../telegram/render/markdown-normalizer.js";
 const TELEGRAM_MESSAGE_LIMIT = 4096;
 const MARKDOWN_V2_RESERVED_CHARS = /([_\*\[\]\(\)~`>#+\-=|{}.!\\])/g;
@@ -90,7 +90,7 @@ export function escapePlainTextForTelegramMarkdownV2(text) {
 function formatMarkdownForTelegram(text) {
     try {
         const preprocessed = normalizeMarkdownForTelegramRendering(text);
-        return escapeMarkdownV2PipesOutsideCode(convert(preprocessed, "keep"));
+        return escapeMarkdownV2PipesOutsideCode(convertToTelegramMarkdownV2(preprocessed));
     }
     catch (error) {
         logger.warn("[Formatter] Failed to convert markdown summary, falling back to raw text", error);

package/dist/summary/markdown-to-telegram-v2.js

@@ -0,0 +1,99 @@
+import { parseTelegramBlocks } from "../telegram/render/block-parser.js";
+import { normalizeMarkdownForTelegramRendering } from "../telegram/render/markdown-normalizer.js";
+/**
+ * Escapes characters reserved in Telegram MarkdownV2.
+ * These must be escaped everywhere except when used as syntactic delimiters
+ * we intentionally emit (e.g. the surrounding * of bold).
+ */
+function escapeMarkdownV2(text) {
+    return text.replace(/([_*[\]()~`>#+\-=|{}.!\\])/g, "\\$1");
+}
+function escapeMarkdownV2Code(text) {
+    return text.replace(/([`\\])/g, "\\$1");
+}
+function escapeMarkdownV2LinkUrl(text) {
+    return text.replace(/([)\\])/g, "\\$1");
+}
+function renderInlineNodes(nodes) {
+    return nodes
+        .map((node) => {
+        switch (node.type) {
+            case "text":
+                return escapeMarkdownV2(node.text);
+            case "bold":
+                return `*${renderInlineNodes(node.children)}*`;
+            case "italic":
+                return `_${renderInlineNodes(node.children)}_`;
+            case "strike":
+                return `~${renderInlineNodes(node.children)}~`;
+            case "code":
+                return `\`${escapeMarkdownV2Code(node.text)}\``;
+            case "link":
+                return `[${renderInlineNodes(node.text)}](${escapeMarkdownV2LinkUrl(node.url)})`;
+            case "underline":
+                return `__${renderInlineNodes(node.children)}__`;
+            case "spoiler":
+                return `||${renderInlineNodes(node.children)}||`;
+            default:
+                return escapeMarkdownV2(String(node));
+        }
+    })
+        .join("");
+}
+function renderBlock(block) {
+    switch (block.type) {
+        case "paragraph":
+            return renderInlineNodes(block.inlines);
+        case "heading": {
+            const content = renderInlineNodes(block.inlines);
+            return `*${content}*`;
+        }
+        case "blockquote":
+            return block.lines
+                .map((line) => renderInlineNodes(line)
+                .split("\n")
+                .map((part) => `> ${part}`)
+                .join("\n"))
+                .join("\n");
+        case "list":
+            return block.items
+                .map((item, index) => {
+                const prefix = block.ordered ? `${index + 1}\\. ` : "\\- ";
+                const body = renderInlineNodes(item);
+                return `${prefix}${body}`;
+            })
+                .join("\n");
+        case "code":
+            return `\`\`\`${escapeMarkdownV2Code(block.language ?? "")}\n${escapeMarkdownV2Code(block.text)}\n\`\`\``;
+        case "table": {
+            if (block.rows.length === 0) {
+                return "";
+            }
+            const header = `\\| ${block.rows[0].map(escapeMarkdownV2).join(" \\| ")} \\|`;
+            const separator = `\\| ${block.rows[0].map(() => "\\-\\-\\-").join(" \\| ")} \\|`;
+            const body = block.rows
+                .slice(1)
+                .map((row) => `\\| ${row.map(escapeMarkdownV2).join(" \\| ")} \\|`);
+            return [header, separator, ...body].join("\n");
+        }
+        case "rule":
+            return "---";
+        case "plain":
+            return escapeMarkdownV2(block.text);
+    }
+}
+/**
+ * Converts standard Markdown into Telegram MarkdownV2.
+ *
+ * Uses the project's existing block parser (unified/remark) so that
+ * headings, lists, tables, code blocks, etc. are handled consistently
+ * with the entity-based Telegram renderer.
+ */
+export function convertToTelegramMarkdownV2(markdown) {
+    const normalized = normalizeMarkdownForTelegramRendering(markdown);
+    const blocks = parseTelegramBlocks(normalized);
+    if (blocks.length === 0) {
+        return "";
+    }
+    return blocks.map(renderBlock).join("\n\n");
+}

package/dist/summary/subagent-formatter.js

@@ -1,10 +1,31 @@
 import { formatModelDisplayName } from "../pinned/format.js";
 import { t } from "../i18n/index.js";
 import { formatCompactToolInfo } from "./formatter.js";
+function shouldPreferInputDetails(tool, input) {
+    if (!input) {
+        return false;
+    }
+    switch (tool) {
+        case "read":
+        case "edit":
+        case "write":
+        case "apply_patch":
+            return typeof input.path === "string" || typeof input.filePath === "string";
+        case "bash":
+            return typeof input.command === "string";
+        case "grep":
+        case "glob":
+            return typeof input.pattern === "string";
+    }
+    return ["query", "url", "name", "prompt", "text"].some((field) => typeof input[field] === "string");
+}
 function formatToolStep(subagent) {
     if (!subagent.currentTool) {
         return "";
     }
+    const toolTitle = shouldPreferInputDetails(subagent.currentTool, subagent.currentToolInput)
+        ? undefined
+        : subagent.currentToolTitle;
     const toolInfo = {
         sessionId: subagent.sessionId ?? subagent.parentSessionId,
         messageId: subagent.cardId,
@@ -13,12 +34,12 @@ function formatToolStep(subagent) {
         state: {
             status: "running",
             input: subagent.currentToolInput ?? {},
-            title: subagent.currentToolTitle,
+            title: toolTitle,
             metadata: {},
             time: { start: subagent.updatedAt },
         },
         input: subagent.currentToolInput,
-        title: subagent.currentToolTitle,
+        title: toolTitle,
         metadata: {},
         hasFileAttachment: false,
     };

package/dist/telegram/render/inline-renderer.js

@@ -32,6 +32,18 @@ function pushEntity(state, entity) {
     }
     state.entities.push(entity);
 }
+function isTelegramTextLinkUrl(url) {
+    try {
+        const parsed = new URL(url);
+        return ["http:", "https:", "tg:", "mailto:"].includes(parsed.protocol);
+    }
+    catch {
+        return false;
+    }
+}
+function isLocalReferenceUrl(url) {
+    return url.startsWith("#") || url.startsWith("/") || url.startsWith("./") || url.startsWith("../");
+}
 function renderIntoState(state, nodes) {
     for (const node of nodes) {
         switch (node.type) {
@@ -81,6 +93,12 @@ function renderIntoState(state, nodes) {
             case "link": {
                 const offset = state.text.length;
                 renderIntoState(state, node.text);
+                if (!isTelegramTextLinkUrl(node.url)) {
+                    if (isLocalReferenceUrl(node.url)) {
+                        appendText(state, ` (${node.url})`);
+                        break;
+                    }
+                }
                 pushEntity(state, {
                     type: "text_link",
                     offset,