@grinev/opencode-telegram-bot 0.15.0 → 0.16.1

package/dist/bot/commands/projects.js

@@ -1,17 +1,10 @@
 import { InlineKeyboard } from "grammy";
-import { setCurrentProject, getCurrentProject } from "../../settings/manager.js";
+import { getCurrentProject } from "../../settings/manager.js";
 import { getProjects } from "../../project/manager.js";
 import { syncSessionDirectoryCache } from "../../session/cache-manager.js";
-import { clearSession } from "../../session/manager.js";
-import { summaryAggregator } from "../../summary/aggregator.js";
-import { pinnedMessageManager } from "../../pinned/manager.js";
-import { keyboardManager } from "../../keyboard/manager.js";
-import { getStoredAgent, resolveProjectAgent } from "../../agent/manager.js";
-import { getStoredModel } from "../../model/manager.js";
-import { formatVariantForButton } from "../../variant/manager.js";
-import { clearAllInteractionState } from "../../interaction/cleanup.js";
-import { createMainKeyboard } from "../utils/keyboard.js";
 import { appendInlineMenuCancelButton, ensureActiveInlineMenu, replyWithInlineMenu, } from "../handlers/inline-menu.js";
+import { switchToProject } from "../utils/switch-project.js";
+import { clearAllInteractionState } from "../../interaction/cleanup.js";
 import { isForegroundBusy, replyBusyBlocked } from "../utils/busy-guard.js";
 import { logger } from "../../utils/logger.js";
 import { t } from "../../i18n/index.js";
