@grinev/opencode-telegram-bot 0.1.1 → 0.2.1

package/dist/app/start-bot-app.js

@@ -3,6 +3,7 @@ import { createBot } from "../bot/index.js";
 import { config } from "../config.js";
 import { loadSettings } from "../settings/manager.js";
 import { processManager } from "../process/manager.js";
+import { warmupSessionDirectoryCache } from "../session/cache-manager.js";
 import { getRuntimeMode } from "../runtime/mode.js";
 import { logger } from "../utils/logger.js";
 async function getBotVersion() {
@@ -25,6 +26,7 @@ export async function startBotApp() {
     logger.debug(`[Runtime] Application start mode: ${mode}`);
     await loadSettings();
     await processManager.initialize();
+    await warmupSessionDirectoryCache();
     const bot = createBot();
     const webhookInfo = await bot.api.getWebhookInfo();
     if (webhookInfo.url) {

package/dist/bot/commands/new.js

@@ -1,5 +1,6 @@
 import { opencodeClient } from "../../opencode/client.js";
 import { setCurrentSession } from "../../session/manager.js";
+import { ingestSessionInfoForCache } from "../../session/cache-manager.js";
 import { getCurrentProject } from "../../settings/manager.js";
 import { pinnedMessageManager } from "../../pinned/manager.js";
 import { keyboardManager } from "../../keyboard/manager.js";
@@ -30,6 +31,7 @@ export async function newCommand(ctx) {
             directory: currentProject.worktree,
         };
         setCurrentSession(sessionInfo);
+        await ingestSessionInfoForCache(session);
         // Initialize pinned message manager and create pinned message
         if (!pinnedMessageManager.isInitialized()) {
             pinnedMessageManager.initialize(ctx.api, ctx.chat.id);

package/dist/bot/commands/projects.js

@@ -1,6 +1,7 @@
 import { InlineKeyboard } from "grammy";
 import { setCurrentProject, 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";
@@ -12,6 +13,7 @@ import { createMainKeyboard } from "../utils/keyboard.js";
 import { logger } from "../../utils/logger.js";
 import { t } from "../../i18n/index.js";
 const MAX_INLINE_BUTTON_LABEL_LENGTH = 64;
+const MAX_PROJECTS_TO_SHOW = 10;
 function formatProjectButtonLabel(label, isActive) {
     const prefix = isActive ? "✅ " : "";
     const availableLength = MAX_INLINE_BUTTON_LABEL_LENGTH - prefix.length;
@@ -22,14 +24,16 @@ function formatProjectButtonLabel(label, isActive) {
 }
 export async function projectsCommand(ctx) {
     try {
+        await syncSessionDirectoryCache();
         const projects = await getProjects();
-        if (projects.length === 0) {
+        const projectsToShow = projects.slice(0, MAX_PROJECTS_TO_SHOW);
+        if (projectsToShow.length === 0) {
             await ctx.reply(t("projects.empty"));
             return;
         }
         const keyboard = new InlineKeyboard();
         const currentProject = getCurrentProject();
-        projects.forEach((project, index) => {
+        projectsToShow.forEach((project, index) => {
             const isActive = currentProject &&
                 (project.id === currentProject.id || project.worktree === currentProject.worktree);
             const label = project.name

package/dist/bot/handlers/permission.js

@@ -2,6 +2,7 @@ import { InlineKeyboard } from "grammy";
 import { permissionManager } from "../../permission/manager.js";
 import { opencodeClient } from "../../opencode/client.js";
 import { getCurrentProject } from "../../settings/manager.js";
+import { getCurrentSession } from "../../session/manager.js";
 import { summaryAggregator } from "../../summary/aggregator.js";
 import { logger } from "../../utils/logger.js";
 import { safeBackgroundTask } from "../../utils/safe-background-task.js";
@@ -69,8 +70,10 @@ export async function handlePermissionCallback(ctx) {
 async function handlePermissionReply(ctx, reply) {
     const requestID = permissionManager.getRequestID();
     const currentProject = getCurrentProject();
+    const currentSession = getCurrentSession();
     const chatId = ctx.chat?.id;
-    if (!requestID || !currentProject || !chatId) {
+    const directory = currentSession?.directory ?? currentProject?.worktree;
+    if (!requestID || !directory || !chatId) {
         await ctx.answerCallbackQuery({
             text: t("permission.no_active_request_callback"),
             show_alert: true,
@@ -94,7 +97,7 @@ async function handlePermissionReply(ctx, reply) {
         taskName: "permission.reply",
         task: () => opencodeClient.permission.reply({
             requestID,
-            directory: currentProject.worktree,
+            directory,
             reply,
         }),
         onSuccess: ({ error }) => {

package/dist/bot/handlers/question.js

@@ -2,6 +2,7 @@ import { InlineKeyboard } from "grammy";
 import { questionManager } from "../../question/manager.js";
 import { opencodeClient } from "../../opencode/client.js";
 import { getCurrentProject } from "../../settings/manager.js";
+import { getCurrentSession } from "../../session/manager.js";
 import { summaryAggregator } from "../../summary/aggregator.js";
 import { logger } from "../../utils/logger.js";
 import { safeBackgroundTask } from "../../utils/safe-background-task.js";
@@ -194,9 +195,11 @@ async function showPollSummary(bot, chatId) {
 }
 async function sendAllAnswersToAgent(bot, chatId) {
     const currentProject = getCurrentProject();
+    const currentSession = getCurrentSession();
     const requestID = questionManager.getRequestID();
     const totalQuestions = questionManager.getTotalQuestions();
-    if (!currentProject) {
+    const directory = currentSession?.directory ?? currentProject?.worktree;
+    if (!directory) {
         logger.error("[QuestionHandler] No project for sending answers");
         await bot.sendMessage(chatId, t("question.no_active_project"));
         return;
@@ -233,7 +236,7 @@ async function sendAllAnswersToAgent(bot, chatId) {
         taskName: "question.reply",
         task: () => opencodeClient.question.reply({
             requestID,
-            directory: currentProject.worktree,
+            directory,
             answers: allAnswers,
         }),
         onSuccess: ({ error }) => {

package/dist/bot/index.js

@@ -8,6 +8,7 @@ import { BOT_COMMANDS } from "./commands/definitions.js";
 import { startCommand } from "./commands/start.js";
 import { helpCommand } from "./commands/help.js";
 import { statusCommand } from "./commands/status.js";
+import { MODEL_BUTTON_TEXT_PATTERN, VARIANT_BUTTON_TEXT_PATTERN } from "./message-patterns.js";
 import { sessionsCommand, handleSessionSelect } from "./commands/sessions.js";
 import { newCommand } from "./commands/new.js";
 import { projectsCommand, handleProjectSelect } from "./commands/projects.js";
@@ -23,12 +24,14 @@ import { handleModelSelect, showModelSelectionMenu } from "./handlers/model.js";
 import { handleVariantSelect, showVariantSelectionMenu } from "./handlers/variant.js";
 import { handleContextButtonPress, handleCompactConfirm, handleCompactCancel, } from "./handlers/context.js";
 import { questionManager } from "../question/manager.js";
+import { permissionManager } from "../permission/manager.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, formatToolInfo } from "../summary/formatter.js";
 import { opencodeClient } from "../opencode/client.js";
-import { getCurrentSession, setCurrentSession } from "../session/manager.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 { getStoredModel } from "../model/manager.js";
@@ -36,6 +39,7 @@ import { formatVariantForButton } from "../variant/manager.js";
 import { createMainKeyboard } from "./utils/keyboard.js";
 import { logger } from "../utils/logger.js";
 import { safeBackgroundTask } from "../utils/safe-background-task.js";
+import { formatErrorDetails } from "../utils/error-format.js";
 import { pinnedMessageManager } from "../pinned/manager.js";
 import { t } from "../i18n/index.js";
 let botInstance = null;
@@ -66,10 +70,9 @@ async function ensureCommandsInitialized(ctx, next) {
     }
     await next();
 }
-async function ensureEventSubscription() {
-    const currentProject = getCurrentProject();
-    if (!currentProject) {
-        logger.error("No current project found for event subscription");
+async function ensureEventSubscription(directory) {
+    if (!directory) {
+        logger.error("No directory found for event subscription");
         return;
     }
     summaryAggregator.setOnComplete(async (sessionId, messageText) => {
@@ -254,8 +257,17 @@ async function ensureEventSubscription() {
             logger.error("[Bot] Error updating keyboard context:", err);
         }
     });
-    logger.info(`[Bot] Subscribing to OpenCode events for project: ${currentProject.worktree}`);
-    subscribeToEvents(currentProject.worktree, (event) => {
+    logger.info(`[Bot] Subscribing to OpenCode events for project: ${directory}`);
+    subscribeToEvents(directory, (event) => {
+        if (event.type === "session.created" || event.type === "session.updated") {
+            const info = event.properties.info;
+            if (info?.directory) {
+                safeBackgroundTask({
+                    taskName: `session.cache.${event.type}`,
+                    task: () => ingestSessionInfoForCache(info),
+                });
+            }
+        }
         summaryAggregator.processEvent(event);
     }).catch((err) => {
         logger.error("Failed to subscribe to events:", err);
@@ -280,6 +292,23 @@ async function isSessionBusy(sessionId, directory) {
         return false;
     }
 }
+async function resetMismatchedSessionContext() {
+    stopEventListening();
+    summaryAggregator.clear();
+    questionManager.clear();
+    permissionManager.clear();
+    clearSession();
+    keyboardManager.clearContext();
+    if (!pinnedMessageManager.isInitialized()) {
+        return;
+    }
+    try {
+        await pinnedMessageManager.clear();
+    }
+    catch (err) {
+        logger.error("[Bot] Failed to clear pinned message during session reset:", err);
+    }
+}
 export function createBot() {
     const bot = new Bot(config.telegram.token);
     // Heartbeat for diagnostics: verify the event loop is not blocked
@@ -369,8 +398,8 @@ export function createBot() {
         }
     });
     // Handle Reply Keyboard button press (model selector)
-    // Pattern: "ProviderName/ModelName" (may contain spaces, dots, parentheses, etc.)
-    bot.hears(/^[A-Za-z0-9\-\. ]+\/[A-Za-z0-9\-\. ()]+\.{0,3}$/, async (ctx) => {
+    // Model button text is produced by formatModelForButton() and always starts with "🤖 ".
+    bot.hears(MODEL_BUTTON_TEXT_PATTERN, async (ctx) => {
         logger.debug(`[Bot] Model button pressed: ${ctx.message?.text}`);
         try {
             await showModelSelectionMenu(ctx);
@@ -392,7 +421,8 @@ export function createBot() {
         }
     });
     // Handle Reply Keyboard button press (variant selector)
-    bot.hears(/^💭 \w+$/, async (ctx) => {
+    // Keep support for both legacy "💭" and current "💡" prefix.
+    bot.hears(VARIANT_BUTTON_TEXT_PATTERN, async (ctx) => {
         logger.debug(`[Bot] Variant button pressed: ${ctx.message?.text}`);
         try {
             await showVariantSelectionMenu(ctx);
@@ -450,7 +480,6 @@ export function createBot() {
             await ctx.reply(t("bot.project_not_selected"));
             return;
         }
-        await ensureEventSubscription();
         botInstance = bot;
         chatIdInstance = ctx.chat.id;
         // Initialize pinned message manager if not already
@@ -460,6 +489,12 @@ export function createBot() {
         // Initialize keyboard manager if not already
         keyboardManager.initialize(bot.api, ctx.chat.id);
         let currentSession = getCurrentSession();
+        if (currentSession && currentSession.directory !== currentProject.worktree) {
+            logger.warn(`[Bot] Session/project mismatch detected. sessionDirectory=${currentSession.directory}, projectDirectory=${currentProject.worktree}. Resetting session context.`);
+            await resetMismatchedSessionContext();
+            await ctx.reply(t("bot.session_reset_project_mismatch"));
+            return;
+        }
         if (!currentSession) {
             await ctx.reply(t("bot.creating_session"));
             const { data: session, error } = await opencodeClient.session.create({
@@ -476,6 +511,7 @@ export function createBot() {
                 directory: currentProject.worktree,
             };
             setCurrentSession(currentSession);
+            await ingestSessionInfoForCache(session);
             // Create pinned message for new session
             try {
                 await pinnedMessageManager.onSessionChange(session.id, session.title);
@@ -504,6 +540,7 @@ export function createBot() {
                 }
             }
         }
+        await ensureEventSubscription(currentSession.directory);
         summaryAggregator.setSession(currentSession.id);
         summaryAggregator.setBotAndChatId(bot, ctx.chat.id);
         const sessionIsBusy = await isSessionBusy(currentSession.id, currentSession.directory);
@@ -517,7 +554,7 @@ export function createBot() {
             const storedModel = getStoredModel();
             const promptOptions = {
                 sessionID: currentSession.id,
-                directory: currentProject.worktree,
+                directory: currentSession.directory,
                 parts: [{ type: "text", text }],
                 agent: currentAgent,
             };
@@ -542,18 +579,20 @@ export function createBot() {
                 task: () => opencodeClient.session.prompt(promptOptions),
                 onSuccess: ({ error }) => {
                     if (error) {
-                        logger.error("OpenCode API error:", JSON.stringify(error, null, 2));
+                        const details = formatErrorDetails(error);
+                        logger.error("OpenCode API error:", error);
                         // Send the error via API directly because ctx is no longer available
                         void bot.api
                             .sendMessage(ctx.chat.id, t("bot.prompt_send_error_detailed", {
-                            details: JSON.stringify(error),
+                            details,
                         }))
                             .catch(() => { });
                         return;
                     }
                     logger.info("[Bot] session.prompt completed");
                 },
-                onError: () => {
+                onError: (error) => {
+                    logger.error("[Bot] session.prompt background task failed:", error);
                     void bot.api.sendMessage(ctx.chat.id, t("bot.prompt_send_error")).catch(() => { });
                 },
             });

package/dist/bot/message-patterns.js

@@ -0,0 +1,3 @@
+export const MODEL_BUTTON_TEXT_PATTERN = /^🤖\s.+$/;
+// Keep support for both legacy "💭" and current "💡" prefix.
+export const VARIANT_BUTTON_TEXT_PATTERN = /^(💡|💭)\s.+$/;

package/dist/i18n/en.js

@@ -26,6 +26,7 @@ export const en = {
     "bot.create_session_error": "🔴 Failed to create session. Try /new or check server status with /status.",
     "bot.session_created": "✅ Session created: {title}",
     "bot.session_busy": "⏳ Agent is already running a task. Wait for completion or use /stop to interrupt current run.",
+    "bot.session_reset_project_mismatch": "⚠️ Active session does not match the selected project, so it was reset. Use /sessions to pick one or /new to create a new session.",
     "bot.prompt_send_error_detailed": "🔴 Failed to send request.\n\nDetails: {details}",
     "bot.prompt_send_error": "🔴 An error occurred while sending request to OpenCode.",
     "status.header_running": "🟢 **OpenCode Server is running**",
@@ -47,7 +48,7 @@ export const en = {
     "status.session_not_selected": "📋 Current session: not selected",
     "status.session_hint": "Use /sessions to select one or /new to create one",
     "status.server_unavailable": "🔴 OpenCode Server is unavailable\n\nUse /opencode_start to start the server.",
-    "projects.empty": "📭 No projects found.",
+    "projects.empty": "📭 No projects found.\n\nOpen a directory in OpenCode and create at least one session, then it will appear here.",
     "projects.select": "Select a project:",
     "projects.select_with_current": "Select a project:\n\nCurrent: 🏗 {project}",
     "projects.fetch_error": "🔴 OpenCode Server is unavailable or an error occurred while loading projects.",

package/dist/i18n/ru.js

@@ -26,6 +26,7 @@ export const ru = {
     "bot.create_session_error": "🔴 Не удалось создать сессию. Попробуйте команду /new или проверьте статус сервера /status.",
     "bot.session_created": "✅ Сессия создана: {title}",
     "bot.session_busy": "⏳ Агент уже выполняет задачу. Дождитесь завершения или используйте /stop, чтобы прервать текущий запуск.",
+    "bot.session_reset_project_mismatch": "⚠️ Активная сессия не соответствует выбранному проекту, поэтому была сброшена. Используйте /sessions для выбора или /new для создания новой сессии.",
     "bot.prompt_send_error_detailed": "🔴 Ошибка при отправке запроса.\n\nДетали: {details}",
     "bot.prompt_send_error": "🔴 Произошла ошибка при отправке запроса в OpenCode.",
     "status.header_running": "🟢 **OpenCode Server запущен**",
@@ -47,7 +48,7 @@ export const ru = {
     "status.session_not_selected": "📋 Текущая сессия: не выбрана",
     "status.session_hint": "Используйте /sessions для выбора или /new для создания",
     "status.server_unavailable": "🔴 OpenCode Server недоступен\n\nИспользуйте /opencode_start для запуска сервера.",
-    "projects.empty": "📭 Проектов нет.",
+    "projects.empty": "📭 Проектов нет.\n\nОткройте директорию в OpenCode и создайте хотя бы одну сессию, после этого она появится здесь.",
     "projects.select": "Выберите проект:",
     "projects.select_with_current": "Выберите проект:\n\nТекущий: 🏗 {project}",
     "projects.fetch_error": "🔴 OpenCode Server недоступен или произошла ошибка при получении списка проектов.",

package/dist/opencode/events.js

@@ -1,12 +1,38 @@
 import { opencodeClient } from "./client.js";
 import { logger } from "../utils/logger.js";
+const RECONNECT_BASE_DELAY_MS = 1000;
+const RECONNECT_MAX_DELAY_MS = 15000;
+const FATAL_NO_STREAM_ERROR = "No stream returned from event subscription";
 let eventStream = null;
 let eventCallback = null;
 let isListening = false;
 let activeDirectory = null;
 let streamAbortController = null;
+function getReconnectDelayMs(attempt) {
+    const exponentialDelay = RECONNECT_BASE_DELAY_MS * Math.pow(2, Math.max(0, attempt - 1));
+    return Math.min(exponentialDelay, RECONNECT_MAX_DELAY_MS);
+}
+function waitWithAbort(ms, signal) {
+    return new Promise((resolve) => {
+        if (signal.aborted) {
+            resolve(false);
+            return;
+        }
+        const onAbort = () => {
+            clearTimeout(timeout);
+            signal.removeEventListener("abort", onAbort);
+            resolve(false);
+        };
+        const timeout = setTimeout(() => {
+            signal.removeEventListener("abort", onAbort);
+            resolve(true);
+        }, ms);
+        signal.addEventListener("abort", onAbort, { once: true });
+    });
+}
 export async function subscribeToEvents(directory, callback) {
     if (isListening && activeDirectory === directory) {
+        eventCallback = callback;
         logger.debug(`Event listener already running for ${directory}`);
         return;
     }
@@ -23,24 +49,59 @@ export async function subscribeToEvents(directory, callback) {
     isListening = true;
     streamAbortController = controller;
     try {
-        const result = await opencodeClient.event.subscribe({ directory }, { signal: controller.signal });
-        if (!result.stream) {
-            throw new Error("No stream returned from event subscription");
-        }
-        eventStream = result.stream;
-        for await (const event of eventStream) {
-            if (!isListening || activeDirectory !== directory) {
-                logger.debug(`Event listener stopped or changed directory, breaking loop`);
-                break;
+        let reconnectAttempt = 0;
+        while (isListening && activeDirectory === directory && !controller.signal.aborted) {
+            try {
+                const result = await opencodeClient.event.subscribe({ directory }, { signal: controller.signal });
+                if (!result.stream) {
+                    throw new Error(FATAL_NO_STREAM_ERROR);
+                }
+                reconnectAttempt = 0;
+                eventStream = result.stream;
+                for await (const event of eventStream) {
+                    if (!isListening || activeDirectory !== directory || controller.signal.aborted) {
+                        logger.debug(`Event listener stopped or changed directory, breaking loop`);
+                        break;
+                    }
+                    // CRITICAL: Explicitly yield to the event loop BEFORE processing the event
+                    // This allows grammY to handle getUpdates between SSE events
+                    await new Promise((resolve) => setImmediate(resolve));
+                    if (eventCallback) {
+                        // Use setImmediate to avoid blocking the event loop
+                        // and let grammY process incoming Telegram updates
+                        const callbackSnapshot = eventCallback;
+                        setImmediate(() => callbackSnapshot(event));
+                    }
+                }
+                eventStream = null;
+                if (!isListening || activeDirectory !== directory || controller.signal.aborted) {
+                    break;
+                }
+                reconnectAttempt++;
+                const reconnectDelay = getReconnectDelayMs(reconnectAttempt);
+                logger.warn(`Event stream ended for ${directory}, reconnecting in ${reconnectDelay}ms (attempt=${reconnectAttempt})`);
+                const shouldContinue = await waitWithAbort(reconnectDelay, controller.signal);
+                if (!shouldContinue) {
+                    break;
+                }
             }
-            // CRITICAL: Explicitly yield to the event loop BEFORE processing the event
-            // This allows grammY to handle getUpdates between SSE events
-            await new Promise((resolve) => setImmediate(resolve));
-            if (eventCallback) {
-                // Use setImmediate to avoid blocking the event loop
-                // and let grammY process incoming Telegram updates
-                const callback = eventCallback;
-                setImmediate(() => callback(event));
+            catch (error) {
+                eventStream = null;
+                if (controller.signal.aborted || !isListening || activeDirectory !== directory) {
+                    logger.info("Event listener aborted");
+                    return;
+                }
+                if (error instanceof Error && error.message === FATAL_NO_STREAM_ERROR) {
+                    logger.error("Event stream fatal error:", error);
+                    throw error;
+                }
+                reconnectAttempt++;
+                const reconnectDelay = getReconnectDelayMs(reconnectAttempt);
+                logger.error(`Event stream error for ${directory}, reconnecting in ${reconnectDelay}ms (attempt=${reconnectAttempt})`, error);
+                const shouldContinue = await waitWithAbort(reconnectDelay, controller.signal);
+                if (!shouldContinue) {
+                    break;
+                }
             }
         }
     }

package/dist/project/manager.js

@@ -1,14 +1,74 @@
+import { readFile, stat } from "node:fs/promises";
+import path from "node:path";
 import { opencodeClient } from "../opencode/client.js";
+import { getCachedSessionProjects } from "../session/cache-manager.js";
+import { logger } from "../utils/logger.js";
+async function isLinkedGitWorktree(worktree) {
+    if (worktree === "/") {
+        return false;
+    }
+    const gitPath = path.join(worktree, ".git");
+    try {
+        const gitStat = await stat(gitPath);
+        if (!gitStat.isFile()) {
+            return false;
+        }
+        const gitPointer = (await readFile(gitPath, "utf-8")).trim();
+        const match = gitPointer.match(/^gitdir:\s*(.+)$/i);
+        if (!match) {
+            return false;
+        }
+        const gitDir = path.resolve(worktree, match[1].trim()).replace(/\\/g, "/").toLowerCase();
+        return gitDir.includes("/.git/worktrees/");
+    }
+    catch {
+        return false;
+    }
+}
+function worktreeKey(worktree) {
+    if (process.platform === "win32") {
+        return worktree.toLowerCase();
+    }
+    return worktree;
+}
 export async function getProjects() {
     const { data: projects, error } = await opencodeClient.project.list();
     if (error || !projects) {
         throw error || new Error("No data received from server");
     }
-    return projects.map((project) => ({
+    const apiProjects = projects.map((project) => ({
         id: project.id,
         worktree: project.worktree,
         name: project.name || project.worktree,
+        lastUpdated: project.time?.updated ?? 0,
     }));
+    const cachedProjects = await getCachedSessionProjects();
+    const mergedByWorktree = new Map();
+    for (const apiProject of apiProjects) {
+        mergedByWorktree.set(worktreeKey(apiProject.worktree), apiProject);
+    }
+    for (const cachedProject of cachedProjects) {
+        const key = worktreeKey(cachedProject.worktree);
+        const existing = mergedByWorktree.get(key);
+        if (existing) {
+            if ((cachedProject.lastUpdated ?? 0) > existing.lastUpdated) {
+                existing.lastUpdated = cachedProject.lastUpdated;
+            }
+            continue;
+        }
+        mergedByWorktree.set(key, {
+            id: cachedProject.id,
+            worktree: cachedProject.worktree,
+            name: cachedProject.name,
+            lastUpdated: cachedProject.lastUpdated ?? 0,
+        });
+    }
+    const projectList = Array.from(mergedByWorktree.values()).sort((left, right) => right.lastUpdated - left.lastUpdated);
+    const linkedWorktreeFlags = await Promise.all(projectList.map((project) => isLinkedGitWorktree(project.worktree)));
+    const visibleProjects = projectList.filter((_, index) => !linkedWorktreeFlags[index]);
+    const hiddenLinkedWorktrees = projectList.length - visibleProjects.length;
+    logger.debug(`[ProjectManager] Projects resolved: api=${projects.length}, cached=${cachedProjects.length}, hiddenLinkedWorktrees=${hiddenLinkedWorktrees}, total=${visibleProjects.length}`);
+    return visibleProjects.map(({ id, worktree, name }) => ({ id, worktree, name }));
 }
 export async function getProjectById(id) {
     const projects = await getProjects();

package/dist/session/cache-manager.js

@@ -0,0 +1,400 @@
+import { createHash } from "node:crypto";
+import path from "node:path";
+import Database from "better-sqlite3";
+import { opencodeClient } from "../opencode/client.js";
+import { getSessionDirectoryCache, setSessionDirectoryCache } from "../settings/manager.js";
+import { logger } from "../utils/logger.js";
+const CACHE_VERSION = 1;
+const INITIAL_WARMUP_LIMIT = 1000;
+const INCREMENTAL_SYNC_LIMIT = 1000;
+const MAX_CACHED_DIRECTORIES = 10;
+const SYNC_SAFETY_WINDOW_MS = 60_000;
+const SYNC_COOLDOWN_MS = 60_000;
+const STORAGE_FALLBACK_SCAN_LIMIT = 200;
+const SQLITE_FALLBACK_QUERY_LIMIT = 200;
+const EMPTY_CACHE = {
+    version: CACHE_VERSION,
+    lastSyncedUpdatedAt: 0,
+    directories: [],
+};
+function createEmptyCacheData() {
+    return {
+        version: EMPTY_CACHE.version,
+        lastSyncedUpdatedAt: EMPTY_CACHE.lastSyncedUpdatedAt,
+        directories: [],
+    };
+}
+let cacheData = createEmptyCacheData();
+let cacheLoaded = false;
+let syncInFlight = null;
+let lastSyncAttemptAt = 0;
+let persistQueue = Promise.resolve();
+function worktreeKey(worktree) {
+    if (process.platform === "win32") {
+        return worktree.toLowerCase();
+    }
+    return worktree;
+}
+function isValidWorktree(worktree) {
+    const trimmed = worktree.trim();
+    return trimmed.length > 0 && trimmed !== "/";
+}
+function normalizeCacheData(raw) {
+    if (!raw || typeof raw !== "object") {
+        return createEmptyCacheData();
+    }
+    const value = raw;
+    const lastSyncedUpdatedAt = typeof value.lastSyncedUpdatedAt === "number" && Number.isFinite(value.lastSyncedUpdatedAt)
+        ? value.lastSyncedUpdatedAt
+        : 0;
+    const directories = Array.isArray(value.directories)
+        ? value.directories
+            .filter((item) => Boolean(item) &&
+            typeof item === "object" &&
+            typeof item.worktree === "string" &&
+            typeof item.lastUpdated === "number")
+            .map((item) => ({
+            worktree: item.worktree.trim(),
+            lastUpdated: item.lastUpdated,
+        }))
+            .filter((item) => isValidWorktree(item.worktree))
+        : [];
+    const data = {
+        version: CACHE_VERSION,
+        lastSyncedUpdatedAt,
+        directories,
+    };
+    dedupeAndTrimDirectories(data);
+    return data;
+}
+function dedupeAndTrimDirectories(data) {
+    const unique = new Map();
+    for (const item of data.directories) {
+        const key = worktreeKey(item.worktree);
+        const existing = unique.get(key);
+        if (!existing || existing.lastUpdated < item.lastUpdated) {
+            unique.set(key, item);
+        }
+    }
+    data.directories = Array.from(unique.values())
+        .sort((a, b) => b.lastUpdated - a.lastUpdated)
+        .slice(0, MAX_CACHED_DIRECTORIES);
+}
+async function ensureCacheLoaded() {
+    if (cacheLoaded) {
+        return;
+    }
+    const storedCache = getSessionDirectoryCache();
+    cacheData = normalizeCacheData(storedCache);
+    cacheLoaded = true;
+    logger.debug(`[SessionCache] Loaded ${cacheData.directories.length} directories from settings.sessionDirectoryCache`);
+}
+function queuePersist() {
+    persistQueue = persistQueue
+        .catch(() => {
+        // Keep queue chain alive if previous write failed.
+    })
+        .then(async () => {
+        try {
+            await setSessionDirectoryCache(cacheData);
+        }
+        catch (error) {
+            logger.error("[SessionCache] Failed to persist sessions cache", error);
+        }
+    });
+    return persistQueue;
+}
+function upsertDirectory(worktree, lastUpdated) {
+    if (!isValidWorktree(worktree)) {
+        return false;
+    }
+    const normalizedWorktree = worktree.trim();
+    const key = worktreeKey(normalizedWorktree);
+    const existingIndex = cacheData.directories.findIndex((item) => worktreeKey(item.worktree) === key);
+    if (existingIndex >= 0) {
+        const existing = cacheData.directories[existingIndex];
+        if (existing.lastUpdated >= lastUpdated) {
+            return false;
+        }
+        cacheData.directories[existingIndex] = {
+            worktree: existing.worktree,
+            lastUpdated,
+        };
+    }
+    else {
+        cacheData.directories.push({
+            worktree: normalizedWorktree,
+            lastUpdated,
+        });
+    }
+    dedupeAndTrimDirectories(cacheData);
+    return true;
+}
+function buildListParams() {
+    const hasWatermark = cacheData.lastSyncedUpdatedAt > 0;
+    if (!hasWatermark) {
+        return { limit: INITIAL_WARMUP_LIMIT };
+    }
+    return {
+        limit: INCREMENTAL_SYNC_LIMIT,
+        start: Math.max(0, cacheData.lastSyncedUpdatedAt - SYNC_SAFETY_WINDOW_MS),
+    };
+}
+function createVirtualProjectId(worktree) {
+    const hash = createHash("sha1").update(worktree).digest("hex").slice(0, 16);
+    return `dir_${hash}`;
+}
+async function runSync() {
+    await ensureCacheLoaded();
+    const params = buildListParams();
+    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;
+    for (const session of sessions) {
+        const updatedAt = session.time?.updated ?? Date.now();
+        if (upsertDirectory(session.directory, updatedAt)) {
+            changed = true;
+        }
+        if (updatedAt > maxUpdated) {
+            maxUpdated = updatedAt;
+        }
+    }
+    if (maxUpdated !== cacheData.lastSyncedUpdatedAt) {
+        cacheData.lastSyncedUpdatedAt = maxUpdated;
+        changed = true;
+    }
+    if (changed) {
+        await queuePersist();
+    }
+    logger.debug(`[SessionCache] Synced sessions: fetched=${sessions.length}, directories=${cacheData.directories.length}, lastSyncedUpdatedAt=${cacheData.lastSyncedUpdatedAt}`);
+}
+function getStorageRootCandidates(pathInfo) {
+    const candidates = new Set();
+    if (pathInfo.home) {
+        candidates.add(path.join(pathInfo.home, ".local", "share", "opencode"));
+    }
+    if (pathInfo.state) {
+        const normalizedState = pathInfo.state.replace(/[\\/]+$/, "");
+        const lowerState = normalizedState.toLowerCase();
+        const marker = `${path.sep}state${path.sep}opencode`;
+        const lowerMarker = marker.toLowerCase();
+        if (lowerState.endsWith(lowerMarker)) {
+            const prefix = normalizedState.slice(0, normalizedState.length - marker.length);
+            candidates.add(path.join(prefix, "share", "opencode"));
+        }
+    }
+    return Array.from(candidates);
+}
+function getPathApi() {
+    return opencodeClient.path;
+}
+async function getStorageRootsFromApi() {
+    const pathApi = getPathApi();
+    if (!pathApi?.get) {
+        return [];
+    }
+    const { data: pathInfo, error } = await pathApi.get();
+    if (error || !pathInfo) {
+        return [];
+    }
+    return getStorageRootCandidates(pathInfo);
+}
+async function querySessionDirectoriesFromSqlite(dbPath) {
+    try {
+        const db = new Database(dbPath, {
+            readonly: true,
+            fileMustExist: true,
+        });
+        try {
+            const rows = db
+                .prepare(`
+            SELECT directory, MAX(time_updated) AS updated
+            FROM session
+            GROUP BY directory
+            ORDER BY updated DESC
+            LIMIT ?
+          `)
+                .all(SQLITE_FALLBACK_QUERY_LIMIT);
+            return rows
+                .filter((item) => Boolean(item) && typeof item.directory === "string")
+                .map((item) => ({
+                worktree: item.directory,
+                lastUpdated: typeof item.updated === "number" && Number.isFinite(item.updated) ? item.updated : 0,
+            }));
+        }
+        finally {
+            db.close();
+        }
+    }
+    catch (error) {
+        logger.debug(`[SessionCache] Failed to read sqlite fallback at ${dbPath}`, error);
+    }
+    return null;
+}
+async function ingestFromSqliteSessionDatabase() {
+    await ensureCacheLoaded();
+    const fs = await import("node:fs/promises");
+    const roots = await getStorageRootsFromApi();
+    for (const root of roots) {
+        const dbPath = path.join(root, "opencode.db");
+        try {
+            await fs.access(dbPath);
+        }
+        catch {
+            continue;
+        }
+        const rows = await querySessionDirectoriesFromSqlite(dbPath);
+        if (!rows || rows.length === 0) {
+            continue;
+        }
+        let changed = false;
+        let maxUpdated = cacheData.lastSyncedUpdatedAt;
+        for (const row of rows) {
+            if (upsertDirectory(row.worktree, row.lastUpdated)) {
+                changed = true;
+            }
+            if (row.lastUpdated > maxUpdated) {
+                maxUpdated = row.lastUpdated;
+            }
+        }
+        if (maxUpdated !== cacheData.lastSyncedUpdatedAt) {
+            cacheData.lastSyncedUpdatedAt = maxUpdated;
+            changed = true;
+        }
+        if (changed) {
+            await queuePersist();
+        }
+        logger.debug(`[SessionCache] SQLite fallback loaded: db=${dbPath}, rows=${rows.length}, directories=${cacheData.directories.length}`);
+        return;
+    }
+}
+async function ingestFromGlobalSessionStorage() {
+    await ensureCacheLoaded();
+    const fs = await import("node:fs/promises");
+    const candidates = await getStorageRootsFromApi();
+    for (const storageRoot of candidates) {
+        const globalDir = path.join(storageRoot, "storage", "session", "global");
+        try {
+            const entries = await fs.readdir(globalDir, { withFileTypes: true });
+            const sessionFiles = entries.filter((entry) => entry.isFile() && entry.name.endsWith(".json"));
+            const withMtime = await Promise.all(sessionFiles.map(async (entry) => {
+                const fullPath = path.join(globalDir, entry.name);
+                const stat = await fs.stat(fullPath);
+                return { fullPath, mtimeMs: stat.mtimeMs };
+            }));
+            const sorted = withMtime
+                .sort((a, b) => b.mtimeMs - a.mtimeMs)
+                .slice(0, STORAGE_FALLBACK_SCAN_LIMIT);
+            let changed = false;
+            let maxUpdated = cacheData.lastSyncedUpdatedAt;
+            for (const file of sorted) {
+                try {
+                    const raw = await fs.readFile(file.fullPath, "utf-8");
+                    const session = JSON.parse(raw);
+                    if (!session.directory) {
+                        continue;
+                    }
+                    const updated = session.time?.updated ?? Math.trunc(file.mtimeMs);
+                    if (upsertDirectory(session.directory, updated)) {
+                        changed = true;
+                    }
+                    if (updated > maxUpdated) {
+                        maxUpdated = updated;
+                    }
+                }
+                catch {
+                    // Ignore malformed session files.
+                }
+            }
+            if (maxUpdated !== cacheData.lastSyncedUpdatedAt) {
+                cacheData.lastSyncedUpdatedAt = maxUpdated;
+                changed = true;
+            }
+            if (changed) {
+                await queuePersist();
+            }
+            logger.debug(`[SessionCache] Storage fallback loaded: root=${storageRoot}, scanned=${sorted.length}, directories=${cacheData.directories.length}`);
+            return;
+        }
+        catch {
+            // Try next candidate path.
+        }
+    }
+}
+export async function warmupSessionDirectoryCache() {
+    await syncSessionDirectoryCache({ force: true });
+    try {
+        await ingestFromSqliteSessionDatabase();
+    }
+    catch (error) {
+        logger.warn("[SessionCache] Failed sqlite fallback warmup", error);
+    }
+    try {
+        await ingestFromGlobalSessionStorage();
+    }
+    catch (error) {
+        logger.warn("[SessionCache] Failed storage fallback warmup", error);
+    }
+}
+export async function syncSessionDirectoryCache(options) {
+    await ensureCacheLoaded();
+    if (!options?.force && Date.now() - lastSyncAttemptAt < SYNC_COOLDOWN_MS) {
+        return;
+    }
+    if (syncInFlight) {
+        return syncInFlight;
+    }
+    syncInFlight = runSync()
+        .then(() => {
+        lastSyncAttemptAt = Date.now();
+    })
+        .catch((error) => {
+        logger.warn("[SessionCache] Failed to sync sessions cache", error);
+        lastSyncAttemptAt = 0;
+    })
+        .finally(() => {
+        syncInFlight = null;
+    });
+    return syncInFlight;
+}
+export async function getCachedSessionDirectories() {
+    await ensureCacheLoaded();
+    return cacheData.directories.map((item) => ({ ...item }));
+}
+export async function getCachedSessionProjects() {
+    const directories = await getCachedSessionDirectories();
+    return directories.map((item) => ({
+        id: createVirtualProjectId(item.worktree),
+        worktree: item.worktree,
+        name: item.worktree,
+        lastUpdated: item.lastUpdated,
+    }));
+}
+export async function upsertSessionDirectory(worktree, lastUpdated = Date.now()) {
+    await ensureCacheLoaded();
+    if (!upsertDirectory(worktree, lastUpdated)) {
+        return;
+    }
+    if (lastUpdated > cacheData.lastSyncedUpdatedAt) {
+        cacheData.lastSyncedUpdatedAt = lastUpdated;
+    }
+    await queuePersist();
+}
+export async function ingestSessionInfoForCache(session) {
+    const directory = session.directory;
+    if (!directory) {
+        return;
+    }
+    const updated = session.time?.updated ?? Date.now();
+    await upsertSessionDirectory(directory, updated);
+}
+export function __resetSessionDirectoryCacheForTests() {
+    cacheData = createEmptyCacheData();
+    cacheLoaded = false;
+    syncInFlight = null;
+    lastSyncAttemptAt = 0;
+    persistQueue = Promise.resolve();
+}

package/dist/settings/manager.js

@@ -17,15 +17,24 @@ async function readSettingsFile() {
         return {};
     }
 }
+let settingsWriteQueue = Promise.resolve();
 function writeSettingsFile(settings) {
-    import("fs/promises").then((fs) => {
-        const settingsFilePath = getSettingsFilePath();
-        fs.mkdir(path.dirname(settingsFilePath), { recursive: true })
-            .then(() => fs.writeFile(settingsFilePath, JSON.stringify(settings, null, 2)))
-            .catch((err) => {
+    settingsWriteQueue = settingsWriteQueue
+        .catch(() => {
+        // Keep write queue alive after failed writes.
+    })
+        .then(async () => {
+        try {
+            const fs = await import("fs/promises");
+            const settingsFilePath = getSettingsFilePath();
+            await fs.mkdir(path.dirname(settingsFilePath), { recursive: true });
+            await fs.writeFile(settingsFilePath, JSON.stringify(settings, null, 2));
+        }
+        catch (err) {
             logger.error("[SettingsManager] Error writing settings file:", err);
-        });
+        }
     });
+    return settingsWriteQueue;
 }
 let currentSettings = {};
 export function getCurrentProject() {
@@ -33,66 +42,81 @@ export function getCurrentProject() {
 }
 export function setCurrentProject(projectInfo) {
     currentSettings.currentProject = projectInfo;
-    writeSettingsFile(currentSettings);
+    void writeSettingsFile(currentSettings);
 }
 export function clearProject() {
     currentSettings.currentProject = undefined;
-    writeSettingsFile(currentSettings);
+    void writeSettingsFile(currentSettings);
 }
 export function getCurrentSession() {
     return currentSettings.currentSession;
 }
 export function setCurrentSession(sessionInfo) {
     currentSettings.currentSession = sessionInfo;
-    writeSettingsFile(currentSettings);
+    void writeSettingsFile(currentSettings);
 }
 export function clearSession() {
     currentSettings.currentSession = undefined;
-    writeSettingsFile(currentSettings);
+    void writeSettingsFile(currentSettings);
 }
 export function getCurrentAgent() {
     return currentSettings.currentAgent;
 }
 export function setCurrentAgent(agentName) {
     currentSettings.currentAgent = agentName;
-    writeSettingsFile(currentSettings);
+    void writeSettingsFile(currentSettings);
 }
 export function clearCurrentAgent() {
     currentSettings.currentAgent = undefined;
-    writeSettingsFile(currentSettings);
+    void writeSettingsFile(currentSettings);
 }
 export function getCurrentModel() {
     return currentSettings.currentModel;
 }
 export function setCurrentModel(modelInfo) {
     currentSettings.currentModel = modelInfo;
-    writeSettingsFile(currentSettings);
+    void writeSettingsFile(currentSettings);
 }
 export function clearCurrentModel() {
     currentSettings.currentModel = undefined;
-    writeSettingsFile(currentSettings);
+    void writeSettingsFile(currentSettings);
 }
 export function getPinnedMessageId() {
     return currentSettings.pinnedMessageId;
 }
 export function setPinnedMessageId(messageId) {
     currentSettings.pinnedMessageId = messageId;
-    writeSettingsFile(currentSettings);
+    void writeSettingsFile(currentSettings);
 }
 export function clearPinnedMessageId() {
     currentSettings.pinnedMessageId = undefined;
-    writeSettingsFile(currentSettings);
+    void writeSettingsFile(currentSettings);
 }
 export function getServerProcess() {
     return currentSettings.serverProcess;
 }
 export function setServerProcess(processInfo) {
     currentSettings.serverProcess = processInfo;
-    writeSettingsFile(currentSettings);
+    void writeSettingsFile(currentSettings);
 }
 export function clearServerProcess() {
     currentSettings.serverProcess = undefined;
-    writeSettingsFile(currentSettings);
+    void writeSettingsFile(currentSettings);
+}
+export function getSessionDirectoryCache() {
+    return currentSettings.sessionDirectoryCache;
+}
+export function setSessionDirectoryCache(cache) {
+    currentSettings.sessionDirectoryCache = cache;
+    return writeSettingsFile(currentSettings);
+}
+export function clearSessionDirectoryCache() {
+    currentSettings.sessionDirectoryCache = undefined;
+    void writeSettingsFile(currentSettings);
+}
+export function __resetSettingsForTests() {
+    currentSettings = {};
+    settingsWriteQueue = Promise.resolve();
 }
 export async function loadSettings() {
     currentSettings = await readSettingsFile();

package/dist/utils/error-format.js

@@ -0,0 +1,29 @@
+const DEFAULT_MAX_ERROR_DETAILS_LENGTH = 1500;
+function clipText(value, maxLength) {
+    if (value.length <= maxLength) {
+        return value;
+    }
+    return `${value.slice(0, Math.max(0, maxLength - 3))}...`;
+}
+export function formatErrorDetails(error, maxLength = DEFAULT_MAX_ERROR_DETAILS_LENGTH) {
+    let details = "";
+    if (error instanceof Error) {
+        details = error.stack ?? `${error.name}: ${error.message}`;
+    }
+    else if (typeof error === "string") {
+        details = error;
+    }
+    else {
+        try {
+            details = JSON.stringify(error, null, 2);
+        }
+        catch {
+            details = String(error);
+        }
+    }
+    const normalized = details.trim();
+    if (!normalized || normalized === "{}" || normalized === "[object Object]") {
+        return "unknown error";
+    }
+    return clipText(normalized, maxLength);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@grinev/opencode-telegram-bot",
-  "version": "0.1.1",
+  "version": "0.2.1",
   "description": "Telegram bot client for OpenCode to run and monitor coding tasks from chat.",
   "type": "module",
   "main": "./dist/index.js",
@@ -53,10 +53,12 @@
   "dependencies": {
     "@grammyjs/menu": "^1.3.1",
     "@opencode-ai/sdk": "^1.1.21",
+    "better-sqlite3": "^12.6.2",
     "dotenv": "^17.2.3",
     "grammy": "^1.39.2"
   },
   "devDependencies": {
+    "@types/better-sqlite3": "^7.6.13",
     "@types/node": "^25.0.8",
     "@typescript-eslint/eslint-plugin": "^8.53.0",
     "@typescript-eslint/parser": "^8.53.0",