@selucas12/cheesy 2.0.0

package/dist/workspace-telegram-bot.js

@@ -0,0 +1,1847 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Node.js version check — must run before anything else
+const [major] = process.versions.node.split('.').map(Number);
+if (major < 18) {
+    console.error(`Cheesyboy requires Node.js >= 18.0.0 (you have ${process.version}).`);
+    console.error('Upgrade: https://nodejs.org/ or use nvm: nvm install 18');
+    process.exit(1);
+}
+/**
+ * Workspace Telegram Bot — long-polling bot for remote Claude Code control.
+ *
+ * Commands:
+ *   /<workspace> <command>   Route a command to the Claude session in that workspace
+ *   /sessions                List all active sessions with workspace names
+ *   /cmd <TOKEN> <command>   Token-based fallback for direct session access
+ *   /help                    Show available commands
+ *   /status [workspace]      Show tmux pane output for a workspace
+ *   /stop [workspace]       Interrupt running prompt (Ctrl+C)
+ *   /compact [workspace]     Compact context in a workspace session
+ */
+const path_1 = __importDefault(require("path"));
+const paths_1 = require("./src/utils/paths");
+require('dotenv').config({ path: path_1.default.join(paths_1.PROJECT_ROOT, '.env'), quiet: true });
+const https_1 = __importDefault(require("https"));
+const http_1 = __importDefault(require("http"));
+const fs_1 = __importDefault(require("fs"));
+const child_process_1 = require("child_process");
+const workspace_router_1 = require("./workspace-router");
+const prompt_bridge_1 = require("./prompt-bridge");
+const callback_parser_1 = require("./src/utils/callback-parser");
+const pty_session_manager_1 = require("./src/utils/pty-session-manager");
+const ghostty_session_manager_1 = require("./src/utils/ghostty-session-manager");
+const deep_link_1 = require("./src/utils/deep-link");
+const transcript_reader_1 = require("./src/utils/transcript-reader");
+const logger_1 = __importDefault(require("./src/core/logger"));
+const logger = new logger_1.default('bot');
+const INJECTION_MODE = process.env.INJECTION_MODE || 'tmux';
+const TMUX_AVAILABLE = (() => {
+    try {
+        (0, child_process_1.execSync)('tmux -V', { stdio: 'ignore' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+})();
+/**
+ * Determine the active injection backend.
+ * Respects INJECTION_MODE env var, falls back in order: ghostty → pty → tmux.
+ */
+function getEffectiveMode() {
+    if (INJECTION_MODE === 'ghostty' && ghostty_session_manager_1.ghosttySessionManager.isAvailable())
+        return 'ghostty';
+    if (INJECTION_MODE === 'pty' && pty_session_manager_1.ptySessionManager.isAvailable())
+        return 'pty';
+    if (TMUX_AVAILABLE && INJECTION_MODE !== 'pty' && INJECTION_MODE !== 'ghostty')
+        return 'tmux';
+    if (ghostty_session_manager_1.ghosttySessionManager.isAvailable())
+        return 'ghostty';
+    if (pty_session_manager_1.ptySessionManager.isAvailable())
+        return 'pty';
+    return 'tmux';
+}
+const BOT_TOKEN = process.env.TELEGRAM_BOT_TOKEN;
+const CHAT_ID = process.env.TELEGRAM_CHAT_ID;
+if (!BOT_TOKEN || BOT_TOKEN === 'YOUR_BOT_TOKEN_HERE') {
+    logger.error('TELEGRAM_BOT_TOKEN not configured in .env');
+    logger.error('  Get your token from @BotFather: https://t.me/BotFather');
+    process.exit(1);
+}
+if (!CHAT_ID || CHAT_ID === 'YOUR_CHAT_ID_HERE') {
+    logger.error('TELEGRAM_CHAT_ID not configured in .env');
+    logger.error('  Get your chat ID from @userinfobot: https://t.me/userinfobot');
+    process.exit(1);
+}
+let lastUpdateId = 0;
+let lastPollTime = null; // timestamp of last successful getUpdates call
+const startTime = Date.now();
+const activeTypingIntervals = new Map(); // workspace → intervalId
+// ── Telegram API helpers ────────────────────────────────────────
+function telegramAPI(method, body) {
+    return new Promise((resolve, reject) => {
+        const payload = JSON.stringify(body);
+        const options = {
+            hostname: 'api.telegram.org',
+            path: `/bot${BOT_TOKEN}/${method}`,
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Content-Length': Buffer.byteLength(payload),
+            },
+            timeout: method === 'getUpdates' ? 35000 : 10000,
+        };
+        const req = https_1.default.request(options, (res) => {
+            let data = '';
+            res.on('data', (chunk) => { data += chunk; });
+            res.on('end', () => {
+                try {
+                    const parsed = JSON.parse(data);
+                    if (!parsed.ok) {
+                        reject(new Error(`Telegram API error: ${parsed.description || data}`));
+                    }
+                    else {
+                        resolve(parsed.result);
+                    }
+                }
+                catch {
+                    reject(new Error(`Invalid JSON from Telegram: ${data.slice(0, 200)}`));
+                }
+            });
+        });
+        req.on('error', reject);
+        req.on('timeout', () => {
+            req.destroy();
+            reject(new Error('Telegram request timed out'));
+        });
+        req.write(payload);
+        req.end();
+    });
+}
+function sendMessage(text) {
+    return telegramAPI('sendMessage', {
+        chat_id: CHAT_ID,
+        text,
+        parse_mode: 'Markdown',
+    });
+}
+function sendHtmlMessage(text) {
+    return telegramAPI('sendMessage', {
+        chat_id: CHAT_ID,
+        text,
+        parse_mode: 'HTML',
+    });
+}
+const TYPING_SIGNAL_PATH = path_1.default.join(paths_1.PROJECT_ROOT, 'src/data', 'typing-active');
+function startTypingIndicator() {
+    stopTypingIndicator();
+    try {
+        fs_1.default.writeFileSync(TYPING_SIGNAL_PATH, String(Date.now()));
+    }
+    catch { }
+    const tick = () => {
+        if (!fs_1.default.existsSync(TYPING_SIGNAL_PATH)) {
+            stopTypingIndicator();
+            return;
+        }
+        telegramAPI('sendChatAction', { chat_id: CHAT_ID, action: 'typing' }).catch(() => { });
+    };
+    tick();
+    const intervalId = setInterval(tick, 4500);
+    const timeoutId = setTimeout(() => stopTypingIndicator(), 5 * 60 * 1000);
+    activeTypingIntervals.set('_active', { intervalId, timeoutId });
+}
+function stopTypingIndicator() {
+    const entry = activeTypingIntervals.get('_active');
+    if (entry) {
+        clearInterval(entry.intervalId);
+        clearTimeout(entry.timeoutId);
+        activeTypingIntervals.delete('_active');
+    }
+    try {
+        fs_1.default.unlinkSync(TYPING_SIGNAL_PATH);
+    }
+    catch { }
+}
+async function registerBotCommands() {
+    const commands = [
+        { command: 'new', description: 'Start Claude in a project directory' },
+        { command: 'resume', description: 'Resume a past Claude conversation' },
+        { command: 'link', description: 'Generate deep link to open Claude' },
+        { command: 'sessions', description: 'List all active Claude sessions' },
+        { command: 'use', description: 'Set or show default workspace' },
+        { command: 'status', description: 'Show current session output' },
+        { command: 'stop', description: 'Interrupt the running prompt' },
+        { command: 'compact', description: 'Compact context in the current session' },
+        { command: 'effort', description: 'Set thinking effort (low/medium/high)' },
+        { command: 'model', description: 'Switch Claude model (sonnet/opus/haiku)' },
+        { command: 'help', description: 'Show available commands' },
+    ];
+    try {
+        // Set for both scopes: all_private_chats takes priority over default in private chats.
+        // If all_private_chats was ever set (e.g. via BotFather), default scope is blocked.
+        await telegramAPI('setMyCommands', { commands, scope: { type: 'all_private_chats' } });
+        await telegramAPI('setMyCommands', { commands, scope: { type: 'default' } });
+        logger.info('Bot commands registered with Telegram');
+    }
+    catch (err) {
+        logger.error(`Failed to register bot commands: ${err.message}`);
+    }
+}
+function answerCallbackQuery(callbackQueryId, text) {
+    return telegramAPI('answerCallbackQuery', {
+        callback_query_id: callbackQueryId,
+        text: text || '',
+    });
+}
+function editMessageText(chatId, messageId, text, replyMarkup) {
+    const body = {
+        chat_id: chatId,
+        message_id: messageId,
+        text,
+        parse_mode: 'Markdown',
+    };
+    if (replyMarkup)
+        body.reply_markup = replyMarkup;
+    return telegramAPI('editMessageText', body);
+}
+// ── Command handlers ────────────────────────────────────────────
+/**
+ * Helper to resolve workspace from arg or default.
+ * Returns the resolved result with workspace and session.
+ */
+function resolveDefaultWorkspace() {
+    const defaultWs = (0, workspace_router_1.getDefaultWorkspace)();
+    if (!defaultWs) {
+        return { type: 'none' };
+    }
+    return (0, workspace_router_1.resolveWorkspace)(defaultWs);
+}
+async function handleHelp() {
+    const defaultWs = (0, workspace_router_1.getDefaultWorkspace)();
+    const msg = [
+        '*Claude Remote Control*',
+        '',
+        '`/<workspace> <command>` — Send command to workspace',
+        '`/use <workspace>` — Set default workspace',
+        '`/use` — Show current default',
+        '`/use clear` — Clear default',
+        '`/compact [workspace]` — Compact context in workspace',
+        '`/new [project]` — Start Claude in a project (shows recent if no arg)',
+        '`/resume [project]` — Resume a past Claude conversation',
+        '`/link <prompt>` — Generate deep link to open Claude',
+        '`/effort [workspace] low|medium|high` — Set thinking effort',
+        '`/model [workspace] <model>` — Switch Claude model',
+        '`/sessions` — List active sessions',
+        '`/status [workspace]` — Show tmux output',
+        '`/stop [workspace]` — Interrupt running prompt',
+        '`/cmd <TOKEN> <command>` — Token-based fallback',
+        '`/help` — This message',
+        '',
+        '_Prefix matching:_ `/ass hello` matches `assistant`',
+        '_Reply-to:_ Reply to any notification to route to that workspace',
+        defaultWs ? `_Default:_ plain text routes to *${escapeMarkdown(defaultWs)}*` : '_Tip:_ Use `/use <workspace>` to send plain text without a prefix',
+    ].join('\n');
+    await sendMessage(msg);
+}
+async function handleLink(prompt) {
+    if (!prompt) {
+        await sendMessage('Usage: `/link <prompt>`\n\nGenerates a clickable link that opens Claude Code with your prompt.');
+        return;
+    }
+    if (!(0, deep_link_1.canGenerateDeepLink)(prompt)) {
+        await sendMessage('\u26a0\ufe0f Prompt too long for deep link (max ~4500 characters).');
+        return;
+    }
+    const deepLink = (0, deep_link_1.generateDeepLink)(prompt);
+    if (!deepLink) {
+        await sendMessage('\u26a0\ufe0f Failed to generate deep link.');
+        return;
+    }
+    // Send the deep link as a clickable button
+    const keyboard = {
+        inline_keyboard: [[
+                { text: '\ud83d\udcbb Open in Claude Code', url: deepLink },
+            ]],
+    };
+    await telegramAPI('sendMessage', {
+        chat_id: CHAT_ID,
+        text: `*Deep Link Generated*\n\n_Tap the button to open Claude Code with:_\n\`${escapeMarkdown(prompt.slice(0, 100))}${prompt.length > 100 ? '...' : ''}\``,
+        parse_mode: 'Markdown',
+        reply_markup: keyboard,
+    });
+}
+/**
+ * /effort [workspace] low|medium|high — Set Claude's thinking effort level
+ */
+async function handleEffort(args) {
+    const validLevels = ['low', 'medium', 'high'];
+    if (!args) {
+        await sendMessage('Usage: `/effort [workspace] low|medium|high`\n\nSet Claude\'s thinking effort level.');
+        return;
+    }
+    const parts = args.split(/\s+/);
+    let workspaceArg = null;
+    let level;
+    // Check if first arg is a valid level or a workspace
+    if (validLevels.includes(parts[0].toLowerCase())) {
+        level = parts[0].toLowerCase();
+    }
+    else if (parts.length >= 2 && validLevels.includes(parts[1].toLowerCase())) {
+        workspaceArg = parts[0];
+        level = parts[1].toLowerCase();
+    }
+    else {
+        await sendMessage(`Invalid effort level. Use: \`low\`, \`medium\`, or \`high\``);
+        return;
+    }
+    // Resolve workspace
+    const resolved = workspaceArg ? (0, workspace_router_1.resolveWorkspace)(workspaceArg) : resolveDefaultWorkspace();
+    if (resolved.type === 'none') {
+        await sendMessage(workspaceArg
+            ? `No session found for workspace \`${escapeMarkdown(workspaceArg)}\``
+            : 'No default workspace set. Use `/use <workspace>` first.');
+        return;
+    }
+    if (resolved.type === 'ambiguous') {
+        const names = resolved.matches.map(m => `\`${escapeMarkdown(m.workspace)}\``).join(', ');
+        await sendMessage(`Multiple matches: ${names}. Be more specific.`);
+        return;
+    }
+    const session = resolved.match.session;
+    const workspace = resolved.workspace;
+    const slashCommand = `/effort ${level}`;
+    const injected = await injectAndRespond(session, slashCommand, workspace);
+    if (injected) {
+        startTypingIndicator();
+        await sendMessage(`\u2699\ufe0f Effort set to *${level}* in *${escapeMarkdown(workspace)}*`);
+    }
+}
+/**
+ * /model [workspace] <model> — Switch Claude model
+ */
+async function handleModel(args) {
+    if (!args) {
+        await sendMessage('Usage: `/model [workspace] <model>`\n\nSwitch Claude model (e.g., `sonnet`, `opus`, `haiku`).');
+        return;
+    }
+    const parts = args.split(/\s+/);
+    let workspaceArg = null;
+    let model;
+    // If 2+ parts, first might be workspace
+    if (parts.length >= 2) {
+        // Try to resolve first part as workspace
+        const maybeWs = (0, workspace_router_1.resolveWorkspace)(parts[0]);
+        if (maybeWs.type === 'exact' || maybeWs.type === 'prefix') {
+            workspaceArg = parts[0];
+            model = parts.slice(1).join(' ');
+        }
+        else {
+            model = parts.join(' ');
+        }
+    }
+    else {
+        model = parts[0];
+    }
+    // Resolve workspace
+    const resolved = workspaceArg ? (0, workspace_router_1.resolveWorkspace)(workspaceArg) : resolveDefaultWorkspace();
+    if (resolved.type === 'none') {
+        await sendMessage(workspaceArg
+            ? `No session found for workspace \`${escapeMarkdown(workspaceArg)}\``
+            : 'No default workspace set. Use `/use <workspace>` first.');
+        return;
+    }
+    if (resolved.type === 'ambiguous') {
+        const names = resolved.matches.map(m => `\`${escapeMarkdown(m.workspace)}\``).join(', ');
+        await sendMessage(`Multiple matches: ${names}. Be more specific.`);
+        return;
+    }
+    const session = resolved.match.session;
+    const workspace = resolved.workspace;
+    const slashCommand = `/model ${model}`;
+    const injected = await injectAndRespond(session, slashCommand, workspace);
+    if (injected) {
+        startTypingIndicator();
+        await sendMessage(`\ud83e\udde0 Model switched to *${escapeMarkdown(model)}* in *${escapeMarkdown(workspace)}*`);
+    }
+}
+async function handleSessions() {
+    (0, workspace_router_1.pruneExpired)();
+    const sessions = (0, workspace_router_1.listActiveSessions)();
+    if (sessions.length === 0) {
+        await sendMessage('No active sessions.');
+        return;
+    }
+    const lines = sessions.map((s) => {
+        const icon = sessionIcon(s);
+        return `${icon} *${escapeMarkdown(s.workspace)}* (${s.age})`;
+    });
+    let footer = '';
+    const defaultWs = (0, workspace_router_1.getDefaultWorkspace)();
+    if (defaultWs) {
+        footer = `\n\n_Default workspace:_ *${escapeMarkdown(defaultWs)}*`;
+    }
+    await sendMessage(`*Active Sessions*\n\n${lines.join('\n')}${footer}`);
+}
+async function handleStatus(workspaceArg) {
+    let workspace;
+    if (workspaceArg) {
+        workspace = workspaceArg;
+    }
+    else {
+        const defaultWs = (0, workspace_router_1.getDefaultWorkspace)();
+        if (defaultWs) {
+            workspace = defaultWs;
+        }
+        else {
+            await sendMessage('Usage: `/status <workspace>` or set a default with `/use`.');
+            return;
+        }
+    }
+    const resolved = (0, workspace_router_1.resolveWorkspace)(workspace);
+    if (resolved.type === 'none') {
+        await sendMessage(`No active session for *${escapeMarkdown(workspace)}*.`);
+        return;
+    }
+    if (resolved.type === 'ambiguous') {
+        const names = resolved.matches.map(m => `\`${escapeMarkdown(m.workspace)}\``).join(', ');
+        await sendMessage(`Multiple matches: ${names}. Be more specific.`);
+        return;
+    }
+    const match = resolved.match;
+    const resolvedName = resolved.workspace;
+    const tmuxName = match.session.tmuxSession;
+    const session = match.session;
+    // Read transcript status (model, context, branch, last message, ...).
+    // Available for any terminal type — Ghostty, tmux, PTY, bare.
+    const transcript = (0, transcript_reader_1.readTranscriptStatus)(session.cwd, session.sessionId ?? undefined);
+    // For tmux/PTY, capture the pane output as before.
+    // For Ghostty (where scrollback capture doesn't work via AppleScript),
+    // skip the pane capture and rely on the transcript's last assistant message.
+    const useGhostty = (isGhosttySession(session) || ghostty_session_manager_1.ghosttySessionManager.has(tmuxName));
+    let paneOutput = null;
+    if (!useGhostty) {
+        try {
+            const raw = await sessionCaptureOutput(tmuxName, session);
+            paneOutput = raw.trim().split('\n').slice(-20).join('\n');
+        }
+        catch (err) {
+            paneOutput = `(capture failed: ${err.message})`;
+        }
+    }
+    const htmlMsg = buildStatusMessage(resolvedName, session, transcript, paneOutput);
+    try {
+        await sendHtmlMessage(htmlMsg);
+    }
+    catch {
+        // Fallback: strip HTML tags and send as plain text.
+        const plain = htmlMsg.replace(/<[^>]+>/g, '');
+        await telegramAPI('sendMessage', { chat_id: CHAT_ID, text: plain });
+    }
+}
+/** Format the rich /status message as HTML for Telegram. */
+function buildStatusMessage(workspace, session, transcript, paneOutput) {
+    const lines = [];
+    lines.push(`\u{1F4CA} <b>${escapeHtml(workspace)}</b>`);
+    // Model + version
+    if (transcript?.model) {
+        const versionStr = transcript.version ? ` <i>(cc ${escapeHtml(transcript.version)})</i>` : '';
+        lines.push(`\u{1F916} <b>Model:</b> <code>${escapeHtml(transcript.model)}</code>${versionStr}`);
+    }
+    // Working directory
+    const cwd = transcript?.cwd || session.cwd;
+    if (cwd)
+        lines.push(`\u{1F4C1} <b>Path:</b> <code>${escapeHtml(cwd)}</code>`);
+    // Git branch
+    if (transcript?.gitBranch) {
+        lines.push(`\u{1F33F} <b>Branch:</b> <code>${escapeHtml(transcript.gitBranch)}</code>`);
+    }
+    // Session
+    if (transcript?.sessionId || session.sessionId) {
+        const sid = (transcript?.sessionId || session.sessionId);
+        const slugStr = transcript?.slug ? ` <i>(${escapeHtml(transcript.slug)})</i>` : '';
+        lines.push(`\u{1F194} <b>Session:</b> <code>${escapeHtml(sid.slice(0, 8))}</code>${slugStr}`);
+    }
+    // Context window usage
+    if (transcript?.contextTokens !== undefined) {
+        const tokensStr = transcript.contextTokens.toLocaleString();
+        if (transcript.contextLimit && transcript.contextPct !== undefined) {
+            const limitStr = transcript.contextLimit.toLocaleString();
+            lines.push(`\u{1F4C8} <b>Context:</b> ${tokensStr} / ${limitStr} (${transcript.contextPct}%)`);
+        }
+        else {
+            lines.push(`\u{1F4C8} <b>Context:</b> ${tokensStr} tokens`);
+        }
+    }
+    // Last activity
+    if (transcript?.lastAssistantTimestamp) {
+        const ago = formatRelativeTime(new Date(transcript.lastAssistantTimestamp));
+        if (ago)
+            lines.push(`\u23F1 <b>Last activity:</b> ${ago}`);
+    }
+    // Rate limit
+    const rateLimit = (0, workspace_router_1.getSessionRateLimit)(workspace);
+    if (rateLimit && rateLimit.remaining !== undefined) {
+        const pct = rateLimit.limit ? Math.round((rateLimit.remaining / rateLimit.limit) * 100) : null;
+        const pctStr = pct !== null ? ` (${pct}%)` : '';
+        let resetStr = '';
+        if (rateLimit.resetsAt) {
+            const resetMs = rateLimit.resetsAt * 1000 - Date.now();
+            if (resetMs > 0) {
+                const mins = Math.ceil(resetMs / 60000);
+                resetStr = mins > 60 ? ` \u2022 resets in ${Math.round(mins / 60)}h` : ` \u2022 resets in ${mins}m`;
+            }
+        }
+        lines.push(`\u{1F4E1} <b>Rate limit:</b> ${rateLimit.remaining}/${rateLimit.limit || '?'}${pctStr}${resetStr}`);
+    }
+    // Last assistant message (Ghostty only — for tmux/PTY we show pane output instead)
+    if (paneOutput === null && transcript?.lastAssistantMessage) {
+        lines.push('');
+        lines.push('\u{1F4AC} <b>Last message:</b>');
+        lines.push(`<pre>${escapeHtml(transcript.lastAssistantMessage)}</pre>`);
+    }
+    // Pane output for tmux/PTY
+    if (paneOutput !== null) {
+        lines.push('');
+        lines.push('\u{1F4DD} <b>Recent output:</b>');
+        lines.push(`<pre>${escapeHtml(paneOutput)}</pre>`);
+    }
+    // Fallback when we have nothing
+    if (!transcript && paneOutput === null) {
+        lines.push('');
+        lines.push('<i>No transcript or pane output available.</i>');
+    }
+    return lines.join('\n');
+}
+/** Format a Date as "Xs ago" / "Xm ago" / "Xh ago" relative to now. */
+function formatRelativeTime(d) {
+    const ms = Date.now() - d.getTime();
+    if (ms < 0)
+        return null;
+    const sec = Math.round(ms / 1000);
+    if (sec < 60)
+        return `${sec}s ago`;
+    const min = Math.round(sec / 60);
+    if (min < 60)
+        return `${min} min ago`;
+    const hr = Math.round(min / 60);
+    if (hr < 24)
+        return `${hr}h ago`;
+    const day = Math.round(hr / 24);
+    return `${day}d ago`;
+}
+async function handleStop(workspaceArg) {
+    let workspace;
+    if (workspaceArg) {
+        workspace = workspaceArg;
+    }
+    else {
+        const defaultWs = (0, workspace_router_1.getDefaultWorkspace)();
+        if (defaultWs) {
+            workspace = defaultWs;
+        }
+        else {
+            await sendMessage('Usage: `/stop <workspace>` or set a default with `/use`.');
+            return;
+        }
+    }
+    const resolved = (0, workspace_router_1.resolveWorkspace)(workspace);
+    if (resolved.type === 'none') {
+        await sendMessage(`No active session for *${escapeMarkdown(workspace)}*.`);
+        return;
+    }
+    if (resolved.type === 'ambiguous') {
+        const names = resolved.matches.map(m => `\`${escapeMarkdown(m.workspace)}\``).join(', ');
+        await sendMessage(`Multiple matches: ${names}. Be more specific.`);
+        return;
+    }
+    const resolvedName = resolved.workspace;
+    const tmuxName = resolved.match.session.tmuxSession;
+    if (!await sessionExists(tmuxName, resolved.match.session)) {
+        await sendMessage(`Session \`${tmuxName}\` not found.`);
+        return;
+    }
+    try {
+        await sessionInterrupt(tmuxName, resolved.match.session);
+        await sendMessage(`\u26d4 Sent interrupt to *${escapeMarkdown(resolvedName)}*`);
+    }
+    catch (err) {
+        await sendMessage(`\u274c Failed to interrupt: ${err.message}`);
+    }
+}
+async function handleCmd(token, command) {
+    const map = (0, workspace_router_1.readSessionMap)();
+    const session = map[token];
+    if (!session) {
+        await sendMessage(`No session found for token \`${token}\`.`);
+        return;
+    }
+    if ((0, workspace_router_1.isExpired)(session)) {
+        await sendMessage(`Session \`${token}\` has expired.`);
+        return;
+    }
+    await injectAndRespond(session, command, (0, workspace_router_1.extractWorkspaceName)(session.cwd));
+}
+async function handleWorkspaceCommand(workspace, command) {
+    const resolved = (0, workspace_router_1.resolveWorkspace)(workspace);
+    if (resolved.type === 'none') {
+        await sendMessage(`No active session for *${escapeMarkdown(workspace)}*. Use /sessions to see available workspaces.`);
+        return;
+    }
+    if (resolved.type === 'ambiguous') {
+        const names = resolved.matches.map(m => `\`${escapeMarkdown(m.workspace)}\``).join(', ');
+        await sendMessage(`Multiple matches: ${names}. Be more specific.`);
+        return;
+    }
+    await injectAndRespond(resolved.match.session, command, resolved.workspace);
+}
+async function handleUse(arg) {
+    // /use — show current default
+    if (!arg) {
+        const current = (0, workspace_router_1.getDefaultWorkspace)();
+        if (current) {
+            await sendMessage(`Default workspace: *${escapeMarkdown(current)}*\n\nPlain text messages will route here. Use \`/use clear\` to unset.`);
+        }
+        else {
+            await sendMessage('No default workspace set. Use `/use <workspace>` to set one.');
+        }
+        return;
+    }
+    // /use clear | /use none — clear default
+    if (arg === 'clear' || arg === 'none') {
+        (0, workspace_router_1.setDefaultWorkspace)(null);
+        await sendMessage('Default workspace cleared.');
+        return;
+    }
+    // /use <workspace> — resolve and set
+    const resolved = (0, workspace_router_1.resolveWorkspace)(arg);
+    if (resolved.type === 'none') {
+        await sendMessage(`No active session for *${escapeMarkdown(arg)}*. Use /sessions to see available workspaces.`);
+        return;
+    }
+    if (resolved.type === 'ambiguous') {
+        const names = resolved.matches.map(m => `\`${escapeMarkdown(m.workspace)}\``).join(', ');
+        await sendMessage(`Multiple matches: ${names}. Be more specific.`);
+        return;
+    }
+    const fullName = resolved.workspace;
+    (0, workspace_router_1.setDefaultWorkspace)(fullName);
+    await sendMessage(`Default workspace set to *${escapeMarkdown(fullName)}*. Plain text messages will route here.`);
+}
+async function handleCompact(workspaceArg) {
+    let workspace;
+    if (workspaceArg) {
+        workspace = workspaceArg;
+    }
+    else {
+        const defaultWs = (0, workspace_router_1.getDefaultWorkspace)();
+        if (defaultWs) {
+            workspace = defaultWs;
+        }
+        else {
+            await sendMessage('Usage: `/compact <workspace>` or set a default with `/use`.');
+            return;
+        }
+    }
+    const resolved = (0, workspace_router_1.resolveWorkspace)(workspace);
+    if (resolved.type === 'none') {
+        await sendMessage(`No active session for *${escapeMarkdown(workspace)}*. Use /sessions to see available workspaces.`);
+        return;
+    }
+    if (resolved.type === 'ambiguous') {
+        const names = resolved.matches.map(m => `\`${escapeMarkdown(m.workspace)}\``).join(', ');
+        await sendMessage(`Multiple matches: ${names}. Be more specific.`);
+        return;
+    }
+    const tmuxName = resolved.match.session.tmuxSession;
+    const compactSession = resolved.match.session;
+    // Inject /compact into tmux
+    const injected = await injectAndRespond(resolved.match.session, '/compact', resolved.workspace);
+    if (!injected)
+        return;
+    // Two-phase polling to detect compact completion:
+    // Phase 1: Wait for "Compacting" to appear (command started processing)
+    // Phase 2: Wait for "Compacting" to disappear (command finished)
+    let started = false;
+    // Phase 1: Wait up to 10s for compact to start
+    for (let i = 0; i < 5; i++) {
+        await sleep(2000);
+        try {
+            const output = await sessionCaptureOutput(tmuxName, compactSession);
+            if (output.includes('Compacting')) {
+                started = true;
+                break;
+            }
+        }
+        catch {
+            break;
+        }
+    }
+    if (!started) {
+        // Command may have finished very quickly or failed to start
+        try {
+            const output = await sessionCaptureOutput(tmuxName, compactSession);
+            if (output.includes('Compacted')) {
+                const lines = output.trim().split('\n').slice(-10).join('\n');
+                await sendMessage(`\u2705 *${escapeMarkdown(resolved.workspace)}* compact done:\n\`\`\`\n${lines}\n\`\`\``);
+            }
+        }
+        catch {
+            // ignore
+        }
+        return;
+    }
+    // Phase 2: Wait up to 60s for "Compacting" to disappear (compact finished)
+    for (let i = 0; i < 30; i++) {
+        await sleep(2000);
+        try {
+            const output = await sessionCaptureOutput(tmuxName, compactSession);
+            if (!output.includes('Compacting')) {
+                const lines = output.trim().split('\n').slice(-10).join('\n');
+                await sendMessage(`\u2705 *${escapeMarkdown(resolved.workspace)}* compact done:\n\`\`\`\n${lines}\n\`\`\``);
+                return;
+            }
+        }
+        catch {
+            break;
+        }
+    }
+    // Timeout — show current session state
+    try {
+        const output = await sessionCaptureOutput(tmuxName, compactSession);
+        const trimmed = output.trim().split('\n').slice(-5).join('\n');
+        await sendMessage(`\u23f3 *${escapeMarkdown(resolved.workspace)}* compact may still be running:\n\`\`\`\n${trimmed}\n\`\`\``);
+    }
+    catch {
+        // ignore
+    }
+}
+async function handleNew(nameArg) {
+    if (!nameArg) {
+        const recent = (0, workspace_router_1.getRecentProjects)(10);
+        if (recent.length === 0) {
+            const home = process.env.HOME;
+            const dirs = process.env.PROJECT_DIRS
+                ? process.env.PROJECT_DIRS.split(',').map(d => d.trim().replace(home, '~')).join(', ')
+                : '~/projects, ~/tools';
+            await sendMessage(`No project history yet.\n\nUse \`/new <project-name>\` to start.\nSearches: ${dirs}, ~/`);
+            return;
+        }
+        const keyboard = [];
+        for (let i = 0; i < recent.length; i += 2) {
+            const row = recent.slice(i, i + 2).map(p => ({
+                text: p.name,
+                callback_data: `new:${p.name}`,
+            }));
+            keyboard.push(row);
+        }
+        await telegramAPI('sendMessage', {
+            chat_id: CHAT_ID,
+            text: '*Start Claude Session*\n\nSelect a project or use `/new <name>`:',
+            parse_mode: 'Markdown',
+            reply_markup: { inline_keyboard: keyboard },
+        });
+        return;
+    }
+    await startProject(nameArg);
+}
+async function startProject(name) {
+    const home = process.env.HOME;
+    // 1. Find project directory — exact match first
+    const configuredDirs = process.env.PROJECT_DIRS
+        ? process.env.PROJECT_DIRS.split(',').map(d => d.trim()).filter(Boolean)
+        : [path_1.default.join(home, 'projects'), path_1.default.join(home, 'tools')];
+    const candidates = [
+        ...configuredDirs.map(d => path_1.default.join(d, name)),
+        path_1.default.join(home, name),
+    ];
+    let projectDir = null;
+    for (const dir of candidates) {
+        try {
+            if (fs_1.default.statSync(dir).isDirectory()) {
+                projectDir = dir;
+                break;
+            }
+        }
+        catch { }
+    }
+    // 2. If no exact match, prefix match against configured dirs ONLY
+    //    (skip ~/ to avoid matching Desktop, Documents, Downloads, Library, etc.)
+    if (!projectDir) {
+        const searchDirs = configuredDirs;
+        const matches = [];
+        for (const base of searchDirs) {
+            try {
+                const entries = fs_1.default.readdirSync(base, { withFileTypes: true });
+                for (const e of entries) {
+                    if (e.isDirectory() && e.name.toLowerCase().startsWith(name.toLowerCase())) {
+                        matches.push({ name: e.name, path: path_1.default.join(base, e.name) });
+                    }
+                }
+            }
+            catch { }
+        }
+        // Deduplicate by name (prefer ~/projects/ over ~/tools/)
+        const unique = [...new Map(matches.map(m => [m.name, m])).values()];
+        if (unique.length === 1) {
+            projectDir = unique[0].path;
+            name = unique[0].name;
+        }
+        else if (unique.length > 1) {
+            // Show matches as inline buttons (max 10)
+            const limited = unique.slice(0, 10);
+            const keyboard = [];
+            for (let i = 0; i < limited.length; i += 2) {
+                keyboard.push(limited.slice(i, i + 2).map(m => ({
+                    text: m.name, callback_data: `new:${m.name}`,
+                })));
+            }
+            await telegramAPI('sendMessage', {
+                chat_id: CHAT_ID,
+                text: `Multiple matches for *${escapeMarkdown(name)}*:`,
+                parse_mode: 'Markdown',
+                reply_markup: { inline_keyboard: keyboard },
+            });
+            return;
+        }
+    }
+    if (!projectDir) {
+        const searchedPaths = configuredDirs.map(d => d.replace(home, '~')).join(', ') + ', ~/';
+        await sendMessage(`Project \`${escapeMarkdown(name)}\` not found.\n\nSearched: ${searchedPaths}`);
+        return;
+    }
+    // 3. Sanitize tmux session name (dots, colons, spaces are invalid in tmux)
+    const tmuxName = name.replace(/[.:\s]/g, '-');
+    // 4. Check existing session (PTY, Ghostty, or tmux)
+    const existingEntry = Object.values((0, workspace_router_1.readSessionMap)()).find(s => s.tmuxSession === tmuxName && !(0, workspace_router_1.isExpired)(s));
+    const alreadyRunning = existingEntry
+        ? await sessionExists(tmuxName, existingEntry)
+        : await sessionExists(tmuxName);
+    if (alreadyRunning) {
+        (0, workspace_router_1.upsertSession)({ cwd: projectDir, tmuxSession: tmuxName, status: 'waiting', sessionId: null });
+        (0, workspace_router_1.recordProjectUsage)(name, projectDir);
+        (0, workspace_router_1.setDefaultWorkspace)(name);
+        await sendMessage(`Session \`${tmuxName}\` already running.\nSet as default — send messages directly.`);
+        return;
+    }
+    // 5. Create session — Ghostty, PTY, or tmux
+    const mode = getEffectiveMode();
+    if (mode === 'tmux') {
+        // tmux path (existing behaviour)
+        try {
+            await tmuxExec(`tmux new-session -d -s "${tmuxName}" -c "${projectDir}"`);
+            await sleep(300);
+            await tmuxExec(`tmux send-keys -t "${tmuxName}" 'claude' C-m`);
+        }
+        catch (err) {
+            await sendMessage(`Failed to start session: ${err.message}`);
+            return;
+        }
+        (0, workspace_router_1.upsertSession)({ cwd: projectDir, tmuxSession: tmuxName, status: 'starting', sessionId: null, sessionType: 'tmux' });
+        (0, workspace_router_1.recordProjectUsage)(name, projectDir);
+        (0, workspace_router_1.setDefaultWorkspace)(name);
+        const msg = await sendMessage(`Started Claude in *${escapeMarkdown(name)}*\n\n` +
+            `*Path:* \`${projectDir}\`\n` +
+            `*Session:* \`${tmuxName}\`\n\n` +
+            `Default workspace set — send messages directly.`);
+        if (msg && msg.message_id) {
+            (0, workspace_router_1.trackNotificationMessage)(msg.message_id, name, 'new-session');
+        }
+    }
+    else if (mode === 'ghostty') {
+        // Ghostty path — opens a new tab in the front Ghostty window
+        const ok = await ghostty_session_manager_1.ghosttySessionManager.openNewTab(projectDir, 'claude');
+        if (!ok) {
+            await sendMessage('Failed to open Ghostty tab.');
+            return;
+        }
+        ghostty_session_manager_1.ghosttySessionManager.register(tmuxName, projectDir);
+        (0, workspace_router_1.upsertSession)({ cwd: projectDir, tmuxSession: tmuxName, status: 'starting', sessionId: null, sessionType: 'ghostty' });
+        (0, workspace_router_1.recordProjectUsage)(name, projectDir);
+        (0, workspace_router_1.setDefaultWorkspace)(name);
+        const msg = await sendMessage(`Started Claude in *${escapeMarkdown(name)}*\n\n` +
+            `*Path:* \`${projectDir}\`\n` +
+            `*Session:* \`${tmuxName}\`\n\n` +
+            `Default workspace set — send messages directly.\n\n` +
+            `_Ghostty tab — visible in your Ghostty window._`);
+        if (msg && msg.message_id) {
+            (0, workspace_router_1.trackNotificationMessage)(msg.message_id, name, 'new-session');
+        }
+    }
+    else if (mode === 'pty') {
+        // PTY path — spawns 'claude' directly (no separate send-keys step)
+        const ok = pty_session_manager_1.ptySessionManager.spawn(tmuxName, projectDir);
+        if (!ok) {
+            await sendMessage('Failed to spawn PTY session.');
+            return;
+        }
+        (0, workspace_router_1.upsertSession)({ cwd: projectDir, tmuxSession: tmuxName, status: 'starting', sessionId: null, sessionType: 'pty' });
+        (0, workspace_router_1.recordProjectUsage)(name, projectDir);
+        (0, workspace_router_1.setDefaultWorkspace)(name);
+        const msg = await sendMessage(`Started Claude in *${escapeMarkdown(name)}*\n\n` +
+            `*Path:* \`${projectDir}\`\n` +
+            `*Session:* \`${tmuxName}\`\n\n` +
+            `Default workspace set — send messages directly.\n\n` +
+            `_Headless PTY mode — full Telegram control. Not attachable from terminal._`);
+        if (msg && msg.message_id) {
+            (0, workspace_router_1.trackNotificationMessage)(msg.message_id, name, 'new-session');
+        }
+    }
+    else {
+        await sendMessage('\u26a0\ufe0f No injection backend available.\n' +
+            'Install tmux, run Ghostty, or run: `npm install node-pty` in ~/.ccgram/');
+    }
+}
+// ── Resume feature ───────────────────────────────────────────────
+/** Format a Unix ms timestamp as a human-readable age (e.g. "2h ago"). */
+function formatSessionAge(ms) {
+    const diff = Math.floor((Date.now() - ms) / 60000); // minutes
+    if (diff < 1)
+        return 'just now';
+    if (diff < 60)
+        return `${diff}m ago`;
+    if (diff < 1440)
+        return `${Math.floor(diff / 60)}h ago`;
+    return `${Math.floor(diff / 1440)}d ago`;
+}
+async function handleResume(nameArg) {
+    if (nameArg) {
+        await resumeProject(nameArg);
+        return;
+    }
+    const allProjects = (0, workspace_router_1.getRecentProjects)(20);
+    const projects = allProjects
+        .map(p => ({ ...p, sessions: (0, workspace_router_1.getClaudeSessionsForProject)(p.path, 1) }))
+        .filter(p => p.sessions.length > 0);
+    if (projects.length === 0) {
+        await sendMessage('No sessions to resume.\n\nUse `/new` to start one — session IDs are saved automatically.');
+        return;
+    }
+    const keyboard = [];
+    for (let i = 0; i < projects.length; i += 2) {
+        const row = projects.slice(i, i + 2).map(p => ({
+            text: `${p.name} \u2022 ${formatSessionAge(p.sessions[0].lastActivity)}`,
+            callback_data: `rp:${p.name}`,
+        }));
+        keyboard.push(row);
+    }
+    await telegramAPI('sendMessage', {
+        chat_id: CHAT_ID,
+        text: '*Resume Session*\n\nSelect a project:',
+        parse_mode: 'Markdown',
+        reply_markup: { inline_keyboard: keyboard },
+    });
+}
+async function resumeProject(projectName) {
+    const allProjects = (0, workspace_router_1.getRecentProjects)(20);
+    const project = allProjects.find(p => p.name === projectName);
+    if (!project) {
+        await sendMessage(`No project found for \`${escapeMarkdown(projectName)}\`.\n\nTry /resume to see available projects.`);
+        return;
+    }
+    const sessions = (0, workspace_router_1.getClaudeSessionsForProject)(project.path, 5);
+    if (sessions.length === 0) {
+        await sendMessage(`No sessions found for \`${escapeMarkdown(projectName)}\`.\n\nUse /new to start one.`);
+        return;
+    }
+    // Always show picker — one session per row (full width for snippet)
+    const keyboard = sessions.map((s, idx) => [{
+            text: `${formatSessionAge(s.lastActivity)}${s.snippet ? ' \u2022 ' + s.snippet : ''}`,
+            callback_data: `rs:${projectName}:${idx}`,
+        }]);
+    await telegramAPI('sendMessage', {
+        chat_id: CHAT_ID,
+        text: `*Resume: ${escapeMarkdown(projectName)}*\n\nChoose a conversation:`,
+        parse_mode: 'Markdown',
+        reply_markup: { inline_keyboard: keyboard },
+    });
+}
+async function resumeSession(projectName, sessionIdx, force = false) {
+    const allProjects = (0, workspace_router_1.getRecentProjects)(20);
+    const project = allProjects.find(p => p.name === projectName);
+    if (!project) {
+        await sendMessage('Session not found. Try /resume again.');
+        return;
+    }
+    const sessions = (0, workspace_router_1.getClaudeSessionsForProject)(project.path, 5);
+    if (sessionIdx < 0 || sessionIdx >= sessions.length) {
+        await sendMessage('Session not found. Try /resume again.');
+        return;
+    }
+    const sessionId = sessions[sessionIdx].id;
+    const tmuxName = projectName.replace(/[.:\s]/g, '-');
+    // Look up the bot's tracked session BEFORE checking sessionExists
+    const map = (0, workspace_router_1.readSessionMap)();
+    const currentEntry = Object.values(map).find(s => s.tmuxSession === tmuxName && !(0, workspace_router_1.isExpired)(s));
+    const running = currentEntry
+        ? await sessionExists(tmuxName, currentEntry)
+        : (isPtySession(tmuxName) || (TMUX_AVAILABLE && await sessionExists(tmuxName)));
+    const botOwnsThisSession = currentEntry?.sessionId === sessionId;
+    // If the bot already has this exact session running, just re-route to it
+    if (running && botOwnsThisSession) {
+        (0, workspace_router_1.upsertSession)({ cwd: project.path, tmuxSession: tmuxName, status: 'waiting', sessionId });
+        (0, workspace_router_1.recordProjectUsage)(projectName, project.path);
+        (0, workspace_router_1.setDefaultWorkspace)(projectName);
+        await sendMessage(`Session \`${tmuxName}\` already running.\nSet as default — send messages directly.`);
+        return;
+    }
+    // Check if the JSONL file was written to very recently — the session may be
+    // active in a direct terminal (not managed by the bot). Warn before creating
+    // a second Claude instance on the same conversation.
+    if (!force && !botOwnsThisSession) {
+        const activeThresholdMs = 5 * 60 * 1000; // 5 minutes
+        const age = Date.now() - sessions[sessionIdx].lastActivity;
+        if (age < activeThresholdMs) {
+            await telegramAPI('sendMessage', {
+                chat_id: CHAT_ID,
+                text: `\u26a0\ufe0f This session appears to be *active* (last activity ${formatSessionAge(sessions[sessionIdx].lastActivity)})\n\n` +
+                    `Claude Code may be running in a terminal. ` +
+                    `Resuming the same session in two places can cause conflicts.\n\n` +
+                    `_If you just finished this session, you can safely resume._`,
+                parse_mode: 'Markdown',
+                reply_markup: {
+                    inline_keyboard: [[
+                            { text: '\u25b6\ufe0f Resume anyway', callback_data: `rc:${projectName}:${sessionIdx}` },
+                        ]],
+                },
+            });
+            return;
+        }
+    }
+    // Handle bot-managed session that needs switching
+    if (running && !botOwnsThisSession) {
+        if (isPtySession(tmuxName)) {
+            // PTY: headless, not reattachable — warn before killing
+            if (!force) {
+                await telegramAPI('sendMessage', {
+                    chat_id: CHAT_ID,
+                    text: `\u26a0\ufe0f *${escapeMarkdown(projectName)}* has an active PTY session\n\n` +
+                        `Resuming a different conversation will terminate it.\n\n` +
+                        `_PTY sessions cannot be reattached from a terminal. ` +
+                        `You will need to use /resume again if you want to return to the current conversation._`,
+                    parse_mode: 'Markdown',
+                    reply_markup: {
+                        inline_keyboard: [[
+                                { text: '\u25b6\ufe0f Resume anyway', callback_data: `rc:${projectName}:${sessionIdx}` },
+                            ]],
+                    },
+                });
+                return;
+            }
+            // Confirmed — kill the PTY so startProjectResume can respawn
+            pty_session_manager_1.ptySessionManager.kill(tmuxName);
+            await sleep(300);
+        }
+        else if (currentEntry && isGhosttySession(currentEntry)) {
+            // Ghostty: old tab stays open idle — warn before opening a new tab
+            if (!force) {
+                await telegramAPI('sendMessage', {
+                    chat_id: CHAT_ID,
+                    text: `\u26a0\ufe0f *${escapeMarkdown(projectName)}* has an active Ghostty session\n\n` +
+                        `Resuming will open a new tab. The existing tab will stay open but idle.\n\n` +
+                        `_You can close the old tab manually._`,
+                    parse_mode: 'Markdown',
+                    reply_markup: {
+                        inline_keyboard: [[
+                                { text: '\u25b6\ufe0f Resume anyway', callback_data: `rc:${projectName}:${sessionIdx}` },
+                            ]],
+                    },
+                });
+                return;
+            }
+            // Confirmed — unregister handle so startProjectResume opens a fresh tab
+            ghostty_session_manager_1.ghosttySessionManager.unregister(tmuxName);
+        }
+        // tmux: no warning needed — startProjectResume switches inline
+    }
+    await startProjectResume(projectName, project.path, sessionId);
+}
+async function startProjectResume(name, projectDir, sessionId) {
+    const tmuxName = name.replace(/[.:\s]/g, '-');
+    const shortId = sessionId.slice(0, 8);
+    // Look up the current session entry BEFORE checking sessionExists
+    const map = (0, workspace_router_1.readSessionMap)();
+    const currentEntry = Object.values(map).find(s => s.tmuxSession === tmuxName && !(0, workspace_router_1.isExpired)(s));
+    const running = currentEntry
+        ? await sessionExists(tmuxName, currentEntry)
+        : (isPtySession(tmuxName) || (TMUX_AVAILABLE && await sessionExists(tmuxName)));
+    // If a tmux session is already running (and not PTY/Ghostty), switch Claude inline
+    // (exit + resume) instead of killing the tmux session. This keeps the terminal attached.
+    if (!isPtySession(tmuxName) && !(currentEntry && isGhosttySession(currentEntry)) && running) {
+        try {
+            // Double Ctrl+C: first interrupts any running Claude task,
+            // second clears the input line if Claude returned to its prompt
+            await tmuxExec(`tmux send-keys -t "${tmuxName}" C-c`);
+            await sleep(500);
+            await tmuxExec(`tmux send-keys -t "${tmuxName}" C-c`);
+            await sleep(500);
+            // Exit Claude — if Claude already exited, /exit is harmless in bash
+            // (just an unknown command, won't affect the subsequent claude launch)
+            await tmuxExec(`tmux send-keys -t "${tmuxName}" '/exit' C-m`);
+            await sleep(2000);
+            await tmuxExec(`tmux send-keys -t "${tmuxName}" 'claude --resume ${sessionId}' C-m`);
+        }
+        catch (err) {
+            await sendMessage(`Failed to switch session: ${err.message}`);
+            return;
+        }
+        (0, workspace_router_1.upsertSession)({ cwd: projectDir, tmuxSession: tmuxName, status: 'starting', sessionId, sessionType: 'tmux' });
+        (0, workspace_router_1.recordProjectUsage)(name, projectDir);
+        (0, workspace_router_1.setDefaultWorkspace)(name);
+        const msg = await sendMessage(`Switched Claude session in *${escapeMarkdown(name)}*\n\n` +
+            `*Path:* \`${projectDir}\`\n` +
+            `*Session:* \`${tmuxName}\`\n` +
+            `*Resumed:* \`${shortId}...\`\n\n` +
+            `Default workspace set — send messages directly.`);
+        if (msg && msg.message_id) {
+            (0, workspace_router_1.trackNotificationMessage)(msg.message_id, name, 'resume-session');
+        }
+        return;
+    }
+    // No session running (or was PTY/Ghostty that's been killed) — create a new one
+    const mode = getEffectiveMode();
+    if (mode === 'tmux') {
+        try {
+            await tmuxExec(`tmux new-session -d -s "${tmuxName}" -c "${projectDir}"`);
+            await sleep(300);
+            await tmuxExec(`tmux send-keys -t "${tmuxName}" 'claude --resume ${sessionId}' C-m`);
+        }
+        catch (err) {
+            await sendMessage(`Failed to start session: ${err.message}`);
+            return;
+        }
+        (0, workspace_router_1.upsertSession)({ cwd: projectDir, tmuxSession: tmuxName, status: 'starting', sessionId, sessionType: 'tmux' });
+        (0, workspace_router_1.recordProjectUsage)(name, projectDir);
+        (0, workspace_router_1.setDefaultWorkspace)(name);
+        const msg = await sendMessage(`Resumed Claude in *${escapeMarkdown(name)}*\n\n` +
+            `*Path:* \`${projectDir}\`\n` +
+            `*Session:* \`${tmuxName}\`\n` +
+            `*Resumed:* \`${shortId}...\`\n\n` +
+            `Default workspace set — send messages directly.`);
+        if (msg && msg.message_id) {
+            (0, workspace_router_1.trackNotificationMessage)(msg.message_id, name, 'resume-session');
+        }
+    }
+    else if (mode === 'ghostty') {
+        const ok = await ghostty_session_manager_1.ghosttySessionManager.openNewTab(projectDir, `claude --resume ${sessionId}`);
+        if (!ok) {
+            await sendMessage('Failed to open Ghostty tab.');
+            return;
+        }
+        ghostty_session_manager_1.ghosttySessionManager.register(tmuxName, projectDir);
+        (0, workspace_router_1.upsertSession)({ cwd: projectDir, tmuxSession: tmuxName, status: 'starting', sessionId, sessionType: 'ghostty' });
+        (0, workspace_router_1.recordProjectUsage)(name, projectDir);
+        (0, workspace_router_1.setDefaultWorkspace)(name);
+        const msg = await sendMessage(`Resumed Claude in *${escapeMarkdown(name)}*\n\n` +
+            `*Path:* \`${projectDir}\`\n` +
+            `*Session:* \`${tmuxName}\`\n` +
+            `*Resumed:* \`${shortId}...\`\n\n` +
+            `Default workspace set — send messages directly.\n\n` +
+            `_Ghostty tab — visible in your Ghostty window._`);
+        if (msg && msg.message_id) {
+            (0, workspace_router_1.trackNotificationMessage)(msg.message_id, name, 'resume-session');
+        }
+    }
+    else if (mode === 'pty') {
+        const ok = pty_session_manager_1.ptySessionManager.spawn(tmuxName, projectDir, ['--resume', sessionId]);
+        if (!ok) {
+            await sendMessage('Failed to spawn PTY session.');
+            return;
+        }
+        (0, workspace_router_1.upsertSession)({ cwd: projectDir, tmuxSession: tmuxName, status: 'starting', sessionId, sessionType: 'pty' });
+        (0, workspace_router_1.recordProjectUsage)(name, projectDir);
+        (0, workspace_router_1.setDefaultWorkspace)(name);
+        const msg = await sendMessage(`Resumed Claude in *${escapeMarkdown(name)}*\n\n` +
+            `*Path:* \`${projectDir}\`\n` +
+            `*Session:* \`${tmuxName}\`\n` +
+            `*Resumed:* \`${shortId}...\`\n\n` +
+            `Default workspace set — send messages directly.\n\n` +
+            `_Headless PTY mode — full Telegram control. Not attachable from terminal._`);
+        if (msg && msg.message_id) {
+            (0, workspace_router_1.trackNotificationMessage)(msg.message_id, name, 'resume-session');
+        }
+    }
+    else {
+        await sendMessage('\u26a0\ufe0f No injection backend available.\n' +
+            'Install tmux, run Ghostty, or run: `npm install node-pty` in ~/.ccgram/');
+    }
+}
+async function injectAndRespond(session, command, workspace) {
+    const tmuxName = session.tmuxSession;
+    if (!await sessionExists(tmuxName, session)) {
+        await sendMessage(`\u26a0\ufe0f Session not found. Start Claude via /new for full remote control, or use tmux.`);
+        return false;
+    }
+    try {
+        if (isPtySession(tmuxName)) {
+            // PTY: write raw bytes directly — no shell quoting needed
+            pty_session_manager_1.ptySessionManager.write(tmuxName, '\x15'); // Ctrl+U: clear line
+            await sleep(150);
+            pty_session_manager_1.ptySessionManager.write(tmuxName, command); // raw command text
+            await sleep(150);
+            pty_session_manager_1.ptySessionManager.write(tmuxName, '\r'); // Enter
+        }
+        else if (isGhosttySession(session)) {
+            // Ghostty: inject via AppleScript input text
+            ghostty_session_manager_1.ghosttySessionManager.register(tmuxName, session.cwd);
+            await ghostty_session_manager_1.ghosttySessionManager.sendKey(tmuxName, 'C-u'); // Ctrl+U: clear line
+            await sleep(150);
+            await ghostty_session_manager_1.ghosttySessionManager.writeLine(tmuxName, command); // text + send key "return" atomically
+        }
+        else {
+            // tmux: existing shell-escaped path
+            const escapedCommand = command.replace(/'/g, "'\"'\"'");
+            await tmuxExec(`tmux send-keys -t ${tmuxName} C-u`);
+            await sleep(150);
+            await tmuxExec(`tmux send-keys -t ${tmuxName} '${escapedCommand}'`);
+            await sleep(150);
+            await tmuxExec(`tmux send-keys -t ${tmuxName} C-m`);
+        }
+        startTypingIndicator();
+        return true;
+    }
+    catch (err) {
+        await sendMessage(`\u274c Failed: ${err.message}`);
+        return false;
+    }
+}
+function tmuxExec(cmd) {
+    return new Promise((resolve, reject) => {
+        (0, child_process_1.exec)(cmd, (err) => {
+            if (err)
+                reject(err);
+            else
+                resolve(true);
+        });
+    });
+}
+// ── PTY / tmux / Ghostty dispatch helpers ────────────────────────
+/** Is this session managed as a live PTY handle by this bot process? */
+function isPtySession(sessionName) {
+    return pty_session_manager_1.ptySessionManager.has(sessionName);
+}
+/** Is this session a Ghostty session (by stored sessionType)? */
+function isGhosttySession(session) {
+    return session.sessionType === 'ghostty';
+}
+/** Check session exists (PTY handle, Ghostty, OR tmux session). */
+async function sessionExists(name, session) {
+    if (pty_session_manager_1.ptySessionManager.has(name))
+        return true;
+    if (session && isGhosttySession(session)) {
+        ghostty_session_manager_1.ghosttySessionManager.register(name, session.cwd);
+        return ghostty_session_manager_1.ghosttySessionManager.isAvailable();
+    }
+    if (TMUX_AVAILABLE) {
+        try {
+            await tmuxExec(`tmux has-session -t ${name} 2>/dev/null`);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    return false;
+}
+/**
+ * Send a named key (Down, Up, Enter, C-m, C-c, C-u, Space) to a session.
+ * For PTY: translates to escape sequence via ptySessionManager.sendKey.
+ * For Ghostty: translates via ghosttySessionManager.sendKey (ANSI or modifiers).
+ * For tmux: passes key name directly to tmux send-keys.
+ */
+async function sessionSendKey(name, key, session) {
+    if (isPtySession(name)) {
+        pty_session_manager_1.ptySessionManager.sendKey(name, key);
+    }
+    else if ((session && isGhosttySession(session)) || ghostty_session_manager_1.ghosttySessionManager.has(name)) {
+        if (session)
+            ghostty_session_manager_1.ghosttySessionManager.register(name, session.cwd);
+        await ghostty_session_manager_1.ghosttySessionManager.sendKey(name, key);
+    }
+    else {
+        await tmuxExec(`tmux send-keys -t ${name} ${key}`);
+    }
+    await sleep(100);
+}
+/** Capture session output. */
+async function sessionCaptureOutput(name, session) {
+    if (isPtySession(name))
+        return pty_session_manager_1.ptySessionManager.capture(name, 20) ?? '';
+    if ((session && isGhosttySession(session)) || ghostty_session_manager_1.ghosttySessionManager.has(name)) {
+        if (session)
+            ghostty_session_manager_1.ghosttySessionManager.register(name, session.cwd);
+        return await ghostty_session_manager_1.ghosttySessionManager.capture(name) ?? '(Ghostty scrollback capture unavailable)';
+    }
+    return capturePane(name);
+}
+/** Send Ctrl+C interrupt to a session. */
+async function sessionInterrupt(name, session) {
+    if (isPtySession(name))
+        pty_session_manager_1.ptySessionManager.interrupt(name);
+    else if ((session && isGhosttySession(session)) || ghostty_session_manager_1.ghosttySessionManager.has(name)) {
+        if (session)
+            ghostty_session_manager_1.ghosttySessionManager.register(name, session.cwd);
+        await ghostty_session_manager_1.ghosttySessionManager.interrupt(name);
+    }
+    else {
+        await tmuxExec(`tmux send-keys -t ${name} C-c`);
+    }
+}
+/** Icon for /sessions listing based on session type and live status. */
+function sessionIcon(s) {
+    if (s.session.sessionType === 'ghostty')
+        return '\u{1F47B}'; // 👻
+    if (s.session.sessionType === 'pty') {
+        return pty_session_manager_1.ptySessionManager.has(s.session.tmuxSession) ? '\u{1F916}' : '\u{1F4A4}'; // 🤖 or 💤
+    }
+    return s.session.description?.startsWith('waiting') ? '\u23f3' : '\u2705'; // ⏳ or ✅
+}
+// ── Callback query handler ───────────────────────────────────────
+async function processCallbackQuery(query) {
+    const chatId = String(query.message?.chat?.id);
+    if (chatId !== String(CHAT_ID)) {
+        logger.warn(`Ignoring callback from unauthorized chat: ${chatId}`);
+        return;
+    }
+    const data = query.data || '';
+    const messageId = query.message?.message_id;
+    const originalText = query.message?.text || '';
+    logger.info(`Callback: ${data}`);
+    const parsed = (0, callback_parser_1.parseCallbackData)(data);
+    if (!parsed) {
+        await answerCallbackQuery(query.id, 'Invalid callback');
+        return;
+    }
+    const { type } = parsed;
+    // Handle new: callback (format: new:<projectName>)
+    if (type === 'new') {
+        const { projectName } = parsed;
+        await answerCallbackQuery(query.id, `Starting ${projectName}...`);
+        try {
+            await editMessageText(chatId, messageId, `${originalText}\n\n— Starting *${escapeMarkdown(projectName)}*...`);
+        }
+        catch { }
+        await startProject(projectName);
+        return;
+    }
+    // Handle rp: callback (format: rp:<projectName>) — show session picker or resume directly
+    if (type === 'rp') {
+        const { projectName } = parsed;
+        await answerCallbackQuery(query.id, `Loading ${projectName}...`);
+        try {
+            await editMessageText(chatId, messageId, `${originalText}\n\n— Loading sessions...`);
+        }
+        catch { }
+        await resumeProject(projectName);
+        return;
+    }
+    // Handle rs: callback (format: rs:<projectName>:<sessionIdx>) — resume specific session
+    if (type === 'rs') {
+        const { projectName, sessionIdx } = parsed;
+        await answerCallbackQuery(query.id, 'Starting resume...');
+        await resumeSession(projectName, sessionIdx);
+        return;
+    }
+    // Handle rc: callback (format: rc:<projectName>:<sessionIdx>) — confirmed resume (kill active + restart)
+    if (type === 'rc') {
+        const { projectName, sessionIdx } = parsed;
+        await answerCallbackQuery(query.id, 'Resuming...');
+        try {
+            await editMessageText(chatId, messageId, `${originalText}\n\n\u2014 Resuming...`);
+        }
+        catch { }
+        await resumeSession(projectName, sessionIdx, true);
+        return;
+    }
+    const { promptId } = parsed;
+    if (type === 'perm') {
+        // Permission response: write response file for the polling hook
+        const pending = (0, prompt_bridge_1.readPending)(promptId);
+        if (!pending) {
+            await answerCallbackQuery(query.id, 'Session not found');
+            return;
+        }
+        const { action } = parsed;
+        // Cheesyboy 4-button vocab: yes / yes_stop / no / explain.
+        // Legacy ccgram vocab still recognized: allow / always / defer / deny.
+        const label = action === 'yes' ? '\u2705 Yes'
+            : action === 'yes_stop' ? '\u2705 Yes, stop asking'
+                : action === 'no' ? '\u274c No'
+                    : action === 'explain' ? '\u{1F4AC} Explain requested'
+                        : action === 'allow' ? '\u2705 Allowed'
+                            : action === 'always' ? '\ud83d\udd13 Always Allowed'
+                                : action === 'defer' ? '\u23F8 Deferred'
+                                    : '\u274c Denied';
+        // Write response file — the permission-hook.js is polling for this
+        try {
+            (0, prompt_bridge_1.writeResponse)(promptId, { action });
+            logger.info(`Wrote permission response for promptId=${promptId}: action=${action}`);
+            await answerCallbackQuery(query.id, label);
+        }
+        catch (err) {
+            logger.error(`Failed to write permission response: ${err.message}`);
+            await answerCallbackQuery(query.id, 'Failed to save response');
+            return;
+        }
+        // Edit message to show result and remove buttons
+        try {
+            await editMessageText(chatId, messageId, `${originalText}\n\n— ${label}`);
+        }
+        catch (err) {
+            logger.error(`Failed to edit message: ${err.message}`);
+        }
+    }
+    else if (type === 'opt') {
+        // Question option: write response file so hook returns updatedInput
+        // (No keystroke injection needed — hook polls for this file)
+        const pending = (0, prompt_bridge_1.readPending)(promptId);
+        if (!pending) {
+            await answerCallbackQuery(query.id, 'Session expired');
+            return;
+        }
+        const optIdx = parsed.optionIndex - 1;
+        const optionLabel = pending.options && pending.options[optIdx]
+            ? pending.options[optIdx]
+            : `Option ${parsed.optionIndex}`;
+        // Multi-select: toggle selection state, update buttons, don't submit yet
+        if (pending.multiSelect) {
+            const selected = pending.selectedOptions || pending.options.map(() => false);
+            selected[optIdx] = !selected[optIdx];
+            (0, prompt_bridge_1.updatePending)(promptId, { selectedOptions: selected });
+            // Rebuild keyboard with updated checkboxes
+            const buttons = pending.options.map((label, idx) => ({
+                text: `${selected[idx] ? '\u2611' : '\u2610'} ${idx + 1}. ${label}`,
+                callback_data: `opt:${promptId}:${idx + 1}`,
+            }));
+            const keyboard = [];
+            for (let i = 0; i < buttons.length; i += 2) {
+                keyboard.push(buttons.slice(i, i + 2));
+            }
+            keyboard.push([{ text: '\u2705 Submit', callback_data: `opt-submit:${promptId}` }]);
+            const checkLabel = selected[optIdx] ? '\u2611' : '\u2610';
+            await answerCallbackQuery(query.id, `${checkLabel} ${optionLabel}`);
+            // Edit message to show updated buttons
+            try {
+                await editMessageText(chatId, messageId, originalText, { inline_keyboard: keyboard });
+            }
+            catch (err) {
+                logger.error(`Failed to edit message: ${err.message}`);
+            }
+            return;
+        }
+        // Single-select: write response file so hook can return updatedInput
+        // (No keystroke injection needed — hook polls for this file)
+        (0, prompt_bridge_1.writeResponse)(promptId, {
+            action: 'answer',
+            selectedOption: parsed.optionIndex,
+            selectedLabel: optionLabel,
+        });
+        logger.info(`Wrote question response for promptId=${promptId}: selectedLabel=${optionLabel}`);
+        await answerCallbackQuery(query.id, `Selected: ${optionLabel}`);
+        // Edit message to show selection and remove buttons
+        try {
+            await editMessageText(chatId, messageId, `${originalText}\n\n\u2714 Selected: *${escapeMarkdown(optionLabel)}*`);
+        }
+        catch (err) {
+            logger.error(`Failed to edit message: ${err.message}`);
+        }
+        // Note: hook will clean up the prompt files after reading the response
+    }
+    else if (type === 'opt-submit') {
+        // Multi-select submit: write response file so hook returns updatedInput
+        const pending = (0, prompt_bridge_1.readPending)(promptId);
+        if (!pending) {
+            await answerCallbackQuery(query.id, 'Session expired');
+            return;
+        }
+        const selected = pending.selectedOptions || [];
+        const selectedLabels = pending.options.filter((_, idx) => selected[idx]);
+        if (selectedLabels.length === 0) {
+            await answerCallbackQuery(query.id, 'No options selected');
+            return;
+        }
+        // Multi-select submit: write response file so hook can return updatedInput
+        // (No keystroke injection needed — hook polls for this file)
+        const selectedIndices = selected
+            .map((sel, idx) => sel ? idx + 1 : null)
+            .filter((idx) => idx !== null);
+        (0, prompt_bridge_1.writeResponse)(promptId, {
+            action: 'answer',
+            selectedOptions: selectedIndices,
+            selectedLabels,
+        });
+        await answerCallbackQuery(query.id, `Submitted ${selectedLabels.length} options`);
+        // Edit message to show selections and remove buttons
+        const selectionText = selectedLabels.map(l => `\u2022 ${escapeMarkdown(l)}`).join('\n');
+        try {
+            await editMessageText(chatId, messageId, `${originalText}\n\n\u2714 Selected:\n${selectionText}`);
+        }
+        catch (err) {
+            logger.error(`Failed to edit message: ${err.message}`);
+        }
+        // Note: hook will clean up the prompt files after reading the response
+    }
+    else if (type === 'qperm') {
+        // Combined question+permission: allow permission AND inject answer keystroke
+        const optIdx = parsed.optionIndex - 1;
+        const pending = (0, prompt_bridge_1.readPending)(promptId);
+        if (!pending) {
+            await answerCallbackQuery(query.id, 'Session not found');
+            return;
+        }
+        const optionLabel = pending.options && pending.options[optIdx]
+            ? pending.options[optIdx]
+            : `Option ${parsed.optionIndex}`;
+        // 1. Write permission response (allow) — unblocks the permission hook
+        try {
+            (0, prompt_bridge_1.writeResponse)(promptId, { action: 'allow', selectedOption: parsed.optionIndex });
+            logger.info(`Wrote qperm response for promptId=${promptId}: option=${parsed.optionIndex}`);
+            await answerCallbackQuery(query.id, `Selected: ${optionLabel}`);
+        }
+        catch (err) {
+            logger.error(`Failed to write qperm response: ${err.message}`);
+            await answerCallbackQuery(query.id, 'Failed to save response');
+            return;
+        }
+        // 2. Schedule keystroke injection after a delay (wait for question UI to appear)
+        if (pending.tmuxSession) {
+            const tmux = pending.tmuxSession;
+            const downPresses = optIdx;
+            const sessionEntryQperm = (0, workspace_router_1.findSessionByTmuxName)(tmux);
+            setTimeout(async () => {
+                try {
+                    for (let i = 0; i < downPresses; i++) {
+                        await sessionSendKey(tmux, 'Down', sessionEntryQperm);
+                    }
+                    await sessionSendKey(tmux, 'Enter', sessionEntryQperm);
+                    startTypingIndicator(); // ensure Stop hook routes response back to Telegram
+                    logger.info(`Injected question answer into ${tmux}: option ${parsed.optionIndex}`);
+                }
+                catch (err) {
+                    logger.error(`Failed to inject question answer: ${err.message}`);
+                }
+            }, 4000); // 4s delay for permission hook to return + question UI to render
+        }
+        // Edit message to show selection
+        try {
+            await editMessageText(chatId, messageId, `${originalText}\n\n— Selected: *${escapeMarkdown(optionLabel)}*`);
+        }
+        catch (err) {
+            logger.error(`Failed to edit message: ${err.message}`);
+        }
+    }
+    else if (type === 'perm-denied') {
+        // Permission denied retry/dismiss
+        const { action } = parsed;
+        const label = action === 'retry' ? '\ud83d\udd04 Retrying...' : '\u274c Dismissed';
+        // Write response file for the polling hook
+        try {
+            (0, prompt_bridge_1.writeResponse)(promptId, { action });
+            logger.info(`Wrote perm-denied response for promptId=${promptId}: action=${action}`);
+            await answerCallbackQuery(query.id, label);
+        }
+        catch (err) {
+            logger.error(`Failed to write perm-denied response: ${err.message}`);
+            await answerCallbackQuery(query.id, 'Failed to save response');
+            return;
+        }
+        // Edit message to show result and remove buttons
+        try {
+            await editMessageText(chatId, messageId, `${originalText}\n\n— ${label}`);
+        }
+        catch (err) {
+            logger.error(`Failed to edit message: ${err.message}`);
+        }
+    }
+    else if (type === 'pre-compact') {
+        // Pre-compact proceed/block
+        const { action } = parsed;
+        const label = action === 'block' ? '\ud83d\uded1 Blocked' : '\u2705 Proceeding...';
+        // Write response file for the polling hook
+        try {
+            (0, prompt_bridge_1.writeResponse)(promptId, { action });
+            logger.info(`Wrote pre-compact response for promptId=${promptId}: action=${action}`);
+            await answerCallbackQuery(query.id, label);
+        }
+        catch (err) {
+            logger.error(`Failed to write pre-compact response: ${err.message}`);
+            await answerCallbackQuery(query.id, 'Failed to save response');
+            return;
+        }
+        // Edit message to show result and remove buttons
+        try {
+            await editMessageText(chatId, messageId, `${originalText}\n\n— ${label}`);
+        }
+        catch (err) {
+            logger.error(`Failed to edit message: ${err.message}`);
+        }
+    }
+}
+// ── Message router ──────────────────────────────────────────────
+async function processMessage(msg) {
+    stopTypingIndicator();
+    // Only accept messages from the configured chat
+    const chatId = String(msg.chat.id);
+    if (chatId !== String(CHAT_ID)) {
+        logger.warn(`Ignoring message from unauthorized chat: ${chatId}`);
+        return;
+    }
+    const text = (msg.text || '').trim();
+    if (!text)
+        return;
+    logger.info(`Received: ${text}`);
+    // /help
+    if (text === '/help' || text === '/start') {
+        await handleHelp();
+        return;
+    }
+    // /sessions
+    if (text === '/sessions') {
+        await handleSessions();
+        return;
+    }
+    // /status [workspace]
+    const statusMatch = text.match(/^\/status(?:\s+(\S+))?$/);
+    if (statusMatch) {
+        await handleStatus(statusMatch[1] || null);
+        return;
+    }
+    // /stop [workspace]
+    const stopMatch = text.match(/^\/stop(?:\s+(\S+))?$/);
+    if (stopMatch) {
+        await handleStop(stopMatch[1] || null);
+        return;
+    }
+    // /use [workspace]
+    const useMatch = text.match(/^\/use(?:\s+(.*))?$/);
+    if (useMatch) {
+        await handleUse(useMatch[1] ? useMatch[1].trim() : null);
+        return;
+    }
+    // /compact [workspace]
+    const compactMatch = text.match(/^\/compact(?:\s+(\S+))?$/);
+    if (compactMatch) {
+        await handleCompact(compactMatch[1] || null);
+        return;
+    }
+    // /new [project]
+    const newMatch = text.match(/^\/new(?:\s+(.+))?$/);
+    if (newMatch) {
+        await handleNew(newMatch[1] ? newMatch[1].trim() : null);
+        return;
+    }
+    // /resume [project]
+    const resumeMatch = text.match(/^\/resume(?:\s+(.+))?$/);
+    if (resumeMatch) {
+        await handleResume(resumeMatch[1] ? resumeMatch[1].trim() : null);
+        return;
+    }
+    // /link <prompt>
+    const linkMatch = text.match(/^\/link(?:\s+(.+))?$/s);
+    if (linkMatch) {
+        await handleLink(linkMatch[1] ? linkMatch[1].trim() : '');
+        return;
+    }
+    // /effort [workspace] low|medium|high
+    const effortMatch = text.match(/^\/effort(?:\s+(.+))?$/);
+    if (effortMatch) {
+        await handleEffort(effortMatch[1] ? effortMatch[1].trim() : '');
+        return;
+    }
+    // /model [workspace] <model>
+    const modelMatch = text.match(/^\/model(?:\s+(.+))?$/);
+    if (modelMatch) {
+        await handleModel(modelMatch[1] ? modelMatch[1].trim() : '');
+        return;
+    }
+    // /cmd TOKEN command
+    const cmdMatch = text.match(/^\/cmd\s+(\S+)\s+(.+)/s);
+    if (cmdMatch) {
+        await handleCmd(cmdMatch[1], cmdMatch[2]);
+        return;
+    }
+    // /<workspace> command  (anything starting with / that isn't a known command)
+    const wsMatch = text.match(/^\/(\S+)\s+(.+)/s);
+    if (wsMatch) {
+        const workspace = wsMatch[1];
+        const command = wsMatch[2];
+        // Skip Telegram built-in bot commands that start with @
+        if (workspace.includes('@'))
+            return;
+        await handleWorkspaceCommand(workspace, command);
+        return;
+    }
+    // If just a slash command with no args, check if it's a workspace (with prefix matching)
+    const bareWs = text.match(/^\/(\S+)$/);
+    if (bareWs) {
+        const resolved = (0, workspace_router_1.resolveWorkspace)(bareWs[1]);
+        if (resolved.type === 'exact' || resolved.type === 'prefix') {
+            await handleStatus(resolved.workspace);
+        }
+        else if (resolved.type === 'ambiguous') {
+            const names = resolved.matches.map(m => `\`${escapeMarkdown(m.workspace)}\``).join(', ');
+            await sendMessage(`Multiple matches: ${names}. Be more specific.`);
+        }
+        else {
+            await sendMessage(`Unknown command: \`${text}\`. Try /help`);
+        }
+        return;
+    }
+    // Plain text — try reply-to routing, then default workspace, then show hint
+    const replyToId = msg.reply_to_message && msg.reply_to_message.message_id;
+    if (replyToId) {
+        const replyWorkspace = (0, workspace_router_1.getWorkspaceForMessage)(replyToId);
+        if (replyWorkspace) {
+            await handleWorkspaceCommand(replyWorkspace, text);
+            return;
+        }
+    }
+    const defaultWs = (0, workspace_router_1.getDefaultWorkspace)();
+    if (defaultWs) {
+        await handleWorkspaceCommand(defaultWs, text);
+        return;
+    }
+    await sendMessage('Use `/help` to see available commands, or `/use <workspace>` to set a default.');
+}
+// ── Long polling loop ───────────────────────────────────────────
+async function poll() {
+    while (true) {
+        try {
+            const updates = await telegramAPI('getUpdates', {
+                offset: lastUpdateId + 1,
+                timeout: 30,
+                allowed_updates: ['message', 'callback_query'],
+            });
+            lastPollTime = Date.now();
+            for (const update of updates) {
+                lastUpdateId = update.update_id;
+                if (update.callback_query) {
+                    try {
+                        await processCallbackQuery(update.callback_query);
+                    }
+                    catch (err) {
+                        logger.error(`Error processing callback query: ${err.message}`);
+                    }
+                }
+                else if (update.message) {
+                    try {
+                        await processMessage(update.message);
+                    }
+                    catch (err) {
+                        logger.error(`Error processing message: ${err.message}`);
+                    }
+                }
+            }
+        }
+        catch (err) {
+            // Network error — back off and retry
+            logger.error(`Polling error: ${err.message}`);
+            await sleep(5000);
+        }
+    }
+}
+// ── Helpers ──────────────────────────────────────────────────────
+function capturePane(tmuxSession) {
+    return new Promise((resolve, reject) => {
+        (0, child_process_1.exec)(`tmux capture-pane -t ${tmuxSession} -p`, (err, stdout) => {
+            if (err)
+                reject(err);
+            else
+                resolve(stdout);
+        });
+    });
+}
+function escapeMarkdown(text) {
+    // Telegram Markdown v1 only needs these escaped
+    return text.replace(/([_*`\[])/g, '\\$1');
+}
+function escapeHtml(text) {
+    return text.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+// ── Health check server ──────────────────────────────────────────
+function startHealthServer(port) {
+    const server = http_1.default.createServer((req, res) => {
+        if (req.url !== '/health') {
+            res.writeHead(404);
+            res.end('Not found');
+            return;
+        }
+        const now = Date.now();
+        const pollAge = lastPollTime ? now - lastPollTime : null;
+        const stale = pollAge === null || pollAge > 60000;
+        const sessions = (0, workspace_router_1.listActiveSessions)();
+        let pendingCount = 0;
+        try {
+            const files = fs_1.default.readdirSync(prompt_bridge_1.PROMPTS_DIR).filter(f => f.startsWith('pending-'));
+            pendingCount = files.length;
+        }
+        catch { }
+        const body = JSON.stringify({
+            status: stale ? 'unhealthy' : 'ok',
+            uptime: Math.floor((now - startTime) / 1000),
+            lastPollAge: pollAge !== null ? Math.floor(pollAge / 1000) : null,
+            activeSessions: sessions.length,
+            pendingPrompts: pendingCount,
+        }, null, 2);
+        res.writeHead(stale ? 503 : 200, { 'Content-Type': 'application/json' });
+        res.end(body);
+    });
+    server.listen(port, '127.0.0.1', () => {
+        logger.info(`Health endpoint: http://127.0.0.1:${port}/health`);
+    });
+    server.on('error', (err) => {
+        logger.warn(`Health server error: ${err.message}`);
+    });
+}
+// ── Startup ─────────────────────────────────────────────────────
+async function start() {
+    // Ensure data directory exists
+    const dataDir = path_1.default.join(paths_1.PROJECT_ROOT, 'src/data');
+    fs_1.default.mkdirSync(dataDir, { recursive: true });
+    const { version } = require(path_1.default.join(paths_1.PROJECT_ROOT, 'package.json'));
+    logger.info(`Cheesyboy v${version} — Starting Telegram bot (long polling)...`);
+    logger.info(`Chat ID: ${CHAT_ID}`);
+    // Prune expired sessions on startup
+    const pruned = (0, workspace_router_1.pruneExpired)();
+    if (pruned > 0) {
+        logger.info(`Pruned ${pruned} expired sessions`);
+    }
+    // Delete any existing webhook to ensure long polling works
+    try {
+        await telegramAPI('deleteWebhook', {});
+        logger.info('Webhook cleared, using long polling');
+    }
+    catch (err) {
+        logger.warn(`Could not delete webhook: ${err.message}`);
+    }
+    // Register bot commands with Telegram (populates the "/" menu in chat)
+    await registerBotCommands();
+    // Start optional health check server
+    const healthPort = parseInt(process.env.HEALTH_PORT, 10);
+    if (healthPort) {
+        startHealthServer(healthPort);
+    }
+    await poll();
+}
+// Graceful shutdown
+process.on('SIGINT', () => {
+    logger.info('Shutting down...');
+    process.exit(0);
+});
+process.on('SIGTERM', () => {
+    logger.info('Shutting down...');
+    process.exit(0);
+});
+start().catch((err) => {
+    logger.error(`Fatal: ${err.message}`);
+    process.exit(1);
+});
+//# sourceMappingURL=workspace-telegram-bot.js.map