omnikey-cli 1.5.7 → 1.6.0

package/telegram-client-dist/{dist/notifyTelegram.js → notifyTelegram.js}

@@ -8,28 +8,27 @@ exports.notify = notify;
 exports.setupMessageListener = setupMessageListener;
 const node_telegram_bot_api_1 = __importDefault(require("node-telegram-bot-api"));
 const agentClient_1 = require("./agentClient");
-const db_1 = require("./db");
 let bot = null;
 function initTelegram(botToken) {
     if (!botToken)
-        throw new Error("Missing telegram bot token");
+        throw new Error('Missing telegram bot token');
     bot = new node_telegram_bot_api_1.default(botToken, { polling: true });
     return bot;
 }
 async function notify(logger, message, options = {}) {
     if (!bot) {
-        throw new Error("Telegram bot not initialized. Call initTelegram first.");
+        throw new Error('Telegram bot not initialized. Call initTelegram first.');
     }
     const chatId = options.chatId ?? process.env.TELEGRAM_CHAT_ID;
     if (!chatId) {
-        throw new Error("Missing chat ID");
+        throw new Error('Missing chat ID');
     }
-    const parseMode = options.parseMode ?? "Markdown";
+    const parseMode = options.parseMode ?? 'Markdown';
     try {
         return await bot.sendMessage(chatId, message, { parse_mode: parseMode });
     }
     catch (err) {
-        logger.error("Failed to send Telegram message:", err);
+        logger.error('Failed to send Telegram message:', err);
         throw err;
     }
 }
@@ -37,18 +36,18 @@ const pendingPrompts = new Map();
 const runningSessions = new Map();
 // Callback-data prefixes. Telegram limits callback_data to 64 bytes — using
 // short prefixes + indices keeps every payload comfortably under the cap.
