@jsayubi/ccgram 1.1.1 → 1.2.0

package/dist/workspace-telegram-bot.js

@@ -34,6 +34,9 @@ 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';
@@ -46,6 +49,23 @@ const TMUX_AVAILABLE = (() => {
         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') {
@@ -152,11 +172,14 @@ 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 {
@@ -188,6 +211,17 @@ function editMessageText(chatId, messageId, text, 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 = [
@@ -200,6 +234,9 @@ async function handleHelp() {
         '`/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',
@@ -212,6 +249,127 @@ async function handleHelp() {
     ].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)();
@@ -258,22 +416,124 @@ async function handleStatus(workspaceArg) {
     const match = resolved.match;
     const resolvedName = resolved.workspace;
     const tmuxName = match.session.tmuxSession;
-    try {
-        const output = await sessionCaptureOutput(tmuxName);
-        // Trim and take last 20 lines to avoid message length limits
-        const trimmed = output.trim().split('\n').slice(-20).join('\n');
-        const htmlMsg = `<b>${escapeHtml(resolvedName)}</b> session output:\n<pre>${escapeHtml(trimmed)}</pre>`;
+    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 {
-            await sendHtmlMessage(htmlMsg);
+            const raw = await sessionCaptureOutput(tmuxName, session);
+            paneOutput = raw.trim().split('\n').slice(-20).join('\n');
         }
-        catch {
-            // Fallback to plain text if HTML fails
-            await telegramAPI('sendMessage', { chat_id: CHAT_ID, text: `${resolvedName} session output:\n${trimmed}` });
+        catch (err) {
+            paneOutput = `(capture failed: ${err.message})`;
         }
     }
-    catch (err) {
-        await sendMessage(`Could not read session \`${tmuxName}\`: ${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;
@@ -302,12 +562,12 @@ async function handleStop(workspaceArg) {
     }
     const resolvedName = resolved.workspace;
     const tmuxName = resolved.match.session.tmuxSession;
-    if (!await sessionExists(tmuxName)) {
+    if (!await sessionExists(tmuxName, resolved.match.session)) {
         await sendMessage(`Session \`${tmuxName}\` not found.`);
         return;
     }
     try {
-        await sessionInterrupt(tmuxName);
+        await sessionInterrupt(tmuxName, resolved.match.session);
         await sendMessage(`\u26d4 Sent interrupt to *${escapeMarkdown(resolvedName)}*`);
     }
     catch (err) {
@@ -399,6 +659,7 @@ async function handleCompact(workspaceArg) {
         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)
@@ -411,7 +672,7 @@ async function handleCompact(workspaceArg) {
     for (let i = 0; i < 5; i++) {
         await sleep(2000);
         try {
-            const output = await sessionCaptureOutput(tmuxName);
+            const output = await sessionCaptureOutput(tmuxName, compactSession);
             if (output.includes('Compacting')) {
                 started = true;
                 break;
@@ -424,7 +685,7 @@ async function handleCompact(workspaceArg) {
     if (!started) {
         // Command may have finished very quickly or failed to start
         try {
-            const output = await sessionCaptureOutput(tmuxName);
+            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\`\`\``);
@@ -439,7 +700,7 @@ async function handleCompact(workspaceArg) {
     for (let i = 0; i < 30; i++) {
         await sleep(2000);
         try {
-            const output = await sessionCaptureOutput(tmuxName);
+            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\`\`\``);
@@ -452,7 +713,7 @@ async function handleCompact(workspaceArg) {
     }
     // Timeout — show current session state
     try {
-        const output = await sessionCaptureOutput(tmuxName);
+        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\`\`\``);
     }
@@ -556,8 +817,11 @@ async function startProject(name) {
     }
     // 3. Sanitize tmux session name (dots, colons, spaces are invalid in tmux)
     const tmuxName = name.replace(/[.:\s]/g, '-');
-    // 4. Check existing session (PTY or tmux)
-    const alreadyRunning = await sessionExists(tmuxName);
+    // 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);
@@ -565,9 +829,9 @@ async function startProject(name) {
         await sendMessage(`Session \`${tmuxName}\` already running.\nSet as default — send messages directly.`);
         return;
     }
-    // 5. Create session — PTY or tmux
-    const usePty = !TMUX_AVAILABLE || INJECTION_MODE === 'pty';
-    if (!usePty) {
+    // 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}"`);
@@ -589,7 +853,27 @@ async function startProject(name) {
             (0, workspace_router_1.trackNotificationMessage)(msg.message_id, name, 'new-session');
         }
     }
-    else if (pty_session_manager_1.ptySessionManager.isAvailable()) {
+    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) {
@@ -609,8 +893,8 @@ async function startProject(name) {
         }
     }
     else {
-        await sendMessage('\u26a0\ufe0f tmux not found and node-pty not installed.\n' +
-            'Install tmux or run: `npm install node-pty` in ~/.ccgram/');
+        await sendMessage('\u26a0\ufe0f No injection backend available.\n' +
+            'Install tmux, run Ghostty, or run: `npm install node-pty` in ~/.ccgram/');
     }
 }
 // ── Resume feature ───────────────────────────────────────────────
@@ -691,12 +975,12 @@ async function resumeSession(projectName, sessionIdx, force = false) {
     }
     const sessionId = sessions[sessionIdx].id;
     const tmuxName = projectName.replace(/[.:\s]/g, '-');
-    const running = await sessionExists(tmuxName);
-    // Look up the bot's tracked session for this workspace (used by multiple checks below)
-    const map = running ? (0, workspace_router_1.readSessionMap)() : {};
-    const currentEntry = running
-        ? Object.values(map).find(s => s.tmuxSession === tmuxName && !(0, workspace_router_1.isExpired)(s))
-        : undefined;
+    // 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) {
@@ -753,6 +1037,26 @@ async function resumeSession(projectName, sessionIdx, force = false) {
             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);
@@ -760,9 +1064,15 @@ async function resumeSession(projectName, sessionIdx, force = false) {
 async function startProjectResume(name, projectDir, sessionId) {
     const tmuxName = name.replace(/[.:\s]/g, '-');
     const shortId = sessionId.slice(0, 8);
-    // If a tmux session is already running, switch Claude inline (exit + resume)
-    // instead of killing the tmux session. This keeps the user's terminal attached.
-    if (!isPtySession(tmuxName) && await sessionExists(tmuxName)) {
+    // 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
@@ -793,9 +1103,9 @@ async function startProjectResume(name, projectDir, sessionId) {
         }
         return;
     }
-    // No session running — create a new one
-    const usePty = !TMUX_AVAILABLE || INJECTION_MODE === 'pty';
-    if (!usePty) {
+    // 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);
@@ -817,7 +1127,27 @@ async function startProjectResume(name, projectDir, sessionId) {
             (0, workspace_router_1.trackNotificationMessage)(msg.message_id, name, 'resume-session');
         }
     }
-    else if (pty_session_manager_1.ptySessionManager.isAvailable()) {
+    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.');
@@ -837,13 +1167,13 @@ async function startProjectResume(name, projectDir, sessionId) {
         }
     }
     else {
-        await sendMessage('\u26a0\ufe0f tmux not found and node-pty not installed.\n' +
-            'Install tmux or run: `npm install node-pty` in ~/.ccgram/');
+        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)) {
+    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;
     }
@@ -856,6 +1186,13 @@ async function injectAndRespond(session, command, workspace) {
             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, "'\"'\"'");
@@ -883,15 +1220,23 @@ function tmuxExec(cmd) {
         });
     });
 }
-// ── PTY / tmux dispatch helpers ──────────────────────────────────
+// ── 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);
 }
-/** Check session exists (PTY handle OR tmux session). */
-async function sessionExists(name) {
+/** 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`);
@@ -906,32 +1251,51 @@ async function sessionExists(name) {
 /**
  * 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) {
+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 (last 20 lines). */
-async function sessionCaptureOutput(name) {
+/** 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) {
+async function sessionInterrupt(name, session) {
     if (isPtySession(name))
         pty_session_manager_1.ptySessionManager.interrupt(name);
-    else
+    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 💤
     }
@@ -1003,7 +1367,10 @@ async function processCallbackQuery(query) {
             return;
         }
         const { action } = parsed;
-        const label = action === 'allow' ? '\u2705 Allowed' : action === 'always' ? '\ud83d\udd13 Always Allowed' : '\u274c Denied';
+        const label = 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 });
@@ -1024,10 +1391,11 @@ async function processCallbackQuery(query) {
         }
     }
     else if (type === 'opt') {
-        // Question option: inject keystroke via tmux
+        // 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 || !pending.tmuxSession) {
-            await answerCallbackQuery(query.id, 'Session not found');
+        if (!pending) {
+            await answerCallbackQuery(query.id, 'Session expired');
             return;
         }
         const optIdx = parsed.optionIndex - 1;
@@ -1060,43 +1428,29 @@ async function processCallbackQuery(query) {
             }
             return;
         }
-        // Single-select: inject arrow keys + Enter into session
-        // Claude Code's AskUserQuestion UI: first option pre-highlighted, Down (N-1) times + Enter
-        const downPresses = optIdx;
-        const tmuxSessOpt = pending.tmuxSession;
-        try {
-            for (let i = 0; i < downPresses; i++) {
-                await sessionSendKey(tmuxSessOpt, 'Down');
-            }
-            await sessionSendKey(tmuxSessOpt, 'Enter');
-            // For multi-question flows: after the last question, send an extra
-            // Enter to confirm the preview/submit step
-            if (pending.isLast) {
-                await sleep(500);
-                await sessionSendKey(tmuxSessOpt, 'Enter');
-            }
-            await answerCallbackQuery(query.id, `Selected: ${optionLabel}`);
-            startTypingIndicator(); // ensure Stop hook routes response back to Telegram
-        }
-        catch (err) {
-            logger.error(`Failed to inject keystroke: ${err.message}`);
-            await answerCallbackQuery(query.id, 'Failed to send selection');
-            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— Selected: *${escapeMarkdown(optionLabel)}*`);
+            await editMessageText(chatId, messageId, `${originalText}\n\n\u2714 Selected: *${escapeMarkdown(optionLabel)}*`);
         }
         catch (err) {
             logger.error(`Failed to edit message: ${err.message}`);
         }
-        (0, prompt_bridge_1.cleanPrompt)(promptId);
+        // Note: hook will clean up the prompt files after reading the response
     }
     else if (type === 'opt-submit') {
-        // Multi-select submit: inject Space toggles for selected options, then Enter
+        // Multi-select submit: write response file so hook returns updatedInput
         const pending = (0, prompt_bridge_1.readPending)(promptId);
-        if (!pending || !pending.tmuxSession) {
-            await answerCallbackQuery(query.id, 'Session not found');
+        if (!pending) {
+            await answerCallbackQuery(query.id, 'Session expired');
             return;
         }
         const selected = pending.selectedOptions || [];
@@ -1105,44 +1459,26 @@ async function processCallbackQuery(query) {
             await answerCallbackQuery(query.id, 'No options selected');
             return;
         }
-        // Inject keystrokes: iterate each option from top, Space if selected, Down to next
-        // Claude Code multi-select UI starts with cursor on first option
-        // After the listed options, Claude Code adds an auto-generated "Other" option,
-        // then Submit. So we need: options.length Downs + 1 more Down to skip "Other"
-        const tmuxSessSubmit = pending.tmuxSession;
-        try {
-            for (let i = 0; i < pending.options.length; i++) {
-                if (selected[i]) {
-                    await sessionSendKey(tmuxSessSubmit, 'Space');
-                }
-                await sessionSendKey(tmuxSessSubmit, 'Down');
-            }
-            // Skip past the auto-added "Other" option to reach Submit
-            await sessionSendKey(tmuxSessSubmit, 'Down');
-            // Cursor is now on Submit — press Enter
-            await sessionSendKey(tmuxSessSubmit, 'Enter');
-            // For multi-question flows: extra Enter to confirm
-            if (pending.isLast) {
-                await sleep(500);
-                await sessionSendKey(tmuxSessSubmit, 'Enter');
-            }
-            await answerCallbackQuery(query.id, `Submitted ${selectedLabels.length} options`);
-            startTypingIndicator(); // ensure Stop hook routes response back to Telegram
-        }
-        catch (err) {
-            logger.error(`Failed to inject keystrokes: ${err.message}`);
-            await answerCallbackQuery(query.id, 'Failed to send selections');
-            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— Selected:\n${selectionText}`);
+            await editMessageText(chatId, messageId, `${originalText}\n\n\u2714 Selected:\n${selectionText}`);
         }
         catch (err) {
             logger.error(`Failed to edit message: ${err.message}`);
         }
-        (0, prompt_bridge_1.cleanPrompt)(promptId);
+        // 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
@@ -1170,12 +1506,13 @@ async function processCallbackQuery(query) {
         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');
+                        await sessionSendKey(tmux, 'Down', sessionEntryQperm);
                     }
-                    await sessionSendKey(tmux, 'Enter');
+                    await sessionSendKey(tmux, 'Enter', sessionEntryQperm);
                     startTypingIndicator(); // ensure Stop hook routes response back to Telegram
                     logger.info(`Injected question answer into ${tmux}: option ${parsed.optionIndex}`);
                 }
@@ -1192,6 +1529,52 @@ async function processCallbackQuery(query) {
             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) {
@@ -1252,6 +1635,24 @@ async function processMessage(msg) {
         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) {