@fonz/tgcc 0.0.1 → 0.3.0

package/dist/bridge.js

@@ -0,0 +1,1193 @@
+import { join } from 'node:path';
+import { existsSync, readFileSync, statSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { EventEmitter } from 'node:events';
+import pino from 'pino';
+import { resolveUserConfig, resolveRepoPath, updateConfig, isValidRepoName, findRepoOwner } from './config.js';
+import { CCProcess, generateMcpConfig } from './cc-process.js';
+import { createTextMessage, createImageMessage, createDocumentMessage, } from './cc-protocol.js';
+import { StreamAccumulator, SubAgentTracker, escapeHtml } from './streaming.js';
+import { TelegramBot } from './telegram.js';
+import { InlineKeyboard } from 'grammy';
+import { McpBridgeServer } from './mcp-bridge.js';
+import { SessionStore, findMissedSessions, formatCatchupMessage, getSessionJsonlPath, summarizeJsonlDelta, } from './session.js';
+import { CtlServer, } from './ctl-server.js';
+// ── Message Batcher ──
+class MessageBatcher {
+    pending = [];
+    timer = null;
+    windowMs;
+    flush;
+    constructor(windowMs, flushFn) {
+        this.windowMs = windowMs;
+        this.flush = flushFn;
+    }
+    add(msg) {
+        this.pending.push(msg);
+        // If this is a media message, flush immediately (don't batch media)
+        if (msg.imageBase64 || msg.filePath) {
+            this.doFlush();
+            return;
+        }
+        if (!this.timer) {
+            this.timer = setTimeout(() => this.doFlush(), this.windowMs);
+        }
+    }
+    doFlush() {
+        if (this.timer) {
+            clearTimeout(this.timer);
+            this.timer = null;
+        }
+        if (this.pending.length === 0)
+            return;
+        // If there's a single message with media, send it directly
+        if (this.pending.length === 1) {
+            this.flush(this.pending[0]);
+            this.pending = [];
+            return;
+        }
+        // Combine text-only messages
+        const combined = this.pending.map(m => m.text).filter(Boolean).join('\n\n');
+        this.flush({ text: combined });
+        this.pending = [];
+    }
+    cancel() {
+        if (this.timer) {
+            clearTimeout(this.timer);
+            this.timer = null;
+        }
+        this.pending = [];
+    }
+}
+// ── Help text ──
+const HELP_TEXT = `<b>TGCC Commands</b>
+
+<b>Session</b>
+/new — Start a fresh session
+/sessions — List recent sessions
+/resume &lt;id&gt; — Resume a session by ID
+/session — Current session info
+
+<b>Info</b>
+/status — Process state, model, uptime
+/cost — Show session cost
+/catchup — Summarize external CC activity
+/ping — Liveness check
+
+<b>Control</b>
+/cancel — Abort current CC turn
+/model &lt;name&gt; — Switch model
+/permissions — Set permission mode
+/repo — List repos (buttons)
+/repo help — Repo management commands
+/repo add &lt;name&gt; &lt;path&gt; — Register a repo
+/repo remove &lt;name&gt; — Unregister a repo
+/repo assign &lt;name&gt; — Set as agent default
+/repo clear — Clear agent default
+
+/help — This message`;
+// ── Bridge ──
+export class Bridge extends EventEmitter {
+    config;
+    agents = new Map();
+    mcpServer;
+    ctlServer;
+    sessionStore;
+    logger;
+    constructor(config, logger) {
+        super();
+        this.config = config;
+        this.logger = logger ?? pino({ level: config.global.logLevel });
+        this.sessionStore = new SessionStore(config.global.stateFile, this.logger);
+        this.mcpServer = new McpBridgeServer((req) => this.handleMcpToolRequest(req), this.logger);
+        this.ctlServer = new CtlServer(this, this.logger);
+    }
+    // ── Startup ──
+    async start() {
+        this.logger.info('Starting bridge');
+        for (const [agentId, agentConfig] of Object.entries(this.config.agents)) {
+            await this.startAgent(agentId, agentConfig);
+        }
+        this.logger.info({ agents: Object.keys(this.config.agents) }, 'Bridge started');
+    }
+    async startAgent(agentId, agentConfig) {
+        this.logger.info({ agentId }, 'Starting agent');
+        const tgBot = new TelegramBot(agentId, agentConfig, this.config.global.mediaDir, (msg) => this.handleTelegramMessage(agentId, msg), (cmd) => this.handleSlashCommand(agentId, cmd), this.logger, (query) => this.handleCallbackQuery(agentId, query));
+        const instance = {
+            id: agentId,
+            config: agentConfig,
+            tgBot,
+            processes: new Map(),
+            accumulators: new Map(),
+            subAgentTrackers: new Map(),
+            batchers: new Map(),
+            pendingTitles: new Map(),
+            pendingPermissions: new Map(),
+        };
+        this.agents.set(agentId, instance);
+        await tgBot.start();
+        // Start control socket for CLI access
+        const ctlSocketPath = join('/tmp/tgcc/ctl', `${agentId}.sock`);
+        this.ctlServer.listen(ctlSocketPath);
+    }
+    // ── Hot reload ──
+    async handleConfigChange(newConfig, diff) {
+        this.logger.info({ diff }, 'Handling config change');
+        // Remove agents
+        for (const agentId of diff.removed) {
+            await this.stopAgent(agentId);
+        }
+        // Add new agents
+        for (const agentId of diff.added) {
+            await this.startAgent(agentId, newConfig.agents[agentId]);
+        }
+        // Handle changed agents
+        for (const agentId of diff.changed) {
+            const oldAgent = this.agents.get(agentId);
+            const newAgentConfig = newConfig.agents[agentId];
+            if (!oldAgent)
+                continue;
+            // If bot token changed, full restart
+            if (oldAgent.config.botToken !== newAgentConfig.botToken) {
+                await this.stopAgent(agentId);
+                await this.startAgent(agentId, newAgentConfig);
+            }
+            else {
+                // Update in-memory config — active processes keep old config
+                oldAgent.config = newAgentConfig;
+            }
+        }
+        this.config = newConfig;
+    }
+    async stopAgent(agentId) {
+        const agent = this.agents.get(agentId);
+        if (!agent)
+            return;
+        this.logger.info({ agentId }, 'Stopping agent');
+        // Stop bot
+        await agent.tgBot.stop();
+        // Kill all CC processes
+        for (const [, proc] of agent.processes) {
+            proc.destroy();
+        }
+        // Cancel batchers
+        for (const [, batcher] of agent.batchers) {
+            batcher.cancel();
+        }
+        // Close MCP sockets
+        for (const userId of agent.processes.keys()) {
+            const socketPath = join(this.config.global.socketDir, `${agentId}-${userId}.sock`);
+            this.mcpServer.close(socketPath);
+        }
+        // Close control socket
+        const ctlSocketPath = join('/tmp/tgcc/ctl', `${agentId}.sock`);
+        this.ctlServer.close(ctlSocketPath);
+        this.agents.delete(agentId);
+    }
+    // ── Message handling ──
+    handleTelegramMessage(agentId, msg) {
+        const agent = this.agents.get(agentId);
+        if (!agent)
+            return;
+        this.logger.debug({ agentId, userId: msg.userId, type: msg.type }, 'TG message received');
+        // Ensure batcher exists
+        if (!agent.batchers.has(msg.userId)) {
+            agent.batchers.set(msg.userId, new MessageBatcher(2000, (combined) => {
+                this.sendToCC(agentId, msg.userId, msg.chatId, combined);
+            }));
+        }
+        // Prepare text with reply context
+        let text = msg.text;
+        if (msg.replyToText) {
+            text = `[Replying to: '${msg.replyToText}']\n\n${text}`;
+        }
+        const batcher = agent.batchers.get(msg.userId);
+        batcher.add({
+            text,
+            imageBase64: msg.imageBase64,
+            imageMediaType: msg.imageMediaType,
+            filePath: msg.filePath,
+            fileName: msg.fileName,
+        });
+    }
+    sendToCC(agentId, userId, chatId, data) {
+        const agent = this.agents.get(agentId);
+        if (!agent)
+            return;
+        // Construct CC message
+        let ccMsg;
+        if (data.imageBase64) {
+            ccMsg = createImageMessage(data.text || 'What do you see in this image?', data.imageBase64, data.imageMediaType);
+        }
+        else if (data.filePath && data.fileName) {
+            ccMsg = createDocumentMessage(data.text, data.filePath, data.fileName);
+        }
+        else {
+            ccMsg = createTextMessage(data.text);
+        }
+        // Get or create CC process
+        let proc = agent.processes.get(userId);
+        if (proc?.takenOver) {
+            // Session was taken over externally — discard old process
+            proc.destroy();
+            agent.processes.delete(userId);
+            proc = undefined;
+        }
+        // Staleness check: detect if session was modified by another client
+        // Skip if background sub-agents are running — their results grow the JSONL
+        // and would cause false-positive staleness detection
+        const accKey2 = `${userId}:${chatId}`;
+        const activeTracker = agent.subAgentTrackers.get(accKey2);
+        const hasBackgroundAgents = activeTracker?.hasDispatchedAgents ?? false;
+        if (proc && proc.state !== 'idle' && !hasBackgroundAgents) {
+            const staleInfo = this.checkSessionStaleness(agentId, userId);
+            if (staleInfo) {
+                // Session was modified externally — silently reconnect for roaming support
+                this.logger.info({ agentId, userId }, 'Session modified externally — reconnecting for roaming');
+                proc.destroy();
+                agent.processes.delete(userId);
+                proc = undefined;
+            }
+        }
+        if (!proc || proc.state === 'idle') {
+            // Save first message text as pending session title
+            if (data.text) {
+                agent.pendingTitles.set(userId, data.text);
+            }
+            proc = this.spawnCCProcess(agentId, userId, chatId);
+            agent.processes.set(userId, proc);
+        }
+        // Show typing indicator
+        agent.tgBot.sendTyping(chatId);
+        proc.sendMessage(ccMsg);
+        this.sessionStore.updateSessionActivity(agentId, userId);
+    }
+    /** Check if the session JSONL was modified externally since we last tracked it. */
+    checkSessionStaleness(agentId, userId) {
+        const userState = this.sessionStore.getUser(agentId, userId);
+        const sessionId = userState.currentSessionId;
+        if (!sessionId)
+            return null;
+        const repo = userState.repo || resolveUserConfig(this.agents.get(agentId).config, userId).repo;
+        const jsonlPath = getSessionJsonlPath(sessionId, repo);
+        const tracking = this.sessionStore.getJsonlTracking(agentId, userId);
+        // No tracking yet (first message or new session) — not stale
+        if (!tracking)
+            return null;
+        try {
+            const stat = statSync(jsonlPath);
+            // File grew or was modified since we last tracked
+            if (stat.size <= tracking.size && stat.mtimeMs <= tracking.mtimeMs) {
+                return null;
+            }
+            // Session is stale — build a summary of what happened
+            const summary = summarizeJsonlDelta(jsonlPath, tracking.size)
+                ?? '<i>ℹ️ Session was updated from another client. Reconnecting...</i>';
+            return { summary };
+        }
+        catch {
+            // File doesn't exist or stat failed — skip check
+            return null;
+        }
+    }
+    /** Update JSONL tracking from the current file state. */
+    updateJsonlTracking(agentId, userId) {
+        const userState = this.sessionStore.getUser(agentId, userId);
+        const sessionId = userState.currentSessionId;
+        if (!sessionId)
+            return;
+        const repo = userState.repo || resolveUserConfig(this.agents.get(agentId).config, userId).repo;
+        const jsonlPath = getSessionJsonlPath(sessionId, repo);
+        try {
+            const stat = statSync(jsonlPath);
+            this.sessionStore.updateJsonlTracking(agentId, userId, stat.size, stat.mtimeMs);
+        }
+        catch {
+            // File doesn't exist yet — clear tracking
+            this.sessionStore.clearJsonlTracking(agentId, userId);
+        }
+    }
+    spawnCCProcess(agentId, userId, chatId) {
+        const agent = this.agents.get(agentId);
+        const userConfig = resolveUserConfig(agent.config, userId);
+        // Check session store for model/repo/permission overrides
+        const userState = this.sessionStore.getUser(agentId, userId);
+        if (userState.model)
+            userConfig.model = userState.model;
+        if (userState.repo)
+            userConfig.repo = userState.repo;
+        if (userState.permissionMode) {
+            userConfig.permissionMode = userState.permissionMode;
+        }
+        // Generate MCP config
+        const mcpServerPath = resolveMcpServerPath();
+        const mcpConfigPath = generateMcpConfig(agentId, userId, this.config.global.socketDir, mcpServerPath);
+        // Start MCP socket listener for this agent-user pair
+        const socketPath = join(this.config.global.socketDir, `${agentId}-${userId}.sock`);
+        this.mcpServer.listen(socketPath);
+        const proc = new CCProcess({
+            agentId,
+            userId,
+            ccBinaryPath: this.config.global.ccBinaryPath,
+            userConfig,
+            mcpConfigPath,
+            sessionId: userState.currentSessionId ?? undefined,
+            continueSession: !!userState.currentSessionId,
+            logger: this.logger,
+        });
+        // ── Wire up event handlers ──
+        proc.on('init', (event) => {
+            this.sessionStore.setCurrentSession(agentId, userId, event.session_id);
+            // Set session title from the first user message
+            const pendingTitle = agent.pendingTitles.get(userId);
+            if (pendingTitle) {
+                this.sessionStore.setSessionTitle(agentId, userId, event.session_id, pendingTitle);
+                agent.pendingTitles.delete(userId);
+            }
+            // Initialize JSONL tracking for staleness detection
+            this.updateJsonlTracking(agentId, userId);
+        });
+        proc.on('stream_event', (event) => {
+            this.handleStreamEvent(agentId, userId, chatId, event);
+        });
+        proc.on('tool_result', (event) => {
+            const accKey = `${userId}:${chatId}`;
+            const tracker = agent.subAgentTrackers.get(accKey);
+            if (!tracker)
+                return;
+            const resultText = typeof event.content === 'string' ? event.content : JSON.stringify(event.content);
+            const meta = event.tool_use_result;
+            // Log warning if structured metadata is missing
+            if (!meta && /agent_id:\s*\S+@\S+/.test(resultText)) {
+                this.logger.warn({ agentId, toolUseId: event.tool_use_id }, 'Spawn detected in text but no structured tool_use_result metadata - skipping');
+            }
+            const spawnMeta = meta?.status === 'teammate_spawned' ? meta : undefined;
+            if (spawnMeta?.status === 'teammate_spawned' && spawnMeta.team_name) {
+                if (!tracker.currentTeamName) {
+                    this.logger.info({ agentId, teamName: spawnMeta.team_name, agentName: spawnMeta.name, agentType: spawnMeta.agent_type }, 'Spawn detected');
+                    tracker.setTeamName(spawnMeta.team_name);
+                    // Wire the "all agents reported" callback to send follow-up to CC
+                    tracker.setOnAllReported(() => {
+                        const ccProc = agent.processes.get(userId);
+                        if (ccProc && ccProc.state === 'active') {
+                            ccProc.sendMessage(createTextMessage('All background agents have reported back. Please read their results and provide a synthesis.'));
+                        }
+                    });
+                }
+                // Set agent metadata from structured data or text fallback
+                if (event.tool_use_id && spawnMeta.name) {
+                    tracker.setAgentMetadata(event.tool_use_id, {
+                        agentName: spawnMeta.name,
+                        agentType: spawnMeta.agent_type,
+                        color: spawnMeta.color,
+                    });
+                }
+            }
+            // Handle tool result (sets status, edits TG message)
+            if (event.tool_use_id) {
+                tracker.handleToolResult(event.tool_use_id, resultText);
+            }
+            // Start mailbox watch AFTER handleToolResult has set agent names
+            if (tracker.currentTeamName && tracker.hasDispatchedAgents && !tracker.isMailboxWatching) {
+                tracker.startMailboxWatch();
+            }
+        });
+        proc.on('assistant', (event) => {
+            // Non-streaming fallback — only used if stream_events don't fire
+            // In practice, stream_events handle the display
+        });
+        proc.on('result', (event) => {
+            this.handleResult(agentId, userId, chatId, event);
+        });
+        proc.on('permission_request', (event) => {
+            const req = event.request;
+            const requestId = event.request_id;
+            // Store pending permission
+            agent.pendingPermissions.set(requestId, {
+                requestId,
+                userId,
+                toolName: req.tool_name,
+                input: req.input,
+            });
+            // Build description of what CC wants to do
+            const toolName = escapeHtml(req.tool_name);
+            const inputPreview = req.input
+                ? escapeHtml(JSON.stringify(req.input).slice(0, 200))
+                : '';
+            const text = inputPreview
+                ? `🔐 CC wants to use <code>${toolName}</code>\n<pre>${inputPreview}</pre>`
+                : `🔐 CC wants to use <code>${toolName}</code>`;
+            const keyboard = new InlineKeyboard()
+                .text('✅ Allow', `perm_allow:${requestId}`)
+                .text('❌ Deny', `perm_deny:${requestId}`)
+                .text('✅ Allow All', `perm_allow_all:${userId}`);
+            agent.tgBot.sendTextWithKeyboard(chatId, text, keyboard, 'HTML');
+        });
+        proc.on('api_error', (event) => {
+            const errMsg = event.error?.message || 'Unknown API error';
+            const status = event.error?.status;
+            const isOverloaded = status === 529 || errMsg.includes('overloaded');
+            const retryInfo = event.retryAttempt != null && event.maxRetries != null
+                ? ` (retry ${event.retryAttempt}/${event.maxRetries})`
+                : '';
+            const text = isOverloaded
+                ? `<blockquote>⚠️ API overloaded, retrying...${retryInfo}</blockquote>`
+                : `<blockquote>⚠️ ${escapeHtml(errMsg)}${retryInfo}</blockquote>`;
+            agent.tgBot.sendText(chatId, text, 'HTML');
+        });
+        proc.on('hang', () => {
+            agent.tgBot.sendText(chatId, '<i>CC session paused. Send a message to continue.</i>', 'HTML');
+        });
+        proc.on('takeover', () => {
+            this.logger.warn({ agentId, userId }, 'Session takeover detected — keeping session for roaming');
+            // Don't clear session — allow roaming between clients.
+            // Just kill the current process; next message will --resume the same session.
+            proc.destroy();
+            agent.processes.delete(userId);
+        });
+        proc.on('exit', () => {
+            // Finalize any active accumulator
+            const accKey = `${userId}:${chatId}`;
+            const acc = agent.accumulators.get(accKey);
+            if (acc) {
+                acc.finalize();
+                agent.accumulators.delete(accKey);
+            }
+            // Clean up sub-agent tracker (stops mailbox watch)
+            const exitTracker = agent.subAgentTrackers.get(accKey);
+            if (exitTracker) {
+                exitTracker.stopMailboxWatch();
+            }
+            agent.subAgentTrackers.delete(accKey);
+        });
+        proc.on('error', (err) => {
+            agent.tgBot.sendText(chatId, `<i>CC error: ${escapeHtml(String(err.message))}</i>`, 'HTML');
+        });
+        return proc;
+    }
+    // ── Stream event handling ──
+    handleStreamEvent(agentId, userId, chatId, event) {
+        const agent = this.agents.get(agentId);
+        if (!agent)
+            return;
+        const accKey = `${userId}:${chatId}`;
+        let acc = agent.accumulators.get(accKey);
+        if (!acc) {
+            const sender = {
+                sendMessage: (cid, text, parseMode) => agent.tgBot.sendText(cid, text, parseMode),
+                editMessage: (cid, msgId, text, parseMode) => agent.tgBot.editText(cid, msgId, text, parseMode),
+                sendPhoto: (cid, buffer, caption) => agent.tgBot.sendPhotoBuffer(cid, buffer, caption),
+            };
+            acc = new StreamAccumulator({ chatId, sender });
+            agent.accumulators.set(accKey, acc);
+        }
+        // Sub-agent tracker — create lazily alongside the accumulator
+        let tracker = agent.subAgentTrackers.get(accKey);
+        if (!tracker) {
+            const subAgentSender = {
+                sendMessage: (cid, text, parseMode) => agent.tgBot.sendText(cid, text, parseMode),
+                editMessage: (cid, msgId, text, parseMode) => agent.tgBot.editText(cid, msgId, text, parseMode),
+                setReaction: (cid, msgId, emoji) => agent.tgBot.setReaction(cid, msgId, emoji),
+            };
+            tracker = new SubAgentTracker({
+                chatId,
+                sender: subAgentSender,
+            });
+            agent.subAgentTrackers.set(accKey, tracker);
+        }
+        // On message_start: always create new message on new CC turn for deterministic behavior
+        if (event.type === 'message_start') {
+            // Soft reset: clear buffer but keep tgMessageId so tool indicators
+            // ("Using Bash...") get overwritten by the actual response text.
+            // Only do a full reset (new TG message) when sub-agents were active,
+            // since their results should appear in a separate message.
+            if (tracker.hadSubAgents) {
+                acc.reset();
+            }
+            else {
+                acc.softReset();
+            }
+            // Only reset tracker if no agents still dispatched
+            if (!tracker.hasDispatchedAgents) {
+                tracker.reset();
+            }
+        }
+        acc.handleEvent(event);
+        tracker.handleEvent(event);
+    }
+    handleResult(agentId, userId, chatId, event) {
+        const agent = this.agents.get(agentId);
+        if (!agent)
+            return;
+        // Set usage stats on the accumulator before finalizing
+        const accKey = `${userId}:${chatId}`;
+        const acc = agent.accumulators.get(accKey);
+        if (acc) {
+            // Extract usage from result event
+            if (event.usage) {
+                acc.setTurnUsage({
+                    inputTokens: event.usage.input_tokens ?? 0,
+                    outputTokens: event.usage.output_tokens ?? 0,
+                    cacheReadTokens: event.usage.cache_read_input_tokens ?? 0,
+                    cacheCreationTokens: event.usage.cache_creation_input_tokens ?? 0,
+                    costUsd: event.total_cost_usd ?? null,
+                });
+            }
+            acc.finalize();
+            // Don't delete — next turn will softReset via message_start and edit the same message
+        }
+        // Update session store with cost
+        if (event.total_cost_usd) {
+            this.sessionStore.updateSessionActivity(agentId, userId, event.total_cost_usd);
+        }
+        // Update JSONL tracking after our own CC turn completes
+        // This prevents false-positive staleness on our own writes
+        this.updateJsonlTracking(agentId, userId);
+        // Handle errors
+        if (event.is_error && event.result) {
+            agent.tgBot.sendText(chatId, `<i>Error: ${escapeHtml(String(event.result))}</i>`, 'HTML');
+        }
+        // If background sub-agents are still running, mailbox watcher handles them.
+        // Ensure mailbox watch is started if we have a team name and dispatched agents.
+        const tracker = agent.subAgentTrackers.get(accKey);
+        if (tracker?.hasDispatchedAgents && tracker.currentTeamName) {
+            this.logger.info({ agentId }, 'Turn ended with background sub-agents still running');
+            // Clear idle timer — don't kill CC while background agents are working
+            const ccProcess = agent.processes.get(userId);
+            if (ccProcess)
+                ccProcess.clearIdleTimer();
+            // Start mailbox watcher (works for general-purpose agents that have SendMessage)
+            tracker.startMailboxWatch();
+            // Fallback: send ONE follow-up after 60s if mailbox hasn't resolved all agents
+            // This handles bash-type agents that can't write to mailbox
+            if (!tracker.hasPendingFollowUp) {
+                tracker.hasPendingFollowUp = true;
+                setTimeout(() => {
+                    if (!tracker.hasDispatchedAgents)
+                        return; // already resolved via mailbox
+                    const proc = agent.processes.get(userId);
+                    if (!proc)
+                        return;
+                    this.logger.info({ agentId }, 'Mailbox timeout — sending single follow-up for remaining agents');
+                    // Mark all remaining dispatched agents as completed (CC already has the results)
+                    for (const info of tracker.activeAgents) {
+                        if (info.status === 'dispatched') {
+                            tracker.markCompleted(info.toolUseId, '(results delivered in CC response)');
+                        }
+                    }
+                    proc.sendMessage(createTextMessage('The background agents should be done by now. Please report their results.'));
+                }, 60_000);
+            }
+        }
+    }
+    // ── Slash commands ──
+    async handleSlashCommand(agentId, cmd) {
+        const agent = this.agents.get(agentId);
+        if (!agent)
+            return;
+        this.logger.debug({ agentId, command: cmd.command, args: cmd.args }, 'Slash command');
+        switch (cmd.command) {
+            case 'start': {
+                await agent.tgBot.sendText(cmd.chatId, '👋 TGCC — Telegram ↔ Claude Code bridge\n\nSend me a message to start a CC session, or use /help for commands.');
+                // Re-register commands with BotFather to ensure menu is up to date
+                try {
+                    const { COMMANDS } = await import('./telegram.js');
+                    await agent.tgBot.bot.api.setMyCommands(COMMANDS);
+                }
+                catch { }
+                break;
+            }
+            case 'help':
+                await agent.tgBot.sendText(cmd.chatId, HELP_TEXT, 'HTML');
+                break;
+            case 'ping': {
+                const proc = agent.processes.get(cmd.userId);
+                const state = proc?.state ?? 'idle';
+                await agent.tgBot.sendText(cmd.chatId, `pong — process: ${state.toUpperCase()}`);
+                break;
+            }
+            case 'status': {
+                const proc = agent.processes.get(cmd.userId);
+                const userState = this.sessionStore.getUser(agentId, cmd.userId);
+                const uptime = proc?.spawnedAt
+                    ? formatDuration(Date.now() - proc.spawnedAt.getTime())
+                    : 'N/A';
+                const status = [
+                    `<b>Agent:</b> ${escapeHtml(agentId)}`,
+                    `<b>Process:</b> ${(proc?.state ?? 'idle').toUpperCase()} (uptime: ${uptime})`,
+                    `<b>Session:</b> <code>${escapeHtml(proc?.sessionId?.slice(0, 8) ?? 'none')}</code>`,
+                    `<b>Model:</b> ${escapeHtml(userState.model || resolveUserConfig(agent.config, cmd.userId).model)}`,
+                    `<b>Repo:</b> ${escapeHtml(userState.repo || resolveUserConfig(agent.config, cmd.userId).repo)}`,
+                    `<b>Cost:</b> $${(proc?.totalCostUsd ?? 0).toFixed(4)}`,
+                ].join('\n');
+                await agent.tgBot.sendText(cmd.chatId, status, 'HTML');
+                break;
+            }
+            case 'cost': {
+                const proc = agent.processes.get(cmd.userId);
+                await agent.tgBot.sendText(cmd.chatId, `Session cost: $${(proc?.totalCostUsd ?? 0).toFixed(4)}`);
+                break;
+            }
+            case 'new': {
+                const proc = agent.processes.get(cmd.userId);
+                if (proc) {
+                    proc.destroy();
+                    agent.processes.delete(cmd.userId);
+                }
+                this.sessionStore.clearSession(agentId, cmd.userId);
+                await agent.tgBot.sendText(cmd.chatId, 'Session cleared. Next message starts fresh.');
+                break;
+            }
+            case 'sessions': {
+                const sessions = this.sessionStore.getRecentSessions(agentId, cmd.userId);
+                if (sessions.length === 0) {
+                    await agent.tgBot.sendText(cmd.chatId, 'No recent sessions.');
+                    break;
+                }
+                const currentSessionId = this.sessionStore.getUser(agentId, cmd.userId).currentSessionId;
+                const lines = [];
+                const keyboard = new InlineKeyboard();
+                sessions.forEach((s, i) => {
+                    const rawTitle = s.title || s.id.slice(0, 8);
+                    const displayTitle = s.title ? escapeHtml(s.title) : `<code>${escapeHtml(s.id.slice(0, 8))}</code>`;
+                    const age = formatAge(new Date(s.lastActivity));
+                    const isCurrent = s.id === currentSessionId;
+                    const current = isCurrent ? ' ✓' : '';
+                    lines.push(`<b>${i + 1}.</b> ${displayTitle}${current}\n    ${s.messageCount} msgs · $${s.totalCostUsd.toFixed(2)} · ${age}`);
+                    // Button: full title (TG allows up to ~40 chars visible), no ellipsis
+                    if (!isCurrent) {
+                        const btnLabel = rawTitle.length > 35 ? rawTitle.slice(0, 35) : rawTitle;
+                        keyboard.text(`${i + 1}. ${btnLabel}`, `resume:${s.id}`).row();
+                    }
+                });
+                await agent.tgBot.sendTextWithKeyboard(cmd.chatId, `📋 <b>Sessions</b>\n\n${lines.join('\n\n')}`, keyboard, 'HTML');
+                break;
+            }
+            case 'resume': {
+                if (!cmd.args) {
+                    await agent.tgBot.sendText(cmd.chatId, 'Usage: /resume <session-id>');
+                    break;
+                }
+                const proc = agent.processes.get(cmd.userId);
+                if (proc) {
+                    proc.destroy();
+                    agent.processes.delete(cmd.userId);
+                }
+                this.sessionStore.setCurrentSession(agentId, cmd.userId, cmd.args.trim());
+                await agent.tgBot.sendText(cmd.chatId, `Will resume session <code>${escapeHtml(cmd.args.trim().slice(0, 8))}</code> on next message.`, 'HTML');
+                break;
+            }
+            case 'session': {
+                const userState = this.sessionStore.getUser(agentId, cmd.userId);
+                const session = userState.sessions.find(s => s.id === userState.currentSessionId);
+                if (!session) {
+                    await agent.tgBot.sendText(cmd.chatId, 'No active session.');
+                    break;
+                }
+                await agent.tgBot.sendText(cmd.chatId, `<b>Session:</b> <code>${escapeHtml(session.id.slice(0, 8))}</code>\n<b>Messages:</b> ${session.messageCount}\n<b>Cost:</b> $${session.totalCostUsd.toFixed(4)}\n<b>Started:</b> ${session.startedAt}`, 'HTML');
+                break;
+            }
+            case 'model': {
+                if (!cmd.args) {
+                    const current = this.sessionStore.getUser(agentId, cmd.userId).model
+                        || resolveUserConfig(agent.config, cmd.userId).model;
+                    await agent.tgBot.sendText(cmd.chatId, `Current model: ${current}\n\nUsage: /model <model-name>`);
+                    break;
+                }
+                this.sessionStore.setModel(agentId, cmd.userId, cmd.args.trim());
+                await agent.tgBot.sendText(cmd.chatId, `Model set to <code>${escapeHtml(cmd.args.trim())}</code>. Takes effect on next spawn.`, 'HTML');
+                break;
+            }
+            case 'repo': {
+                const repoArgs = cmd.args?.trim().split(/\s+/) ?? [];
+                const repoSub = repoArgs[0];
+                this.logger.debug({ repoSub, repoArgs, repos: Object.keys(this.config.repos), hasArgs: !!cmd.args, argsRaw: cmd.args }, '/repo command debug');
+                if (repoSub === 'add') {
+                    // /repo add <name> <path>
+                    const repoName = repoArgs[1];
+                    const repoAddPath = repoArgs[2];
+                    if (!repoName || !repoAddPath) {
+                        await agent.tgBot.sendText(cmd.chatId, 'Usage: /repo add <name> <path>');
+                        break;
+                    }
+                    if (!isValidRepoName(repoName)) {
+                        await agent.tgBot.sendText(cmd.chatId, 'Invalid repo name. Use alphanumeric + hyphens only.');
+                        break;
+                    }
+                    if (!existsSync(repoAddPath)) {
+                        await agent.tgBot.sendText(cmd.chatId, `Path not found: ${repoAddPath}`);
+                        break;
+                    }
+                    if (this.config.repos[repoName]) {
+                        await agent.tgBot.sendText(cmd.chatId, `Repo "${repoName}" already exists.`);
+                        break;
+                    }
+                    updateConfig((cfg) => {
+                        const repos = (cfg.repos ?? {});
+                        repos[repoName] = repoAddPath;
+                        cfg.repos = repos;
+                    });
+                    await agent.tgBot.sendText(cmd.chatId, `Repo <code>${escapeHtml(repoName)}</code> added → ${escapeHtml(repoAddPath)}`, 'HTML');
+                    break;
+                }
+                if (repoSub === 'remove') {
+                    // /repo remove <name>
+                    const repoName = repoArgs[1];
+                    if (!repoName) {
+                        await agent.tgBot.sendText(cmd.chatId, 'Usage: /repo remove <name>');
+                        break;
+                    }
+                    if (!this.config.repos[repoName]) {
+                        await agent.tgBot.sendText(cmd.chatId, `Repo "${repoName}" not found.`);
+                        break;
+                    }
+                    // Check if any agent has it assigned
+                    const rawCfg = JSON.parse(readFileSync(join(homedir(), '.tgcc', 'config.json'), 'utf-8'));
+                    const owner = findRepoOwner(rawCfg, repoName);
+                    if (owner) {
+                        await agent.tgBot.sendText(cmd.chatId, `Can't remove: repo "${repoName}" is assigned to agent "${owner}". Use /repo clear on that agent first.`);
+                        break;
+                    }
+                    updateConfig((cfg) => {
+                        const repos = (cfg.repos ?? {});
+                        delete repos[repoName];
+                        cfg.repos = repos;
+                    });
+                    await agent.tgBot.sendText(cmd.chatId, `Repo <code>${escapeHtml(repoName)}</code> removed.`, 'HTML');
+                    break;
+                }
+                if (repoSub === 'assign') {
+                    // /repo assign <name> — assign to THIS agent
+                    const repoName = repoArgs[1];
+                    if (!repoName) {
+                        await agent.tgBot.sendText(cmd.chatId, 'Usage: /repo assign <name>');
+                        break;
+                    }
+                    if (!this.config.repos[repoName]) {
+                        await agent.tgBot.sendText(cmd.chatId, `Repo "${repoName}" not found in registry.`);
+                        break;
+                    }
+                    const rawCfg2 = JSON.parse(readFileSync(join(homedir(), '.tgcc', 'config.json'), 'utf-8'));
+                    const existingOwner = findRepoOwner(rawCfg2, repoName);
+                    if (existingOwner && existingOwner !== agentId) {
+                        await agent.tgBot.sendText(cmd.chatId, `Repo "${repoName}" is already assigned to agent "${existingOwner}".`);
+                        break;
+                    }
+                    updateConfig((cfg) => {
+                        const agents = (cfg.agents ?? {});
+                        const agentCfg = agents[agentId];
+                        if (agentCfg) {
+                            const defaults = (agentCfg.defaults ?? {});
+                            defaults.repo = repoName;
+                            agentCfg.defaults = defaults;
+                        }
+                    });
+                    await agent.tgBot.sendText(cmd.chatId, `Repo <code>${escapeHtml(repoName)}</code> assigned to agent <code>${escapeHtml(agentId)}</code>.`, 'HTML');
+                    break;
+                }
+                if (repoSub === 'help') {
+                    const helpText = [
+                        '<b>Repo Management</b>',
+                        '',
+                        '/repo — List repos (buttons)',
+                        '/repo help — This help text',
+                        '/repo add &lt;name&gt; &lt;path&gt; — Register a repo',
+                        '/repo remove &lt;name&gt; — Unregister a repo',
+                        '/repo assign &lt;name&gt; — Set as this agent\'s default',
+                        '/repo clear — Clear this agent\'s default',
+                    ].join('\n');
+                    await agent.tgBot.sendText(cmd.chatId, helpText, 'HTML');
+                    break;
+                }
+                if (repoSub === 'clear') {
+                    // /repo clear — clear THIS agent's default repo
+                    updateConfig((cfg) => {
+                        const agents = (cfg.agents ?? {});
+                        const agentCfg = agents[agentId];
+                        if (agentCfg) {
+                            const defaults = (agentCfg.defaults ?? {});
+                            delete defaults.repo;
+                            agentCfg.defaults = defaults;
+                        }
+                    });
+                    await agent.tgBot.sendText(cmd.chatId, `Default repo cleared for agent <code>${escapeHtml(agentId)}</code>.`, 'HTML');
+                    break;
+                }
+                if (!cmd.args) {
+                    const current = this.sessionStore.getUser(agentId, cmd.userId).repo
+                        || resolveUserConfig(agent.config, cmd.userId).repo;
+                    // Show available repos as inline keyboard buttons
+                    const repoEntries = Object.entries(this.config.repos);
+                    if (repoEntries.length > 0) {
+                        const keyboard = new InlineKeyboard();
+                        for (const [name] of repoEntries) {
+                            keyboard.text(name, `repo:${name}`).row();
+                        }
+                        keyboard.text('➕ Add', 'repo_add:prompt').text('❓ Help', 'repo_help:show').row();
+                        await agent.tgBot.sendTextWithKeyboard(cmd.chatId, `Current repo: <code>${escapeHtml(current)}</code>\n\nSelect a repo:\n\n<i>Type /repo help for management commands</i>`, keyboard, 'HTML');
+                    }
+                    else {
+                        await agent.tgBot.sendText(cmd.chatId, `Current repo: ${current}\n\nUsage: /repo <path>`);
+                    }
+                    break;
+                }
+                // Fallback: /repo <path-or-name> — switch working directory for session
+                const repoPath = resolveRepoPath(this.config.repos, cmd.args.trim());
+                if (!existsSync(repoPath)) {
+                    await agent.tgBot.sendText(cmd.chatId, `Path not found: ${repoPath}`);
+                    break;
+                }
+                // Kill current process (different CWD needs new process)
+                const proc = agent.processes.get(cmd.userId);
+                if (proc) {
+                    proc.destroy();
+                    agent.processes.delete(cmd.userId);
+                }
+                this.sessionStore.setRepo(agentId, cmd.userId, repoPath);
+                const userState = this.sessionStore.getUser(agentId, cmd.userId);
+                const lastActive = new Date(userState.lastActivity).getTime();
+                const staleMs = 24 * 60 * 60 * 1000;
+                if (Date.now() - lastActive > staleMs || !userState.currentSessionId) {
+                    this.sessionStore.clearSession(agentId, cmd.userId);
+                    await agent.tgBot.sendText(cmd.chatId, `Repo set to <code>${escapeHtml(repoPath)}</code>. Session cleared (stale).`, 'HTML');
+                }
+                else {
+                    await agent.tgBot.sendText(cmd.chatId, `Repo set to <code>${escapeHtml(repoPath)}</code>. Session kept (active &lt;24h).`, 'HTML');
+                }
+                break;
+            }
+            case 'cancel': {
+                const proc = agent.processes.get(cmd.userId);
+                if (proc && proc.state === 'active') {
+                    proc.cancel();
+                    await agent.tgBot.sendText(cmd.chatId, 'Cancelled.');
+                }
+                else {
+                    await agent.tgBot.sendText(cmd.chatId, 'No active turn to cancel.');
+                }
+                break;
+            }
+            case 'catchup': {
+                const userState = this.sessionStore.getUser(agentId, cmd.userId);
+                const repo = userState.repo || resolveUserConfig(agent.config, cmd.userId).repo;
+                const lastActivity = new Date(userState.lastActivity || 0);
+                const missed = findMissedSessions(repo, userState.knownSessionIds, lastActivity);
+                const message = formatCatchupMessage(repo, missed);
+                await agent.tgBot.sendText(cmd.chatId, message, 'HTML');
+                break;
+            }
+            case 'permissions': {
+                const validModes = ['dangerously-skip', 'acceptEdits', 'default', 'plan'];
+                const userState = this.sessionStore.getUser(agentId, cmd.userId);
+                const agentDefault = agent.config.defaults.permissionMode;
+                const currentMode = userState.permissionMode || agentDefault;
+                if (cmd.args) {
+                    const mode = cmd.args.trim();
+                    if (!validModes.includes(mode)) {
+                        await agent.tgBot.sendText(cmd.chatId, `Invalid mode. Valid: ${validModes.join(', ')}`);
+                        break;
+                    }
+                    this.sessionStore.setPermissionMode(agentId, cmd.userId, mode);
+                    // Kill current process so new mode takes effect on next spawn
+                    const proc = agent.processes.get(cmd.userId);
+                    if (proc) {
+                        proc.destroy();
+                        agent.processes.delete(cmd.userId);
+                    }
+                    await agent.tgBot.sendText(cmd.chatId, `Permission mode set to <code>${escapeHtml(mode)}</code>. Takes effect on next message.`, 'HTML');
+                    break;
+                }
+                // No args — show current mode + inline keyboard
+                const keyboard = new InlineKeyboard();
+                keyboard.text('🔓 Bypass', 'permissions:dangerously-skip').text('✏️ Accept Edits', 'permissions:acceptEdits').row();
+                keyboard.text('🔒 Default', 'permissions:default').text('📋 Plan', 'permissions:plan').row();
+                await agent.tgBot.sendTextWithKeyboard(cmd.chatId, `Current: <code>${escapeHtml(currentMode)}</code>\nDefault: <code>${escapeHtml(agentDefault)}</code>\n\nSelect a mode for this session:`, keyboard, 'HTML');
+                break;
+            }
+        }
+    }
+    // ── Callback query handling (inline buttons) ──
+    async handleCallbackQuery(agentId, query) {
+        const agent = this.agents.get(agentId);
+        if (!agent)
+            return;
+        this.logger.debug({ agentId, action: query.action, data: query.data }, 'Callback query');
+        switch (query.action) {
+            case 'resume': {
+                const sessionId = query.data;
+                const proc = agent.processes.get(query.userId);
+                if (proc) {
+                    proc.destroy();
+                    agent.processes.delete(query.userId);
+                }
+                this.sessionStore.setCurrentSession(agentId, query.userId, sessionId);
+                await agent.tgBot.answerCallbackQuery(query.callbackQueryId, 'Session set');
+                await agent.tgBot.sendText(query.chatId, `Will resume session <code>${escapeHtml(sessionId.slice(0, 8))}</code> on next message.`, 'HTML');
+                break;
+            }
+            case 'delete': {
+                const sessionId = query.data;
+                const deleted = this.sessionStore.deleteSession(agentId, query.userId, sessionId);
+                if (deleted) {
+                    await agent.tgBot.answerCallbackQuery(query.callbackQueryId, 'Session deleted');
+                    await agent.tgBot.sendText(query.chatId, `Session <code>${escapeHtml(sessionId.slice(0, 8))}</code> deleted.`, 'HTML');
+                }
+                else {
+                    await agent.tgBot.answerCallbackQuery(query.callbackQueryId, 'Session not found');
+                }
+                break;
+            }
+            case 'repo': {
+                const repoName = query.data;
+                const repoPath = resolveRepoPath(this.config.repos, repoName);
+                if (!existsSync(repoPath)) {
+                    await agent.tgBot.answerCallbackQuery(query.callbackQueryId, 'Path not found');
+                    break;
+                }
+                // Kill current process (different CWD needs new process)
+                const proc = agent.processes.get(query.userId);
+                if (proc) {
+                    proc.destroy();
+                    agent.processes.delete(query.userId);
+                }
+                this.sessionStore.setRepo(agentId, query.userId, repoPath);
+                const userState2 = this.sessionStore.getUser(agentId, query.userId);
+                const lastActive2 = new Date(userState2.lastActivity).getTime();
+                const staleMs2 = 24 * 60 * 60 * 1000;
+                await agent.tgBot.answerCallbackQuery(query.callbackQueryId, `Repo: ${repoName}`);
+                if (Date.now() - lastActive2 > staleMs2 || !userState2.currentSessionId) {
+                    this.sessionStore.clearSession(agentId, query.userId);
+                    await agent.tgBot.sendText(query.chatId, `Repo set to <code>${escapeHtml(repoPath)}</code>. Session cleared (stale).`, 'HTML');
+                }
+                else {
+                    await agent.tgBot.sendText(query.chatId, `Repo set to <code>${escapeHtml(repoPath)}</code>. Session kept (active &lt;24h).`, 'HTML');
+                }
+                break;
+            }
+            case 'repo_add': {
+                await agent.tgBot.answerCallbackQuery(query.callbackQueryId, 'Usage below');
+                await agent.tgBot.sendText(query.chatId, 'Send: <code>/repo add &lt;name&gt; &lt;path&gt;</code>', 'HTML');
+                break;
+            }
+            case 'permissions': {
+                const validModes = ['dangerously-skip', 'acceptEdits', 'default', 'plan'];
+                const mode = query.data;
+                if (!validModes.includes(mode)) {
+                    await agent.tgBot.answerCallbackQuery(query.callbackQueryId, 'Invalid mode');
+                    break;
+                }
+                this.sessionStore.setPermissionMode(agentId, query.userId, mode);
+                // Kill current process so new mode takes effect on next spawn
+                const proc = agent.processes.get(query.userId);
+                if (proc) {
+                    proc.destroy();
+                    agent.processes.delete(query.userId);
+                }
+                await agent.tgBot.answerCallbackQuery(query.callbackQueryId, `Mode: ${mode}`);
+                await agent.tgBot.sendText(query.chatId, `Permission mode set to <code>${escapeHtml(mode)}</code>. Takes effect on next message.`, 'HTML');
+                break;
+            }
+            case 'repo_help': {
+                await agent.tgBot.answerCallbackQuery(query.callbackQueryId);
+                const helpText = [
+                    '<b>Repo Management</b>',
+                    '',
+                    '/repo — List repos (buttons)',
+                    '/repo help — This help text',
+                    '/repo add &lt;name&gt; &lt;path&gt; — Register a repo',
+                    '/repo remove &lt;name&gt; — Unregister a repo',
+                    '/repo assign &lt;name&gt; — Set as this agent\'s default',
+                    '/repo clear — Clear this agent\'s default',
+                ].join('\n');
+                await agent.tgBot.sendText(query.chatId, helpText, 'HTML');
+                break;
+            }
+            case 'perm_allow': {
+                const requestId = query.data;
+                const pending = agent.pendingPermissions.get(requestId);
+                if (!pending) {
+                    await agent.tgBot.answerCallbackQuery(query.callbackQueryId, 'Permission expired');
+                    break;
+                }
+                const proc = agent.processes.get(pending.userId);
+                if (proc) {
+                    proc.respondToPermission(requestId, true);
+                }
+                agent.pendingPermissions.delete(requestId);
+                await agent.tgBot.answerCallbackQuery(query.callbackQueryId, '✅ Allowed');
+                break;
+            }
+            case 'perm_deny': {
+                const requestId = query.data;
+                const pending = agent.pendingPermissions.get(requestId);
+                if (!pending) {
+                    await agent.tgBot.answerCallbackQuery(query.callbackQueryId, 'Permission expired');
+                    break;
+                }
+                const proc = agent.processes.get(pending.userId);
+                if (proc) {
+                    proc.respondToPermission(requestId, false);
+                }
+                agent.pendingPermissions.delete(requestId);
+                await agent.tgBot.answerCallbackQuery(query.callbackQueryId, '❌ Denied');
+                break;
+            }
+            case 'perm_allow_all': {
+                // Allow all pending permissions for this user
+                const targetUserId = query.data;
+                const toAllow = [];
+                for (const [reqId, pending] of agent.pendingPermissions) {
+                    if (pending.userId === targetUserId) {
+                        toAllow.push(reqId);
+                    }
+                }
+                const proc = agent.processes.get(targetUserId);
+                for (const reqId of toAllow) {
+                    if (proc)
+                        proc.respondToPermission(reqId, true);
+                    agent.pendingPermissions.delete(reqId);
+                }
+                await agent.tgBot.answerCallbackQuery(query.callbackQueryId, `✅ Allowed ${toAllow.length} permission(s)`);
+                break;
+            }
+            default:
+                await agent.tgBot.answerCallbackQuery(query.callbackQueryId);
+        }
+    }
+    // ── Control socket handlers (CLI interface) ──
+    handleCtlMessage(agentId, text, sessionId) {
+        const agent = this.agents.get(agentId);
+        if (!agent) {
+            // Return error via the CtlAckResponse shape won't work — but the ctl-server
+            // protocol handles errors separately. We'll throw and let it catch.
+            throw new Error(`Unknown agent: ${agentId}`);
+        }
+        // Use the first allowed user as the "CLI user" identity
+        const userId = agent.config.allowedUsers[0];
+        const chatId = Number(userId);
+        // If explicit session requested, set it
+        if (sessionId) {
+            this.sessionStore.setCurrentSession(agentId, userId, sessionId);
+        }
+        // Route through the same sendToCC path as Telegram
+        this.sendToCC(agentId, userId, chatId, { text });
+        const proc = agent.processes.get(userId);
+        return {
+            type: 'ack',
+            sessionId: proc?.sessionId ?? this.sessionStore.getUser(agentId, userId).currentSessionId,
+            state: proc?.state ?? 'idle',
+        };
+    }
+    handleCtlStatus(agentId) {
+        const agents = [];
+        const sessions = [];
+        const agentIds = agentId ? [agentId] : [...this.agents.keys()];
+        for (const id of agentIds) {
+            const agent = this.agents.get(id);
+            if (!agent)
+                continue;
+            // Aggregate process state across users
+            let state = 'idle';
+            for (const [, proc] of agent.processes) {
+                if (proc.state === 'active') {
+                    state = 'active';
+                    break;
+                }
+                if (proc.state === 'spawning')
+                    state = 'spawning';
+            }
+            const userId = agent.config.allowedUsers[0];
+            const proc = agent.processes.get(userId);
+            const userConfig = resolveUserConfig(agent.config, userId);
+            agents.push({
+                id,
+                state,
+                sessionId: proc?.sessionId ?? null,
+                repo: this.sessionStore.getUser(id, userId).repo || userConfig.repo,
+            });
+            // List sessions for this agent
+            const userState = this.sessionStore.getUser(id, userId);
+            for (const sess of userState.sessions.slice(-5).reverse()) {
+                sessions.push({
+                    id: sess.id,
+                    agentId: id,
+                    messageCount: sess.messageCount,
+                    totalCostUsd: sess.totalCostUsd,
+                });
+            }
+        }
+        return { type: 'status', agents, sessions };
+    }
+    // ── MCP tool handling ──
+    async handleMcpToolRequest(request) {
+        const agent = this.agents.get(request.agentId);
+        if (!agent) {
+            return { id: request.id, success: false, error: `Unknown agent: ${request.agentId}` };
+        }
+        // Find the chat ID for this user (from the most recent message)
+        // We use the userId to find which chat to send to
+        const chatId = Number(request.userId); // In TG, private chat ID === user ID
+        try {
+            switch (request.tool) {
+                case 'send_file':
+                    await agent.tgBot.sendFile(chatId, request.params.path, request.params.caption);
+                    return { id: request.id, success: true };
+                case 'send_image':
+                    await agent.tgBot.sendImage(chatId, request.params.path, request.params.caption);
+                    return { id: request.id, success: true };
+                case 'send_voice':
+                    await agent.tgBot.sendVoice(chatId, request.params.path, request.params.caption);
+                    return { id: request.id, success: true };
+                default:
+                    return { id: request.id, success: false, error: `Unknown tool: ${request.tool}` };
+            }
+        }
+        catch (err) {
+            return { id: request.id, success: false, error: err instanceof Error ? err.message : 'Unknown error' };
+        }
+    }
+    // ── Shutdown ──
+    async stop() {
+        this.logger.info('Stopping bridge');
+        for (const agentId of [...this.agents.keys()]) {
+            await this.stopAgent(agentId);
+        }
+        this.mcpServer.closeAll();
+        this.ctlServer.closeAll();
+        this.logger.info('Bridge stopped');
+    }
+}
+// ── Helpers ──
+function formatDuration(ms) {
+    const secs = Math.floor(ms / 1000);
+    if (secs < 60)
+        return `${secs}s`;
+    const mins = Math.floor(secs / 60);
+    if (mins < 60)
+        return `${mins}m`;
+    const hours = Math.floor(mins / 60);
+    return `${hours}h ${mins % 60}m`;
+}
+function formatAge(date) {
+    const diffMs = Date.now() - date.getTime();
+    const mins = Math.floor(diffMs / 60000);
+    if (mins < 60)
+        return `${mins}m ago`;
+    const hours = Math.floor(mins / 60);
+    if (hours < 24)
+        return `${hours}h ago`;
+    const days = Math.floor(hours / 24);
+    return `${days}d ago`;
+}
+/** Environment-aware MCP server path resolution */
+function resolveMcpServerPath() {
+    const baseDir = import.meta.dirname ?? '.';
+    // Check for compiled JS first (production/tsx runtime)
+    const jsPath = join(baseDir, 'mcp-server.js');
+    if (existsSync(jsPath)) {
+        return jsPath;
+    }
+    // Fallback to TS source (development)
+    return join(baseDir, 'mcp-server.ts');
+}
+//# sourceMappingURL=bridge.js.map