-const CB_SESSION = "s:"; // session picker; "s:new" or "s:<idx>"
-const CB_INSTRUCTION = "t:"; // instruction picker; "t:skip" or "t:<idx>"
-const CB_PROJECT = "g:"; // project picker;     "g:skip" or "g:<idx>"
-const CB_CANCEL = "x:cancel";
+const CB_SESSION = 's:'; // session picker; "s:new" or "s:<idx>"
+const CB_INSTRUCTION = 't:'; // instruction picker; "t:skip" or "t:<idx>"
+const CB_PROJECT = 'g:'; // project picker;     "g:skip" or "g:<idx>"
+const CB_CANCEL = 'x:cancel';
 function isAuthorizedChat(chatId) {
-    const allowed = parseInt(process.env.TELEGRAM_CHAT_ID || "0", 10);
+    const allowed = parseInt(process.env.TELEGRAM_CHAT_ID || '0', 10);
     return allowed !== 0 && chatId === allowed;
 }
 function truncate(text, max) {
     if (text.length <= max)
         return text;
-    return text.slice(0, max - 1) + "…";
+    return text.slice(0, max - 1) + '…';
 }
 /**
  * Strip XML-ish agent tags, code fences, markdown emphasis, and collapse
@@ -56,14 +55,14 @@ function truncate(text, max) {
  */
 function cleanForTelegram(text) {
     return text
-        .replace(/<\/?(?:shell_script|final_answer|user_input|stored_instructions|project_context|shell_function_calls)[^>]*>/gi, "")
-        .replace(/```[a-zA-Z0-9_-]*\n?/g, "")
-        .replace(/```/g, "")
-        .replace(/\*\*([^*]+)\*\*/g, "$1")
-        .replace(/\*([^*\n]+)\*/g, "$1")
-        .replace(/`([^`\n]+)`/g, "$1")
-        .replace(/[ \t]+\n/g, "\n")
-        .replace(/\n{3,}/g, "\n\n")
+        .replace(/<\/?(?:shell_script|final_answer|user_input|stored_instructions|project_context|shell_function_calls)[^>]*>/gi, '')
+        .replace(/```[a-zA-Z0-9_-]*\n?/g, '')
+        .replace(/```/g, '')
+        .replace(/\*\*([^*]+)\*\*/g, '$1')
+        .replace(/\*([^*\n]+)\*/g, '$1')
+        .replace(/`([^`\n]+)`/g, '$1')
+        .replace(/[ \t]+\n/g, '\n')
+        .replace(/\n{3,}/g, '\n\n')
         .trim();
 }
 /**
@@ -75,11 +74,11 @@ function cleanForTelegram(text) {
  * <pre><code class="language-...">, <a href="...">, <blockquote>.
  */
 function escapeHtml(s) {
-    return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+    return s.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
 }
 function markdownToTelegramHtml(input) {
     // Strip agent envelope tags but preserve the body's markdown.
-    let text = input.replace(/<\/?(?:shell_script|final_answer|user_input|stored_instructions|project_context|shell_function_calls)[^>]*>/gi, "");
+    let text = input.replace(/<\/?(?:shell_script|final_answer|user_input|stored_instructions|project_context|shell_function_calls)[^>]*>/gi, '');
     // 1. Extract fenced code blocks and inline code into placeholders so
     //    subsequent transforms do not corrupt their contents.
     const placeholders = [];
@@ -88,8 +87,8 @@ function markdownToTelegramHtml(input) {
         return `\u0000PH${idx}\u0000`;
     };
     text = text.replace(/```([a-zA-Z0-9_+.-]*)\n?([\s\S]*?)```/g, (_m, lang, body) => {
-        const cls = lang ? ` class="language-${escapeHtml(lang)}"` : "";
-        return stash(`<pre><code${cls}>${escapeHtml(body.replace(/\n$/, ""))}</code></pre>`);
+        const cls = lang ? ` class="language-${escapeHtml(lang)}"` : '';
+        return stash(`<pre><code${cls}>${escapeHtml(body.replace(/\n$/, ''))}</code></pre>`);
     });
     text = text.replace(/`([^`\n]+)`/g, (_m, body) => stash(`<code>${escapeHtml(body)}</code>`));
     // 1b. GFM tables → fixed-width <pre> blocks (Telegram HTML has no <table>).
@@ -98,15 +97,15 @@ function markdownToTelegramHtml(input) {
     text = text.replace(/(^|\n)([^\n]*\|[^\n]*)\n[ \t]*\|?[ \t]*:?-{2,}:?[ \t]*(?:\|[ \t]*:?-{2,}:?[ \t]*)+\|?[ \t]*\n((?:[^\n]*\|[^\n]*(?:\n|$))+)/g, (_m, lead, header, body) => {
         const splitRow = (row) => {
             let r = row.trim();
-            if (r.startsWith("|"))
+            if (r.startsWith('|'))
                 r = r.slice(1);
-            if (r.endsWith("|"))
+            if (r.endsWith('|'))
                 r = r.slice(0, -1);
-            return r.split("|").map((c) => c.trim());
+            return r.split('|').map((c) => c.trim());
         };
         const headerCells = splitRow(header);
         const bodyRows = body
-            .split("\n")
+            .split('\n')
             .map((l) => l.trim())
             .filter((l) => l.length > 0)
             .map(splitRow);
@@ -114,16 +113,16 @@ function markdownToTelegramHtml(input) {
         const pad = (cells) => {
             const out = cells.slice();
             while (out.length < colCount)
-                out.push("");
+                out.push('');
             return out;
         };
         const allRows = [pad(headerCells), ...bodyRows.map(pad)];
         // Strip inline markdown that won't render inside <pre>.
         const cleanCell = (s) => s
-            .replace(/\*\*([^*]+)\*\*/g, "$1")
-            .replace(/__([^_]+)__/g, "$1")
-            .replace(/`([^`]+)`/g, "$1")
-            .replace(/\[([^\]]+)\]\([^)]+\)/g, "$1");
+            .replace(/\*\*([^*]+)\*\*/g, '$1')
+            .replace(/__([^_]+)__/g, '$1')
+            .replace(/`([^`]+)`/g, '$1')
+            .replace(/\[([^\]]+)\]\([^)]+\)/g, '$1');
         const cleaned = allRows.map((row) => row.map(cleanCell));
         const widths = [];
         for (let c = 0; c < colCount; c++) {
@@ -132,45 +131,45 @@ function markdownToTelegramHtml(input) {
                 w = Math.max(w, row[c]?.length ?? 0);
             widths[c] = w;
         }
-        const renderRow = (row) => row.map((cell, i) => cell.padEnd(widths[i], " ")).join(" │ ");
-        const sep = widths.map((w) => "─".repeat(w)).join("─┼─");
+        const renderRow = (row) => row.map((cell, i) => cell.padEnd(widths[i], ' ')).join(' │ ');
+        const sep = widths.map((w) => '─'.repeat(w)).join('─┼─');
         const lines = [];
         lines.push(renderRow(cleaned[0]));
         lines.push(sep);
         for (let i = 1; i < cleaned.length; i++)
             lines.push(renderRow(cleaned[i]));
-        return `${lead}${stash(`<pre>${escapeHtml(lines.join("\n"))}</pre>`)}\n`;
+        return `${lead}${stash(`<pre>${escapeHtml(lines.join('\n'))}</pre>`)}\n`;
     });
     // 2. Everything outside code is HTML-escaped now.
     text = escapeHtml(text);
     // 3. Inline-link conversion before emphasis so the URL never gets italicised.
     text = text.replace(/\[([^\]]+)\]\(([^)\s]+)\)/g, (_m, label, href) => `<a href="${href}">${label}</a>`);
     // 4. Bold / italic / strike-through. Order matters — handle ** before *.
-    text = text.replace(/\*\*([^\n*]+)\*\*/g, "<b>$1</b>");
-    text = text.replace(/__([^\n_]+)__/g, "<b>$1</b>");
-    text = text.replace(/(^|[^*])\*([^\n*]+)\*(?!\*)/g, "$1<i>$2</i>");
-    text = text.replace(/(^|[^_])_([^\n_]+)_(?!_)/g, "$1<i>$2</i>");
-    text = text.replace(/~~([^\n~]+)~~/g, "<s>$1</s>");
+    text = text.replace(/\*\*([^\n*]+)\*\*/g, '<b>$1</b>');
+    text = text.replace(/__([^\n_]+)__/g, '<b>$1</b>');
+    text = text.replace(/(^|[^*])\*([^\n*]+)\*(?!\*)/g, '$1<i>$2</i>');
+    text = text.replace(/(^|[^_])_([^\n_]+)_(?!_)/g, '$1<i>$2</i>');
+    text = text.replace(/~~([^\n~]+)~~/g, '<s>$1</s>');
     // 5. Headings (#, ##, ###) → bold line. Telegram has no real heading style.
-    text = text.replace(/^[ \t]*#{1,6}[ \t]+(.+)$/gm, "<b>$1</b>");
+    text = text.replace(/^[ \t]*#{1,6}[ \t]+(.+)$/gm, '<b>$1</b>');
     // 6. Bullet lists: turn "- " / "* " / "+ " into "• ".
-    text = text.replace(/^[ \t]*[-*+][ \t]+/gm, "• ");
+    text = text.replace(/^[ \t]*[-*+][ \t]+/gm, '• ');
     // 7. Block quotes — Telegram supports <blockquote>.
     text = text.replace(/(^|\n)((?:&gt; .*(?:\n|$))+)/g, (_m, lead, block) => {
         const inner = block
             .split(/\n/)
             .filter((l) => l.length)
-            .map((l) => l.replace(/^&gt; ?/, ""))
-            .join("\n");
+            .map((l) => l.replace(/^&gt; ?/, ''))
+            .join('\n');
         return `${lead}<blockquote>${inner}</blockquote>\n`;
     });
     // 8. Collapse trailing whitespace and excessive blank lines.
     text = text
-        .replace(/[ \t]+\n/g, "\n")
-        .replace(/\n{3,}/g, "\n\n")
+        .replace(/[ \t]+\n/g, '\n')
+        .replace(/\n{3,}/g, '\n\n')
         .trim();
     // 9. Restore the stashed code segments.
-    text = text.replace(/\u0000PH(\d+)\u0000/g, (_m, idx) => placeholders[Number(idx)] ?? "");
+    text = text.replace(/\u0000PH(\d+)\u0000/g, (_m, idx) => placeholders[Number(idx)] ?? '');
     return text;
 }
 /**
@@ -183,11 +182,11 @@ function splitForTelegram(html, max = 3800) {
         return [html];
     const chunks = [];
     const paragraphs = html.split(/\n\n+/);
-    let current = "";
+    let current = '';
     const flush = () => {
         if (current.trim())
             chunks.push(current.trim());
-        current = "";
+        current = '';
     };
     for (const p of paragraphs) {
         if (p.length > max) {
@@ -200,7 +199,7 @@ function splitForTelegram(html, max = 3800) {
         if (current.length + p.length + 2 > max) {
             flush();
         }
-        current += (current ? "\n\n" : "") + p;
+        current += (current ? '\n\n' : '') + p;
     }
     flush();
     return chunks;
@@ -208,7 +207,7 @@ function splitForTelegram(html, max = 3800) {
 // ─── Inline-keyboard builders ────────────────────────────────────────────────
 function buildSessionKeyboard(sessions) {
     const rows = [
-        [{ text: "🆕  New session", callback_data: `${CB_SESSION}new` }],
+        [{ text: '🆕  New session', callback_data: `${CB_SESSION}new` }],
     ];
     sessions.forEach((s, idx) => {
         const label = truncate(s.title || s.id, 48);
@@ -219,13 +218,13 @@ function buildSessionKeyboard(sessions) {
             },
         ]);
     });
-    rows.push([{ text: "✕  Cancel", callback_data: CB_CANCEL }]);
+    rows.push([{ text: '✕  Cancel', callback_data: CB_CANCEL }]);
     return rows;
 }
 function buildInstructionKeyboard(templates) {
     const rows = [];
     templates.forEach((t, idx) => {
-        const marker = t.isDefault ? "⭐" : "📝";
+        const marker = t.isDefault ? '⭐' : '📝';
         rows.push([
             {
                 text: `${marker}  ${truncate(t.heading, 50)}`,
@@ -233,10 +232,8 @@ function buildInstructionKeyboard(templates) {
             },
         ]);
     });
-    rows.push([
-        { text: "⏭  Skip instructions", callback_data: `${CB_INSTRUCTION}skip` },
-    ]);
-    rows.push([{ text: "✕  Cancel", callback_data: CB_CANCEL }]);
+    rows.push([{ text: '⏭  Skip instructions', callback_data: `${CB_INSTRUCTION}skip` }]);
+    rows.push([{ text: '✕  Cancel', callback_data: CB_CANCEL }]);
     return rows;
 }
 function buildProjectKeyboard(groups) {
@@ -249,94 +246,82 @@ function buildProjectKeyboard(groups) {
             },
         ]);
     });
-    rows.push([{ text: "⏭  Skip project", callback_data: `${CB_PROJECT}skip` }]);
-    rows.push([{ text: "✕  Cancel", callback_data: CB_CANCEL }]);
+    rows.push([{ text: '⏭  Skip project', callback_data: `${CB_PROJECT}skip` }]);
+    rows.push([{ text: '✕  Cancel', callback_data: CB_CANCEL }]);
     return rows;
 }
 function renderInstructionStep(state) {
     if (state.templates.length === 0) {
         return {
             text: [
-                "*Step 1 of 3 · Task instructions*",
-                "",
-                "_No saved templates. Skip to continue._",
-            ].join("\n"),
+                '*Step 1 of 3 · Task instructions*',
+                '',
+                '_No saved templates. Skip to continue._',
+            ].join('\n'),
             keyboard: [
                 [
                     {
-                        text: "⏭  Skip instructions",
+                        text: '⏭  Skip instructions',
                         callback_data: `${CB_INSTRUCTION}skip`,
                     },
                 ],
-                [{ text: "✕  Cancel", callback_data: CB_CANCEL }],
+                [{ text: '✕  Cancel', callback_data: CB_CANCEL }],
             ],
         };
     }
     return {
         text: [
-            "*Step 1 of 3 · Task instructions*",
-            "",
-            "Pick a saved template to prepend to your prompt, or skip.",
-        ].join("\n"),
+            '*Step 1 of 3 · Task instructions*',
+            '',
+            'Pick a saved template to prepend to your prompt, or skip.',
+        ].join('\n'),
         keyboard: buildInstructionKeyboard(state.templates),
     };
 }
 function renderProjectStep(state) {
     const heading = state.chosenInstructionsHeading
         ? `✓ Instructions: *${state.chosenInstructionsHeading}*`
-        : "✓ Instructions: _skipped_";
+        : '✓ Instructions: _skipped_';
     if (state.groups.length === 0) {
         return {
-            text: [
-                "*Step 2 of 3 · Project*",
-                heading,
-                "",
-                "_No projects yet. Skip to continue._",
-            ].join("\n"),
+            text: ['*Step 2 of 3 · Project*', heading, '', '_No projects yet. Skip to continue._'].join('\n'),
             keyboard: [
-                [{ text: "⏭  Skip project", callback_data: `${CB_PROJECT}skip` }],
-                [{ text: "✕  Cancel", callback_data: CB_CANCEL }],
+                [{ text: '⏭  Skip project', callback_data: `${CB_PROJECT}skip` }],
+                [{ text: '✕  Cancel', callback_data: CB_CANCEL }],
             ],
         };
     }
     return {
-        text: [
-            "*Step 2 of 3 · Project*",
-            heading,
-            "",
-            "Pick a project for context, or skip.",
-        ].join("\n"),
+        text: ['*Step 2 of 3 · Project*', heading, '', 'Pick a project for context, or skip.'].join('\n'),
         keyboard: buildProjectKeyboard(state.groups),
     };
 }
 function renderPromptStep(state) {
     const lines = [
-        "*Step 3 of 3 · Prompt*",
+        '*Step 3 of 3 · Prompt*',
         state.chosenInstructionsHeading
             ? `✓ Instructions: *${state.chosenInstructionsHeading}*`
-            : "✓ Instructions: _skipped_",
-        state.chosenGroupName
-            ? `✓ Project: *${state.chosenGroupName}*`
-            : "✓ Project: _skipped_",
-        "",
-        "Send your prompt as the next message.",
+            : '✓ Instructions: _skipped_',
+        state.chosenGroupName ? `✓ Project: *${state.chosenGroupName}*` : '✓ Project: _skipped_',
+        '',
+        'Send your prompt as the next message.',
     ];
     return {
-        text: lines.join("\n"),
-        keyboard: [[{ text: "✕  Cancel", callback_data: CB_CANCEL }]],
+        text: lines.join('\n'),
+        keyboard: [[{ text: '✕  Cancel', callback_data: CB_CANCEL }]],
     };
 }
 async function showStep(logger, chatId, state) {
     if (!bot)
         return;
-    const copy = state.phase === "selectInstruction"
+    const copy = state.phase === 'selectInstruction'
         ? renderInstructionStep(state)
-        : state.phase === "selectProject"
+        : state.phase === 'selectProject'
             ? renderProjectStep(state)
             : renderPromptStep(state);
     if (state.wizardMessageId == null) {
         const sent = await bot.sendMessage(chatId, copy.text, {
-            parse_mode: "Markdown",
+            parse_mode: 'Markdown',
             reply_markup: { inline_keyboard: copy.keyboard },
         });
         state.wizardMessageId = sent.message_id;
@@ -346,17 +331,17 @@ async function showStep(logger, chatId, state) {
         await bot.editMessageText(copy.text, {
             chat_id: chatId,
             message_id: state.wizardMessageId,
-            parse_mode: "Markdown",
+            parse_mode: 'Markdown',
             reply_markup: { inline_keyboard: copy.keyboard },
         });
     }
     catch (err) {
         // Fall back to a fresh message if the previous one is no longer editable.
-        logger.warn("Failed to edit wizard message; sending a new one", {
+        logger.warn('Failed to edit wizard message; sending a new one', {
             error: err.message,
         });
         const sent = await bot.sendMessage(chatId, copy.text, {
-            parse_mode: "Markdown",
+            parse_mode: 'Markdown',
             reply_markup: { inline_keyboard: copy.keyboard },
         });
         state.wizardMessageId = sent.message_id;
@@ -369,7 +354,7 @@ async function finishWizardMessage(chatId, state, finalText) {
         await bot.editMessageText(finalText, {
             chat_id: chatId,
             message_id: state.wizardMessageId,
-            parse_mode: "Markdown",
+            parse_mode: 'Markdown',
             reply_markup: { inline_keyboard: [] },
         });
     }
@@ -380,16 +365,16 @@ async function finishWizardMessage(chatId, state, finalText) {
 // ─── Pickers / commands ──────────────────────────────────────────────────────
 async function sendSessionPicker(logger, chatId, sessions, verbose) {
     if (!bot)
-        throw new Error("Bot not initialized");
-    const verboseTag = verbose ? " · 🔍 _verbose_" : "";
+        throw new Error('Bot not initialized');
+    const verboseTag = verbose ? ' · 🔍 _verbose_' : '';
     const text = sessions.length === 0
         ? `*OmniKey Agent*${verboseTag}\n\nNo previous sessions. Start a new one?`
         : `*OmniKey Agent*${verboseTag}\n\nResume a recent session or start fresh:`;
     await bot.sendMessage(chatId, text, {
-        parse_mode: "Markdown",
+        parse_mode: 'Markdown',
         reply_markup: { inline_keyboard: buildSessionKeyboard(sessions) },
     });
-    logger.info("Sent /cmd session picker", {
+    logger.info('Sent /cmd session picker', {
         chatId,
         count: sessions.length,
         verbose,
@@ -405,7 +390,7 @@ async function handleCmdCommand(logger, chatId, verbose) {
         await sendSessionPicker(logger, chatId, sessions, verbose);
     }
     catch (err) {
-        logger.error("Failed to list recent sessions", {
+        logger.error('Failed to list recent sessions', {
             error: err.message,
         });
         await notify(logger, `❌ Failed to load sessions: ${err.message}`, { chatId });
@@ -428,14 +413,30 @@ async function handleTaskCommand(logger, chatId) {
     }
     // 2. Otherwise show final answer from the most recent completed session.
     try {
-        const session = (0, db_1.getMostRecentSession)();
+        const sessions = await (0, agentClient_1.listRecentSessions)(logger, 1);
+        const session = sessions[0];
         if (!session) {
-            await notify(logger, "🗒️ No sessions found.", { chatId });
+            await notify(logger, '🗒️ No sessions found.', { chatId });
             return;
         }
-        const finalAnswer = (0, agentClient_1.extractFinalAnswerFromHistory)(session.historyJson);
+        const messages = await (0, agentClient_1.getSessionMessages)(logger, session.id);
+        let finalAnswer = null;
+        if (messages) {
+            for (let i = messages.length - 1; i >= 0; i--) {
+                const msg = messages[i];
+                if (msg.role !== 'assistant')
+                    continue;
+                const block = msg.blocks?.find((b) => b.kind === 'finalAnswer');
+                if (block) {
+                    finalAnswer = block.text;
+                    break;
+                }
+            }
+        }
         if (!finalAnswer) {
-            await notify(logger, `🗒️ Most recent session \`${session.id}\` has no final answer yet.`, { chatId });
+            await notify(logger, `🗒️ Most recent session \`${session.id}\` has no final answer yet.`, {
+                chatId,
+            });
             return;
         }
         const title = session.title || session.id;
