@grinev/opencode-telegram-bot 0.14.1 → 0.16.0

package/dist/bot/commands/open.js

@@ -0,0 +1,314 @@
+import { InlineKeyboard } from "grammy";
+import path from "node:path";
+import { appendInlineMenuCancelButton, ensureActiveInlineMenu } from "../handlers/inline-menu.js";
+import { interactionManager } from "../../interaction/manager.js";
+import { isForegroundBusy, replyBusyBlocked } from "../utils/busy-guard.js";
+import { pathToDisplayPath, scanDirectory, buildEntryLabel, buildTreeHeader, isScanError, MAX_ENTRIES_PER_PAGE, } from "../utils/file-tree.js";
+import { getBrowserRoots, isWithinAllowedRoot, isAllowedRoot } from "../utils/browser-roots.js";
+import { upsertSessionDirectory } from "../../session/cache-manager.js";
+import { getProjectByWorktree } from "../../project/manager.js";
+import { switchToProject } from "../utils/switch-project.js";
+import { logger } from "../../utils/logger.js";
+import { t } from "../../i18n/index.js";
+const CALLBACK_PREFIX = "open:";
+const CALLBACK_NAV_PREFIX = "open:nav:";
+const CALLBACK_SELECT_PREFIX = "open:sel:";
+const CALLBACK_PAGE_PREFIX = "open:pg:";
+const CALLBACK_ROOTS = "open:roots";
+const MAX_BUTTON_LABEL_LENGTH = 64;
+/**
+ * Separator used inside pagination callback data between the encoded path
+ * reference and the page number. We avoid `:` because it appears in Windows
+ * drive letters (e.g. `C:\`) and is already used as a prefix delimiter.
+ */
+const PAGE_SEPARATOR = "|";
+function truncateLabel(label, maxLen = MAX_BUTTON_LABEL_LENGTH) {
+    if (label.length <= maxLen) {
+        return label;
+    }
+    return label.slice(0, Math.max(0, maxLen - 3)) + "...";
+}
+/**
+ * Encode a path into callback data. Telegram limits callback_data to 64 bytes.
+ * Long absolute paths can exceed this, so we encode them as a compact index
+ * when necessary. The index is stored in a module-level map that lives for the
+ * duration of the current inline menu interaction.
+ */
+const pathIndex = new Map();
+let pathCounter = 0;
+/** Clear the path index. Exported so it can be called on menu cancel/cleanup. */
+export function clearOpenPathIndex() {
+    pathIndex.clear();
+    pathCounter = 0;
+}
+/**
+ * @param prefix   Callback-data prefix that precedes the path.
+ * @param fullPath Absolute path to encode.
+ * @param reserveBytes Extra bytes to reserve for a suffix that will be
+ *   appended *after* the returned value (e.g. the page separator + digits in
+ *   pagination callbacks). The total callback_data must stay ≤ 64 bytes.
+ */
+function encodePathForCallback(prefix, fullPath, reserveBytes = 0) {
+    const naive = `${prefix}${fullPath}`;
+    if (Buffer.byteLength(naive, "utf-8") + reserveBytes <= 64) {
+        return naive;
+    }
+    // Use a short numeric key instead
+    const key = `#${pathCounter++}`;
+    pathIndex.set(key, fullPath);
+    return `${prefix}${key}`;
+}
+function decodePathFromCallback(prefix, data) {
+    if (!data.startsWith(prefix)) {
+        return null;
+    }
+    const raw = data.slice(prefix.length);
+    if (raw.startsWith("#")) {
+        return pathIndex.get(raw) ?? null;
+    }
+    return raw;
+}
+/**
+ * Encode a pagination callback. The path part goes through the same 64-byte
+ * safe encoding used by nav/select callbacks, followed by a separator and
+ * the page number.
+ *
+ * We reserve bytes for the page suffix so the 64-byte check inside
+ * `encodePathForCallback` accounts for the complete final callback length.
+ */
+function encodePaginationCallback(currentPath, page) {
+    const pageSuffix = `${PAGE_SEPARATOR}${page}`;
+    const reserveBytes = Buffer.byteLength(pageSuffix, "utf-8");
+    const pathRef = encodePathForCallback(CALLBACK_PAGE_PREFIX, currentPath, reserveBytes);
+    return `${pathRef}${pageSuffix}`;
+}
+/**
+ * Decode a pagination callback into { path, page } or null on failure.
+ */
+function decodePaginationCallback(data) {
+    if (!data.startsWith(CALLBACK_PAGE_PREFIX)) {
+        return null;
+    }
+    const payload = data.slice(CALLBACK_PAGE_PREFIX.length);
+    const sepIndex = payload.lastIndexOf(PAGE_SEPARATOR);
+    if (sepIndex < 0) {
+        return null;
+    }
+    const pathRef = payload.slice(0, sepIndex);
+    const pageNum = Number.parseInt(payload.slice(sepIndex + 1), 10);
+    if (Number.isNaN(pageNum)) {
+        return null;
+    }
+    // Resolve indexed path references
+    const resolvedPath = pathRef.startsWith("#") ? (pathIndex.get(pathRef) ?? null) : pathRef;
+    if (resolvedPath === null) {
+        return null;
+    }
+    return { path: resolvedPath, page: pageNum };
+}
+function buildBrowseKeyboard(entries, currentPath, hasParent, page, totalCount) {
+    const keyboard = new InlineKeyboard();
+    const totalPages = Math.max(1, Math.ceil(totalCount / MAX_ENTRIES_PER_PAGE));
+    // Directory entries
+    for (const entry of entries) {
+        const label = truncateLabel(buildEntryLabel(entry));
+        keyboard.text(label, encodePathForCallback(CALLBACK_NAV_PREFIX, entry.fullPath)).row();
+    }
+    // Navigation: Up + Back to roots
+    // Suppress "Up" when at an allowed root (don't let user navigate above it)
+    const atRoot = isAllowedRoot(currentPath);
+    const showUp = hasParent && !atRoot;
+    const roots = getBrowserRoots();
+    const showRoots = roots.length > 1;
+    if (showUp || showRoots) {
+        if (showUp) {
+            const parentPath = path.dirname(currentPath);
+            keyboard.text(t("open.back"), encodePathForCallback(CALLBACK_NAV_PREFIX, parentPath));
+        }
+        if (showRoots) {
+            keyboard.text(t("open.roots"), CALLBACK_ROOTS);
+        }
+        keyboard.row();
+    }
+    // Pagination
+    if (totalPages > 1) {
+        if (page > 0) {
+            keyboard.text(t("open.prev_page"), encodePaginationCallback(currentPath, page - 1));
+        }
+        if (page < totalPages - 1) {
+            keyboard.text(t("open.next_page"), encodePaginationCallback(currentPath, page + 1));
+        }
+        keyboard.row();
+    }
+    // Select current folder
+    keyboard
+        .text(t("open.select_current"), encodePathForCallback(CALLBACK_SELECT_PREFIX, currentPath))
+        .row();
+    // Cancel
+    appendInlineMenuCancelButton(keyboard, "open");
+    return keyboard;
+}
+async function renderBrowseView(dirPath, page = 0) {
+    const result = await scanDirectory(dirPath, page);
+    if (isScanError(result)) {
+        return { error: result.error };
+    }
+    const { entries, totalCount, page: clampedPage, currentPath, displayPath, hasParent } = result;
+    const totalPages = Math.max(1, Math.ceil(totalCount / MAX_ENTRIES_PER_PAGE));
+    const header = buildTreeHeader(displayPath, totalCount, clampedPage, totalPages);
+    const keyboard = buildBrowseKeyboard(entries, currentPath, hasParent, clampedPage, totalCount);
+    return { text: header, keyboard };
+}
+function buildRootsKeyboard() {
+    const keyboard = new InlineKeyboard();
+    const roots = getBrowserRoots();
+    for (const root of roots) {
+        const label = truncateLabel(`📂 ${pathToDisplayPath(root)}`);
+        keyboard.text(label, encodePathForCallback(CALLBACK_NAV_PREFIX, root)).row();
+    }
+    appendInlineMenuCancelButton(keyboard, "open");
+    return keyboard;
+}
+export async function openCommand(ctx) {
+    try {
+        if (isForegroundBusy()) {
+            await replyBusyBlocked(ctx);
+            return;
+        }
+        // Reset path index for new interaction
+        clearOpenPathIndex();
+        const roots = getBrowserRoots();
+        let text;
+        let keyboard;
+        if (roots.length === 1) {
+            // Single root — navigate directly into it
+            const view = await renderBrowseView(roots[0]);
+            if ("error" in view) {
+                await ctx.reply(t("open.scan_error", { error: view.error }));
+                return;
+            }
+            text = view.text;
+            keyboard = view.keyboard;
+        }
+        else {
+            // Multiple roots — show root selection
+            text = t("open.select_root");
+            keyboard = buildRootsKeyboard();
+        }
+        const message = await ctx.reply(text, { reply_markup: keyboard });
+        interactionManager.start({
+            kind: "inline",
+            expectedInput: "callback",
+            metadata: {
+                menuKind: "open",
+                messageId: message.message_id,
+            },
+        });
+    }
+    catch (error) {
+        logger.error("[Bot] Error opening directory browser:", error);
+        await ctx.reply(t("open.open_error"));
+    }
+}
+export async function handleOpenCallback(ctx) {
+    const data = ctx.callbackQuery?.data;
+    if (!data || !data.startsWith(CALLBACK_PREFIX)) {
+        return false;
+    }
+    if (isForegroundBusy()) {
+        await replyBusyBlocked(ctx);
+        return true;
+    }
+    const isActiveMenu = await ensureActiveInlineMenu(ctx, "open");
+    if (!isActiveMenu) {
+        return true;
+    }
+    try {
+        // Back to root selection (multi-root mode)
+        if (data === CALLBACK_ROOTS) {
+            await showRoots(ctx);
+            return true;
+        }
+        // Navigate into a directory (including "up")
+        const navPath = decodePathFromCallback(CALLBACK_NAV_PREFIX, data);
+        if (navPath !== null) {
+            if (!isWithinAllowedRoot(navPath)) {
+                await ctx.answerCallbackQuery({ text: t("open.access_denied") });
+                return true;
+            }
+            await navigateTo(ctx, navPath);
+            return true;
+        }
+        // Pagination
+        const pageInfo = decodePaginationCallback(data);
+        if (pageInfo !== null) {
+            if (!isWithinAllowedRoot(pageInfo.path)) {
+                await ctx.answerCallbackQuery({ text: t("open.access_denied") });
+                return true;
+            }
+            await navigateTo(ctx, pageInfo.path, pageInfo.page);
+            return true;
+        }
+        // Select directory as project
+        const selectPath = decodePathFromCallback(CALLBACK_SELECT_PREFIX, data);
+        if (selectPath !== null) {
+            if (!isWithinAllowedRoot(selectPath)) {
+                await ctx.answerCallbackQuery({ text: t("open.access_denied") });
+                return true;
+            }
+            await selectDirectory(ctx, selectPath);
+            return true;
+        }
+        return false;
+    }
+    catch (error) {
+        logger.error("[Bot] Error handling open callback:", error);
+        await ctx.answerCallbackQuery({ text: t("callback.processing_error") });
+        return true;
+    }
+}
+async function showRoots(ctx) {
+    const text = t("open.select_root");
+    const keyboard = buildRootsKeyboard();
+    await ctx.answerCallbackQuery();
+    await ctx.editMessageText(text, { reply_markup: keyboard });
+}
+async function navigateTo(ctx, dirPath, page = 0) {
+    const view = await renderBrowseView(dirPath, page);
+    if ("error" in view) {
+        await ctx.answerCallbackQuery({ text: view.error });
+        return;
+    }
+    await ctx.answerCallbackQuery();
+    await ctx.editMessageText(view.text, {
+        reply_markup: view.keyboard,
+    });
+}
+async function selectDirectory(ctx, directory) {
+    const displayPath = pathToDisplayPath(directory);
+    try {
+        logger.info(`[Bot] Adding project directory: ${directory}`);
+        // Register directory in the session cache first — getProjectByWorktree
+        // needs the entry to exist so it can resolve the project. If the
+        // subsequent switch fails, the entry stays in the cache, which is
+        // acceptable: it's a real directory the user explicitly selected and
+        // will simply appear in /projects for retry.
+        await upsertSessionDirectory(directory, Date.now());
+        const projectInfo = await getProjectByWorktree(directory);
+        const replyKeyboard = await switchToProject(ctx, { ...projectInfo, name: displayPath }, "open_project_selected");
+        await ctx.answerCallbackQuery();
+        await ctx.reply(t("open.selected", { project: displayPath }), {
+            reply_markup: replyKeyboard,
+        });
+        // Clean up the inline menu message
+        await ctx.deleteMessage();
+        // Clear path index after selection
+        clearOpenPathIndex();
+        logger.info(`[Bot] Project added and selected: ${displayPath}`);
+    }
+    catch (error) {
+        logger.error("[Bot] Error selecting directory:", error);
+        await ctx.answerCallbackQuery({ text: t("callback.processing_error") });
+        await ctx.reply(t("open.select_error"));
+    }
+}

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 } 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,34 +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 = getStoredAgent();
-        const currentModel = getStoredModel();
-        const contextInfo = { tokensUsed: 0, tokensLimit: contextLimit };
-        const variantName = formatVariantForButton(currentModel.variant || "default");
-        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/sessions.js