@@ -179,35 +172,9 @@ export async function handleProjectSelect(ctx) {
         if (!selectedProject) {
             throw new Error(`Project with id ${projectId} not found`);
         }
-        logger.info(`[Bot] Project selected: ${selectedProject.name || selectedProject.worktree} (id: ${projectId})`);
-        setCurrentProject(selectedProject);
-        clearSession();
-        summaryAggregator.clear();
-        clearAllInteractionState("project_switched");
-        // Clear pinned message when switching projects
-        try {
-            await pinnedMessageManager.clear();
-        }
-        catch (err) {
-            logger.error("[Bot] Error clearing pinned message:", err);
-        }
-        // Initialize keyboard manager if not already
-        if (ctx.chat) {
-            keyboardManager.initialize(ctx.api, ctx.chat.id);
-        }
-        // Refresh context limit for current model
-        await pinnedMessageManager.refreshContextLimit();
-        const contextLimit = pinnedMessageManager.getContextLimit();
-        // Reset context to 0 (no session selected) with current model's limit
-        keyboardManager.updateContext(0, contextLimit);
-        // Get current state for keyboard (with context = 0)
-        const currentAgent = await resolveProjectAgent(getStoredAgent());
-        const currentModel = getStoredModel();
-        const contextInfo = { tokensUsed: 0, tokensLimit: contextLimit };
-        const variantName = formatVariantForButton(currentModel.variant || "default");
-        keyboardManager.updateAgent(currentAgent);
-        const keyboard = createMainKeyboard(currentAgent, currentModel, contextInfo, variantName);
         const projectName = selectedProject.name || selectedProject.worktree;
+        logger.info(`[Bot] Project selected: ${projectName} (id: ${projectId})`);
+        const keyboard = await switchToProject(ctx, selectedProject, "project_switched");
         await ctx.answerCallbackQuery();
         await ctx.reply(t("projects.selected", { project: projectName }), {
             reply_markup: keyboard,

package/dist/bot/commands/start.js

@@ -9,6 +9,7 @@ import { clearProject } from "../../settings/manager.js";
 import { foregroundSessionState } from "../../scheduled-task/foreground-state.js";
 import { abortCurrentOperation } from "./abort.js";
 import { t } from "../../i18n/index.js";
+import { assistantRunState } from "../assistant-run-state.js";
 export async function startCommand(ctx) {
     if (ctx.chat) {
         if (!pinnedMessageManager.isInitialized()) {
@@ -18,6 +19,7 @@ export async function startCommand(ctx) {
     }
     await abortCurrentOperation(ctx, { notifyUser: false });
     foregroundSessionState.clearAll("start_command_reset");
+    assistantRunState.clearAll("start_command_reset");
     clearSession();
     clearProject();
     keyboardManager.clearContext();

package/dist/bot/handlers/inline-menu.js

@@ -3,7 +3,15 @@ import { logger } from "../../utils/logger.js";
 import { t } from "../../i18n/index.js";
 const INLINE_MENU_CANCEL_PREFIX = "inline:cancel:";
 const LEGACY_CONTEXT_CANCEL_CALLBACK = "compact:cancel";
-const INLINE_MENU_KINDS = ["project", "session", "model", "agent", "variant", "context"];
+const INLINE_MENU_KINDS = [
+    "project",
+    "session",
+    "model",
+    "agent",
+    "variant",
+    "context",
+    "open",
+];
 function isInlineMenuKind(value) {
     return INLINE_MENU_KINDS.includes(value);
 }

package/dist/bot/handlers/prompt.js

@@ -17,6 +17,7 @@ import { formatErrorDetails } from "../../utils/error-format.js";
 import { logger } from "../../utils/logger.js";
 import { t } from "../../i18n/index.js";
 import { foregroundSessionState } from "../../scheduled-task/foreground-state.js";
+import { assistantRunState } from "../assistant-run-state.js";
 /** Module-level references for async callbacks that don't have ctx. */
 let botInstance = null;
 let chatIdInstance = null;
@@ -61,6 +62,7 @@ async function resetMismatchedSessionContext() {
     stopEventListening();
     summaryAggregator.clear();
     foregroundSessionState.clearAll("session_mismatch_reset");
+    assistantRunState.clearAll("session_mismatch_reset");
     clearAllInteractionState("session_mismatch_reset");
     clearSession();
     keyboardManager.clearContext();
@@ -209,6 +211,12 @@ export async function processUserPrompt(ctx, text, deps, fileParts = [], options
         };
         logger.info(`[Bot] Calling session.prompt (fire-and-forget) with agent=${currentAgent}, fileCount=${fileParts.length}...`);
         foregroundSessionState.markBusy(currentSession.id);
+        assistantRunState.startRun(currentSession.id, {
+            startedAt: Date.now(),
+            configuredAgent: currentAgent,
+            configuredProviderID: storedModel.providerID,
+            configuredModelID: storedModel.modelID,
+        });
         setPromptResponseMode(currentSession.id, responseMode);
         // CRITICAL: DO NOT wait for session.prompt to complete.
         // If we wait, the handler will not finish and grammY will not call getUpdates,
@@ -220,6 +228,7 @@ export async function processUserPrompt(ctx, text, deps, fileParts = [], options
             onSuccess: ({ error }) => {
                 if (error) {
                     foregroundSessionState.markIdle(currentSession.id);
+                    assistantRunState.clearRun(currentSession.id, "session_prompt_api_error");
                     clearPromptResponseMode(currentSession.id);
                     const details = formatErrorDetails(error, 6000);
                     logger.error("[Bot] OpenCode API returned an error for session.prompt", promptErrorLogContext);
@@ -233,6 +242,7 @@ export async function processUserPrompt(ctx, text, deps, fileParts = [], options
             },
             onError: (error) => {
                 foregroundSessionState.markIdle(currentSession.id);
+                assistantRunState.clearRun(currentSession.id, "session_prompt_background_error");
                 clearPromptResponseMode(currentSession.id);
                 const details = formatErrorDetails(error, 6000);
                 logger.error("[Bot] session.prompt background task failed", promptErrorLogContext);
@@ -246,6 +256,7 @@ export async function processUserPrompt(ctx, text, deps, fileParts = [], options
     catch (err) {
         if (currentSession) {
             foregroundSessionState.markIdle(currentSession.id);
+            assistantRunState.clearRun(currentSession.id, "session_prompt_handler_error");
         }
         logger.error("Error in prompt handler:", err);
         if (interactionManager.getSnapshot()) {

package/dist/bot/index.js

@@ -16,6 +16,7 @@ import { AGENT_MODE_BUTTON_TEXT_PATTERN, MODEL_BUTTON_TEXT_PATTERN, VARIANT_BUTT
 import { sessionsCommand, handleSessionSelect } from "./commands/sessions.js";
 import { newCommand } from "./commands/new.js";
 import { projectsCommand, handleProjectSelect } from "./commands/projects.js";
+import { openCommand, handleOpenCallback, clearOpenPathIndex } from "./commands/open.js";
 import { abortCommand } from "./commands/abort.js";
 import { opencodeStartCommand } from "./commands/opencode-start.js";
 import { opencodeStopCommand } from "./commands/opencode-stop.js";
@@ -35,9 +36,9 @@ import { questionManager } from "../question/manager.js";
 import { interactionManager } from "../interaction/manager.js";
 import { clearAllInteractionState } from "../interaction/cleanup.js";
 import { keyboardManager } from "../keyboard/manager.js";
-import { subscribeToEvents } from "../opencode/events.js";
+import { stopEventListening, subscribeToEvents } from "../opencode/events.js";
 import { summaryAggregator } from "../summary/aggregator.js";
-import { formatSummary, formatSummaryWithMode, formatToolInfo, getAssistantParseMode, } from "../summary/formatter.js";
+import { formatToolInfo } from "../summary/formatter.js";
 import { renderSubagentCards } from "../summary/subagent-formatter.js";
 import { ToolMessageBatcher } from "../summary/tool-message-batcher.js";
 import { getCurrentSession } from "../session/manager.js";
@@ -54,17 +55,20 @@ import { downloadTelegramFile, toDataUri } from "./utils/file-download.js";
 import { finalizeAssistantResponse } from "./utils/finalize-assistant-response.js";
 import { sendTtsResponseForSession } from "./utils/send-tts-response.js";
 import { deliverThinkingMessage } from "./utils/thinking-message.js";
-import { sendBotText } from "./utils/telegram-text.js";
+import { editRenderedBotPart, getTelegramRenderedPartSignature, sendRenderedBotPart, } from "./utils/telegram-text.js";
+import { formatAssistantRunFooter } from "./utils/assistant-run-footer.js";
 import { getModelCapabilities, supportsInput } from "../model/capabilities.js";
 import { getStoredModel } from "../model/manager.js";
 import { foregroundSessionState } from "../scheduled-task/foreground-state.js";
 import { scheduledTaskRuntime } from "../scheduled-task/runtime.js";
+import { assistantRunState } from "./assistant-run-state.js";
 import { ResponseStreamer } from "./streaming/response-streamer.js";
 import { ToolCallStreamer } from "./streaming/tool-call-streamer.js";
-import { editMessageWithMarkdownFallback, sendMessageWithMarkdownFallback, } from "./utils/send-with-markdown-fallback.js";
+import { prepareAssistantFinalStreamingPayload, prepareAssistantStreamingPayload, renderAssistantFinalPartsSafe, } from "./utils/assistant-rendering.js";
 let botInstance = null;
 let chatIdInstance = null;
 let commandsInitialized = false;
+let heartbeatTimer = null;
 const TELEGRAM_DOCUMENT_CAPTION_MAX_LENGTH = 1024;
 const RESPONSE_STREAM_THROTTLE_MS = config.bot.responseStreamThrottleMs;
 const RESPONSE_STREAM_TEXT_LIMIT = 3800;
@@ -73,6 +77,7 @@ const SUBAGENT_STREAM_PREFIX = "🧩";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const TEMP_DIR = path.join(__dirname, "..", ".tmp");
+const sessionCompletionTasks = new Map();
 function getCurrentReplyKeyboard() {
     if (!keyboardManager.isInitialized()) {
         return undefined;
@@ -90,14 +95,23 @@ function prepareDocumentCaption(caption) {
     return `${normalizedCaption.slice(0, TELEGRAM_DOCUMENT_CAPTION_MAX_LENGTH - 3)}...`;
 }
 function prepareStreamingPayload(messageText) {
-    const parts = formatSummaryWithMode(messageText, config.bot.messageFormatMode, RESPONSE_STREAM_TEXT_LIMIT);
-    if (parts.length === 0) {
-        return null;
-    }
-    return {
-        parts,
-        format: "raw",
-    };
+    return prepareAssistantStreamingPayload(messageText, RESPONSE_STREAM_TEXT_LIMIT);
+}
+function prepareFinalStreamingPayload(messageText) {
+    return prepareAssistantFinalStreamingPayload(messageText, RESPONSE_STREAM_TEXT_LIMIT);
+}
+function enqueueSessionCompletionTask(sessionId, task) {
+    const previousTask = sessionCompletionTasks.get(sessionId) ?? Promise.resolve();
+    const nextTask = previousTask
+        .catch(() => undefined)
+        .then(task)
+        .finally(() => {
+        if (sessionCompletionTasks.get(sessionId) === nextTask) {
+            sessionCompletionTasks.delete(sessionId);
+        }
+    });
+    sessionCompletionTasks.set(sessionId, nextTask);
+    return nextTask;
 }
 const toolMessageBatcher = new ToolMessageBatcher({
     sendText: async (sessionId, text) => {
@@ -141,39 +155,36 @@ const toolMessageBatcher = new ToolMessageBatcher({
 });
 const responseStreamer = new ResponseStreamer({
     throttleMs: RESPONSE_STREAM_THROTTLE_MS,
-    sendText: async (text, format, options) => {
+    sendPart: async (part, options) => {
         if (!botInstance || !chatIdInstance || chatIdInstance <= 0) {
             throw new Error("Bot context missing for streamed send");
         }
-        const parseMode = format === "markdown_v2" ? "MarkdownV2" : undefined;
-        const sentMessage = await sendMessageWithMarkdownFallback({
+        return sendRenderedBotPart({
             api: botInstance.api,
             chatId: chatIdInstance,
-            text,
+            part,
             options,
-            parseMode,
         });
-        return sentMessage.message_id;
     },
-    editText: async (messageId, text, format, options) => {
+    editPart: async (messageId, part, options) => {
         if (!botInstance || !chatIdInstance || chatIdInstance <= 0) {
             throw new Error("Bot context missing for streamed edit");
         }
-        const parseMode = format === "markdown_v2" ? "MarkdownV2" : undefined;
         try {
-            await editMessageWithMarkdownFallback({
+            return await editRenderedBotPart({
                 api: botInstance.api,
                 chatId: chatIdInstance,
                 messageId,
-                text,
+                part,
                 options,
-                parseMode,
             });
         }
         catch (error) {
             const errorMessage = error instanceof Error ? error.message.toLowerCase() : String(error).toLowerCase();
             if (errorMessage.includes("message is not modified")) {
-                return;
+                return {
+                    deliveredSignature: getTelegramRenderedPartSignature(part),
+                };
             }
             throw error;
         }
@@ -298,84 +309,82 @@ async function ensureEventSubscription(directory) {
         if (!preparedStreamPayload) {
             return;
         }
+        // Reply keyboards make the first streamed message non-editable in Telegram,
+        // so partial chunks must be sent without reply_markup and finalized later.
         preparedStreamPayload.sendOptions = { disable_notification: true };
         preparedStreamPayload.editOptions = undefined;
         responseStreamer.enqueue(sessionId, messageId, preparedStreamPayload);
     });
-    summaryAggregator.setOnComplete(async (sessionId, messageId, messageText) => {
-        if (!botInstance || !chatIdInstance) {
-            logger.error("Bot or chat ID not available for sending message");
-            clearPromptResponseMode(sessionId);
-            responseStreamer.clearMessage(sessionId, messageId, "bot_context_missing");
-            toolCallStreamer.clearSession(sessionId, "bot_context_missing");
-            foregroundSessionState.markIdle(sessionId);
-            return;
-        }
-        const currentSession = getCurrentSession();
-        if (currentSession?.id !== sessionId) {
-            clearPromptResponseMode(sessionId);
-            responseStreamer.clearMessage(sessionId, messageId, "session_mismatch");
-            toolCallStreamer.clearSession(sessionId, "session_mismatch");
-            foregroundSessionState.markIdle(sessionId);
-            await scheduledTaskRuntime.flushDeferredDeliveries();
-            return;
-        }
-        const botApi = botInstance.api;
-        const chatId = chatIdInstance;
-        try {
-            await finalizeAssistantResponse({
-                sessionId,
-                messageId,
-                messageText,
-                responseStreamer,
-                flushPendingServiceMessages: () => Promise.all([
-                    toolMessageBatcher.flushSession(sessionId, "assistant_message_completed"),
-                    toolCallStreamer.flushSession(sessionId, "assistant_message_completed"),
-                ]).then(() => undefined),
-                prepareStreamingPayload,
-                formatSummary,
-                formatRawSummary: (text) => formatSummaryWithMode(text, "raw"),
-                resolveFormat: () => (getAssistantParseMode() === "MarkdownV2" ? "markdown_v2" : "raw"),
-                getReplyKeyboard: getCurrentReplyKeyboard,
-                sendText: async (text, rawFallbackText, options, format) => {
-                    await sendBotText({
-                        api: botApi,
-                        chatId,
-                        text,
-                        rawFallbackText,
-                        options: options,
-                        format,
-                    });
-                },
-                deleteMessages: async (messageIds) => {
-                    for (const msgId of messageIds) {
-                        try {
-                            await botApi.deleteMessage(chatId, msgId);
-                        }
-                        catch (err) {
-                            logger.warn(`[Bot] Failed to delete streamed message ${msgId}:`, err);
-                        }
-                    }
-                },
-            });
-            await sendTtsResponseForSession({
-                api: botApi,
-                sessionId,
-                chatId,
-                text: messageText,
-            });
-        }
-        catch (err) {
-            clearPromptResponseMode(sessionId);
-            logger.error("Failed to send message to Telegram:", err);
-            // Stop processing events after critical error to prevent infinite loop
-            logger.error("[Bot] CRITICAL: Stopping event processing due to error");
-            summaryAggregator.clear();
-        }
-        finally {
-            foregroundSessionState.markIdle(sessionId);
-            await scheduledTaskRuntime.flushDeferredDeliveries();
-        }
+    summaryAggregator.setOnComplete((sessionId, messageId, messageText, completionInfo) => {
+        void enqueueSessionCompletionTask(sessionId, async () => {
+            if (!botInstance || !chatIdInstance) {
+                logger.error("Bot or chat ID not available for sending message");
+                clearPromptResponseMode(sessionId);
+                responseStreamer.clearMessage(sessionId, messageId, "bot_context_missing");
+                toolCallStreamer.clearSession(sessionId, "bot_context_missing");
+                assistantRunState.clearRun(sessionId, "bot_context_missing");
+                foregroundSessionState.markIdle(sessionId);
+                return;
+            }
+            const currentSession = getCurrentSession();
+            if (currentSession?.id !== sessionId) {
+                clearPromptResponseMode(sessionId);
+                responseStreamer.clearMessage(sessionId, messageId, "session_mismatch");
+                toolCallStreamer.clearSession(sessionId, "session_mismatch");
+                assistantRunState.clearRun(sessionId, "session_mismatch");
+                foregroundSessionState.markIdle(sessionId);
+                await scheduledTaskRuntime.flushDeferredDeliveries();
+                return;
+            }
+            const botApi = botInstance.api;
+            const chatId = chatIdInstance;
+            try {
+                assistantRunState.markResponseCompleted(sessionId, {
+                    agent: completionInfo.agent,
+                    providerID: completionInfo.providerID,
+                    modelID: completionInfo.modelID,
+                });
+                await finalizeAssistantResponse({
+                    sessionId,
+                    messageId,
+                    messageText,
+                    responseStreamer,
+                    flushPendingServiceMessages: () => Promise.all([
+                        toolMessageBatcher.flushSession(sessionId, "assistant_message_completed"),
+                        toolCallStreamer.breakSession(sessionId, "assistant_message_completed"),
+                    ]).then(() => undefined),
+                    prepareStreamingPayload: prepareFinalStreamingPayload,
+                    renderFinalParts: (text) => renderAssistantFinalPartsSafe(text),
+                    getReplyKeyboard: getCurrentReplyKeyboard,
+                    sendRenderedPart: async (part, options) => {
+                        await sendRenderedBotPart({
+                            api: botApi,
+                            chatId,
+                            part,
+                            options: options,
+                        });
+                    },
+                });
+                await sendTtsResponseForSession({
+                    api: botApi,
+                    sessionId,
+                    chatId,
+                    text: messageText,
+                });
+            }
+            catch (err) {
+                clearPromptResponseMode(sessionId);
+                assistantRunState.clearRun(sessionId, "assistant_finalize_failed");
+                logger.error("Failed to send message to Telegram:", err);
+                // Stop processing events after critical error to prevent infinite loop
+                logger.error("[Bot] CRITICAL: Stopping event processing due to error");
+                summaryAggregator.clear();
+                foregroundSessionState.markIdle(sessionId);
+            }
+            finally {
+                await scheduledTaskRuntime.flushDeferredDeliveries();
+            }
+        });
     });
     summaryAggregator.setOnTool(async (toolInfo) => {
         if (!botInstance || !chatIdInstance) {
@@ -434,6 +443,9 @@ async function ensureEventSubscription(directory) {
         if (!currentSession || currentSession.id !== fileInfo.sessionId) {
             return;
         }
+        if (config.bot.hideToolFileMessages) {
+            return;
+        }
         try {
             await toolCallStreamer.breakSession(fileInfo.sessionId, "tool_file_boundary");
             const toolMessage = formatToolInfo(fileInfo);
@@ -568,9 +580,54 @@ async function ensureEventSubscription(directory) {
             logger.error("[Bot] Error reloading context after compaction:", err);
         }
     });
+    summaryAggregator.setOnSessionIdle(async (sessionId) => {
+        await sessionCompletionTasks.get(sessionId)?.catch(() => undefined);
+        const completedRun = assistantRunState.finishRun(sessionId, "session_idle");
+        clearPromptResponseMode(sessionId);
+        if (!botInstance || !chatIdInstance) {
+            foregroundSessionState.markIdle(sessionId);
+            return;
+        }
+        const currentSession = getCurrentSession();
+        if (!currentSession || currentSession.id !== sessionId) {
+            foregroundSessionState.markIdle(sessionId);
+            await scheduledTaskRuntime.flushDeferredDeliveries();
+            return;
+        }
+        try {
+            await Promise.all([
+                toolMessageBatcher.flushSession(sessionId, "session_idle"),
+                toolCallStreamer.flushSession(sessionId, "session_idle"),
+            ]);
+            if (completedRun?.hasCompletedResponse) {
+                const agent = completedRun.actualAgent || completedRun.configuredAgent;
+                const providerID = completedRun.actualProviderID || completedRun.configuredProviderID;
+                const modelID = completedRun.actualModelID || completedRun.configuredModelID;
+                if (agent && providerID && modelID) {
+                    const keyboard = getCurrentReplyKeyboard();
+                    await botInstance.api.sendMessage(chatIdInstance, formatAssistantRunFooter({
+                        agent,
+                        providerID,
+                        modelID,
+                        elapsedMs: Date.now() - completedRun.startedAt,
+                    }), {
+                        ...(keyboard ? { reply_markup: keyboard } : {}),
+                    });
+                }
+            }
+        }
+        catch (err) {
+            logger.error("[Bot] Failed to send session idle footer:", err);
+        }
+        finally {
+            foregroundSessionState.markIdle(sessionId);
+            await scheduledTaskRuntime.flushDeferredDeliveries();
+        }
+    });
     summaryAggregator.setOnSessionError(async (sessionId, message) => {
         if (!botInstance || !chatIdInstance) {
             clearPromptResponseMode(sessionId);
+            assistantRunState.clearRun(sessionId, "session_error_no_bot_context");
             foregroundSessionState.markIdle(sessionId);
             return;
         }
@@ -579,12 +636,14 @@ async function ensureEventSubscription(directory) {
             clearPromptResponseMode(sessionId);
             responseStreamer.clearSession(sessionId, "session_error_not_current");
             toolCallStreamer.clearSession(sessionId, "session_error_not_current");
+            assistantRunState.clearRun(sessionId, "session_error_not_current");
             foregroundSessionState.markIdle(sessionId);
             await scheduledTaskRuntime.flushDeferredDeliveries();
             return;
         }
         responseStreamer.clearSession(sessionId, "session_error");
         clearPromptResponseMode(sessionId);
+        assistantRunState.clearRun(sessionId, "session_error");
         await Promise.all([
             toolMessageBatcher.flushSession(sessionId, "session_error"),
             toolCallStreamer.flushSession(sessionId, "session_error"),
@@ -661,6 +720,12 @@ async function ensureEventSubscription(directory) {
 }
 export function createBot() {
     clearAllInteractionState("bot_startup");
+    sessionCompletionTasks.clear();
+    assistantRunState.clearAll("bot_startup");
+    if (heartbeatTimer) {
+        clearInterval(heartbeatTimer);
+        heartbeatTimer = null;
+    }
     const botOptions = {};
     if (config.telegram.proxyUrl) {
         const proxyUrl = config.telegram.proxyUrl;
@@ -683,7 +748,7 @@ export function createBot() {
     const bot = new Bot(config.telegram.token, botOptions);
     // Heartbeat for diagnostics: verify the event loop is not blocked
     let heartbeatCounter = 0;
-    setInterval(() => {
+    heartbeatTimer = setInterval(() => {
         heartbeatCounter++;
         if (heartbeatCounter % 6 === 0) {
             // Log every 30 seconds (5 sec * 6)
@@ -736,6 +801,7 @@ export function createBot() {
     bot.command("opencode_start", opencodeStartCommand);
     bot.command("opencode_stop", opencodeStopCommand);
     bot.command("projects", projectsCommand);
+    bot.command("open", openCommand);
     bot.command("sessions", sessionsCommand);
     bot.command("new", newCommand);
     bot.command("abort", abortCommand);
@@ -753,8 +819,13 @@ export function createBot() {
         }
         try {
             const handledInlineCancel = await handleInlineMenuCancel(ctx);
+            if (handledInlineCancel) {
+                // Clean up path index when the open-directory menu is cancelled
+                clearOpenPathIndex();
+            }
             const handledSession = await handleSessionSelect(ctx);
             const handledProject = await handleProjectSelect(ctx);
+            const handledOpen = await handleOpenCallback(ctx);
             const handledQuestion = await handleQuestionCallback(ctx);
             const handledPermission = await handlePermissionCallback(ctx);
             const handledAgent = await handleAgentSelect(ctx);
@@ -765,10 +836,11 @@ export function createBot() {
             const handledTaskList = await handleTaskListCallback(ctx);
             const handledRenameCancel = await handleRenameCancel(ctx);
             const handledCommands = await handleCommandsCallback(ctx, { bot, ensureEventSubscription });
-            logger.debug(`[Bot] Callback handled: inlineCancel=${handledInlineCancel}, session=${handledSession}, project=${handledProject}, question=${handledQuestion}, permission=${handledPermission}, agent=${handledAgent}, model=${handledModel}, variant=${handledVariant}, compactConfirm=${handledCompactConfirm}, task=${handledTask}, taskList=${handledTaskList}, rename=${handledRenameCancel}, commands=${handledCommands}`);
+            logger.debug(`[Bot] Callback handled: inlineCancel=${handledInlineCancel}, session=${handledSession}, project=${handledProject}, open=${handledOpen}, question=${handledQuestion}, permission=${handledPermission}, agent=${handledAgent}, model=${handledModel}, variant=${handledVariant}, compactConfirm=${handledCompactConfirm}, task=${handledTask}, taskList=${handledTaskList}, rename=${handledRenameCancel}, commands=${handledCommands}`);
             if (!handledInlineCancel &&
                 !handledSession &&
                 !handledProject &&
+                !handledOpen &&
                 !handledQuestion &&
                 !handledPermission &&
                 !handledAgent &&
@@ -989,3 +1061,18 @@ export function createBot() {
     });
     return bot;
 }
+export function cleanupBotRuntime(reason) {
+    stopEventListening();
+    summaryAggregator.clear();
+    responseStreamer.clearAll(reason);
+    toolCallStreamer.clearAll(reason);
+    toolMessageBatcher.clearAll(reason);
+    sessionCompletionTasks.clear();
+    assistantRunState.clearAll(reason);
+    if (heartbeatTimer) {
+        clearInterval(heartbeatTimer);
+        heartbeatTimer = null;
+    }
+    botInstance = null;
+    chatIdInstance = null;
+}