@@ -447,20 +448,20 @@ async function handleTaskCommand(logger, chatId) {
         for (const chunk of chunks) {
             try {
                 await bot.sendMessage(chatId, chunk, {
-                    parse_mode: "HTML",
+                    parse_mode: 'HTML',
                     disable_web_page_preview: true,
                 });
             }
             catch (err) {
-                logger.warn("HTML render failed for /task; falling back to plain", {
+                logger.warn('HTML render failed for /task; falling back to plain', {
                     error: err.message,
                 });
-                await bot.sendMessage(chatId, chunk.replace(/<[^>]+>/g, ""));
+                await bot.sendMessage(chatId, chunk.replace(/<[^>]+>/g, ''));
             }
         }
     }
     catch (err) {
-        logger.error("Failed to handle /task", { error: err.message });
+        logger.error('Failed to handle /task', { error: err.message });
         await notify(logger, `❌ /task failed: ${err.message}`, {
             chatId,
         });
@@ -474,13 +475,13 @@ async function startNewSessionWizard(logger, chatId) {
     try {
         [templates, groups] = await Promise.all([
             (0, agentClient_1.listTaskTemplates)(logger).catch((e) => {
-                logger.warn("Failed to load task templates", {
+                logger.warn('Failed to load task templates', {
                     error: e.message,
                 });
                 return [];
             }),
             (0, agentClient_1.listProjectGroups)(logger).catch((e) => {
-                logger.warn("Failed to load project groups", {
+                logger.warn('Failed to load project groups', {
                     error: e.message,
                 });
                 return [];
@@ -488,12 +489,12 @@ async function startNewSessionWizard(logger, chatId) {
         ]);
     }
     catch (err) {
-        logger.error("Failed to load wizard data", {
+        logger.error('Failed to load wizard data', {
             error: err.message,
         });
     }
     const state = {
-        phase: "selectInstruction",
+        phase: 'selectInstruction',
         sessionId: null,
         wizardMessageId: null,
         templates,
@@ -511,7 +512,7 @@ async function startResumeSession(logger, chatId, sessionId) {
         return;
     const verbose = pendingVerbose.get(chatId) ?? false;
     const state = {
-        phase: "awaitPrompt",
+        phase: 'awaitPrompt',
         sessionId,
         wizardMessageId: null,
         templates: [],
@@ -523,23 +524,23 @@ async function startResumeSession(logger, chatId, sessionId) {
     };
     pendingPrompts.set(chatId, state);
     await bot.sendMessage(chatId, [
-        `*Resuming session* \`${sessionId}\`${verbose ? " · 🔍 _verbose_" : ""}`,
-        "",
-        "Send your prompt as the next message.",
-    ].join("\n"), {
-        parse_mode: "Markdown",
+        `*Resuming session* \`${sessionId}\`${verbose ? ' · 🔍 _verbose_' : ''}`,
+        '',
+        'Send your prompt as the next message.',
+    ].join('\n'), {
+        parse_mode: 'Markdown',
         reply_markup: {
-            inline_keyboard: [[{ text: "✕  Cancel", callback_data: CB_CANCEL }]],
+            inline_keyboard: [[{ text: '✕  Cancel', callback_data: CB_CANCEL }]],
         },
     });
 }
 async function handleCallbackQuery(logger, query) {
     if (!bot)
         return;
-    const data = query.data || "";
+    const data = query.data || '';
     const chatId = query.message?.chat.id;
     if (!chatId || !isAuthorizedChat(chatId)) {
-        await bot.answerCallbackQuery(query.id, { text: "Unauthorized" });
+        await bot.answerCallbackQuery(query.id, { text: 'Unauthorized' });
         return;
     }
     // Cancel from anywhere — clear state and acknowledge.
@@ -549,15 +550,15 @@ async function handleCallbackQuery(logger, query) {
         sessionListCache.delete(chatId);
         pendingVerbose.delete(chatId);
         if (state?.wizardMessageId) {
-            await finishWizardMessage(chatId, state, "✕  Cancelled.");
+            await finishWizardMessage(chatId, state, '✕  Cancelled.');
         }
-        await bot.answerCallbackQuery(query.id, { text: "Cancelled" });
+        await bot.answerCallbackQuery(query.id, { text: 'Cancelled' });
         return;
     }
     // Step 0 — session picker
     if (data.startsWith(CB_SESSION)) {
         const tok = data.slice(CB_SESSION.length);
-        if (tok === "new") {
+        if (tok === 'new') {
             await bot.answerCallbackQuery(query.id);
             await startNewSessionWizard(logger, chatId);
             return;
@@ -567,7 +568,7 @@ async function handleCallbackQuery(logger, query) {
         const chosen = Number.isInteger(idx) ? sessions[idx] : undefined;
         if (!chosen) {
             await bot.answerCallbackQuery(query.id, {
-                text: "Session no longer available",
+                text: 'Session no longer available',
             });
             return;
         }
@@ -578,12 +579,12 @@ async function handleCallbackQuery(logger, query) {
     // Step 1 — instruction picker
     if (data.startsWith(CB_INSTRUCTION)) {
         const state = pendingPrompts.get(chatId);
-        if (!state || state.phase !== "selectInstruction") {
-            await bot.answerCallbackQuery(query.id, { text: "Step expired" });
+        if (!state || state.phase !== 'selectInstruction') {
+            await bot.answerCallbackQuery(query.id, { text: 'Step expired' });
             return;
         }
         const tok = data.slice(CB_INSTRUCTION.length);
-        if (tok === "skip") {
+        if (tok === 'skip') {
             state.chosenInstructions = null;
             state.chosenInstructionsHeading = null;
         }
@@ -591,7 +592,7 @@ async function handleCallbackQuery(logger, query) {
             const idx = Number(tok);
             const t = state.templates[idx];
             if (!t) {
-                await bot.answerCallbackQuery(query.id, { text: "Template not found" });
+                await bot.answerCallbackQuery(query.id, { text: 'Template not found' });
                 return;
             }
             // Don't prepend the body to the user prompt — instead promote this
@@ -605,17 +606,17 @@ async function handleCallbackQuery(logger, query) {
                 state.chosenInstructionsHeading = t.heading;
             }
             catch (err) {
-                logger.error("Failed to set default task template", {
+                logger.error('Failed to set default task template', {
                     templateId: t.id,
                     error: err.message,
                 });
                 await bot.answerCallbackQuery(query.id, {
-                    text: "Failed to set default",
+                    text: 'Failed to set default',
                 });
                 return;
             }
         }
-        state.phase = "selectProject";
+        state.phase = 'selectProject';
         await bot.answerCallbackQuery(query.id);
         await showStep(logger, chatId, state);
         return;
@@ -623,24 +624,24 @@ async function handleCallbackQuery(logger, query) {
     // Step 2 — project picker
     if (data.startsWith(CB_PROJECT)) {
         const state = pendingPrompts.get(chatId);
-        if (!state || state.phase !== "selectProject") {
-            await bot.answerCallbackQuery(query.id, { text: "Step expired" });
+        if (!state || state.phase !== 'selectProject') {
+            await bot.answerCallbackQuery(query.id, { text: 'Step expired' });
             return;
         }
         const tok = data.slice(CB_PROJECT.length);
-        if (tok === "skip") {
+        if (tok === 'skip') {
             state.chosenGroupName = null;
         }
         else {
             const idx = Number(tok);
             const g = state.groups[idx];
             if (!g) {
-                await bot.answerCallbackQuery(query.id, { text: "Project not found" });
+                await bot.answerCallbackQuery(query.id, { text: 'Project not found' });
                 return;
             }
             state.chosenGroupName = g.groupName;
         }
-        state.phase = "awaitPrompt";
+        state.phase = 'awaitPrompt';
         await bot.answerCallbackQuery(query.id);
         await showStep(logger, chatId, state);
         return;
@@ -650,23 +651,21 @@ async function handleCallbackQuery(logger, query) {
 async function runAgentForChat(logger, chatId, pending, prompt) {
     pendingPrompts.delete(chatId);
     if (runningSessions.has(chatId)) {
-        await notify(logger, "⏳ A session is already running. Wait for it to finish.", { chatId });
+        await notify(logger, '⏳ A session is already running. Wait for it to finish.', { chatId });
         return;
     }
     // Mark the wizard as resolved so the user sees a clean trail of choices.
     if (pending.wizardMessageId) {
         const summary = [
-            "✅ *Session started*",
+            '✅ *Session started*',
             pending.chosenInstructionsHeading
                 ? `📝 Instructions: *${pending.chosenInstructionsHeading}*`
-                : "📝 Instructions: _none_",
-            pending.chosenGroupName
-                ? `📁 Project: *${pending.chosenGroupName}*`
-                : "📁 Project: _none_",
-            pending.verbose ? "🔍 Verbose: *on*" : "",
+                : '📝 Instructions: _none_',
+            pending.chosenGroupName ? `📁 Project: *${pending.chosenGroupName}*` : '📁 Project: _none_',
+            pending.verbose ? '🔍 Verbose: *on*' : '',
         ]
             .filter(Boolean)
-            .join("\n");
+            .join('\n');
         await finishWizardMessage(chatId, pending, summary);
     }
     // The selected task template is already promoted to default on the
@@ -674,7 +673,7 @@ async function runAgentForChat(logger, chatId, pending, prompt) {
     // stored_instructions on the server side. We send the user's prompt
     // verbatim — no preamble injection here.
     const composedPrompt = prompt;
-    const placeholderId = pending.sessionId ?? "(new)";
+    const placeholderId = pending.sessionId ?? '(new)';
     const abortController = new AbortController();
     const state = {
         sessionId: placeholderId,
@@ -684,7 +683,7 @@ async function runAgentForChat(logger, chatId, pending, prompt) {
         stoppedByUser: false,
     };
     runningSessions.set(chatId, state);
-    await notify(logger, "🚀 Starting agent run… (send /stop to cancel)", {
+    await notify(logger, '🚀 Starting agent run… (send /stop to cancel)', {
         chatId,
     });
     const REASONING_MAX = 1200;
@@ -696,7 +695,7 @@ async function runAgentForChat(logger, chatId, pending, prompt) {
             await bot.sendMessage(chatId, body);
         }
         catch (e) {
-            logger.warn("Failed to forward block to telegram", {
+            logger.warn('Failed to forward block to telegram', {
                 error: e.message,
             });
         }
@@ -706,20 +705,20 @@ async function runAgentForChat(logger, chatId, pending, prompt) {
             return;
         try {
             await bot.sendMessage(chatId, body, {
-                parse_mode: "HTML",
+                parse_mode: 'HTML',
                 disable_web_page_preview: true,
             });
         }
         catch (e) {
             // Fall back to plain text if Telegram rejects the HTML payload.
-            logger.warn("HTML render failed; falling back to plain text", {
+            logger.warn('HTML render failed; falling back to plain text', {
                 error: e.message,
             });
             try {
-                await bot.sendMessage(chatId, body.replace(/<[^>]+>/g, ""));
+                await bot.sendMessage(chatId, body.replace(/<[^>]+>/g, ''));
             }
             catch (e2) {
-                logger.warn("Plain-text fallback also failed", {
+                logger.warn('Plain-text fallback also failed', {
                     error: e2.message,
                 });
             }
@@ -732,7 +731,7 @@ async function runAgentForChat(logger, chatId, pending, prompt) {
             groupName: pending.chosenGroupName ?? undefined,
             signal: abortController.signal,
             onBlock: async (block) => {
-                if (block.kind === "reasoning") {
+                if (block.kind === 'reasoning') {
                     const cleaned = cleanForTelegram(block.text);
                     if (!cleaned)
                         return;
@@ -740,11 +739,11 @@ async function runAgentForChat(logger, chatId, pending, prompt) {
                     if (cleaned === lastSent)
                         return;
                     lastSent = cleaned;
-                    const prefix = pending.verbose ? "💭 " : "";
+                    const prefix = pending.verbose ? '💭 ' : '';
                     await sendPlain(prefix + truncate(cleaned, REASONING_MAX));
                     return;
                 }
-                if (block.kind === "finalAnswer") {
+                if (block.kind === 'finalAnswer') {
                     // finalAnswer — render markdown as Telegram HTML and split into
                     // 4096-char-safe chunks so long answers are never truncated.
                     const html = markdownToTelegramHtml(block.text);
@@ -763,29 +762,29 @@ async function runAgentForChat(logger, chatId, pending, prompt) {
                     return;
                 const VERBOSE_MAX = 1500;
                 switch (block.kind) {
-                    case "shellCommand": {
+                    case 'shellCommand': {
                         const body = truncate(block.text.trim(), VERBOSE_MAX);
                         await sendHtml(`🛠 <b>Shell command</b>\n<pre><code class="language-bash">${escapeHtml(body)}</code></pre>`);
                         return;
                     }
-                    case "terminalOutput": {
+                    case 'terminalOutput': {
                         const body = truncate(block.text.trim(), VERBOSE_MAX);
                         if (!body)
                             return;
                         await sendHtml(`📤 <b>Terminal output</b>\n<pre>${escapeHtml(body)}</pre>`);
                         return;
                     }
-                    case "webCall": {
+                    case 'webCall': {
                         const body = truncate(cleanForTelegram(block.text) || block.text, VERBOSE_MAX);
                         await sendHtml(`🌐 <b>Web call</b>\n${escapeHtml(body)}`);
                         return;
                     }
-                    case "mcpCall": {
+                    case 'mcpCall': {
                         const body = truncate(cleanForTelegram(block.text) || block.text, VERBOSE_MAX);
                         await sendHtml(`🔌 <b>MCP call</b>\n${escapeHtml(body)}`);
                         return;
                     }
-                    case "imageRendering": {
+                    case 'imageRendering': {
                         const body = truncate(cleanForTelegram(block.text) || block.text, VERBOSE_MAX);
                         await sendHtml(`🖼 <b>Image</b>\n${escapeHtml(body)}`);
                         return;
@@ -794,21 +793,23 @@ async function runAgentForChat(logger, chatId, pending, prompt) {
             },
         });
         state.sessionId = result.sessionId;
-        logger.info("Agent run completed", {
+        logger.info('Agent run completed', {
             chatId,
             sessionId: result.sessionId,
         });
     }
     catch (err) {
         if (err instanceof agentClient_1.AgentAbortError || state.stoppedByUser) {
-            logger.info("Agent run stopped by user", {
+            logger.info('Agent run stopped by user', {
                 chatId,
                 sessionId: state.sessionId,
             });
-            await notify(logger, `🛑 Agent run stopped by user (session \`${state.sessionId}\`).`, { chatId });
+            await notify(logger, `🛑 Agent run stopped by user (session \`${state.sessionId}\`).`, {
+                chatId,
+            });
         }
         else {
-            logger.error("Agent run failed", { error: err.message });
+            logger.error('Agent run failed', { error: err.message });
             await notify(logger, `❌ Agent run failed: ${err.message}`, {
                 chatId,
             });
@@ -822,72 +823,70 @@ async function runAgentForChat(logger, chatId, pending, prompt) {
 async function handleStopCommand(logger, chatId) {
     const running = runningSessions.get(chatId);
     if (!running) {
-        await notify(logger, "🛑 No agent session is currently running.", {
+        await notify(logger, '🛑 No agent session is currently running.', {
             chatId,
         });
         return;
     }
     if (running.abortController.signal.aborted) {
-        await notify(logger, "⏳ Stop already requested — waiting for shutdown…", {
+        await notify(logger, '⏳ Stop already requested — waiting for shutdown…', {
             chatId,
         });
         return;
     }
     running.stoppedByUser = true;
     running.abortController.abort();
-    logger.info("User requested agent stop", {
+    logger.info('User requested agent stop', {
         chatId,
         sessionId: running.sessionId,
     });
     await notify(logger, `🛑 Stop requested for session \`${running.sessionId}\`.`, { chatId });
 }
 function setupMessageListener(logger, bot) {
-    bot.on("callback_query", (q) => {
+    bot.on('callback_query', (q) => {
         void handleCallbackQuery(logger, q).catch((err) => {
-            logger.error("callback_query handler crashed", {
+            logger.error('callback_query handler crashed', {
                 error: err.message,
             });
         });
     });
-    bot.on("message", async (msg) => {
+    bot.on('message', async (msg) => {
         const chatId = msg.chat.id;
         if (!isAuthorizedChat(chatId)) {
-            logger.warn("Received message from unauthorized chat ID:", chatId);
+            logger.warn('Received message from unauthorized chat ID:', chatId);
             return;
         }
-        const text = (msg.text || "").trim();
+        const text = (msg.text || '').trim();
         logger.info(`Received message from chat ID ${chatId}: ${text}`);
         const lower = text.toLowerCase();
-        if (lower === "/cmd" || lower.startsWith("/cmd ")) {
-            const args = text
-                .slice("/cmd".length)
-                .trim()
-                .split(/\s+/)
-                .filter(Boolean);
-            const verbose = args.some((a) => a === "--verbose" || a === "-v" || a === "--verbos");
+        if (lower === '/cmd' || lower.startsWith('/cmd ')) {
+            const args = text.slice('/cmd'.length).trim().split(/\s+/).filter(Boolean);
+            const verbose = args.some((a) => a === '--verbose' || a === '-v' || a === '--verbos');
             await handleCmdCommand(logger, chatId, verbose);
             return;
         }
-        if (lower === "/task") {
+        if (lower === '/task') {
             await handleTaskCommand(logger, chatId);
             return;
         }
-        if (lower === "/stop") {
+        if (lower === '/stop') {
             await handleStopCommand(logger, chatId);
             return;
         }
         // If we are awaiting a prompt for a /cmd selection, treat this message as the prompt.
         const pending = pendingPrompts.get(chatId);
-        if (pending && text && !text.startsWith("/")) {
-            if (pending.phase !== "awaitPrompt") {
-                await notify(logger, "👉 Pick the remaining options on the wizard above first.", { chatId });
+        if (pending && text && !text.startsWith('/')) {
+            if (pending.phase !== 'awaitPrompt') {
+                await notify(logger, '👉 Pick the remaining options on the wizard above first.', {
+                    chatId,
+                });
                 return;
             }
             if (pending.sessionId) {
-                const exists = (0, db_1.getSessionById)(pending.sessionId);
-                if (!exists) {
+                const messages = await (0, agentClient_1.getSessionMessages)(logger, pending.sessionId);
+                if (messages === null) {
                     pendingPrompts.delete(chatId);
-                    await notify(logger, "❌ Selected session no longer exists.", {
+                    await notify(logger, '❌ Selected session no longer exists.', {
                         chatId,
                     });
                     return;
@@ -896,6 +895,6 @@ function setupMessageListener(logger, bot) {
             await runAgentForChat(logger, chatId, pending, text);
             return;
         }
-        logger.info("Ignoring unknown message");
+        logger.info('Ignoring unknown message');
     });
 }