@@ -1,5 +1,6 @@
 import { InlineKeyboard } from "grammy";
 import { opencodeClient } from "../../opencode/client.js";
+import { resolveProjectAgent } from "../../agent/manager.js";
 import { setCurrentSession } from "../../session/manager.js";
 import { getCurrentProject } from "../../settings/manager.js";
 import { clearAllInteractionState } from "../../interaction/cleanup.js";
@@ -214,6 +215,8 @@ export async function handleSessionSelect(ctx) {
         }
         if (ctx.chat) {
             const chatId = ctx.chat.id;
+            const currentAgent = await resolveProjectAgent();
+            keyboardManager.updateAgent(currentAgent);
             // Update keyboard with loaded context (callback executes async via setImmediate, so update manually)
             const contextInfo = pinnedMessageManager.getContextInfo();
             if (contextInfo) {

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/commands/status.js

@@ -1,6 +1,6 @@
 import { opencodeClient } from "../../opencode/client.js";
 import { getCurrentSession } from "../../session/manager.js";
-import { getCurrentProject } from "../../settings/manager.js";
+import { getCurrentProject, isTtsEnabled } from "../../settings/manager.js";
 import { fetchCurrentAgent } from "../../agent/manager.js";
 import { getAgentDisplayName } from "../../agent/types.js";
 import { fetchCurrentModel } from "../../model/manager.js";
@@ -22,6 +22,9 @@ export async function statusCommand(ctx) {
         if (data.version) {
             message += `${t("status.line.version", { version: data.version })}\n`;
         }
+        message += `${t("status.line.tts", {
+            tts: isTtsEnabled() ? t("status.tts.on") : t("status.tts.off"),
+        })}\n`;
         // Add process management information
         if (processManager.isRunning()) {
             const uptime = processManager.getUptime();
@@ -33,7 +36,7 @@ export async function statusCommand(ctx) {
         else {
             message += `${t("status.line.managed_no")}\n`;
         }
-        // Add agent mode information
+        // Add agent information
         const currentAgent = await fetchCurrentAgent();
         const agentDisplay = currentAgent
             ? getAgentDisplayName(currentAgent)

package/dist/bot/commands/tts.js

@@ -0,0 +1,13 @@
+import { isTtsConfigured } from "../../tts/client.js";
+import { isTtsEnabled, setTtsEnabled } from "../../settings/manager.js";
+import { t } from "../../i18n/index.js";
+export async function ttsCommand(ctx) {
+    const enabled = !isTtsEnabled();
+    if (enabled && !isTtsConfigured()) {
+        await ctx.reply(t("tts.not_configured"));
+        return;
+    }
+    setTtsEnabled(enabled);
+    const message = enabled ? t("tts.enabled") : t("tts.disabled");
+    await ctx.reply(message);
+}

package/dist/bot/handlers/agent.js

@@ -1,6 +1,6 @@
 import { InlineKeyboard } from "grammy";
 import { selectAgent, getAvailableAgents, fetchCurrentAgent } from "../../agent/manager.js";
-import { getAgentDisplayName, getAgentEmoji } from "../../agent/types.js";
+import { getAgentDisplayName } from "../../agent/types.js";
 import { getStoredModel } from "../../model/manager.js";
 import { formatVariantForButton } from "../../variant/manager.js";
 import { logger } from "../../utils/logger.js";
@@ -81,11 +81,10 @@ export async function buildAgentSelectionMenu(currentAgent) {
     }
     // Add button for each agent
     agents.forEach((agent) => {
-        const emoji = getAgentEmoji(agent.name);
         const isActive = agent.name === currentAgent;
         const label = isActive
-            ? `✅ ${emoji} ${agent.name.toUpperCase()}`
-            : `${emoji} ${agent.name.charAt(0).toUpperCase() + agent.name.slice(1)}`;
+            ? `✅ ${getAgentDisplayName(agent.name)}`
+            : getAgentDisplayName(agent.name);
         keyboard.text(label, `agent:${agent.name}`).row();
     });
     return keyboard;

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/model.js

@@ -4,7 +4,7 @@ import { formatModelForDisplay } from "../../model/types.js";
 import { formatVariantForButton } from "../../variant/manager.js";
 import { logger } from "../../utils/logger.js";
 import { createMainKeyboard } from "../utils/keyboard.js";
-import { getStoredAgent } from "../../agent/manager.js";
+import { getStoredAgent, resolveProjectAgent } from "../../agent/manager.js";
 import { pinnedMessageManager } from "../../pinned/manager.js";
 import { keyboardManager } from "../../keyboard/manager.js";
 import { clearActiveInlineMenu, ensureActiveInlineMenu, replyWithInlineMenu, } from "./inline-menu.js";
@@ -61,11 +61,12 @@ export async function handleModelSelect(ctx) {
         // Refresh context limit for new model
         await pinnedMessageManager.refreshContextLimit();
         // Update Reply Keyboard with new model and context
-        const currentAgent = getStoredAgent();
+        const currentAgent = await resolveProjectAgent(getStoredAgent());
         const contextInfo = pinnedMessageManager.getContextInfo() ??
             (pinnedMessageManager.getContextLimit() > 0
                 ? { tokensUsed: 0, tokensLimit: pinnedMessageManager.getContextLimit() }
                 : null);
+        keyboardManager.updateAgent(currentAgent);
         if (contextInfo) {
             keyboardManager.updateContext(contextInfo.tokensUsed, contextInfo.tokensLimit);
         }

package/dist/bot/handlers/prompt.js

@@ -1,8 +1,8 @@
 import { opencodeClient } from "../../opencode/client.js";
 import { clearSession, getCurrentSession, setCurrentSession } from "../../session/manager.js";
 import { ingestSessionInfoForCache } from "../../session/cache-manager.js";
-import { getCurrentProject } from "../../settings/manager.js";
-import { getStoredAgent } from "../../agent/manager.js";
+import { getCurrentProject, isTtsEnabled } from "../../settings/manager.js";
+import { getStoredAgent, resolveProjectAgent } from "../../agent/manager.js";
 import { getStoredModel } from "../../model/manager.js";
 import { formatVariantForButton } from "../../variant/manager.js";
 import { createMainKeyboard } from "../utils/keyboard.js";
@@ -17,15 +17,28 @@ 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;
+const promptResponseModes = new Map();
 export function getPromptBotInstance() {
     return botInstance;
 }
 export function getPromptChatId() {
     return chatIdInstance;
 }
+export function setPromptResponseMode(sessionId, responseMode) {
+    promptResponseModes.set(sessionId, responseMode);
+}
+export function clearPromptResponseMode(sessionId) {
+    promptResponseModes.delete(sessionId);
+}
+export function consumePromptResponseMode(sessionId) {
+    const responseMode = promptResponseModes.get(sessionId) ?? null;
+    promptResponseModes.delete(sessionId);
+    return responseMode;
+}
 async function isSessionBusy(sessionId, directory) {
     try {
         const { data, error } = await opencodeClient.session.status({ directory });
@@ -49,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();
@@ -72,8 +86,9 @@ async function resetMismatchedSessionContext() {
  * @param fileParts - Optional file parts (for photo/document attachments)
  * @returns true if the prompt was dispatched, false if it was blocked/failed early.
  */
-export async function processUserPrompt(ctx, text, deps, fileParts = []) {
+export async function processUserPrompt(ctx, text, deps, fileParts = [], options = {}) {
     const { bot, ensureEventSubscription } = deps;
+    const responseMode = options.responseMode ?? (isTtsEnabled() ? "text_and_tts" : "text_only");
     const currentProject = getCurrentProject();
     if (!currentProject) {
         await ctx.reply(t("bot.project_not_selected"));
@@ -118,10 +133,11 @@ export async function processUserPrompt(ctx, text, deps, fileParts = []) {
         catch (err) {
             logger.error("[Bot] Error creating pinned message for new session:", err);
         }
-        const currentAgent = getStoredAgent();
+        const currentAgent = await resolveProjectAgent(getStoredAgent());
         const currentModel = getStoredModel();
         const contextInfo = pinnedMessageManager.getContextInfo();
         const variantName = formatVariantForButton(currentModel.variant || "default");
+        keyboardManager.updateAgent(currentAgent);
         const keyboard = createMainKeyboard(currentAgent, currentModel, contextInfo ?? undefined, variantName);
         await ctx.reply(t("bot.session_created", { title: session.title }), {
             reply_markup: keyboard,
@@ -149,7 +165,7 @@ export async function processUserPrompt(ctx, text, deps, fileParts = []) {
         return false;
     }
     try {
-        const currentAgent = getStoredAgent();
+        const currentAgent = await resolveProjectAgent(getStoredAgent());
         const storedModel = getStoredModel();
         // Build parts array with text and files
         const parts = [];
@@ -195,6 +211,13 @@ export async function processUserPrompt(ctx, text, deps, fileParts = []) {
         };
         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,
         // which blocks receiving button callback_query updates.
@@ -205,6 +228,8 @@ export async function processUserPrompt(ctx, text, deps, fileParts = []) {
             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);
                     logger.error("[Bot] session.prompt error details:", details);
@@ -217,6 +242,8 @@ export async function processUserPrompt(ctx, text, deps, fileParts = []) {
             },
             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);
                 logger.error("[Bot] session.prompt background failure details:", details);
@@ -229,6 +256,7 @@ export async function processUserPrompt(ctx, text, deps, fileParts = []) {
     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/handlers/variant.js

@@ -1,7 +1,7 @@
 import { InlineKeyboard } from "grammy";
 import { getAvailableVariants, getCurrentVariant, setCurrentVariant, formatVariantForDisplay, formatVariantForButton, } from "../../variant/manager.js";
 import { getStoredModel } from "../../model/manager.js";
-import { getStoredAgent } from "../../agent/manager.js";
+import { getStoredAgent, resolveProjectAgent } from "../../agent/manager.js";
 import { logger } from "../../utils/logger.js";
 import { keyboardManager } from "../../keyboard/manager.js";
 import { pinnedMessageManager } from "../../pinned/manager.js";
@@ -47,11 +47,12 @@ export async function handleVariantSelect(ctx) {
         keyboardManager.updateModel(updatedModel);
         keyboardManager.updateVariant(variantId);
         // Build keyboard with correct context info
-        const currentAgent = getStoredAgent();
+        const currentAgent = await resolveProjectAgent(getStoredAgent());
         const contextInfo = pinnedMessageManager.getContextInfo() ??
             (pinnedMessageManager.getContextLimit() > 0
                 ? { tokensUsed: 0, tokensLimit: pinnedMessageManager.getContextLimit() }
                 : null);
+        keyboardManager.updateAgent(currentAgent);
         if (contextInfo) {
             keyboardManager.updateContext(contextInfo.tokensUsed, contextInfo.tokensLimit);
         }