@spfunctions/cli 1.4.4 → 1.4.5

package/dist/telegram/agent-bridge.js

@@ -0,0 +1,368 @@
+"use strict";
+/**
+ * Agent bridge — connects Telegram to pi-agent-core
+ *
+ * Uses the SAME tools as sf agent --plain. Multi-turn tool calling
+ * is handled by pi-agent-core's Agent class (not manual OpenRouter calls).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOrCreateAgent = getOrCreateAgent;
+exports.runAgentMessage = runAgentMessage;
+const config_js_1 = require("../config.js");
+let piModules = null;
+async function loadPiModules() {
+    if (piModules)
+        return piModules;
+    const [piAgent, piAi] = await Promise.all([
+        import('@mariozechner/pi-agent-core'),
+        import('@mariozechner/pi-ai'),
+    ]);
+    const typebox = await import('@sinclair/typebox');
+    piModules = { Agent: piAgent.Agent, streamSimple: piAi.streamSimple, Type: typebox.Type };
+    return piModules;
+}
+async function buildTools(sfClient, thesisId, latestContext) {
+    const { Type } = await loadPiModules();
+    const config = (0, config_js_1.loadConfig)();
+    const emptyParams = Type.Object({});
+    // Import Kalshi functions
+    const kalshi = await import('../kalshi.js');
+    const { kalshiFetchAllSeries, kalshiFetchMarketsBySeries, kalshiFetchMarket } = await import('../client.js');
+    const tools = [
+        {
+            name: 'get_context', label: 'Context',
+            description: 'Get thesis snapshot with causal tree, edges, evaluation',
+            parameters: emptyParams,
+            execute: async () => {
+                const ctx = await sfClient.getContext(thesisId);
+                return { content: [{ type: 'text', text: JSON.stringify(ctx, null, 2) }], details: {} };
+            },
+        },
+        {
+            name: 'inject_signal', label: 'Signal',
+            description: 'Inject a signal (news, note, observation) into the thesis',
+            parameters: Type.Object({
+                content: Type.String({ description: 'Signal content' }),
+                type: Type.Optional(Type.String({ description: 'news | user_note | external' })),
+            }),
+            execute: async (_id, p) => {
+                await sfClient.injectSignal(thesisId, p.type || 'user_note', p.content, 'telegram');
+                return { content: [{ type: 'text', text: 'Signal injected.' }], details: {} };
+            },
+        },
+        {
+            name: 'trigger_evaluation', label: 'Evaluate',
+            description: 'Trigger a deep evaluation cycle',
+            parameters: emptyParams,
+            execute: async () => {
+                await sfClient.evaluate(thesisId);
+                return { content: [{ type: 'text', text: 'Evaluation triggered. Results in ~2 minutes.' }], details: {} };
+            },
+        },
+        {
+            name: 'scan_markets', label: 'Scan',
+            description: 'Search Kalshi markets by keyword, series, or ticker',
+            parameters: Type.Object({
+                query: Type.Optional(Type.String({ description: 'Keyword search' })),
+                series: Type.Optional(Type.String({ description: 'Series ticker' })),
+                market: Type.Optional(Type.String({ description: 'Market ticker' })),
+            }),
+            execute: async (_id, p) => {
+                let result;
+                if (p.market) {
+                    result = await kalshiFetchMarket(p.market);
+                }
+                else if (p.series) {
+                    result = await kalshiFetchMarketsBySeries(p.series);
+                }
+                else if (p.query) {
+                    const series = await kalshiFetchAllSeries();
+                    const kws = p.query.toLowerCase().split(/\s+/);
+                    result = series.filter((s) => kws.every((k) => ((s.title || '') + (s.ticker || '')).toLowerCase().includes(k)))
+                        .filter((s) => parseFloat(s.volume_fp || '0') > 1000)
+                        .sort((a, b) => parseFloat(b.volume_fp || '0') - parseFloat(a.volume_fp || '0'))
+                        .slice(0, 10);
+                }
+                else {
+                    result = { error: 'Provide query, series, or market' };
+                }
+                return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }], details: {} };
+            },
+        },
+        {
+            name: 'list_theses', label: 'List',
+            description: 'List all theses',
+            parameters: emptyParams,
+            execute: async () => {
+                const theses = await sfClient.listTheses();
+                return { content: [{ type: 'text', text: JSON.stringify(theses, null, 2) }], details: {} };
+            },
+        },
+        {
+            name: 'get_positions', label: 'Positions',
+            description: 'Get Kalshi positions with live prices and P&L',
+            parameters: emptyParams,
+            execute: async () => {
+                const positions = await kalshi.getPositions();
+                if (!positions)
+                    return { content: [{ type: 'text', text: 'Kalshi not configured.' }], details: {} };
+                for (const pos of positions) {
+                    const price = await kalshi.getMarketPrice(pos.ticker);
+                    if (price != null) {
+                        pos.current_value = price;
+                        pos.unrealized_pnl = Math.round((price - pos.average_price_paid) * pos.quantity);
+                    }
+                }
+                const formatted = positions.map((p) => ({
+                    ticker: p.ticker, qty: p.quantity,
+                    avg_price: `${p.average_price_paid}¢`, current: `${p.current_value}¢`,
+                    pnl: `$${((p.unrealized_pnl || 0) / 100).toFixed(2)}`,
+                }));
+                return { content: [{ type: 'text', text: JSON.stringify(formatted, null, 2) }], details: {} };
+            },
+        },
+        {
+            name: 'get_balance', label: 'Balance',
+            description: 'Get Kalshi account balance',
+            parameters: emptyParams,
+            execute: async () => {
+                const bal = await kalshi.getBalance();
+                if (!bal)
+                    return { content: [{ type: 'text', text: 'Kalshi not configured.' }], details: {} };
+                return { content: [{ type: 'text', text: JSON.stringify(bal, null, 2) }], details: {} };
+            },
+        },
+        {
+            name: 'get_orders', label: 'Orders',
+            description: 'Get resting orders on Kalshi',
+            parameters: emptyParams,
+            execute: async () => {
+                const result = await kalshi.getOrders({ status: 'resting', limit: 50 });
+                if (!result)
+                    return { content: [{ type: 'text', text: 'Kalshi not configured.' }], details: {} };
+                return { content: [{ type: 'text', text: JSON.stringify(result.orders, null, 2) }], details: {} };
+            },
+        },
+        {
+            name: 'get_fills', label: 'Fills',
+            description: 'Get recent trade fills',
+            parameters: Type.Object({ ticker: Type.Optional(Type.String()) }),
+            execute: async (_id, p) => {
+                const result = await kalshi.getFills({ ticker: p.ticker, limit: 20 });
+                if (!result)
+                    return { content: [{ type: 'text', text: 'Kalshi not configured.' }], details: {} };
+                return { content: [{ type: 'text', text: JSON.stringify(result.fills, null, 2) }], details: {} };
+            },
+        },
+        {
+            name: 'get_settlements', label: 'Settlements',
+            description: 'Get settled contracts with P&L',
+            parameters: emptyParams,
+            execute: async () => {
+                const result = await kalshi.getSettlements({ limit: 50 });
+                if (!result)
+                    return { content: [{ type: 'text', text: 'Kalshi not configured.' }], details: {} };
+                return { content: [{ type: 'text', text: JSON.stringify(result.settlements, null, 2) }], details: {} };
+            },
+        },
+        {
+            name: 'get_edges', label: 'Edges',
+            description: 'Top 10 edges across all active theses',
+            parameters: emptyParams,
+            execute: async () => {
+                const { theses } = await sfClient.listTheses();
+                const active = (theses || []).filter((t) => t.status === 'active');
+                const results = await Promise.allSettled(active.map(async (t) => {
+                    const ctx = await sfClient.getContext(t.id);
+                    return (ctx.edges || []).map((e) => ({ ...e, thesisId: t.id }));
+                }));
+                const allEdges = [];
+                for (const r of results) {
+                    if (r.status === 'fulfilled')
+                        allEdges.push(...r.value);
+                }
+                allEdges.sort((a, b) => Math.abs(b.edge || 0) - Math.abs(a.edge || 0));
+                return { content: [{ type: 'text', text: JSON.stringify(allEdges.slice(0, 10), null, 2) }], details: {} };
+            },
+        },
+        {
+            name: 'get_schedule', label: 'Schedule',
+            description: 'Exchange status (open/closed) and trading hours',
+            parameters: emptyParams,
+            execute: async () => {
+                const res = await fetch('https://api.elections.kalshi.com/trade-api/v2/exchange/status', { headers: { 'Accept': 'application/json' } });
+                if (!res.ok)
+                    return { content: [{ type: 'text', text: `API error: ${res.status}` }], details: {} };
+                const data = await res.json();
+                return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }], details: {} };
+            },
+        },
+        {
+            name: 'get_feed', label: 'Feed',
+            description: 'Recent evaluation history',
+            parameters: Type.Object({ hours: Type.Optional(Type.Number({ description: 'Hours of history (default 24)' })) }),
+            execute: async (_id, p) => {
+                const data = await sfClient.getFeed(p.hours || 24);
+                return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }], details: {} };
+            },
+        },
+        {
+            name: 'web_search', label: 'Search',
+            description: 'Search the web for latest news',
+            parameters: Type.Object({ query: Type.String({ description: 'Search query' }) }),
+            execute: async (_id, p) => {
+                const tavilyKey = process.env.TAVILY_API_KEY || config.tavilyKey;
+                if (!tavilyKey)
+                    return { content: [{ type: 'text', text: 'Tavily not configured.' }], details: {} };
+                const res = await fetch('https://api.tavily.com/search', {
+                    method: 'POST', headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ api_key: tavilyKey, query: p.query, max_results: 3, search_depth: 'basic', include_answer: true }),
+                });
+                if (!res.ok)
+                    return { content: [{ type: 'text', text: `Search failed: ${res.status}` }], details: {} };
+                const data = await res.json();
+                const answer = data.answer ? `Summary: ${data.answer}\n\n` : '';
+                const results = (data.results || []).map((r) => `${r.title}: ${(r.content || '').slice(0, 150)}`).join('\n\n');
+                return { content: [{ type: 'text', text: `${answer}${results}` }], details: {} };
+            },
+        },
+        {
+            name: 'create_thesis', label: 'Create',
+            description: 'Create a new thesis',
+            parameters: Type.Object({ rawThesis: Type.String({ description: 'Thesis statement' }) }),
+            execute: async (_id, p) => {
+                const result = await sfClient.createThesis(p.rawThesis, true);
+                return { content: [{ type: 'text', text: `Created: ${result.id}\nConfidence: ${Math.round((result.confidence || 0.5) * 100)}%` }], details: {} };
+            },
+        },
+        {
+            name: 'what_if', label: 'What-If',
+            description: 'Override causal tree node probabilities and see how edges change. Zero LLM cost.',
+            parameters: Type.Object({
+                overrides: Type.Array(Type.Object({
+                    nodeId: Type.String({ description: 'Node ID (e.g. n1, n3.1)' }),
+                    newProbability: Type.Number({ description: 'New probability 0-1' }),
+                })),
+            }),
+            execute: async (_id, p) => {
+                const ctx = latestContext;
+                const allNodes = [];
+                function flatten(nodes) { for (const n of nodes) {
+                    allNodes.push(n);
+                    if (n.children?.length)
+                        flatten(n.children);
+                } }
+                flatten(ctx?.causalTree?.nodes || []);
+                const overrideMap = new Map(p.overrides.map((o) => [o.nodeId, o.newProbability]));
+                const topNodes = (ctx?.causalTree?.nodes || []).filter((n) => !n.parentId || n.depth === 0);
+                const oldConf = topNodes.reduce((s, n) => s + (n.probability || 0.5), 0) / Math.max(topNodes.length, 1);
+                for (const n of allNodes) {
+                    if (overrideMap.has(n.id))
+                        n.probability = overrideMap.get(n.id);
+                }
+                const newConf = topNodes.reduce((s, n) => s + (n.probability || 0.5), 0) / Math.max(topNodes.length, 1);
+                const edges = (ctx?.edges || []).slice(0, 10).map((e) => {
+                    const node = allNodes.find((n) => n.id === e.relatedNodeId);
+                    if (!node || !overrideMap.has(node.id))
+                        return { market: e.market, oldEdge: e.edge, newEdge: e.edge, signal: 'unchanged' };
+                    const scale = node.probability / (e.confidence || 0.5);
+                    const newThesis = Math.round(e.thesisPrice * scale);
+                    const newEdge = newThesis - e.marketPrice;
+                    return { market: e.market, oldEdge: e.edge, newEdge, signal: Math.abs(newEdge - e.edge) < 1 ? 'unchanged' : 'changed' };
+                }).filter((e) => e.signal !== 'unchanged');
+                return { content: [{ type: 'text', text: JSON.stringify({ confidence: { old: Math.round(oldConf * 100), new: Math.round(newConf * 100) }, edges }, null, 2) }], details: {} };
+            },
+        },
+    ];
+    return tools;
+}
+async function getOrCreateAgent(sfClient, session) {
+    if (session.agent)
+        return session.agent;
+    const { Agent, streamSimple } = await loadPiModules();
+    const piAi = await import('@mariozechner/pi-ai');
+    const { getModel } = piAi;
+    const config = (0, config_js_1.loadConfig)();
+    const openrouterKey = config.openrouterKey || process.env.OPENROUTER_API_KEY;
+    if (!openrouterKey)
+        throw new Error('OpenRouter not configured. Use slash commands or run sf setup.');
+    const ctx = await sfClient.getContext(session.thesisId);
+    const conf = typeof ctx.confidence === 'number' ? Math.round(ctx.confidence * 100) : 50;
+    const tools = await buildTools(sfClient, session.thesisId, ctx);
+    // Resolve model object (not just a string — pi-ai needs api/provider/baseUrl)
+    const modelName = config.model || 'anthropic/claude-sonnet-4.6';
+    let model;
+    try {
+        model = getModel('openrouter', modelName);
+    }
+    catch {
+        model = {
+            modelId: modelName, provider: 'openrouter', api: 'openai-completions',
+            baseUrl: 'https://openrouter.ai/api/v1', id: modelName, name: modelName,
+            inputPrice: 0, outputPrice: 0, contextWindow: 200000,
+            supportsImages: true, supportsTools: true,
+        };
+    }
+    const systemPrompt = `You are a prediction market trading assistant on Telegram. Be concise.
+
+Thesis: ${(ctx.thesis || ctx.rawThesis || 'N/A').slice(0, 200)}
+ID: ${session.thesisId.slice(0, 8)}
+Confidence: ${conf}%
+
+Rules:
+- Keep responses short — Telegram messages should be brief.
+- Prices are in cents (¢). P&L in dollars ($). Tool outputs are pre-formatted.
+- Use Chinese if user writes Chinese, English if English.
+- Call tools when needed. Don't guess data.`;
+    const agent = new Agent({
+        initialState: {
+            systemPrompt,
+            model,
+            tools,
+            thinkingLevel: 'off',
+        },
+        streamFn: streamSimple,
+        getApiKey: (provider) => provider === 'openrouter' ? openrouterKey : undefined,
+    });
+    // Restore session messages if available
+    if (session.agentMessages.length > 0) {
+        try {
+            agent.replaceMessages(session.agentMessages);
+        }
+        catch { /* start fresh */ }
+    }
+    session.agent = agent;
+    return agent;
+}
+async function runAgentMessage(client, session, userMessage) {
+    const agent = await getOrCreateAgent(client, session);
+    return new Promise((resolve, reject) => {
+        let response = '';
+        let toolLog = '';
+        const timeout = setTimeout(() => {
+            resolve(response || toolLog || 'Response timeout (45s). Try a simpler question.');
+        }, 45_000);
+        const unsub = agent.subscribe((event) => {
+            if (event.type === 'message_update') {
+                const e = event.assistantMessageEvent;
+                if (e.type === 'text_delta')
+                    response += e.delta;
+            }
+            if (event.type === 'tool_execution_start') {
+                toolLog += `⚡ ${event.toolName}\n`;
+            }
+            if (event.type === 'agent_end') {
+                clearTimeout(timeout);
+                unsub?.();
+                // Save messages for session continuity
+                session.agentMessages = agent.state.messages || [];
+                resolve(response || toolLog || '(no response)');
+            }
+        });
+        agent.prompt(userMessage).catch((err) => {
+            clearTimeout(timeout);
+            unsub?.();
+            reject(err);
+        });
+    });
+}

