remoat 0.2.0

package/dist/bot/index.js

@@ -0,0 +1,1393 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startBot = void 0;
+const grammy_1 = require("grammy");
+const better_sqlite3_1 = __importDefault(require("better-sqlite3"));
+const i18n_1 = require("../utils/i18n");
+const logger_1 = require("../utils/logger");
+const config_1 = require("../utils/config");
+const configLoader_1 = require("../utils/configLoader");
+const messageParser_1 = require("../commands/messageParser");
+const slashCommandHandler_1 = require("../commands/slashCommandHandler");
+const cleanupCommandHandler_1 = require("../commands/cleanupCommandHandler");
+const modeService_1 = require("../services/modeService");
+const modelService_1 = require("../services/modelService");
+const templateRepository_1 = require("../database/templateRepository");
+const workspaceBindingRepository_1 = require("../database/workspaceBindingRepository");
+const chatSessionRepository_1 = require("../database/chatSessionRepository");
+const workspaceService_1 = require("../services/workspaceService");
+const telegramTopicManager_1 = require("../services/telegramTopicManager");
+const titleGeneratorService_1 = require("../services/titleGeneratorService");
+const chatSessionService_1 = require("../services/chatSessionService");
+const responseMonitor_1 = require("../services/responseMonitor");
+const antigravityLauncher_1 = require("../services/antigravityLauncher");
+const pathUtils_1 = require("../utils/pathUtils");
+const promptDispatcher_1 = require("../services/promptDispatcher");
+const cdpBridgeManager_1 = require("../services/cdpBridgeManager");
+const streamMessageFormatter_1 = require("../utils/streamMessageFormatter");
+const telegramFormatter_1 = require("../utils/telegramFormatter");
+const processLogBuffer_1 = require("../utils/processLogBuffer");
+const imageHandler_1 = require("../utils/imageHandler");
+const voiceHandler_1 = require("../utils/voiceHandler");
+const modeUi_1 = require("../ui/modeUi");
+const modelsUi_1 = require("../ui/modelsUi");
+const templateUi_1 = require("../ui/templateUi");
+const autoAcceptUi_1 = require("../ui/autoAcceptUi");
+const screenshotUi_1 = require("../ui/screenshotUi");
+const projectListUi_1 = require("../ui/projectListUi");
+const sessionPickerUi_1 = require("../ui/sessionPickerUi");
+const PHASE_ICONS = {
+    sending: '📡',
+    thinking: '🧠',
+    generating: '✍️',
+    complete: '✅',
+    timeout: '⏰',
+    error: '❌',
+};
+const MAX_OUTBOUND_GENERATED_IMAGES = 4;
+const TELEGRAM_MSG_LIMIT = 4096;
+const MAX_INLINE_CHUNKS = 5;
+/** Convert Telegram HTML back to readable Markdown for .md file attachment */
+function stripHtmlForFile(html) {
+    let text = html;
+    // Code blocks: <pre><code class="language-X">...</code></pre> → ```X\n...\n```
+    text = text.replace(/<pre>\s*<code\s+class="language-([^"]*)">([\s\S]*?)<\/code>\s*<\/pre>/gi, (_m, lang, content) => `\n\`\`\`${lang}\n${content}\n\`\`\`\n`);
+    // Code blocks: <pre>...</pre> → ```\n...\n```
+    text = text.replace(/<pre[^>]*>([\s\S]*?)<\/pre>/gi, (_m, content) => `\n\`\`\`\n${content}\n\`\`\`\n`);
+    // Inline code
+    text = text.replace(/<code>([\s\S]*?)<\/code>/gi, '`$1`');
+    // Bold
+    text = text.replace(/<b>([\s\S]*?)<\/b>/gi, '**$1**');
+    // Italic
+    text = text.replace(/<i>([\s\S]*?)<\/i>/gi, '*$1*');
+    // Strikethrough
+    text = text.replace(/<s>([\s\S]*?)<\/s>/gi, '~~$1~~');
+    // Links
+    text = text.replace(/<a\s+href="([^"]*)">([\s\S]*?)<\/a>/gi, '[$2]($1)');
+    // Blockquotes
+    text = text.replace(/<blockquote>([\s\S]*?)<\/blockquote>/gi, (_m, content) => content.split('\n').map((l) => `> ${l}`).join('\n'));
+    // Strip remaining tags
+    text = text.replace(/<[^>]+>/g, '');
+    // Decode entities
+    text = text.replace(/&amp;/g, '&').replace(/&lt;/g, '<').replace(/&gt;/g, '>').replace(/&quot;/g, '"');
+    // Collapse excessive newlines
+    text = text.replace(/\n{3,}/g, '\n\n').trim();
+    return text;
+}
+const userStopRequestedChannels = new Set();
+function channelKey(ch) {
+    return ch.threadId ? `${ch.chatId}:${ch.threadId}` : String(ch.chatId);
+}
+function createSerialTaskQueue(queueName, traceId) {
+    let queue = Promise.resolve();
+    let taskSeq = 0;
+    return (task, label = 'queue-task') => {
+        taskSeq += 1;
+        const seq = taskSeq;
+        queue = queue.then(async () => {
+            try {
+                await task();
+            }
+            catch (err) {
+                logger_1.logger.error(`[sendQueue:${traceId}:${queueName}] error #${seq} label=${label}:`, err?.message || err);
+            }
+        });
+        return queue;
+    };
+}
+async function sendPromptToAntigravity(bridge, channel, prompt, cdp, modeService, modelService, inboundImages = [], options) {
+    const api = bridge.botApi;
+    const monitorTraceId = channelKey(channel);
+    const enqueueGeneral = createSerialTaskQueue('general', monitorTraceId);
+    const enqueueResponse = createSerialTaskQueue('response', monitorTraceId);
+    const enqueueActivity = createSerialTaskQueue('activity', monitorTraceId);
+    const sendMsg = async (text) => {
+        try {
+            const truncated = text.length > TELEGRAM_MSG_LIMIT ? text.slice(0, TELEGRAM_MSG_LIMIT - 20) + '\n...(truncated)' : text;
+            const msg = await api.sendMessage(channel.chatId, truncated, {
+                parse_mode: 'HTML',
+                message_thread_id: channel.threadId,
+            });
+            return msg.message_id;
+        }
+        catch (e) {
+            logger_1.logger.error('[sendMsg] Failed:', e);
+            return null;
+        }
+    };
+    const editMsg = async (msgId, text) => {
+        try {
+            const truncated = text.length > TELEGRAM_MSG_LIMIT ? text.slice(0, TELEGRAM_MSG_LIMIT - 20) + '\n...(truncated)' : text;
+            await api.editMessageText(channel.chatId, msgId, truncated, { parse_mode: 'HTML' });
+        }
+        catch (e) {
+            const desc = e?.description || e?.message || '';
+            if (!desc.includes('message is not modified')) {
+                logger_1.logger.error('[editMsg] Failed:', desc);
+            }
+        }
+    };
+    const sendEmbed = (title, description) => enqueueGeneral(async () => {
+        const text = `<b>${(0, telegramFormatter_1.escapeHtml)(title)}</b>\n\n${(0, telegramFormatter_1.escapeHtml)(description)}`;
+        await sendMsg(text);
+    }, 'send-embed');
+    /** Send a potentially long response, splitting into chunks and attaching a .md file if needed. */
+    const sendChunkedResponse = async (title, footer, rawBody, isAlreadyHtml) => {
+        const formattedBody = isAlreadyHtml ? rawBody : (0, telegramFormatter_1.formatForTelegram)(rawBody);
+        const fullMsg = `<b>${(0, telegramFormatter_1.escapeHtml)(title)}</b>\n\n${formattedBody}\n\n<i>${(0, telegramFormatter_1.escapeHtml)(footer)}</i>`;
+        if (fullMsg.length <= TELEGRAM_MSG_LIMIT) {
+            await upsertLiveResponse(title, rawBody, footer, { expectedVersion: liveResponseUpdateVersion, isAlreadyHtml, skipTruncation: true });
+            return;
+        }
+        const bodyChunks = (0, telegramFormatter_1.splitTelegramHtml)(formattedBody, TELEGRAM_MSG_LIMIT - 200);
+        const inlineCount = Math.min(bodyChunks.length, MAX_INLINE_CHUNKS);
+        const hasFile = bodyChunks.length > MAX_INLINE_CHUNKS;
+        const total = hasFile ? inlineCount : bodyChunks.length;
+        for (let pi = 0; pi < inlineCount; pi++) {
+            const partLabel = hasFile ? `(${pi + 1}/${inlineCount}+file)` : `(${pi + 1}/${total})`;
+            if (pi === 0) {
+                await upsertLiveResponse(`${title} ${partLabel}`, bodyChunks[pi], footer, { expectedVersion: liveResponseUpdateVersion, isAlreadyHtml: true, skipTruncation: true });
+            }
+            else {
+                await sendMsg(`${bodyChunks[pi]}\n\n<i>${(0, telegramFormatter_1.escapeHtml)(footer)} ${partLabel}</i>`);
+            }
+        }
+        if (hasFile) {
+            try {
+                const fileContent = stripHtmlForFile(formattedBody);
+                const buf = Buffer.from(fileContent, 'utf-8');
+                const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
+                await api.sendDocument(channel.chatId, new grammy_1.InputFile(buf, `response-${timestamp}.md`), {
+                    caption: `📄 Full response (${rawBody.length} chars)`,
+                    message_thread_id: channel.threadId,
+                });
+            }
+            catch (e) {
+                logger_1.logger.error('[sendPrompt] Failed to send response file:', e);
+            }
+        }
+    };
+    if (!cdp.isConnected()) {
+        await sendEmbed(`${PHASE_ICONS.error} Connection Error`, `Not connected to Antigravity.\nStart with \`${(0, pathUtils_1.getAntigravityCdpHint)(9223)}\`, then send a message to auto-connect.`);
+        return;
+    }
+    const localMode = modeService.getCurrentMode();
+    const modeName = modeService_1.MODE_UI_NAMES[localMode] || localMode;
+    const currentModel = (await cdp.getCurrentModel()) || modelService.getCurrentModel();
+    await sendEmbed(`${PHASE_ICONS.sending} [${modeName} - ${currentModel}] Sending...`, (0, streamMessageFormatter_1.buildModeModelLines)(modeName, currentModel, currentModel).join('\n'));
+    let isFinalized = false;
+    let elapsedTimer = null;
+    let lastProgressText = '';
+    let lastActivityLogText = '';
+    const LIVE_RESPONSE_MAX_LEN = 3800;
+    const LIVE_ACTIVITY_MAX_LEN = 3800;
+    const processLogBuffer = new processLogBuffer_1.ProcessLogBuffer({ maxChars: LIVE_ACTIVITY_MAX_LEN, maxEntries: 120, maxEntryLength: 220 });
+    let liveResponseMsgId = null;
+    let liveActivityMsgId = null;
+    let lastLiveResponseKey = '';
+    let lastLiveActivityKey = '';
+    let liveResponseUpdateVersion = 0;
+    let liveActivityUpdateVersion = 0;
+    const ACTIVITY_PLACEHOLDER = (0, i18n_1.t)('Collecting process logs...');
+    const buildLiveResponseText = (title, rawText, footer, isAlreadyHtml = false, skipTruncation = false) => {
+        const normalized = (rawText || '').trim();
+        const body = normalized
+            ? (isAlreadyHtml ? normalized : (0, telegramFormatter_1.formatForTelegram)(normalized))
+            : (0, i18n_1.t)('Waiting for output...');
+        const truncated = (!skipTruncation && body.length > LIVE_RESPONSE_MAX_LEN)
+            ? '...(beginning truncated)\n' + body.slice(-LIVE_RESPONSE_MAX_LEN + 30)
+            : body;
+        return `<b>${(0, telegramFormatter_1.escapeHtml)(title)}</b>\n\n${truncated}\n\n<i>${(0, telegramFormatter_1.escapeHtml)(footer)}</i>`;
+    };
+    const buildLiveActivityText = (title, rawText, footer) => {
+        const normalized = (rawText || '').trim();
+        const body = normalized
+            ? (0, streamMessageFormatter_1.fitForSingleEmbedDescription)((0, telegramFormatter_1.formatForTelegram)(normalized), LIVE_ACTIVITY_MAX_LEN)
+            : ACTIVITY_PLACEHOLDER;
+        return `<b>${(0, telegramFormatter_1.escapeHtml)(title)}</b>\n\n${body}\n\n<i>${(0, telegramFormatter_1.escapeHtml)(footer)}</i>`;
+    };
+    const appendProcessLogs = (text) => {
+        const normalized = (text || '').trim();
+        if (!normalized)
+            return processLogBuffer.snapshot();
+        return processLogBuffer.append(normalized);
+    };
+    const upsertLiveResponse = (title, rawText, footer, opts) => enqueueResponse(async () => {
+        if (opts?.skipWhenFinalized && isFinalized)
+            return;
+        if (opts?.expectedVersion !== undefined && opts.expectedVersion !== liveResponseUpdateVersion)
+            return;
+        const text = buildLiveResponseText(title, rawText, footer, opts?.isAlreadyHtml, opts?.skipTruncation);
+        const renderKey = `${title}|${rawText.slice(0, 200)}|${footer}`;
+        if (renderKey === lastLiveResponseKey && liveResponseMsgId)
+            return;
+        lastLiveResponseKey = renderKey;
+        if (liveResponseMsgId) {
+            await editMsg(liveResponseMsgId, text);
+        }
+        else {
+            liveResponseMsgId = await sendMsg(text);
+        }
+    }, 'upsert-response');
+    const upsertLiveActivity = (title, rawText, footer, opts) => enqueueActivity(async () => {
+        if (opts?.skipWhenFinalized && isFinalized)
+            return;
+        if (opts?.expectedVersion !== undefined && opts.expectedVersion !== liveActivityUpdateVersion)
+            return;
+        const text = buildLiveActivityText(title, rawText, footer);
+        const renderKey = `${title}|${rawText.slice(0, 200)}|${footer}`;
+        if (renderKey === lastLiveActivityKey && liveActivityMsgId)
+            return;
+        lastLiveActivityKey = renderKey;
+        if (liveActivityMsgId) {
+            await editMsg(liveActivityMsgId, text);
+        }
+        else {
+            liveActivityMsgId = await sendMsg(text);
+        }
+    }, 'upsert-activity');
+    const sendGeneratedImages = async (responseText) => {
+        const imageIntentPattern = /(image|images|png|jpg|jpeg|gif|webp|illustration|diagram|render)/i;
+        const imageUrlPattern = /https?:\/\/\S+\.(png|jpg|jpeg|gif|webp)/i;
+        if (!imageIntentPattern.test(prompt) && !responseText.includes('![') && !imageUrlPattern.test(responseText))
+            return;
+        const extracted = await cdp.extractLatestResponseImages(MAX_OUTBOUND_GENERATED_IMAGES);
+        if (extracted.length === 0)
+            return;
+        for (let i = 0; i < extracted.length; i++) {
+            const file = await (0, imageHandler_1.toTelegramInputFile)(extracted[i], i);
+            if (file) {
+                try {
+                    await api.sendPhoto(channel.chatId, new grammy_1.InputFile(file.buffer, file.name), {
+                        caption: `🖼️ Generated image (${i + 1}/${extracted.length})`,
+                        message_thread_id: channel.threadId,
+                    });
+                }
+                catch (e) {
+                    logger_1.logger.error('[sendGeneratedImages] Failed:', e);
+                }
+            }
+        }
+    };
+    const tryEmergencyExtractText = async () => {
+        try {
+            const contextId = cdp.getPrimaryContextId();
+            const expression = `(() => {
+                const panel = document.querySelector('.antigravity-agent-side-panel');
+                const scope = panel || document;
+                const candidateSelectors = ['.rendered-markdown', '.leading-relaxed.select-text', '.flex.flex-col.gap-y-3', '[data-message-author-role="assistant"]', '[data-message-role="assistant"]', '[class*="assistant-message"]', '[class*="message-content"]', '[class*="markdown-body"]', '.prose'];
+                const looksLikeActivity = (text) => { const n = (text || '').trim().toLowerCase(); if (!n) return true; return /^(?:analy[sz]ing|reading|writing|running|searching|planning|thinking|processing|loading|executing|testing|debugging|analyzed|read|wrote|ran)/i.test(n) && n.length <= 220; };
+                const clean = (text) => (text || '').replace(/\\r/g, '').replace(/\\n{3,}/g, '\\n\\n').trim();
+                const candidates = []; const seen = new Set();
+                for (const selector of candidateSelectors) { const nodes = scope.querySelectorAll(selector); for (const node of nodes) { if (!node || seen.has(node)) continue; seen.add(node); candidates.push(node); } }
+                for (let i = candidates.length - 1; i >= 0; i--) { const node = candidates[i]; const text = clean(node.innerText || node.textContent || ''); if (!text || text.length < 20) continue; if (looksLikeActivity(text)) continue; if (/^(good|bad)$/i.test(text)) continue; return text; }
+                return '';
+            })()`;
+            const callParams = { expression, returnByValue: true, awaitPromise: true };
+            if (contextId !== null)
+                callParams.contextId = contextId;
+            const res = await cdp.call('Runtime.evaluate', callParams);
+            const value = res?.result?.value;
+            return typeof value === 'string' ? value.trim() : '';
+        }
+        catch {
+            return '';
+        }
+    };
+    let monitor = null;
+    try {
+        let injectResult;
+        if (inboundImages.length > 0) {
+            injectResult = await cdp.injectMessageWithImageFiles(prompt, inboundImages.map(i => i.localPath));
+            if (!injectResult.ok) {
+                await sendEmbed((0, i18n_1.t)('🖼️ Attached image fallback'), (0, i18n_1.t)('Failed to attach image directly, resending via URL reference.'));
+                injectResult = await cdp.injectMessage((0, imageHandler_1.buildPromptWithAttachmentUrls)(prompt, inboundImages));
+            }
+        }
+        else {
+            injectResult = await cdp.injectMessage(prompt);
+        }
+        if (!injectResult.ok) {
+            isFinalized = true;
+            await sendEmbed(`${PHASE_ICONS.error} Message Injection Failed`, `Failed to send message: ${injectResult.error}`);
+            return;
+        }
+        const startTime = Date.now();
+        await upsertLiveActivity(`${PHASE_ICONS.thinking} Process Log`, '', (0, i18n_1.t)('⏱️ Elapsed: 0s | Process log'));
+        monitor = new responseMonitor_1.ResponseMonitor({
+            cdpService: cdp,
+            pollIntervalMs: 2000,
+            maxDurationMs: 1800000,
+            stopGoneConfirmCount: 3,
+            onPhaseChange: () => { },
+            onProcessLog: (logText) => {
+                if (isFinalized)
+                    return;
+                if (logText && logText.trim().length > 0)
+                    lastActivityLogText = appendProcessLogs(logText);
+                const elapsed = Math.round((Date.now() - startTime) / 1000);
+                liveActivityUpdateVersion += 1;
+                const v = liveActivityUpdateVersion;
+                upsertLiveActivity(`${PHASE_ICONS.thinking} Process Log`, lastActivityLogText || ACTIVITY_PLACEHOLDER, (0, i18n_1.t)(`⏱️ Elapsed: ${elapsed}s | Process log`), { expectedVersion: v, skipWhenFinalized: true }).catch(() => { });
+            },
+            onProgress: (text) => {
+                if (isFinalized)
+                    return;
+                const isStructured = monitor?.getLastExtractionSource() === 'structured';
+                const separated = isStructured ? { output: text, logs: '' } : (0, telegramFormatter_1.splitOutputAndLogs)(text);
+                if (separated.output && separated.output.trim().length > 0)
+                    lastProgressText = separated.output;
+            },
+            onComplete: async (finalText, meta) => {
+                isFinalized = true;
+                if (elapsedTimer) {
+                    clearInterval(elapsedTimer);
+                    elapsedTimer = null;
+                }
+                const wasStoppedByUser = userStopRequestedChannels.delete(channelKey(channel));
+                if (wasStoppedByUser) {
+                    logger_1.logger.info(`[sendPrompt:${monitorTraceId}] Stopped by user`);
+                    await sendMsg('⏹️ Generation stopped.');
+                    return;
+                }
+                try {
+                    const elapsed = Math.round((Date.now() - startTime) / 1000);
+                    const isQuotaError = monitor.getPhase() === 'quotaReached' || monitor.getQuotaDetected();
+                    if (isQuotaError) {
+                        const finalLogText = lastActivityLogText || processLogBuffer.snapshot();
+                        liveActivityUpdateVersion += 1;
+                        await upsertLiveActivity(`${PHASE_ICONS.thinking} Process Log`, finalLogText || ACTIVITY_PLACEHOLDER, (0, i18n_1.t)(`⏱️ Time: ${elapsed}s | Process log`), { expectedVersion: liveActivityUpdateVersion });
+                        liveResponseUpdateVersion += 1;
+                        await upsertLiveResponse('⚠️ Model Quota Reached', 'Model quota limit reached. Please wait or switch to a different model.', (0, i18n_1.t)(`⏱️ Time: ${elapsed}s | Quota Reached`), { expectedVersion: liveResponseUpdateVersion });
+                        try {
+                            const payload = await (0, modelsUi_1.buildModelsUI)(cdp, () => bridge.quota.fetchQuota());
+                            if (payload) {
+                                await api.sendMessage(channel.chatId, payload.text, { parse_mode: 'HTML', message_thread_id: channel.threadId, reply_markup: payload.keyboard });
+                            }
+                        }
+                        catch (e) {
+                            logger_1.logger.error('[Quota] Failed to send model selection UI:', e);
+                        }
+                        return;
+                    }
+                    const responseText = (finalText && finalText.trim().length > 0) ? finalText : lastProgressText;
+                    const emergencyText = (!responseText || responseText.trim().length === 0) ? await tryEmergencyExtractText() : '';
+                    const finalResponseText = responseText && responseText.trim().length > 0 ? responseText : emergencyText;
+                    const isAlreadyHtml = meta?.source === 'structured';
+                    const separated = isAlreadyHtml ? { output: finalResponseText, logs: '' } : (0, telegramFormatter_1.splitOutputAndLogs)(finalResponseText);
+                    const finalOutputText = separated.output || finalResponseText;
+                    const finalLogText = lastActivityLogText || processLogBuffer.snapshot();
+                    if (finalLogText && finalLogText.trim().length > 0) {
+                        logger_1.logger.divider('Process Log');
+                        console.info(finalLogText);
+                    }
+                    if (finalOutputText && finalOutputText.trim().length > 0) {
+                        logger_1.logger.divider(`Output (${finalOutputText.length} chars)`);
+                        console.info(finalOutputText);
+                    }
+                    logger_1.logger.divider();
+                    liveActivityUpdateVersion += 1;
+                    await upsertLiveActivity(`${PHASE_ICONS.thinking} Process Log`, finalLogText || ACTIVITY_PLACEHOLDER, (0, i18n_1.t)(`⏱️ Time: ${elapsed}s | Process log`), { expectedVersion: liveActivityUpdateVersion });
+                    liveResponseUpdateVersion += 1;
+                    if (finalOutputText && finalOutputText.trim().length > 0) {
+                        const title = `${PHASE_ICONS.complete} Final Output`;
+                        const footer = (0, i18n_1.t)(`⏱️ Time: ${elapsed}s | Complete`);
+                        await sendChunkedResponse(title, footer, finalOutputText, isAlreadyHtml);
+                    }
+                    else {
+                        await upsertLiveResponse(`${PHASE_ICONS.complete} Complete`, (0, i18n_1.t)('Failed to extract response. Use /screenshot to verify.'), (0, i18n_1.t)(`⏱️ Time: ${elapsed}s | Complete`), { expectedVersion: liveResponseUpdateVersion });
+                    }
+                    if (options) {
+                        try {
+                            const sessionInfo = await options.chatSessionService.getCurrentSessionInfo(cdp);
+                            if (sessionInfo && sessionInfo.hasActiveChat && sessionInfo.title && sessionInfo.title !== (0, i18n_1.t)('(Untitled)')) {
+                                const session = options.chatSessionRepo.findByChannelId(channelKey(channel));
+                                const projectName = session
+                                    ? bridge.pool.extractProjectName(session.workspacePath)
+                                    : cdp.getCurrentWorkspaceName();
+                                if (projectName) {
+                                    (0, cdpBridgeManager_1.registerApprovalSessionChannel)(bridge, projectName, sessionInfo.title, channel);
+                                }
+                                if (session && session.displayName !== sessionInfo.title) {
+                                    const newName = options.titleGenerator.sanitizeForChannelName(sessionInfo.title);
+                                    const formattedName = `${session.sessionNumber}-${newName}`;
+                                    const threadId = session.channelId.includes(':')
+                                        ? Number(session.channelId.split(':')[1])
+                                        : undefined;
+                                    if (threadId) {
+                                        try {
+                                            options.topicManager.setChatId(Number(session.channelId.split(':')[0]));
+                                            await options.topicManager.renameTopic(threadId, formattedName);
+                                        }
+                                        catch { /* topic rename optional */ }
+                                    }
+                                    options.chatSessionRepo.updateDisplayName(channelKey(channel), sessionInfo.title);
+                                }
+                            }
+                        }
+                        catch (e) {
+                            logger_1.logger.error('[Rename] Failed:', e);
+                        }
+                    }
+                    await sendGeneratedImages(finalOutputText || '');
+                }
+                catch (error) {
+                    logger_1.logger.error(`[sendPrompt:${monitorTraceId}] onComplete failed:`, error);
+                }
+            },
+            onTimeout: async (lastText) => {
+                isFinalized = true;
+                if (elapsedTimer) {
+                    clearInterval(elapsedTimer);
+                    elapsedTimer = null;
+                }
+                userStopRequestedChannels.delete(channelKey(channel));
+                try {
+                    const elapsed = Math.round((Date.now() - startTime) / 1000);
+                    const timeoutText = (lastText && lastText.trim().length > 0) ? lastText : lastProgressText;
+                    const timeoutIsHtml = monitor.getLastExtractionSource() === 'structured';
+                    const separated = timeoutIsHtml ? { output: timeoutText || '', logs: '' } : (0, telegramFormatter_1.splitOutputAndLogs)(timeoutText || '');
+                    const sanitizedTimeoutLogs = lastActivityLogText || processLogBuffer.snapshot();
+                    const payload = separated.output && separated.output.trim().length > 0
+                        ? `${separated.output}\n\n[Monitor Ended] Timeout after 30 minutes.`
+                        : 'Monitor ended after 30 minutes. No text was retrieved.';
+                    liveResponseUpdateVersion += 1;
+                    const timeoutTitle = `${PHASE_ICONS.timeout} Timeout`;
+                    const timeoutFooter = `⏱️ Elapsed: ${elapsed}s | Timeout`;
+                    await sendChunkedResponse(timeoutTitle, timeoutFooter, payload, timeoutIsHtml);
+                    liveActivityUpdateVersion += 1;
+                    await upsertLiveActivity(`${PHASE_ICONS.thinking} Process Log`, sanitizedTimeoutLogs || ACTIVITY_PLACEHOLDER, (0, i18n_1.t)(`⏱️ Time: ${elapsed}s | Process log`), { expectedVersion: liveActivityUpdateVersion });
+                }
+                catch (error) {
+                    logger_1.logger.error(`[sendPrompt:${monitorTraceId}] onTimeout failed:`, error);
+                }
+            },
+        });
+        await monitor.start();
+        elapsedTimer = setInterval(() => {
+            if (isFinalized) {
+                clearInterval(elapsedTimer);
+                return;
+            }
+            const elapsed = Math.round((Date.now() - startTime) / 1000);
+            liveActivityUpdateVersion += 1;
+            const v = liveActivityUpdateVersion;
+            upsertLiveActivity(`${PHASE_ICONS.thinking} Process Log`, lastActivityLogText || ACTIVITY_PLACEHOLDER, (0, i18n_1.t)(`⏱️ Elapsed: ${elapsed}s | Process log`), { expectedVersion: v, skipWhenFinalized: true }).catch(() => { });
+        }, 5000);
+    }
+    catch (e) {
+        isFinalized = true;
+        userStopRequestedChannels.delete(channelKey(channel));
+        if (elapsedTimer) {
+            clearInterval(elapsedTimer);
+        }
+        if (monitor) {
+            await monitor.stop().catch(() => { });
+        }
+        await sendEmbed(`${PHASE_ICONS.error} Error`, (0, i18n_1.t)(`Error occurred during processing: ${e.message}`));
+    }
+}
+// =============================================================================
+// Bot main entry point
+// =============================================================================
+const startBot = async (cliLogLevel) => {
+    const config = (0, config_1.loadConfig)();
+    logger_1.logger.setLogLevel(cliLogLevel ?? config.logLevel);
+    const dbPath = process.env.NODE_ENV === 'test' ? ':memory:' : configLoader_1.ConfigLoader.getDefaultDbPath();
+    const db = new better_sqlite3_1.default(dbPath);
+    db.pragma('journal_mode = WAL');
+    const modeService = new modeService_1.ModeService();
+    const modelService = new modelService_1.ModelService();
+    const templateRepo = new templateRepository_1.TemplateRepository(db);
+    const workspaceBindingRepo = new workspaceBindingRepository_1.WorkspaceBindingRepository(db);
+    const chatSessionRepo = new chatSessionRepository_1.ChatSessionRepository(db);
+    const workspaceService = new workspaceService_1.WorkspaceService(config.workspaceBaseDir);
+    await (0, antigravityLauncher_1.ensureAntigravityRunning)();
+    const bridge = (0, cdpBridgeManager_1.initCdpBridge)(config.autoApproveFileEdits);
+    bridge.botToken = config.telegramBotToken;
+    const chatSessionService = new chatSessionService_1.ChatSessionService();
+    const titleGenerator = new titleGeneratorService_1.TitleGeneratorService();
+    const promptDispatcher = new promptDispatcher_1.PromptDispatcher({
+        bridge,
+        modeService,
+        modelService,
+        sendPromptImpl: sendPromptToAntigravity,
+    });
+    const slashCommandHandler = new slashCommandHandler_1.SlashCommandHandler(templateRepo);
+    const cleanupHandler = new cleanupCommandHandler_1.CleanupCommandHandler(chatSessionRepo, workspaceBindingRepo);
+    const bot = new grammy_1.Bot(config.telegramBotToken);
+    bridge.botApi = bot.api;
+    const topicManager = new telegramTopicManager_1.TelegramTopicManager(bot.api, 0);
+    // Auth middleware
+    bot.use(async (ctx, next) => {
+        const userId = String(ctx.from?.id ?? '');
+        if (!config.allowedUserIds.includes(userId)) {
+            if (ctx.callbackQuery) {
+                await ctx.answerCallbackQuery({ text: 'You do not have permission.' });
+            }
+            return;
+        }
+        await next();
+    });
+    // Helper to build TelegramChannel from context
+    const getChannel = (ctx) => ({
+        chatId: ctx.chat.id,
+        threadId: ctx.message?.message_thread_id ?? undefined,
+    });
+    const getChannelFromCb = (ctx) => ({
+        chatId: ctx.chat.id,
+        threadId: ctx.callbackQuery?.message?.message_thread_id ?? undefined,
+    });
+    const resolveWorkspaceAndCdp = async (ch) => {
+        const key = channelKey(ch);
+        const binding = workspaceBindingRepo.findByChannelId(key);
+        if (!binding)
+            return null;
+        const workspacePath = workspaceService.getWorkspacePath(binding.workspacePath);
+        try {
+            const cdp = await bridge.pool.getOrConnect(workspacePath);
+            const projectName = bridge.pool.extractProjectName(workspacePath);
+            bridge.lastActiveWorkspace = projectName;
+            bridge.lastActiveChannel = ch;
+            (0, cdpBridgeManager_1.registerApprovalWorkspaceChannel)(bridge, projectName, ch);
+            (0, cdpBridgeManager_1.ensureApprovalDetector)(bridge, cdp, projectName);
+            (0, cdpBridgeManager_1.ensureErrorPopupDetector)(bridge, cdp, projectName);
+            (0, cdpBridgeManager_1.ensurePlanningDetector)(bridge, cdp, projectName);
+            return { cdp, projectName, workspacePath };
+        }
+        catch (e) {
+            logger_1.logger.error(`[resolveWorkspaceAndCdp] Connection failed:`, e);
+            return null;
+        }
+    };
+    const replyHtml = async (ctx, text, keyboard) => {
+        await ctx.reply(text, {
+            parse_mode: 'HTML',
+            reply_markup: keyboard,
+        });
+    };
+    // /start command
+    bot.command('start', async (ctx) => {
+        await replyHtml(ctx, `<b>Remoat Online</b>\n\n` +
+            `Use /help for available commands.\n` +
+            `Send any text message to forward it to Antigravity.`);
+    });
+    // /help command
+    bot.command('help', async (ctx) => {
+        await replyHtml(ctx, `<b>📖 Remoat Commands</b>\n\n` +
+            `<b>💬 Chat</b>\n` +
+            `/new — Start a new chat session\n` +
+            `/chat — Show current session info\n\n` +
+            `<b>⏹️ Control</b>\n` +
+            `/stop — Interrupt active LLM generation\n` +
+            `/screenshot — Capture Antigravity screen\n\n` +
+            `<b>⚙️ Settings</b>\n` +
+            `/mode — Display and change execution mode\n` +
+            `/model — Display and change LLM model\n\n` +
+            `<b>📁 Projects</b>\n` +
+            `/project — Display project list\n\n` +
+            `<b>📝 Templates</b>\n` +
+            `/template — Show templates\n` +
+            `/template_add — Register a template\n` +
+            `/template_delete — Delete a template\n\n` +
+            `<b>🔧 System</b>\n` +
+            `/status — Display overall bot status\n` +
+            `/autoaccept — Toggle auto-approve mode\n` +
+            `/cleanup [days] — Clean up inactive sessions\n` +
+            `/ping — Check latency\n\n` +
+            `<i>Text messages are sent directly to Antigravity</i>`);
+    });
+    // /mode command
+    bot.command('mode', async (ctx) => {
+        await (0, modeUi_1.sendModeUI)(async (text, keyboard) => { await replyHtml(ctx, text, keyboard); }, modeService, { getCurrentCdp: () => (0, cdpBridgeManager_1.getCurrentCdp)(bridge) });
+    });
+    // /model command
+    bot.command('model', async (ctx) => {
+        const modelName = ctx.match?.trim();
+        if (modelName) {
+            const cdp = (0, cdpBridgeManager_1.getCurrentCdp)(bridge);
+            if (!cdp) {
+                await ctx.reply('Not connected to CDP.');
+                return;
+            }
+            const res = await cdp.setUiModel(modelName);
+            if (res.ok) {
+                await ctx.reply(`Model changed to <b>${(0, telegramFormatter_1.escapeHtml)(res.model || modelName)}</b>.`, { parse_mode: 'HTML' });
+            }
+            else {
+                await ctx.reply(res.error || 'Failed to change model.');
+            }
+        }
+        else {
+            await (0, modelsUi_1.sendModelsUI)(async (text, keyboard) => { await replyHtml(ctx, text, keyboard); }, { getCurrentCdp: () => (0, cdpBridgeManager_1.getCurrentCdp)(bridge), fetchQuota: async () => bridge.quota.fetchQuota() });
+        }
+    });
+    // /template command
+    bot.command('template', async (ctx) => {
+        const templates = templateRepo.findAll();
+        await (0, templateUi_1.sendTemplateUI)(async (text, keyboard) => { await replyHtml(ctx, text, keyboard); }, templates);
+    });
+    // /template_add command
+    bot.command('template_add', async (ctx) => {
+        const args = (ctx.match || '').trim();
+        const parts = args.split(/\s+/);
+        if (parts.length < 2) {
+            await ctx.reply('Usage: /template_add <name> <prompt>');
+            return;
+        }
+        const name = parts[0];
+        const prompt = parts.slice(1).join(' ');
+        const result = await slashCommandHandler.handleCommand('template', ['add', name, prompt]);
+        await ctx.reply(result.message);
+    });
+    // /template_delete command
+    bot.command('template_delete', async (ctx) => {
+        const name = (ctx.match || '').trim();
+        if (!name) {
+            await ctx.reply('Usage: /template_delete <name>');
+            return;
+        }
+        const result = await slashCommandHandler.handleCommand('template', ['delete', name]);
+        await ctx.reply(result.message);
+    });
+    // /status command
+    bot.command('status', async (ctx) => {
+        const activeNames = bridge.pool.getActiveWorkspaceNames();
+        const currentMode = modeService.getCurrentMode();
+        const autoAcceptStatus = bridge.autoAccept.isEnabled() ? '🟢 ON' : '⚪ OFF';
+        let text = `<b>🔧 Bot Status</b>\n\n`;
+        text += `<b>CDP:</b> ${activeNames.length > 0 ? `🟢 ${activeNames.length} project(s) connected` : '⚪ Disconnected'}\n`;
+        text += `<b>Mode:</b> ${(0, telegramFormatter_1.escapeHtml)(modeService_1.MODE_DISPLAY_NAMES[currentMode] || currentMode)}\n`;
+        text += `<b>Auto Approve:</b> ${autoAcceptStatus}\n`;
+        if (activeNames.length > 0) {
+            text += `\n<b>Connected Projects:</b>\n`;
+            for (const name of activeNames) {
+                const cdp = bridge.pool.getConnected(name);
+                const contexts = cdp ? cdp.getContexts().length : 0;
+                text += `• <b>${(0, telegramFormatter_1.escapeHtml)(name)}</b> — Contexts: ${contexts}\n`;
+            }
+        }
+        else {
+            text += `\nSend a message to auto-connect to a project.`;
+        }
+        await replyHtml(ctx, text);
+    });
+    // /autoaccept command
+    bot.command('autoaccept', async (ctx) => {
+        const requestedMode = (ctx.match || '').trim();
+        if (requestedMode === 'on' || requestedMode === 'off') {
+            const result = bridge.autoAccept.handle(requestedMode);
+            await ctx.reply(result.message);
+        }
+        else {
+            await (0, autoAcceptUi_1.sendAutoAcceptUI)(async (text, keyboard) => { await replyHtml(ctx, text, keyboard); }, bridge.autoAccept);
+        }
+    });
+    // /cleanup command
+    bot.command('cleanup', async (ctx) => {
+        const days = Math.max(1, parseInt((ctx.match || '').trim(), 10) || 7);
+        const guildId = String(ctx.chat.id);
+        const inactive = cleanupHandler.findInactiveSessions(guildId, days);
+        if (inactive.length === 0) {
+            await replyHtml(ctx, `No inactive sessions older than <b>${days}</b> day(s).`);
+            return;
+        }
+        const list = inactive.slice(0, 20).map(({ binding, session }) => {
+            const label = session?.displayName ?? binding.workspacePath;
+            return `• ${(0, telegramFormatter_1.escapeHtml)(label)}`;
+        }).join('\n');
+        const extra = inactive.length > 20 ? `\n…and ${inactive.length - 20} more` : '';
+        const keyboard = new grammy_1.InlineKeyboard()
+            .text('📦 Archive', `${cleanupCommandHandler_1.CLEANUP_ARCHIVE_BTN}:${days}`)
+            .text('🗑 Delete', `${cleanupCommandHandler_1.CLEANUP_DELETE_BTN}:${days}`)
+            .text('❌ Cancel', cleanupCommandHandler_1.CLEANUP_CANCEL_BTN);
+        await replyHtml(ctx, `<b>🧹 Cleanup</b>\n\n` +
+            `Found <b>${inactive.length}</b> session(s) older than <b>${days}</b> day(s):\n\n` +
+            `${list}${extra}\n\n` +
+            `Choose an action:`, keyboard);
+    });
+    // /screenshot command
+    bot.command('screenshot', async (ctx) => {
+        await (0, screenshotUi_1.handleScreenshot)(async (input, caption) => { await ctx.replyWithPhoto(input, { caption }); }, async (text) => { await ctx.reply(text); }, (0, cdpBridgeManager_1.getCurrentCdp)(bridge));
+    });
+    // /stop command
+    bot.command('stop', async (ctx) => {
+        const ch = getChannel(ctx);
+        const resolved = await resolveWorkspaceAndCdp(ch);
+        const cdp = resolved?.cdp ?? (0, cdpBridgeManager_1.getCurrentCdp)(bridge);
+        if (!cdp) {
+            await ctx.reply('⚠️ Not connected to CDP.');
+            return;
+        }
+        try {
+            const contextId = cdp.getPrimaryContextId();
+            const callParams = { expression: responseMonitor_1.RESPONSE_SELECTORS.CLICK_STOP_BUTTON, returnByValue: true, awaitPromise: false };
+            if (contextId !== null)
+                callParams.contextId = contextId;
+            const result = await cdp.call('Runtime.evaluate', callParams);
+            const value = result?.result?.value;
+            if (value?.ok) {
+                const ch = getChannel(ctx);
+                userStopRequestedChannels.add(channelKey(ch));
+                await replyHtml(ctx, `<b>⏹️ Generation Interrupted</b>\nAI response generation was safely stopped.`);
+            }
+            else {
+                await replyHtml(ctx, `<b>⚠️ Could Not Stop</b>\n${(0, telegramFormatter_1.escapeHtml)(value?.error || 'Stop button not found.')}`);
+            }
+        }
+        catch (e) {
+            await ctx.reply(`❌ Error during stop: ${e.message}`);
+        }
+    });
+    // /project command
+    bot.command('project', async (ctx) => {
+        const workspaces = workspaceService.scanWorkspaces();
+        const { text, keyboard } = (0, projectListUi_1.buildProjectListUI)(workspaces, 0);
+        await replyHtml(ctx, text, keyboard);
+    });
+    // /new command
+    bot.command('new', async (ctx) => {
+        const ch = getChannel(ctx);
+        const key = channelKey(ch);
+        const session = chatSessionRepo.findByChannelId(key);
+        const binding = workspaceBindingRepo.findByChannelId(key);
+        const workspaceName = session?.workspacePath ?? binding?.workspacePath;
+        if (!workspaceName) {
+            await ctx.reply('⚠️ No project is bound to this chat. Use /project to select one.');
+            return;
+        }
+        const workspacePath = workspaceService.getWorkspacePath(workspaceName);
+        let cdp;
+        try {
+            cdp = await bridge.pool.getOrConnect(workspacePath);
+        }
+        catch (e) {
+            await ctx.reply(`⚠️ Failed to connect: ${e.message}`);
+            return;
+        }
+        try {
+            const chatResult = await chatSessionService.startNewChat(cdp);
+            if (chatResult.ok) {
+                await replyHtml(ctx, `<b>💬 New Chat Started</b>\nSend your message now.`);
+            }
+            else {
+                await ctx.reply(`⚠️ Could not start new chat: ${chatResult.error}`);
+            }
+        }
+        catch (e) {
+            await ctx.reply(`⚠️ Error: ${e.message}`);
+        }
+    });
+    // /chat command
+    bot.command('chat', async (ctx) => {
+        const ch = getChannel(ctx);
+        const key = channelKey(ch);
+        const session = chatSessionRepo.findByChannelId(key);
+        if (!session) {
+            const activeNames = bridge.pool.getActiveWorkspaceNames();
+            const anyCdp = activeNames.length > 0 ? bridge.pool.getConnected(activeNames[0]) : null;
+            const info = anyCdp
+                ? await chatSessionService.getCurrentSessionInfo(anyCdp)
+                : { title: '(CDP Disconnected)', hasActiveChat: false };
+            await replyHtml(ctx, `<b>💬 Chat Session Info</b>\n\n` +
+                `<b>Title:</b> ${(0, telegramFormatter_1.escapeHtml)(info.title)}\n` +
+                `<b>Status:</b> ${info.hasActiveChat ? '🟢 Active' : '⚪ Inactive'}\n\n` +
+                `<i>Use /project to bind a project first.</i>`);
+            return;
+        }
+        const allSessions = chatSessionRepo.findByCategoryId(session.categoryId);
+        const sessionList = allSessions.map(s => {
+            const name = s.displayName || `session-${s.sessionNumber}`;
+            const current = s.channelId === key ? ' ← Current' : '';
+            return `• ${name}${current}`;
+        }).join('\n');
+        await replyHtml(ctx, `<b>💬 Chat Session Info</b>\n\n` +
+            `<b>Current:</b> #${session.sessionNumber} — ${(0, telegramFormatter_1.escapeHtml)(session.displayName || '(Unset)')}\n` +
+            `<b>Project:</b> ${(0, telegramFormatter_1.escapeHtml)(session.workspacePath)}\n` +
+            `<b>Total sessions:</b> ${allSessions.length}\n\n` +
+            `<b>Sessions:</b>\n${(0, telegramFormatter_1.escapeHtml)(sessionList)}`);
+    });
+    // /ping command
+    bot.command('ping', async (ctx) => {
+        const start = Date.now();
+        const msg = await ctx.reply('🏓 Pong!');
+        const latency = Date.now() - start;
+        await bot.api.editMessageText(ctx.chat.id, msg.message_id, `🏓 Pong! Latency: <b>${latency}ms</b>`, { parse_mode: 'HTML' });
+    });
+    // =============================================================================
+    // Callback query handler (inline keyboard buttons)
+    // =============================================================================
+    bot.on('callback_query:data', async (ctx) => {
+        const data = ctx.callbackQuery.data;
+        const ch = getChannelFromCb(ctx);
+        // Mode selection
+        if (data.startsWith('mode_select:')) {
+            const selectedMode = data.replace('mode_select:', '');
+            modeService.setMode(selectedMode);
+            const cdp = (0, cdpBridgeManager_1.getCurrentCdp)(bridge);
+            if (cdp) {
+                const res = await cdp.setUiMode(selectedMode);
+                if (!res.ok)
+                    logger_1.logger.warn(`[Mode] UI switch failed: ${res.error}`);
+            }
+            const { text, keyboard } = await (0, modeUi_1.buildModeUI)(modeService, { getCurrentCdp: () => (0, cdpBridgeManager_1.getCurrentCdp)(bridge) });
+            try {
+                await ctx.editMessageText(text, { parse_mode: 'HTML', reply_markup: keyboard });
+            }
+            catch { /* may fail if unchanged */ }
+            await ctx.answerCallbackQuery({ text: `Mode: ${modeService_1.MODE_DISPLAY_NAMES[selectedMode] || selectedMode}` });
+            return;
+        }
+        // Exhausted model button — show alert toast
+        if (data.startsWith('model_exhausted_')) {
+            const modelName = data.replace('model_exhausted_', '');
+            await ctx.answerCallbackQuery({ text: `⛔ ${modelName} is exhausted. Wait for quota reset or pick another model.`, show_alert: true });
+            return;
+        }
+        // Model selection
+        if (data.startsWith('model_btn_')) {
+            const modelName = data.replace('model_btn_', '');
+            const cdp = (0, cdpBridgeManager_1.getCurrentCdp)(bridge);
+            if (!cdp) {
+                await ctx.answerCallbackQuery({ text: 'Not connected to CDP.' });
+                return;
+            }
+            const res = await cdp.setUiModel(modelName);
+            if (res.ok) {
+                const payload = await (0, modelsUi_1.buildModelsUI)(cdp, () => bridge.quota.fetchQuota());
+                if (payload)
+                    try {
+                        await ctx.editMessageText(payload.text, { parse_mode: 'HTML', reply_markup: payload.keyboard });
+                    }
+                    catch { }
+                await ctx.answerCallbackQuery({ text: `Model: ${res.model}` });
+            }
+            else {
+                await ctx.answerCallbackQuery({ text: res.error || 'Failed to change model.' });
+            }
+            return;
+        }
+        // Model refresh
+        if (data === 'model_refresh_btn') {
+            const cdp = (0, cdpBridgeManager_1.getCurrentCdp)(bridge);
+            if (!cdp) {
+                await ctx.answerCallbackQuery({ text: 'Not connected.' });
+                return;
+            }
+            const payload = await (0, modelsUi_1.buildModelsUI)(cdp, () => bridge.quota.fetchQuota());
+            if (payload)
+                try {
+                    await ctx.editMessageText(payload.text, { parse_mode: 'HTML', reply_markup: payload.keyboard });
+                }
+                catch { }
+            await ctx.answerCallbackQuery({ text: 'Refreshed' });
+            return;
+        }
+        // Auto-accept buttons
+        if (data === autoAcceptUi_1.AUTOACCEPT_BTN_ON || data === autoAcceptUi_1.AUTOACCEPT_BTN_OFF) {
+            const action = data === autoAcceptUi_1.AUTOACCEPT_BTN_ON ? 'on' : 'off';
+            bridge.autoAccept.handle(action);
+            await (0, autoAcceptUi_1.sendAutoAcceptUI)(async (text, keyboard) => { try {
+                await ctx.editMessageText(text, { parse_mode: 'HTML', reply_markup: keyboard });
+            }
+            catch { } }, bridge.autoAccept);
+            await ctx.answerCallbackQuery({ text: `Auto-accept: ${action.toUpperCase()}` });
+            return;
+        }
+        if (data === autoAcceptUi_1.AUTOACCEPT_BTN_REFRESH) {
+            await (0, autoAcceptUi_1.sendAutoAcceptUI)(async (text, keyboard) => { try {
+                await ctx.editMessageText(text, { parse_mode: 'HTML', reply_markup: keyboard });
+            }
+            catch { } }, bridge.autoAccept);
+            await ctx.answerCallbackQuery({ text: 'Refreshed' });
+            return;
+        }
+        // Project selection
+        if (data.startsWith(`${projectListUi_1.PROJECT_SELECT_ID}:`)) {
+            const workspacePath = data.replace(`${projectListUi_1.PROJECT_SELECT_ID}:`, '');
+            if (!workspaceService.exists(workspacePath)) {
+                await ctx.answerCallbackQuery({ text: `Project "${workspacePath}" not found.` });
+                return;
+            }
+            let key = channelKey(ch);
+            const guildId = String(ch.chatId);
+            const isForum = ctx.chat?.type === 'supergroup' && ctx.chat.is_forum === true;
+            // Auto-create topic if conditions are met
+            if (config.useTopics && isForum && !ch.threadId) {
+                try {
+                    const existing = workspaceBindingRepo.findByWorkspacePathAndGuildId(workspacePath, guildId);
+                    const existingTopic = existing.find(b => b.channelId.includes(':'));
+                    let topicId;
+                    if (existingTopic) {
+                        topicId = Number(existingTopic.channelId.split(':')[1]);
+                        topicManager.registerTopic(workspacePath, topicId);
+                    }
+                    else {
+                        topicManager.setChatId(ch.chatId);
+                        const sanitized = topicManager.sanitizeName(workspacePath);
+                        const result = await topicManager.ensureTopic(sanitized);
+                        topicId = result.topicId;
+                    }
+                    key = `${ch.chatId}:${topicId}`;
+                    // Send welcome message in the new topic
+                    const fullPath = workspaceService.getWorkspacePath(workspacePath);
+                    await bot.api.sendMessage(ch.chatId, `<b>📁 Project Selected</b>\n\n✅ <b>${(0, telegramFormatter_1.escapeHtml)(workspacePath)}</b>\n<code>${(0, telegramFormatter_1.escapeHtml)(fullPath)}</code>\n\nSend messages here to interact with this project.`, { parse_mode: 'HTML', message_thread_id: topicId });
+                    workspaceBindingRepo.upsert({ channelId: key, workspacePath, guildId });
+                    await ctx.answerCallbackQuery({ text: `Topic created for: ${workspacePath}` });
+                    return;
+                }
+                catch (e) {
+                    logger_1.logger.warn(`[ProjectSelect] Topic creation failed, falling back: ${e.message}`);
+                    // Fall through to default behavior
+                }
+            }
+            workspaceBindingRepo.upsert({ channelId: key, workspacePath, guildId });
+            const fullPath = workspaceService.getWorkspacePath(workspacePath);
+            await ctx.editMessageText(`<b>📁 Project Selected</b>\n\n✅ <b>${(0, telegramFormatter_1.escapeHtml)(workspacePath)}</b>\n<code>${(0, telegramFormatter_1.escapeHtml)(fullPath)}</code>\n\nSend messages here to interact with this project.`, { parse_mode: 'HTML' });
+            await ctx.answerCallbackQuery({ text: `Selected: ${workspacePath}` });
+            return;
+        }
+        // Project page navigation
+        if (data.startsWith(`${projectListUi_1.PROJECT_PAGE_PREFIX}:`)) {
+            const page = (0, projectListUi_1.parseProjectPageId)(data);
+            if (!isNaN(page)) {
+                const workspaces = workspaceService.scanWorkspaces();
+                const { text, keyboard } = (0, projectListUi_1.buildProjectListUI)(workspaces, page);
+                try {
+                    await ctx.editMessageText(text, { parse_mode: 'HTML', reply_markup: keyboard });
+                }
+                catch { }
+            }
+            await ctx.answerCallbackQuery();
+            return;
+        }
+        // Template button
+        if (data.startsWith(templateUi_1.TEMPLATE_BTN_PREFIX)) {
+            const templateId = (0, templateUi_1.parseTemplateButtonId)(data);
+            if (isNaN(templateId)) {
+                await ctx.answerCallbackQuery({ text: 'Invalid template.' });
+                return;
+            }
+            const template = templateRepo.findById(templateId);
+            if (!template) {
+                await ctx.answerCallbackQuery({ text: 'Template not found.' });
+                return;
+            }
+            const resolved = await resolveWorkspaceAndCdp(ch);
+            if (!resolved) {
+                const cdp = (0, cdpBridgeManager_1.getCurrentCdp)(bridge);
+                if (!cdp) {
+                    await ctx.answerCallbackQuery({ text: 'Not connected.' });
+                    return;
+                }
+                await promptDispatcher.send({ channel: ch, prompt: template.prompt, cdp, inboundImages: [], options: { chatSessionService, chatSessionRepo, topicManager, titleGenerator } });
+            }
+            else {
+                await promptDispatcher.send({ channel: ch, prompt: template.prompt, cdp: resolved.cdp, inboundImages: [], options: { chatSessionService, chatSessionRepo, topicManager, titleGenerator } });
+            }
+            await ctx.answerCallbackQuery({ text: `Running: ${template.name}` });
+            return;
+        }
+        // Session selection
+        if ((0, sessionPickerUi_1.isSessionSelectId)(data)) {
+            const selectedTitle = data.replace(`${sessionPickerUi_1.SESSION_SELECT_ID}:`, '');
+            const key = channelKey(ch);
+            const binding = workspaceBindingRepo.findByChannelId(key);
+            if (!binding) {
+                await ctx.answerCallbackQuery({ text: 'No project bound.' });
+                return;
+            }
+            const workspacePath = workspaceService.getWorkspacePath(binding.workspacePath);
+            try {
+                const cdp = await bridge.pool.getOrConnect(workspacePath);
+                const activateResult = await chatSessionService.activateSessionByTitle(cdp, selectedTitle);
+                if (activateResult.ok) {
+                    await ctx.editMessageText(`<b>🔗 Joined Session</b>\n\n<b>${(0, telegramFormatter_1.escapeHtml)(selectedTitle)}</b>`, { parse_mode: 'HTML' });
+                }
+                else {
+                    await ctx.answerCallbackQuery({ text: `Failed: ${activateResult.error}` });
+                }
+            }
+            catch (e) {
+                await ctx.answerCallbackQuery({ text: `Error: ${e.message}` });
+            }
+            return;
+        }
+        // Approval buttons
+        const approvalAction = (0, cdpBridgeManager_1.parseApprovalCustomId)(data);
+        if (approvalAction) {
+            const projectName = approvalAction.projectName ?? bridge.lastActiveWorkspace;
+            const detector = projectName ? bridge.pool.getApprovalDetector(projectName) : undefined;
+            if (!detector) {
+                await ctx.answerCallbackQuery({ text: 'Approval detector not found.' });
+                return;
+            }
+            let success = false;
+            let actionLabel = '';
+            if (approvalAction.action === 'approve') {
+                success = await detector.approveButton();
+                actionLabel = 'Allow';
+            }
+            else if (approvalAction.action === 'always_allow') {
+                success = await detector.alwaysAllowButton();
+                actionLabel = 'Allow Chat';
+            }
+            else {
+                success = await detector.denyButton();
+                actionLabel = 'Deny';
+            }
+            if (success) {
+                try {
+                    await ctx.editMessageReplyMarkup({ reply_markup: undefined });
+                }
+                catch { }
+                await ctx.answerCallbackQuery({ text: `${actionLabel} executed.` });
+            }
+            else {
+                await ctx.answerCallbackQuery({ text: 'Button not found.' });
+            }
+            return;
+        }
+        // Planning buttons
+        const planningAction = (0, cdpBridgeManager_1.parsePlanningCustomId)(data);
+        if (planningAction) {
+            const projectName = planningAction.projectName ?? bridge.lastActiveWorkspace;
+            const detector = projectName ? bridge.pool.getPlanningDetector(projectName) : undefined;
+            if (!detector) {
+                await ctx.answerCallbackQuery({ text: 'Planning detector not found.' });
+                return;
+            }
+            if (planningAction.action === 'open') {
+                const clicked = await detector.clickOpenButton();
+                if (clicked) {
+                    await new Promise(r => setTimeout(r, 500));
+                    let planContent = null;
+                    for (let attempt = 0; attempt < 3; attempt++) {
+                        planContent = await detector.extractPlanContent();
+                        if (planContent)
+                            break;
+                        await new Promise(r => setTimeout(r, 500));
+                    }
+                    if (planContent) {
+                        const truncated = planContent.length > 3800 ? planContent.substring(0, 3800) + '\n\n(truncated)' : planContent;
+                        await bot.api.sendMessage(ch.chatId, `<b>Plan Content</b>\n\n${(0, telegramFormatter_1.escapeHtml)(truncated)}`, { parse_mode: 'HTML', message_thread_id: ch.threadId });
+                    }
+                }
+                await ctx.answerCallbackQuery({ text: clicked ? 'Opened' : 'Open button not found.' });
+            }
+            else {
+                const clicked = await detector.clickProceedButton();
+                if (clicked)
+                    try {
+                        await ctx.editMessageReplyMarkup({ reply_markup: undefined });
+                    }
+                    catch { }
+                await ctx.answerCallbackQuery({ text: clicked ? 'Proceeding...' : 'Proceed button not found.' });
+            }
+            return;
+        }
+        // Error popup buttons
+        const errorAction = (0, cdpBridgeManager_1.parseErrorPopupCustomId)(data);
+        if (errorAction) {
+            const projectName = errorAction.projectName ?? bridge.lastActiveWorkspace;
+            const detector = projectName ? bridge.pool.getErrorPopupDetector(projectName) : undefined;
+            if (!detector) {
+                await ctx.answerCallbackQuery({ text: 'Error popup detector not found.' });
+                return;
+            }
+            if (errorAction.action === 'dismiss') {
+                const clicked = await detector.clickDismissButton();
+                if (clicked)
+                    try {
+                        await ctx.editMessageReplyMarkup({ reply_markup: undefined });
+                    }
+                    catch { }
+                await ctx.answerCallbackQuery({ text: clicked ? 'Dismissed' : 'Button not found.' });
+            }
+            else if (errorAction.action === 'copy_debug') {
+                const clicked = await detector.clickCopyDebugInfoButton();
+                let clipboardOk = false;
+                if (clicked) {
+                    await new Promise(r => setTimeout(r, 300));
+                    const clipboardContent = await detector.readClipboard();
+                    if (clipboardContent) {
+                        clipboardOk = true;
+                        const truncated = clipboardContent.length > 3800 ? clipboardContent.substring(0, 3800) + '\n(truncated)' : clipboardContent;
+                        await bot.api.sendMessage(ch.chatId, `<b>Debug Info</b>\n\n<pre>${(0, telegramFormatter_1.escapeHtml)(truncated)}</pre>`, { parse_mode: 'HTML', message_thread_id: ch.threadId });
+                    }
+                }
+                const feedbackText = !clicked ? 'Button not found.' : clipboardOk ? 'Copied' : 'Could not read clipboard.';
+                await ctx.answerCallbackQuery({ text: feedbackText });
+            }
+            else {
+                const clicked = await detector.clickRetryButton();
+                if (clicked)
+                    try {
+                        await ctx.editMessageReplyMarkup({ reply_markup: undefined });
+                    }
+                    catch { }
+                await ctx.answerCallbackQuery({ text: clicked ? 'Retrying...' : 'Button not found.' });
+            }
+            return;
+        }
+        // Cleanup buttons
+        if (data.startsWith(cleanupCommandHandler_1.CLEANUP_ARCHIVE_BTN) || data.startsWith(cleanupCommandHandler_1.CLEANUP_DELETE_BTN) || data === cleanupCommandHandler_1.CLEANUP_CANCEL_BTN) {
+            if (data === cleanupCommandHandler_1.CLEANUP_CANCEL_BTN) {
+                try {
+                    await ctx.editMessageText('Cleanup cancelled.');
+                }
+                catch { }
+                await ctx.answerCallbackQuery({ text: 'Cancelled' });
+                return;
+            }
+            const isDelete = data.startsWith(cleanupCommandHandler_1.CLEANUP_DELETE_BTN);
+            const callbackDays = parseInt(data.split(':')[1], 10) || 7;
+            const guildId = String(ch.chatId);
+            const inactive = cleanupHandler.findInactiveSessions(guildId, callbackDays);
+            let processed = 0;
+            for (const { binding } of inactive) {
+                const threadId = binding.channelId.includes(':')
+                    ? Number(binding.channelId.split(':')[1])
+                    : undefined;
+                if (threadId) {
+                    try {
+                        if (isDelete) {
+                            await bot.api.deleteForumTopic(ch.chatId, threadId);
+                        }
+                        else {
+                            await bot.api.closeForumTopic(ch.chatId, threadId);
+                        }
+                    }
+                    catch (e) {
+                        logger_1.logger.warn(`[Cleanup] Topic operation failed for ${binding.channelId}: ${e.message}`);
+                    }
+                }
+                cleanupHandler.cleanupByChannelId(binding.channelId);
+                processed++;
+            }
+            const action = isDelete ? 'deleted' : 'archived';
+            try {
+                await ctx.editMessageText(`✅ Cleanup complete — ${processed} session(s) ${action}.`);
+            }
+            catch { }
+            await ctx.answerCallbackQuery({ text: `${processed} session(s) ${action}` });
+            return;
+        }
+        await ctx.answerCallbackQuery();
+    });
+    // =============================================================================
+    // Text message handler (main chat flow)
+    // =============================================================================
+    bot.on('message:text', async (ctx) => {
+        const ch = getChannel(ctx);
+        const key = channelKey(ch);
+        const text = ctx.message.text.trim();
+        if (!text)
+            return;
+        // Check if it looks like a text command
+        const parsed = (0, messageParser_1.parseMessageContent)(text);
+        if (parsed.isCommand && parsed.commandName) {
+            if (parsed.commandName === 'autoaccept') {
+                const result = bridge.autoAccept.handle(parsed.args?.[0]);
+                await ctx.reply(result.message);
+                return;
+            }
+            if (parsed.commandName === 'screenshot') {
+                await (0, screenshotUi_1.handleScreenshot)(async (input, caption) => { await ctx.replyWithPhoto(input, { caption }); }, async (text) => { await ctx.reply(text); }, (0, cdpBridgeManager_1.getCurrentCdp)(bridge));
+                return;
+            }
+            if (parsed.commandName === 'status') {
+                const activeNames = bridge.pool.getActiveWorkspaceNames();
+                const currentMode = modeService.getCurrentMode();
+                let statusText = `<b>🔧 Bot Status</b>\n\n`;
+                statusText += `<b>CDP:</b> ${activeNames.length > 0 ? `🟢 ${activeNames.length} project(s)` : '⚪ Disconnected'}\n`;
+                statusText += `<b>Mode:</b> ${(0, telegramFormatter_1.escapeHtml)(modeService_1.MODE_DISPLAY_NAMES[currentMode] || currentMode)}\n`;
+                statusText += `<b>Auto Approve:</b> ${bridge.autoAccept.isEnabled() ? '🟢 ON' : '⚪ OFF'}`;
+                await replyHtml(ctx, statusText);
+                return;
+            }
+            const result = await slashCommandHandler.handleCommand(parsed.commandName, parsed.args || []);
+            await ctx.reply(result.message);
+            if (result.prompt) {
+                const cdp = (0, cdpBridgeManager_1.getCurrentCdp)(bridge);
+                if (cdp) {
+                    await promptDispatcher.send({
+                        channel: ch,
+                        prompt: result.prompt,
+                        cdp,
+                        inboundImages: [],
+                        options: { chatSessionService, chatSessionRepo, topicManager, titleGenerator },
+                    });
+                }
+                else {
+                    await ctx.reply('Not connected to CDP. Send a message first to connect to a project.');
+                }
+            }
+            return;
+        }
+        // Regular message — route to Antigravity
+        const resolved = await resolveWorkspaceAndCdp(ch);
+        if (!resolved) {
+            await ctx.reply('No project is configured for this chat. Use /project to select one.');
+            return;
+        }
+        const session = chatSessionRepo.findByChannelId(key);
+        if (session?.displayName) {
+            (0, cdpBridgeManager_1.registerApprovalSessionChannel)(bridge, resolved.projectName, session.displayName, ch);
+        }
+        if (session?.isRenamed && session.displayName) {
+            const activationResult = await chatSessionService.activateSessionByTitle(resolved.cdp, session.displayName);
+            if (!activationResult.ok) {
+                await ctx.reply(`⚠️ Could not route to session (${session.displayName}).`);
+                return;
+            }
+        }
+        else if (session && !session.isRenamed) {
+            try {
+                await chatSessionService.startNewChat(resolved.cdp);
+            }
+            catch { /* continue anyway */ }
+        }
+        const userMsgDetector = bridge.pool.getUserMessageDetector?.(resolved.projectName);
+        if (userMsgDetector)
+            userMsgDetector.addEchoHash(text);
+        await promptDispatcher.send({
+            channel: ch,
+            prompt: text,
+            cdp: resolved.cdp,
+            inboundImages: [],
+            options: { chatSessionService, chatSessionRepo, topicManager, titleGenerator },
+        });
+    });
+    // Photo message handler
+    bot.on('message:photo', async (ctx) => {
+        const ch = getChannel(ctx);
+        const photos = ctx.message.photo;
+        if (!photos || photos.length === 0)
+            return;
+        const largest = photos[photos.length - 1];
+        const caption = ctx.message.caption?.trim() || 'Please review the attached images and respond accordingly.';
+        const resolved = await resolveWorkspaceAndCdp(ch);
+        if (!resolved) {
+            await ctx.reply('No project configured. Use /project first.');
+            return;
+        }
+        const inboundImages = await (0, imageHandler_1.downloadTelegramImages)(bot.api, config.telegramBotToken, [largest], String(ctx.message.message_id));
+        try {
+            await promptDispatcher.send({
+                channel: ch,
+                prompt: caption,
+                cdp: resolved.cdp,
+                inboundImages,
+                options: { chatSessionService, chatSessionRepo, topicManager, titleGenerator },
+            });
+        }
+        finally {
+            await (0, imageHandler_1.cleanupInboundImageAttachments)(inboundImages);
+        }
+    });
+    // Voice message handler (voice-to-prompt via local Whisper transcription)
+    bot.on('message:voice', async (ctx) => {
+        const ch = getChannel(ctx);
+        const whisperIssue = (0, voiceHandler_1.checkWhisperAvailability)();
+        if (whisperIssue) {
+            await ctx.reply(whisperIssue);
+            return;
+        }
+        const resolved = await resolveWorkspaceAndCdp(ch);
+        if (!resolved) {
+            await ctx.reply('No project configured. Use /project first.');
+            return;
+        }
+        await ctx.reply('🎙️ Transcribing voice message...');
+        let voicePath;
+        try {
+            voicePath = await (0, voiceHandler_1.downloadTelegramVoice)(bot.api, config.telegramBotToken, ctx.message.voice);
+        }
+        catch (error) {
+            logger_1.logger.error('[Voice] Download failed:', error?.message || error);
+            await ctx.reply('❌ Could not download voice message. Please try again.');
+            return;
+        }
+        const transcript = await (0, voiceHandler_1.transcribeVoice)(voicePath);
+        if (!transcript) {
+            await ctx.reply('❌ Could not transcribe voice message. Please try again or type your prompt.');
+            return;
+        }
+        // Check if transcription is a slash command
+        const parsed = (0, messageParser_1.parseMessageContent)(transcript);
+        if (parsed.isCommand && parsed.commandName) {
+            const result = await slashCommandHandler.handleCommand(parsed.commandName, parsed.args || []);
+            await ctx.reply(`🎙️ "${transcript}"\n\n${result.message}`);
+            if (result.prompt) {
+                const cdp = (0, cdpBridgeManager_1.getCurrentCdp)(bridge);
+                if (cdp) {
+                    await promptDispatcher.send({
+                        channel: ch,
+                        prompt: result.prompt,
+                        cdp,
+                        inboundImages: [],
+                        options: { chatSessionService, chatSessionRepo, topicManager, titleGenerator },
+                    });
+                }
+            }
+            return;
+        }
+        await ctx.reply(`📝 "${transcript}"`);
+        const userMsgDetector = bridge.pool.getUserMessageDetector?.(resolved.projectName);
+        if (userMsgDetector)
+            userMsgDetector.addEchoHash(transcript);
+        await promptDispatcher.send({
+            channel: ch,
+            prompt: transcript,
+            cdp: resolved.cdp,
+            inboundImages: [],
+            options: { chatSessionService, chatSessionRepo, topicManager, titleGenerator },
+        });
+    });
+    logger_1.logger.info('Starting Remoat Telegram bot...');
+    // Graceful shutdown: close database on exit
+    const closeDb = () => { try {
+        db.close();
+    }
+    catch { /* ignore */ } };
+    process.on('exit', closeDb);
+    process.on('SIGINT', () => { closeDb(); process.exit(0); });
+    process.on('SIGTERM', () => { closeDb(); process.exit(0); });
+    bot.catch((err) => {
+        logger_1.logger.error('Bot error:', err);
+    });
+    await bot.start({
+        onStart: async (botInfo) => {
+            logger_1.logger.info(`Bot started as @${botInfo.username} | extractionMode=${config.extractionMode}`);
+            try {
+                await bot.api.setMyCommands([
+                    { command: 'start', description: 'Welcome message' },
+                    { command: 'help', description: 'Show all commands' },
+                    { command: 'project', description: 'Select a project' },
+                    { command: 'new', description: 'Start a new chat session' },
+                    { command: 'chat', description: 'Current session info' },
+                    { command: 'mode', description: 'Change execution mode' },
+                    { command: 'model', description: 'Change LLM model' },
+                    { command: 'stop', description: 'Interrupt active generation' },
+                    { command: 'screenshot', description: 'Capture Antigravity screen' },
+                    { command: 'template', description: 'Show prompt templates' },
+                    { command: 'template_add', description: 'Register a template' },
+                    { command: 'template_delete', description: 'Delete a template' },
+                    { command: 'autoaccept', description: 'Toggle auto-approve mode' },
+                    { command: 'status', description: 'Bot status overview' },
+                    { command: 'ping', description: 'Check latency' },
+                ]);
+                logger_1.logger.info('Telegram command menu registered successfully');
+            }
+            catch (err) {
+                logger_1.logger.error('Failed to register command menu:', err);
+            }
+        },
+    });
+};
+exports.startBot = startBot;
+//# sourceMappingURL=index.js.map