package/dist/telegram/bot.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Telegram Bot — main entry point
+ *
+ * Handles slash commands (zero LLM) and free text (via pi-agent-core).
+ * Polls delta API for push notifications.
+ */
+export declare function startBot(opts: {
+    token?: string;
+    chatId?: number;
+}): Promise<void>;

package/dist/telegram/bot.js

@@ -0,0 +1,297 @@
+"use strict";
+/**
+ * Telegram Bot — main entry point
+ *
+ * Handles slash commands (zero LLM) and free text (via pi-agent-core).
+ * Polls delta API for push notifications.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startBot = startBot;
+const grammy_1 = require("grammy");
+const client_js_1 = require("../client.js");
+const config_js_1 = require("../config.js");
+const format_js_1 = require("./format.js");
+const commands_js_1 = require("./commands.js");
+const poller_js_1 = require("./poller.js");
+const sessions = new Map();
+function getSession(chatId) {
+    if (!sessions.has(chatId)) {
+        sessions.set(chatId, { thesisId: null, agentMessages: [] });
+    }
+    return sessions.get(chatId);
+}
+async function startBot(opts) {
+    const config = (0, config_js_1.loadConfig)();
+    const botToken = opts.token || config.telegramBotToken || process.env.TELEGRAM_BOT_TOKEN;
+    if (!botToken) {
+        console.error('No Telegram bot token. Use --token, set TELEGRAM_BOT_TOKEN, or add to ~/.sf/config.json');
+        process.exit(1);
+    }
+    const client = new client_js_1.SFClient(config.apiKey, config.apiUrl);
+    const bot = new grammy_1.Bot(botToken);
+    const allowedChat = opts.chatId || null;
+    const pollers = new Map();
+    // Auth guard
+    function isAllowed(chatId) {
+        return !allowedChat || chatId === allowedChat;
+    }
+    // ── /start ──
+    bot.command('start', async (ctx) => {
+        if (!isAllowed(ctx.chat.id))
+            return;
+        const session = getSession(ctx.chat.id);
+        // Auto-detect first active thesis
+        try {
+            const { theses } = await client.listTheses();
+            const active = (theses || []).filter((t) => t.status === 'active');
+            if (active.length > 0) {
+                session.thesisId = active[0].id;
+                await ctx.reply(`✅ Connected to SimpleFunctions\n\n` +
+                    `Active thesis: <b>${(active[0].rawThesis || '').slice(0, 60)}</b>\n` +
+                    `ID: <code>${active[0].id.slice(0, 8)}</code>\n\n` +
+                    `Commands:\n` +
+                    `/context — thesis snapshot\n` +
+                    `/positions — Kalshi positions\n` +
+                    `/edges — top edges\n` +
+                    `/balance — account balance\n` +
+                    `/orders — resting orders\n` +
+                    `/eval — trigger evaluation\n` +
+                    `/list — all theses\n` +
+                    `/switch — switch thesis\n\n` +
+                    `Or just type naturally.`, { parse_mode: 'HTML' });
+                // Start polling for this chat
+                if (pollers.has(ctx.chat.id))
+                    clearInterval(pollers.get(ctx.chat.id));
+                pollers.set(ctx.chat.id, (0, poller_js_1.startPoller)(bot, ctx.chat.id, client, session.thesisId));
+            }
+            else {
+                await ctx.reply('No active theses found. Create one with `sf create "your thesis"`');
+            }
+        }
+        catch (err) {
+            await ctx.reply(`❌ Connection failed: ${err.message}\nCheck SF_API_KEY in ~/.sf/config.json`);
+        }
+    });
+    // ── /context ──
+    bot.command('context', async (ctx) => {
+        if (!isAllowed(ctx.chat.id))
+            return;
+        const session = getSession(ctx.chat.id);
+        if (!session.thesisId) {
+            await ctx.reply('No thesis selected. Use /start or /switch <id>');
+            return;
+        }
+        try {
+            const text = await (0, commands_js_1.handleContext)(client, session.thesisId);
+            for (const chunk of (0, format_js_1.splitMessage)(text))
+                await ctx.reply(chunk, { parse_mode: 'HTML' });
+        }
+        catch (err) {
+            await ctx.reply(`❌ ${err.message}`);
+        }
+    });
+    // ── /positions ──
+    bot.command('positions', async (ctx) => {
+        if (!isAllowed(ctx.chat.id))
+            return;
+        try {
+            const text = await (0, commands_js_1.handlePositions)();
+            for (const chunk of (0, format_js_1.splitMessage)(text))
+                await ctx.reply(chunk, { parse_mode: 'HTML' });
+        }
+        catch (err) {
+            await ctx.reply(`❌ ${err.message}`);
+        }
+    });
+    // ── /edges ──
+    bot.command('edges', async (ctx) => {
+        if (!isAllowed(ctx.chat.id))
+            return;
+        try {
+            const text = await (0, commands_js_1.handleEdges)(client);
+            for (const chunk of (0, format_js_1.splitMessage)(text))
+                await ctx.reply(chunk, { parse_mode: 'HTML' });
+        }
+        catch (err) {
+            await ctx.reply(`❌ ${err.message}`);
+        }
+    });
+    // ── /balance ──
+    bot.command('balance', async (ctx) => {
+        if (!isAllowed(ctx.chat.id))
+            return;
+        try {
+            const text = await (0, commands_js_1.handleBalance)();
+            await ctx.reply(text, { parse_mode: 'HTML' });
+        }
+        catch (err) {
+            await ctx.reply(`❌ ${err.message}`);
+        }
+    });
+    // ── /orders ──
+    bot.command('orders', async (ctx) => {
+        if (!isAllowed(ctx.chat.id))
+            return;
+        try {
+            const text = await (0, commands_js_1.handleOrders)();
+            for (const chunk of (0, format_js_1.splitMessage)(text))
+                await ctx.reply(chunk, { parse_mode: 'HTML' });
+        }
+        catch (err) {
+            await ctx.reply(`❌ ${err.message}`);
+        }
+    });
+    // ── /eval ──
+    bot.command('eval', async (ctx) => {
+        if (!isAllowed(ctx.chat.id))
+            return;
+        const session = getSession(ctx.chat.id);
+        if (!session.thesisId) {
+            await ctx.reply('No thesis selected.');
+            return;
+        }
+        try {
+            const text = await (0, commands_js_1.handleEval)(client, session.thesisId);
+            await ctx.reply(text);
+        }
+        catch (err) {
+            await ctx.reply(`❌ ${err.message}`);
+        }
+    });
+    // ── /list ──
+    bot.command('list', async (ctx) => {
+        if (!isAllowed(ctx.chat.id))
+            return;
+        try {
+            const text = await (0, commands_js_1.handleList)(client);
+            for (const chunk of (0, format_js_1.splitMessage)(text))
+                await ctx.reply(chunk, { parse_mode: 'HTML' });
+        }
+        catch (err) {
+            await ctx.reply(`❌ ${err.message}`);
+        }
+    });
+    // ── /switch <id> ──
+    bot.command('switch', async (ctx) => {
+        if (!isAllowed(ctx.chat.id))
+            return;
+        const session = getSession(ctx.chat.id);
+        const newId = ctx.match?.trim();
+        if (!newId) {
+            await ctx.reply('Usage: /switch <thesis_id>');
+            return;
+        }
+        // Find matching thesis (prefix match)
+        try {
+            const { theses } = await client.listTheses();
+            const match = (theses || []).find((t) => t.id.startsWith(newId));
+            if (match) {
+                session.thesisId = match.id;
+                session.agentMessages = []; // reset conversation
+                // Restart poller
+                if (pollers.has(ctx.chat.id))
+                    clearInterval(pollers.get(ctx.chat.id));
+                pollers.set(ctx.chat.id, (0, poller_js_1.startPoller)(bot, ctx.chat.id, client, session.thesisId));
+                await ctx.reply(`Switched to: <code>${match.id.slice(0, 8)}</code> — ${(match.rawThesis || '').slice(0, 60)}`, { parse_mode: 'HTML' });
+            }
+            else {
+                await ctx.reply(`No thesis found matching "${newId}". Use /list to see all.`);
+            }
+        }
+        catch (err) {
+            await ctx.reply(`❌ ${err.message}`);
+        }
+    });
+    // ── Free text → LLM agent ──
+    bot.on('message:text', async (ctx) => {
+        if (!isAllowed(ctx.chat.id))
+            return;
+        const session = getSession(ctx.chat.id);
+        const userMessage = ctx.message.text;
+        if (userMessage.startsWith('/'))
+            return; // skip unhandled commands
+        // Auto-detect thesis if not set
+        if (!session.thesisId) {
+            try {
+                const { theses } = await client.listTheses();
+                const active = (theses || []).filter((t) => t.status === 'active');
+                if (active.length > 0) {
+                    session.thesisId = active[0].id;
+                }
+                else {
+                    await ctx.reply('No active theses. Create one with `sf create "your thesis"` then /start');
+                    return;
+                }
+            }
+            catch {
+                await ctx.reply('Could not connect. Use /start first.');
+                return;
+            }
+        }
+        try {
+            // Show "typing" indicator
+            await ctx.replyWithChatAction('typing');
+            // Lazy-load agent module (heavy imports)
+            const { runAgentMessage } = await import('./agent-bridge.js');
+            // Timeout after 30 seconds
+            const timeout = new Promise((_, reject) => setTimeout(() => reject(new Error('Response timeout (30s)')), 30_000));
+            const response = await Promise.race([
+                runAgentMessage(client, session, userMessage),
+                timeout,
+            ]);
+            if (!response || response.trim().length === 0) {
+                await ctx.reply('No response generated. Try rephrasing or use a slash command.');
+            }
+            else {
+                for (const chunk of (0, format_js_1.splitMessage)(response)) {
+                    // Use plain text if HTML parsing might fail
+                    try {
+                        await ctx.reply(chunk, { parse_mode: 'HTML' });
+                    }
+                    catch {
+                        await ctx.reply(chunk); // fallback to plain text
+                    }
+                }
+            }
+        }
+        catch (err) {
+            console.error('[Telegram] Agent error:', err.message);
+            await ctx.reply(`❌ ${err.message}`);
+        }
+    });
+    // ── Callback queries (for inline keyboard confirmations) ──
+    bot.on('callback_query:data', async (ctx) => {
+        const data = ctx.callbackQuery.data;
+        if (data.startsWith('order_confirm:')) {
+            // TODO: execute pending order
+            await ctx.answerCallbackQuery({ text: 'Order execution coming soon' });
+        }
+        else if (data === 'order_cancel') {
+            await ctx.answerCallbackQuery({ text: 'Order cancelled' });
+            await ctx.editMessageText('❌ Order cancelled.');
+        }
+    });
+    // ── Start bot ──
+    console.log('🤖 SimpleFunctions Telegram bot starting...');
+    console.log(`   SF API: ${config.apiKey ? '✓' : '✗'}`);
+    console.log(`   Kalshi: ${process.env.KALSHI_API_KEY_ID ? '✓' : '✗'}`);
+    console.log(`   OpenRouter: ${config.openrouterKey ? '✓' : '✗'}`);
+    if (allowedChat)
+        console.log(`   Restricted to chat: ${allowedChat}`);
+    console.log('   Press Ctrl+C to stop.\n');
+    // Prevent crashes from killing the daemon
+    process.on('uncaughtException', (err) => {
+        console.error('[Telegram] Uncaught exception:', err.message);
+    });
+    process.on('unhandledRejection', (err) => {
+        console.error('[Telegram] Unhandled rejection:', err?.message || err);
+    });
+    // Cleanup on exit
+    process.on('SIGINT', () => {
+        for (const timer of pollers.values())
+            clearInterval(timer);
+        bot.stop();
+        process.exit(0);
+    });
+    await bot.start();
+}