@gonzih/cc-tg 0.9.21 → 0.9.22

package/dist/bot.js

@@ -11,16 +11,17 @@ import https from "https";
 import http from "http";
 import { ClaudeProcess, extractText } from "./claude.js";
 import { transcribeVoice, isVoiceAvailable } from "./voice.js";
-import { CronManager } from "./cron.js";
 import { formatForTelegram, splitLongMessage } from "./formatter.js";
 import { detectUsageLimit } from "./usage-limit.js";
+import { getCurrentToken, rotateToken, getTokenIndex, getTokenCount } from "./tokens.js";
+import { writeChatLog } from "./notifier.js";
+import { CronManager } from "./cron.js";
 const BOT_COMMANDS = [
     { command: "start", description: "Reset session and start fresh" },
     { command: "reset", description: "Reset Claude session" },
     { command: "stop", description: "Stop the current Claude task" },
     { command: "status", description: "Check if a session is active" },
     { command: "help", description: "Show all available commands" },
-    { command: "cron", description: "Manage cron jobs — add/list/edit/remove/clear" },
     { command: "reload_mcp", description: "Restart the cc-agent MCP server process" },
     { command: "mcp_status", description: "Check MCP server connection status" },
     { command: "mcp_version", description: "Show cc-agent npm version and npx cache info" },
@@ -28,22 +29,11 @@ const BOT_COMMANDS = [
     { command: "restart", description: "Restart the bot process in-place" },
     { command: "get_file", description: "Send a file from the server to this chat" },
     { command: "cost", description: "Show session token usage and cost" },
+    { command: "skills", description: "List available Claude skills with descriptions" },
+    { command: "cron", description: "Manage cron jobs — add/list/edit/remove/clear" },
+    { command: "voice_retry", description: "Retry failed voice message transcriptions" },
+    { command: "drivers", description: "List available agent drivers" },
 ];
-async function withRetry(fn, attempts, delays) {
-    for (let i = 0; i < attempts; i++) {
-        try {
-            return await fn();
-        }
-        catch (e) {
-            if (i < attempts - 1) {
-                await new Promise(r => setTimeout(r, delays[i] ?? 2000));
-                continue;
-            }
-            throw e;
-        }
-    }
-    throw new Error('unreachable');
-}
 const FLUSH_DELAY_MS = 800; // debounce streaming chunks into one Telegram message
 const TYPING_INTERVAL_MS = 4000; // re-send typing action before Telegram's 5s expiry
 // Claude Sonnet 4.6 pricing (per 1M tokens)
@@ -79,10 +69,6 @@ function formatCostReport(cost) {
         `  Cache write: ${formatTokens(cost.totalCacheWriteTokens)} tokens ($${cacheWriteCost.toFixed(3)})`,
     ].join("\n");
 }
-function formatCronCostFooter(usage) {
-    const cost = computeCostUsd(usage);
-    return `\n💰 Cron cost: $${cost.toFixed(4)} (${formatTokens(usage.inputTokens)} in / ${formatTokens(usage.outputTokens)} out tokens)`;
-}
 function formatAgentCostSummary(text) {
     try {
         const data = JSON.parse(text);
@@ -169,12 +155,17 @@ export class CcTgBot {
     sessions = new Map();
     pendingRetries = new Map();
     opts;
-    cron;
     costStore;
     botUsername = "";
     botId = 0;
+    redis;
+    namespace;
+    lastActiveChatId;
+    cron;
     constructor(opts) {
         this.opts = opts;
+        this.redis = opts.redis;
+        this.namespace = opts.namespace ?? "default";
         this.bot = new TelegramBot(opts.telegramToken, { polling: true });
         this.bot.on("message", (msg) => this.handleTelegram(msg));
         this.bot.on("polling_error", (err) => console.error("[tg]", err.message));
@@ -183,11 +174,10 @@ export class CcTgBot {
             this.botId = me.id;
             console.log(`[tg] bot identity: @${this.botUsername} (id=${this.botId})`);
         }).catch((err) => console.error("[tg] getMe failed:", err.message));
-        // Cron manager — fires each task into an isolated ClaudeProcess
-        this.cron = new CronManager(opts.cwd ?? process.cwd(), (chatId, prompt) => {
-            this.runCronTask(chatId, prompt);
-        });
         this.costStore = new CostStore(opts.cwd ?? process.cwd());
+        this.cron = new CronManager(opts.cwd ?? process.cwd(), (chatId, prompt, _jobId, done) => {
+            this.runCronTask(chatId, prompt, done);
+        });
         this.registerBotCommands();
         console.log("cc-tg bot started");
         console.log(`[voice] whisper available: ${isVoiceAvailable()}`);
@@ -197,6 +187,55 @@ export class CcTgBot {
             .then(() => console.log("[tg] bot commands registered"))
             .catch((err) => console.error("[tg] setMyCommands failed:", err.message));
     }
+    /** Write a message to the Redis chat log. Fire-and-forget — no-op if Redis is not configured. */
+    writeChatMessage(role, source, content, chatId) {
+        if (!this.redis)
+            return;
+        const msg = {
+            id: `${source}-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`,
+            source,
+            role,
+            content,
+            timestamp: new Date().toISOString(),
+            chatId,
+        };
+        writeChatLog(this.redis, this.namespace, msg);
+    }
+    /** Returns the last chatId that sent a message — used by the chat bridge when no fixed chatId is configured. */
+    getLastActiveChatId() {
+        return this.lastActiveChatId;
+    }
+    /** Session key: "chatId:threadId" for topics, "chatId:main" for DMs/non-topic groups */
+    sessionKey(chatId, threadId) {
+        return `${chatId}:${threadId ?? 'main'}`;
+    }
+    /**
+     * Send a message back to the correct thread (or plain chat if no thread).
+     * When threadId is undefined, calls sendMessage with exactly 2 args to preserve
+     * backward-compatible call signatures (no extra options object).
+     */
+    replyToChat(chatId, text, threadId, opts) {
+        if (threadId !== undefined) {
+            return this.bot.sendMessage(chatId, text, { ...opts, message_thread_id: threadId });
+        }
+        if (opts) {
+            return this.bot.sendMessage(chatId, text, opts);
+        }
+        return this.bot.sendMessage(chatId, text);
+    }
+    /** Parse THREAD_CWD_MAP env var — maps thread name or thread_id to a CWD path */
+    getThreadCwdMap() {
+        const raw = process.env.THREAD_CWD_MAP;
+        if (!raw)
+            return {};
+        try {
+            return JSON.parse(raw);
+        }
+        catch {
+            console.warn('[cc-tg] THREAD_CWD_MAP is not valid JSON, ignoring');
+            return {};
+        }
+    }
     isAllowed(userId) {
         if (!this.opts.allowedUserIds?.length)
             return true;
@@ -205,10 +244,20 @@ export class CcTgBot {
     async handleTelegram(msg) {
         const chatId = msg.chat.id;
         const userId = msg.from?.id ?? chatId;
+        // Forum topic thread_id — undefined for DMs and non-topic group messages
+        const threadId = msg.message_thread_id;
+        // Thread name is available on the service message that creates a new topic.
+        // forum_topic_created is not in older @types/node-telegram-bot-api versions, so cast via unknown.
+        const rawMsg = msg;
+        const threadName = rawMsg.forum_topic_created
+            ? rawMsg.forum_topic_created.name
+            : undefined;
         if (!this.isAllowed(userId)) {
-            await this.bot.sendMessage(chatId, "Not authorized.");
+            await this.replyToChat(chatId, "Not authorized.", threadId);
             return;
         }
+        // Track the last chat that sent us a message for the chat bridge
+        this.lastActiveChatId = chatId;
         // Group chat handling
         const isGroup = msg.chat.type === "group" || msg.chat.type === "supergroup";
         if (isGroup) {
@@ -227,17 +276,17 @@ export class CcTgBot {
         }
         // Voice message — transcribe then feed as text
         if (msg.voice || msg.audio) {
-            await this.handleVoice(chatId, msg);
+            await this.handleVoice(chatId, msg, threadId, threadName);
             return;
         }
         // Photo — send as base64 image content block to Claude
         if (msg.photo?.length) {
-            await this.handlePhoto(chatId, msg);
+            await this.handlePhoto(chatId, msg, threadId, threadName);
             return;
         }
         // Document — download to CWD/.cc-tg/uploads/, tell Claude the path
         if (msg.document) {
-            await this.handleDocument(chatId, msg);
+            await this.handleDocument(chatId, msg, threadId, threadName);
             return;
         }
         let text = msg.text?.trim();
@@ -247,68 +296,69 @@ export class CcTgBot {
         if (this.botUsername) {
             text = text.replace(new RegExp(`@${this.botUsername}\\s*`, "g"), "").trim();
         }
+        const sessionKey = this.sessionKey(chatId, threadId);
         // /start or /reset — kill existing session and ack
         if (text === "/start" || text === "/reset") {
-            this.killSession(chatId);
-            await this.bot.sendMessage(chatId, "Session reset. Send a message to start.");
+            this.killSession(chatId, true, threadId);
+            await this.replyToChat(chatId, "Session reset. Send a message to start.", threadId);
             return;
         }
         // /stop — kill active session (interrupt running Claude task)
         if (text === "/stop") {
-            const has = this.sessions.has(chatId);
-            this.killSession(chatId);
-            await this.bot.sendMessage(chatId, has ? "Stopped." : "No active session.");
+            const has = this.sessions.has(sessionKey);
+            this.killSession(chatId, true, threadId);
+            await this.replyToChat(chatId, has ? "Stopped." : "No active session.", threadId);
             return;
         }
         // /help — list all commands
         if (text === "/help") {
             const lines = BOT_COMMANDS.map((c) => `/${c.command} — ${c.description}`);
-            await this.bot.sendMessage(chatId, lines.join("\n"));
+            await this.replyToChat(chatId, lines.join("\n"), threadId);
             return;
         }
         // /status
         if (text === "/status") {
-            const has = this.sessions.has(chatId);
+            const has = this.sessions.has(sessionKey);
             let status = has ? "Session active." : "No active session.";
             const sleeping = this.pendingRetries.size;
             if (sleeping > 0)
                 status += `\n⏸ ${sleeping} request(s) sleeping (usage limit).`;
-            await this.bot.sendMessage(chatId, status);
-            return;
-        }
-        // /cron <schedule> <prompt> | /cron list | /cron clear | /cron remove <id>
-        if (text.startsWith("/cron")) {
-            await this.handleCron(chatId, text);
+            await this.replyToChat(chatId, status, threadId);
             return;
         }
         // /reload_mcp — kill cc-agent process so Claude Code auto-restarts it
         if (text === "/reload_mcp") {
-            await this.handleReloadMcp(chatId);
+            await this.handleReloadMcp(chatId, threadId);
             return;
         }
         // /mcp_status — run `claude mcp list` and show connection status
         if (text === "/mcp_status") {
-            await this.handleMcpStatus(chatId);
+            await this.handleMcpStatus(chatId, threadId);
             return;
         }
         // /mcp_version — show published npm version and cached npx entries
         if (text === "/mcp_version") {
-            await this.handleMcpVersion(chatId);
+            await this.handleMcpVersion(chatId, threadId);
             return;
         }
         // /clear_npx_cache — wipe ~/.npm/_npx/ then restart cc-agent
         if (text === "/clear_npx_cache") {
-            await this.handleClearNpxCache(chatId);
+            await this.handleClearNpxCache(chatId, threadId);
             return;
         }
         // /restart — restart the bot process in-place
         if (text === "/restart") {
-            await this.handleRestart(chatId);
+            await this.handleRestart(chatId, threadId);
+            return;
+        }
+        // /cron <schedule> <prompt> | /cron list | /cron clear | /cron remove <id>
+        if (text.startsWith("/cron")) {
+            await this.handleCron(chatId, text, threadId);
             return;
         }
         // /get_file <path> — send a file from the server to the user
         if (text.startsWith("/get_file")) {
-            await this.handleGetFile(chatId, text);
+            await this.handleGetFile(chatId, text, threadId);
             return;
         }
         // /cost — show session token usage and cost
@@ -324,85 +374,237 @@ export class CcTgBot {
             catch (err) {
                 console.error("[cost] cc-agent cost_summary failed:", err.message);
             }
-            await this.bot.sendMessage(chatId, reply);
+            await this.replyToChat(chatId, reply, threadId);
             return;
         }
-        const session = this.getOrCreateSession(chatId);
+        // /skills — list available Claude skills from ~/.claude/skills/
+        if (text === "/skills") {
+            await this.replyToChat(chatId, listSkills(), threadId);
+            return;
+        }
+        // /voice_retry — retry failed voice message transcriptions
+        if (text === "/voice_retry") {
+            await this.handleVoiceRetry(chatId, threadId);
+            return;
+        }
+        // /drivers — list available agent drivers via cc-agent MCP
+        if (text === "/drivers") {
+            await this.handleDrivers(chatId, threadId);
+            return;
+        }
+        const session = this.getOrCreateSession(chatId, threadId, threadName);
         try {
-            const prompt = buildPromptWithReplyContext(text, msg);
+            const enriched = await enrichPromptWithUrls(text);
+            const prompt = buildPromptWithReplyContext(enriched, msg);
             session.currentPrompt = prompt;
             session.claude.sendPrompt(prompt);
             this.startTyping(chatId, session);
+            this.writeChatMessage("user", "telegram", text, chatId);
+        }
+        catch (err) {
+            await this.replyToChat(chatId, `Error sending to Claude: ${err.message}`, threadId);
+            this.killSession(chatId, true, threadId);
+        }
+    }
+    /**
+     * Feed a text message into the active Claude session for the given chat.
+     * Called by the notifier when a UI message arrives via Redis pub/sub.
+     */
+    async handleUserMessage(chatId, text) {
+        const session = this.getOrCreateSession(chatId);
+        try {
+            const enriched = await enrichPromptWithUrls(text);
+            session.currentPrompt = enriched;
+            session.claude.sendPrompt(enriched);
+            this.startTyping(chatId, session);
+            this.writeChatMessage("user", "ui", text, chatId);
         }
         catch (err) {
-            await this.bot.sendMessage(chatId, `Error sending to Claude: ${err.message}`);
-            this.killSession(chatId);
+            await this.replyToChat(chatId, `Error sending to Claude: ${err.message}`);
+            this.killSession(chatId, true);
         }
     }
-    async handleVoice(chatId, msg) {
+    async handleVoice(chatId, msg, threadId, threadName) {
         const fileId = msg.voice?.file_id ?? msg.audio?.file_id;
         if (!fileId)
             return;
         console.log(`[voice:${chatId}] received voice message, transcribing...`);
-        this.bot.sendChatAction(chatId, "typing").catch(() => { });
+        this.bot.sendChatAction(chatId, "typing", threadId !== undefined ? { message_thread_id: threadId } : undefined).catch(() => { });
+        // Store in Redis before transcription so we can retry on failure
+        const pendingEntry = JSON.stringify({
+            file_id: fileId,
+            chat_id: chatId,
+            message_id: msg.message_id,
+            timestamp: Date.now(),
+        });
+        if (this.redis) {
+            await this.redis.rpush("voice:pending", pendingEntry).catch((err) => console.warn("[voice] redis rpush voice:pending failed:", err.message));
+        }
         try {
-            const transcript = await withRetry(async () => {
-                const fileLink = await this.bot.getFileLink(fileId);
-                return transcribeVoice(fileLink);
-            }, 3, [2000, 5000]);
+            const fileLink = await this.bot.getFileLink(fileId);
+            const transcript = await transcribeVoice(fileLink);
             console.log(`[voice:${chatId}] transcribed: ${transcript}`);
+            // Remove from pending on success
+            if (this.redis) {
+                await this.redis.lrem("voice:pending", 0, pendingEntry).catch((err) => console.warn("[voice] redis lrem voice:pending failed:", err.message));
+            }
             if (!transcript || transcript === "[empty transcription]") {
-                await this.bot.sendMessage(chatId, "Could not transcribe voice message.");
+                await this.replyToChat(chatId, "Could not transcribe voice message.", threadId);
                 return;
             }
             // Feed transcript into Claude as if user typed it
-            const session = this.getOrCreateSession(chatId);
+            const session = this.getOrCreateSession(chatId, threadId, threadName);
             try {
                 const prompt = buildPromptWithReplyContext(transcript, msg);
+                this.writeChatMessage("user", "telegram", transcript, chatId);
                 session.currentPrompt = prompt;
                 session.claude.sendPrompt(prompt);
                 this.startTyping(chatId, session);
             }
             catch (err) {
-                await this.bot.sendMessage(chatId, `Error sending to Claude: ${err.message}`);
-                this.killSession(chatId);
+                await this.replyToChat(chatId, `Error sending to Claude: ${err.message}`, threadId);
+                this.killSession(chatId, true, threadId);
             }
         }
         catch (err) {
-            const errMsg = err instanceof Error
-                ? (err.message || err.toString() || `signal: ${err.signal || 'unknown'}`)
-                : String(err);
-            const stderr = err.stderr ? ` | stderr: ${err.stderr.slice(0, 200)}` : '';
-            console.error(`[voice:${chatId}] error:`, errMsg, stderr);
-            await this.bot.sendMessage(chatId, `Voice transcription failed: ${errMsg}${stderr}`);
+            const errMsg = err.message;
+            console.error(`[voice:${chatId}] error:`, errMsg);
+            // Push to voice:failed on failure (entry stays in voice:pending for retry)
+            if (this.redis) {
+                const failedEntry = JSON.stringify({
+                    file_id: fileId,
+                    chat_id: chatId,
+                    message_id: msg.message_id,
+                    timestamp: Date.now(),
+                    error: errMsg,
+                    failed_at: Date.now(),
+                });
+                this.redis.rpush("voice:failed", failedEntry)
+                    .then(() => this.redis.expire("voice:failed", 48 * 60 * 60))
+                    .catch((redisErr) => console.warn("[voice] redis write voice:failed failed:", redisErr.message));
+            }
+            // User-friendly error messages
+            let userMsg;
+            if (errMsg.includes("whisper-cpp not found") || errMsg.includes("whisper not found")) {
+                userMsg = "Voice transcription unavailable — whisper-cpp not installed";
+            }
+            else if (errMsg.includes("No whisper model found")) {
+                userMsg = "Voice transcription unavailable — no whisper model found";
+            }
+            else if (errMsg.includes("HTTP") && errMsg.includes("downloading")) {
+                userMsg = "Could not download voice file from Telegram";
+            }
+            else {
+                userMsg = `Voice transcription failed: ${errMsg}`;
+            }
+            await this.replyToChat(chatId, userMsg, threadId);
+        }
+    }
+    async handleVoiceRetry(chatId, threadId) {
+        if (!this.redis) {
+            await this.replyToChat(chatId, "Redis not configured — voice retry unavailable.", threadId);
+            return;
+        }
+        const [pendingRaw, failedRaw] = await Promise.all([
+            this.redis.lrange("voice:pending", 0, -1).catch(() => []),
+            this.redis.lrange("voice:failed", 0, -1).catch(() => []),
+        ]);
+        // Deduplicate by file_id across both lists
+        const allEntries = new Map();
+        for (const raw of [...pendingRaw, ...failedRaw]) {
+            try {
+                const entry = JSON.parse(raw);
+                if (entry.file_id)
+                    allEntries.set(entry.file_id, entry);
+            }
+            catch { /* skip malformed entries */ }
+        }
+        if (allEntries.size === 0) {
+            await this.replyToChat(chatId, "No pending voice messages to retry.", threadId);
+            return;
+        }
+        await this.replyToChat(chatId, `Retrying ${allEntries.size} voice message(s)...`, threadId);
+        let succeeded = 0;
+        let failed = 0;
+        const errors = [];
+        for (const [fileId, entry] of allEntries) {
+            try {
+                const fileLink = await this.bot.getFileLink(fileId);
+                const transcript = await transcribeVoice(fileLink);
+                if (transcript && transcript !== "[empty transcription]") {
+                    const session = this.getOrCreateSession(entry.chat_id, threadId, undefined);
+                    session.claude.sendPrompt(transcript);
+                    this.writeChatMessage("user", "telegram", transcript, entry.chat_id);
+                    // Remove from both lists
+                    const matchPending = pendingRaw.find((r) => r.includes(`"${fileId}"`));
+                    const matchFailed = failedRaw.find((r) => r.includes(`"${fileId}"`));
+                    if (matchPending)
+                        await this.redis.lrem("voice:pending", 0, matchPending).catch(() => { });
+                    if (matchFailed)
+                        await this.redis.lrem("voice:failed", 0, matchFailed).catch(() => { });
+                    succeeded++;
+                }
+                else {
+                    failed++;
+                    errors.push(`${fileId}: empty transcription`);
+                }
+            }
+            catch (err) {
+                const errMsg = err.message;
+                failed++;
+                errors.push(`${fileId}: ${errMsg}`);
+                // Permanently unretryable (expired Telegram link) — remove from voice:pending
+                if (errMsg.includes("Bad Request") || errMsg.includes("file_id")) {
+                    const matchPending = pendingRaw.find((r) => r.includes(`"${fileId}"`));
+                    if (matchPending)
+                        await this.redis.lrem("voice:pending", 0, matchPending).catch(() => { });
+                }
+            }
         }
+        // Purge stale entries from voice:pending older than 48h
+        const staleThreshold = 48 * 60 * 60 * 1000;
+        let purged = 0;
+        for (const raw of pendingRaw) {
+            try {
+                const entry = JSON.parse(raw);
+                if (entry.timestamp && Date.now() - entry.timestamp > staleThreshold) {
+                    await this.redis.lrem("voice:pending", 0, raw).catch(() => { });
+                    purged++;
+                }
+            }
+            catch { /* skip malformed entries */ }
+        }
+        const lines = [`Voice retry complete: ${succeeded} succeeded, ${failed} failed, ${purged} stale entries purged.`];
+        if (errors.length > 0)
+            lines.push(...errors.map((e) => `• ${e}`));
+        await this.replyToChat(chatId, lines.join("\n"), threadId);
     }
-    async handlePhoto(chatId, msg) {
+    async handlePhoto(chatId, msg, threadId, threadName) {
         // Pick highest resolution photo
         const photos = msg.photo;
         const best = photos[photos.length - 1];
         const caption = msg.caption?.trim();
         console.log(`[photo:${chatId}] received image file_id=${best.file_id}`);
-        this.bot.sendChatAction(chatId, "typing").catch(() => { });
+        this.bot.sendChatAction(chatId, "typing", threadId !== undefined ? { message_thread_id: threadId } : undefined).catch(() => { });
         try {
             const fileLink = await this.bot.getFileLink(best.file_id);
             const imageData = await fetchAsBase64(fileLink);
             // Telegram photos are always JPEG
-            const session = this.getOrCreateSession(chatId);
+            const session = this.getOrCreateSession(chatId, threadId, threadName);
             session.claude.sendImage(imageData, "image/jpeg", caption);
             this.startTyping(chatId, session);
         }
         catch (err) {
             console.error(`[photo:${chatId}] error:`, err.message);
-            await this.bot.sendMessage(chatId, `Failed to process image: ${err.message}`);
+            await this.replyToChat(chatId, `Failed to process image: ${err.message}`, threadId);
         }
     }
-    async handleDocument(chatId, msg) {
+    async handleDocument(chatId, msg, threadId, threadName) {
         const doc = msg.document;
         const caption = msg.caption?.trim();
         const fileName = doc.file_name ?? `file_${doc.file_id}`;
         console.log(`[doc:${chatId}] received document file_name=${fileName} mime=${doc.mime_type}`);
-        this.bot.sendChatAction(chatId, "typing").catch(() => { });
+        this.bot.sendChatAction(chatId, "typing", threadId !== undefined ? { message_thread_id: threadId } : undefined).catch(() => { });
         try {
             const uploadsDir = join(this.opts.cwd ?? process.cwd(), ".cc-tg", "uploads");
             mkdirSync(uploadsDir, { recursive: true });
@@ -413,22 +615,34 @@ export class CcTgBot {
             const prompt = caption
                 ? `${caption}\n\nATTACHMENTS: [${fileName}](${destPath})`
                 : `ATTACHMENTS: [${fileName}](${destPath})`;
-            const session = this.getOrCreateSession(chatId);
+            const session = this.getOrCreateSession(chatId, threadId, threadName);
             session.claude.sendPrompt(prompt);
             this.startTyping(chatId, session);
         }
         catch (err) {
             console.error(`[doc:${chatId}] error:`, err.message);
-            await this.bot.sendMessage(chatId, `Failed to receive document: ${err.message}`);
+            await this.replyToChat(chatId, `Failed to receive document: ${err.message}`, threadId);
         }
     }
-    getOrCreateSession(chatId) {
-        const existing = this.sessions.get(chatId);
+    getOrCreateSession(chatId, threadId, threadName) {
+        const key = this.sessionKey(chatId, threadId);
+        const existing = this.sessions.get(key);
         if (existing && !existing.claude.exited)
             return existing;
+        // Determine CWD for this thread — check THREAD_CWD_MAP by name then by ID
+        let sessionCwd = this.opts.cwd;
+        const threadCwdMap = this.getThreadCwdMap();
+        if (threadName && threadCwdMap[threadName]) {
+            sessionCwd = threadCwdMap[threadName];
+            console.log(`[cc-tg] thread "${threadName}" → cwd: ${sessionCwd}`);
+        }
+        else if (threadId !== undefined && threadCwdMap[String(threadId)]) {
+            sessionCwd = threadCwdMap[String(threadId)];
+            console.log(`[cc-tg] thread ${threadId} → cwd: ${sessionCwd}`);
+        }
         const claude = new ClaudeProcess({
-            cwd: this.opts.cwd,
-            token: this.opts.claudeToken,
+            cwd: sessionCwd,
+            token: getCurrentToken() || this.opts.claudeToken,
         });
         const session = {
             claude,
@@ -438,6 +652,7 @@ export class CcTgBot {
             writtenFiles: new Set(),
             currentPrompt: "",
             isRetry: false,
+            threadId,
         };
         claude.on("usage", (usage) => {
             this.costStore.addUsage(chatId, usage);
@@ -446,33 +661,47 @@ export class CcTgBot {
             // Verbose logging — log every message type and subtype
             const subtype = msg.payload.subtype ?? "";
             const toolName = this.extractToolName(msg);
-            const logParts = [`[claude:${chatId}] msg=${msg.type}`];
+            const logParts = [`[claude:${key}] msg=${msg.type}`];
             if (subtype)
                 logParts.push(`subtype=${subtype}`);
             if (toolName)
                 logParts.push(`tool=${toolName}`);
             console.log(logParts.join(" "));
             // Track files written by Write/Edit tool calls
-            this.trackWrittenFiles(msg, session, this.opts.cwd);
+            this.trackWrittenFiles(msg, session, sessionCwd);
+            // Publish tool call events to the chat log
+            if (msg.type === "assistant") {
+                const message = msg.payload.message;
+                const content = message?.content;
+                if (Array.isArray(content)) {
+                    for (const block of content) {
+                        if (block.type !== "tool_use")
+                            continue;
+                        const name = block.name;
+                        const input = block.input;
+                        this.writeChatMessage("tool", "cc-tg", `[tool] ${name}: ${JSON.stringify(input ?? {})}`, chatId);
+                    }
+                }
+            }
             this.handleClaudeMessage(chatId, session, msg);
         });
         claude.on("stderr", (data) => {
             const line = data.trim();
             if (line)
-                console.error(`[claude:${chatId}:stderr]`, line);
+                console.error(`[claude:${key}:stderr]`, line);
         });
         claude.on("exit", (code) => {
-            console.log(`[claude:${chatId}] exited code=${code}`);
+            console.log(`[claude:${key}] exited code=${code}`);
             this.stopTyping(session);
-            this.sessions.delete(chatId);
+            this.sessions.delete(key);
         });
         claude.on("error", (err) => {
-            console.error(`[claude:${chatId}] process error: ${err.message}`);
+            console.error(`[claude:${key}] process error: ${err.message}`);
             this.bot.sendMessage(chatId, `Claude process error: ${err.message}`).catch(() => { });
             this.stopTyping(session);
-            this.sessions.delete(chatId);
+            this.sessions.delete(key);
         });
-        this.sessions.set(chatId, session);
+        this.sessions.set(key, session);
         return session;
     }
     handleClaudeMessage(chatId, session, msg) {
@@ -488,33 +717,58 @@ export class CcTgBot {
         // Check for usage/rate limit signals before forwarding to Telegram
         const sig = detectUsageLimit(text);
         if (sig.detected) {
+            const threadId = session.threadId;
+            const retryKey = this.sessionKey(chatId, threadId);
             const lastPrompt = session.currentPrompt;
-            const prevRetry = this.pendingRetries.get(chatId);
+            const prevRetry = this.pendingRetries.get(retryKey);
             const attempt = (prevRetry?.attempt ?? 0) + 1;
             if (prevRetry)
                 clearTimeout(prevRetry.timer);
-            this.bot.sendMessage(chatId, sig.humanMessage).catch(() => { });
-            this.killSession(chatId);
+            this.replyToChat(chatId, sig.humanMessage, threadId).catch(() => { });
+            this.killSession(chatId, true, threadId);
+            // Token rotation: if this is a usage_exhausted signal and we have multiple
+            // tokens, rotate to the next one and retry immediately instead of sleeping.
+            // Only rotate if we haven't yet cycled through all tokens (attempt <= count-1).
+            if (sig.reason === "usage_exhausted" && getTokenCount() > 1 && attempt <= getTokenCount() - 1) {
+                const prevIdx = getTokenIndex();
+                rotateToken();
+                const newIdx = getTokenIndex();
+                const total = getTokenCount();
+                console.log(`[cc-tg] Token ${prevIdx + 1}/${total} exhausted, rotating to token ${newIdx + 1}/${total}`);
+                this.replyToChat(chatId, `🔄 Token ${prevIdx + 1}/${total} exhausted, switching to token ${newIdx + 1}/${total}...`, threadId).catch(() => { });
+                this.pendingRetries.set(retryKey, { text: lastPrompt, attempt, timer: setTimeout(() => { }, 0) });
+                try {
+                    const retrySession = this.getOrCreateSession(chatId, threadId);
+                    retrySession.currentPrompt = lastPrompt;
+                    retrySession.isRetry = true;
+                    retrySession.claude.sendPrompt(lastPrompt);
+                    this.startTyping(chatId, retrySession);
+                }
+                catch (err) {
+                    this.replyToChat(chatId, `❌ Failed to retry with rotated token: ${err.message}`, threadId).catch(() => { });
+                }
+                return;
+            }
             if (attempt > 3) {
-                this.bot.sendMessage(chatId, "❌ Claude usage limit persists after 3 retries. Please try again later.").catch(() => { });
-                this.pendingRetries.delete(chatId);
+                this.replyToChat(chatId, "❌ Claude usage limit persists after 3 retries. Please try again later.", threadId).catch(() => { });
+                this.pendingRetries.delete(retryKey);
                 return;
             }
-            console.log(`[usage-limit:${chatId}] ${sig.reason} — scheduling retry attempt=${attempt} in ${sig.retryAfterMs}ms`);
+            console.log(`[usage-limit:${retryKey}] ${sig.reason} — scheduling retry attempt=${attempt} in ${sig.retryAfterMs}ms`);
             const timer = setTimeout(() => {
-                this.pendingRetries.delete(chatId);
+                this.pendingRetries.delete(retryKey);
                 try {
-                    const retrySession = this.getOrCreateSession(chatId);
+                    const retrySession = this.getOrCreateSession(chatId, threadId);
                     retrySession.currentPrompt = lastPrompt;
                     retrySession.isRetry = true;
                     retrySession.claude.sendPrompt(lastPrompt);
                     this.startTyping(chatId, retrySession);
                 }
                 catch (err) {
-                    this.bot.sendMessage(chatId, `❌ Failed to retry: ${err.message}`).catch(() => { });
+                    this.replyToChat(chatId, `❌ Failed to retry: ${err.message}`, threadId).catch(() => { });
                 }
             }, sig.retryAfterMs);
-            this.pendingRetries.set(chatId, { text: lastPrompt, attempt, timer });
+            this.pendingRetries.set(retryKey, { text: lastPrompt, attempt, timer });
             return;
         }
         // Accumulate text and debounce — Claude streams chunks rapidly
@@ -526,9 +780,11 @@ export class CcTgBot {
     startTyping(chatId, session) {
         this.stopTyping(session);
         // Send immediately, then keep alive every 4s
-        this.bot.sendChatAction(chatId, "typing").catch(() => { });
+        // Pass message_thread_id so typing appears in the correct forum topic thread
+        const threadOpts = session.threadId !== undefined ? { message_thread_id: session.threadId } : undefined;
+        this.bot.sendChatAction(chatId, "typing", threadOpts).catch(() => { });
         session.typingTimer = setInterval(() => {
-            this.bot.sendChatAction(chatId, "typing").catch(() => { });
+            this.bot.sendChatAction(chatId, "typing", threadOpts).catch(() => { });
         }, TYPING_INTERVAL_MS);
     }
     stopTyping(session) {
@@ -543,15 +799,17 @@ export class CcTgBot {
         session.flushTimer = null;
         if (!raw)
             return;
+        this.writeChatMessage("assistant", "cc-tg", raw, chatId);
         const text = session.isRetry ? `✅ Claude is back!\n\n${raw}` : raw;
         session.isRetry = false;
-        // Format for Telegram MarkdownV2 and split if needed (max 4096 chars)
+        // Format for Telegram HTML and split if needed (max 4096 chars)
         const formatted = formatForTelegram(text);
         const chunks = splitLongMessage(formatted);
+        const threadId = session.threadId;
         for (const chunk of chunks) {
-            this.bot.sendMessage(chatId, chunk, { parse_mode: "MarkdownV2" }).catch(() => {
-                // MarkdownV2 parse failed — retry as plain text
-                this.bot.sendMessage(chatId, chunk).catch((err) => console.error(`[tg:${chatId}] send failed:`, err.message));
+            this.replyToChat(chatId, chunk, threadId, { parse_mode: "HTML" }).catch(() => {
+                // HTML parse failed — retry as plain text
+                this.replyToChat(chatId, chunk, threadId).catch((err) => console.error(`[tg:${chatId}] send failed:`, err.message));
             });
         }
         // Hybrid file upload: find files mentioned in result text that Claude actually wrote
@@ -724,11 +982,12 @@ export class CcTgBot {
             const MAX_TG_FILE_BYTES = 50 * 1024 * 1024;
             if (fileSize > MAX_TG_FILE_BYTES) {
                 const mb = (fileSize / (1024 * 1024)).toFixed(1);
-                this.bot.sendMessage(chatId, `File too large for Telegram (${mb}mb). Find it at: ${filePath}`).catch(() => { });
+                this.replyToChat(chatId, `File too large for Telegram (${mb}mb). Find it at: ${filePath}`, session.threadId).catch(() => { });
                 continue;
             }
             console.log(`[claude:files] uploading to telegram: ${filePath}`);
-            this.bot.sendDocument(chatId, filePath).catch((err) => console.error(`[tg:${chatId}] sendDocument failed for ${filePath}:`, err.message));
+            const docOpts = session.threadId ? { message_thread_id: session.threadId } : undefined;
+            this.bot.sendDocument(chatId, filePath, docOpts).catch((err) => console.error(`[tg:${chatId}] sendDocument failed for ${filePath}:`, err.message));
         }
         // Clear written files for next turn
         session.writtenFiles.clear();
@@ -743,203 +1002,6 @@ export class CcTgBot {
         const toolUse = content.find((b) => b.type === "tool_use");
         return toolUse?.name ?? "";
     }
-    runCronTask(chatId, prompt) {
-        // Fresh isolated Claude session — never touches main conversation
-        const cronProcess = new ClaudeProcess({
-            cwd: this.opts.cwd,
-            token: this.opts.claudeToken,
-        });
-        const taskPrompt = [
-            "You are handling a scheduled background task.",
-            "This is NOT part of the user's ongoing conversation.",
-            "Be concise. Report results only. No greetings or pleasantries.",
-            "If there is nothing to report, say so in one sentence.",
-            "",
-            `SCHEDULED TASK: ${prompt}`,
-        ].join("\n");
-        let output = "";
-        const cronUsage = { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0 };
-        cronProcess.on("usage", (usage) => {
-            cronUsage.inputTokens += usage.inputTokens;
-            cronUsage.outputTokens += usage.outputTokens;
-            cronUsage.cacheReadTokens += usage.cacheReadTokens;
-            cronUsage.cacheWriteTokens += usage.cacheWriteTokens;
-        });
-        cronProcess.on("message", (msg) => {
-            if (msg.type === "result") {
-                const text = extractText(msg);
-                if (text)
-                    output += text;
-                const result = output.trim();
-                if (result) {
-                    let footer = "";
-                    try {
-                        footer = formatCronCostFooter(cronUsage);
-                    }
-                    catch (err) {
-                        console.error(`[cron] cost footer error:`, err.message);
-                    }
-                    const cronFormatted = formatForTelegram(`🕐 ${result}${footer}`);
-                    const chunks = splitLongMessage(cronFormatted);
-                    (async () => {
-                        for (const chunk of chunks) {
-                            try {
-                                await this.bot.sendMessage(chatId, chunk, { parse_mode: "MarkdownV2" });
-                            }
-                            catch {
-                                // MarkdownV2 parse failed — retry as plain text
-                                try {
-                                    await this.bot.sendMessage(chatId, chunk);
-                                }
-                                catch (err) {
-                                    console.error(`[cron] failed to send result to chat=${chatId}:`, err.message);
-                                }
-                            }
-                        }
-                    })();
-                }
-                cronProcess.kill();
-            }
-        });
-        cronProcess.on("error", (err) => {
-            console.error(`[cron] task error for chat=${chatId}:`, err.message);
-            cronProcess.kill();
-        });
-        cronProcess.on("exit", () => {
-            console.log(`[cron] task complete for chat=${chatId}`);
-        });
-        cronProcess.sendPrompt(taskPrompt);
-    }
-    async handleCron(chatId, text) {
-        const args = text.slice("/cron".length).trim();
-        // /cron list
-        if (args === "list" || args === "") {
-            const jobs = this.cron.list(chatId);
-            if (!jobs.length) {
-                await this.bot.sendMessage(chatId, "No cron jobs.");
-                return;
-            }
-            const lines = jobs.map((j, i) => {
-                const short = j.prompt.length > 50 ? j.prompt.slice(0, 50) + "…" : j.prompt;
-                return `#${i + 1} ${j.schedule} — "${short}"`;
-            });
-            await this.bot.sendMessage(chatId, `Cron jobs (${jobs.length}):\n${lines.join("\n")}`);
-            return;
-        }
-        // /cron clear
-        if (args === "clear") {
-            const n = this.cron.clearAll(chatId);
-            await this.bot.sendMessage(chatId, `Cleared ${n} cron job(s).`);
-            return;
-        }
-        // /cron remove <id>
-        if (args.startsWith("remove ")) {
-            const id = args.slice("remove ".length).trim();
-            const ok = this.cron.remove(chatId, id);
-            await this.bot.sendMessage(chatId, ok ? `Removed ${id}.` : `Not found: ${id}`);
-            return;
-        }
-        // /cron edit [<#> ...]
-        if (args === "edit" || args.startsWith("edit ")) {
-            await this.handleCronEdit(chatId, args.slice("edit".length).trim());
-            return;
-        }
-        // /cron every 1h <prompt>
-        const scheduleMatch = args.match(/^(every\s+\d+[mhd])\s+(.+)$/i);
-        if (!scheduleMatch) {
-            await this.bot.sendMessage(chatId, "Usage:\n/cron every 1h <prompt>\n/cron list\n/cron edit\n/cron remove <id>\n/cron clear");
-            return;
-        }
-        const schedule = scheduleMatch[1];
-        const prompt = scheduleMatch[2];
-        const job = this.cron.add(chatId, schedule, prompt);
-        if (!job) {
-            await this.bot.sendMessage(chatId, "Invalid schedule. Use: every 30m / every 2h / every 1d");
-            return;
-        }
-        await this.bot.sendMessage(chatId, `Cron set [${job.id}]: ${schedule} — "${prompt}"`);
-    }
-    async handleCronEdit(chatId, editArgs) {
-        const jobs = this.cron.list(chatId);
-        // No args — show numbered list with edit instructions
-        if (!editArgs) {
-            if (!jobs.length) {
-                await this.bot.sendMessage(chatId, "No cron jobs to edit.");
-                return;
-            }
-            const lines = jobs.map((j, i) => {
-                const short = j.prompt.length > 50 ? j.prompt.slice(0, 50) + "…" : j.prompt;
-                return `#${i + 1} ${j.schedule} — "${short}"`;
-            });
-            await this.bot.sendMessage(chatId, `Cron jobs:\n${lines.join("\n")}\n\n` +
-                "Edit options:\n" +
-                "/cron edit <#> every <N><unit> <new prompt>\n" +
-                "/cron edit <#> schedule every <N><unit>\n" +
-                "/cron edit <#> prompt <new prompt>");
-            return;
-        }
-        // Expect: <index> <rest>
-        const indexMatch = editArgs.match(/^(\d+)\s+(.+)$/);
-        if (!indexMatch) {
-            await this.bot.sendMessage(chatId, "Usage: /cron edit <#> every <N><unit> <new prompt>");
-            return;
-        }
-        const index = parseInt(indexMatch[1], 10) - 1;
-        if (index < 0 || index >= jobs.length) {
-            await this.bot.sendMessage(chatId, `Invalid job number. Use /cron edit to see the list.`);
-            return;
-        }
-        const job = jobs[index];
-        const editCmd = indexMatch[2];
-        // /cron edit <#> schedule every <N><unit>
-        if (editCmd.startsWith("schedule ")) {
-            const newSchedule = editCmd.slice("schedule ".length).trim();
-            const result = this.cron.update(chatId, job.id, { schedule: newSchedule });
-            if (result === null) {
-                await this.bot.sendMessage(chatId, "Invalid schedule. Use: every 30m / every 2h / every 1d");
-            }
-            else if (result === false) {
-                await this.bot.sendMessage(chatId, "Job not found.");
-            }
-            else {
-                await this.bot.sendMessage(chatId, `#${index + 1} schedule updated to ${newSchedule}.`);
-            }
-            return;
-        }
-        // /cron edit <#> prompt <new-prompt>
-        if (editCmd.startsWith("prompt ")) {
-            const newPrompt = editCmd.slice("prompt ".length).trim();
-            const result = this.cron.update(chatId, job.id, { prompt: newPrompt });
-            if (result === false) {
-                await this.bot.sendMessage(chatId, "Job not found.");
-            }
-            else {
-                await this.bot.sendMessage(chatId, `#${index + 1} prompt updated to "${newPrompt}".`);
-            }
-            return;
-        }
-        // /cron edit <#> every <N><unit> <new-prompt>
-        const fullMatch = editCmd.match(/^(every\s+\d+[mhd])\s+(.+)$/i);
-        if (fullMatch) {
-            const newSchedule = fullMatch[1];
-            const newPrompt = fullMatch[2];
-            const result = this.cron.update(chatId, job.id, { schedule: newSchedule, prompt: newPrompt });
-            if (result === null) {
-                await this.bot.sendMessage(chatId, "Invalid schedule. Use: every 30m / every 2h / every 1d");
-            }
-            else if (result === false) {
-                await this.bot.sendMessage(chatId, "Job not found.");
-            }
-            else {
-                await this.bot.sendMessage(chatId, `#${index + 1} updated: ${newSchedule} — "${newPrompt}"`);
-            }
-            return;
-        }
-        await this.bot.sendMessage(chatId, "Edit options:\n" +
-            "/cron edit <#> every <N><unit> <new prompt>\n" +
-            "/cron edit <#> schedule every <N><unit>\n" +
-            "/cron edit <#> prompt <new prompt>");
-    }
     /** Find cc-agent PIDs via pgrep. Returns array of numeric PIDs. */
     findCcAgentPids() {
         try {
@@ -965,25 +1027,33 @@ export class CcTgBot {
         }
         return pids;
     }
-    async handleReloadMcp(chatId) {
-        await this.bot.sendMessage(chatId, "Reloading MCP...");
+    async handleReloadMcp(chatId, threadId) {
+        await this.replyToChat(chatId, "Clearing npx cache and reloading MCP...", threadId);
+        try {
+            const home = process.env.HOME ?? "~";
+            execSync(`rm -rf "${home}/.npm/_npx/"`, { encoding: "utf8", shell: "/bin/sh" });
+            console.log("[mcp] cleared ~/.npm/_npx/");
+        }
+        catch (err) {
+            await this.replyToChat(chatId, `Warning: failed to clear npx cache: ${err.message}`, threadId);
+        }
         const pids = this.killCcAgent();
         if (pids.length === 0) {
-            await this.bot.sendMessage(chatId, "No cc-agent process found — MCP will start fresh on the next agent call.");
+            await this.replyToChat(chatId, "NPX cache cleared. No cc-agent process found — MCP will start fresh on the next agent call.", threadId);
             return;
         }
-        await this.bot.sendMessage(chatId, `Sent SIGTERM to cc-agent (pid${pids.length > 1 ? "s" : ""}: ${pids.join(", ")}).\nMCP restarted. New process will load on next agent call.`);
+        await this.replyToChat(chatId, `NPX cache cleared. Sent SIGTERM to cc-agent (pid${pids.length > 1 ? "s" : ""}: ${pids.join(", ")}).\nMCP restarted. New process will load on next agent call.`, threadId);
     }
-    async handleMcpStatus(chatId) {
+    async handleMcpStatus(chatId, threadId) {
         try {
             const output = execSync("claude mcp list", { encoding: "utf8", shell: "/bin/sh" }).trim();
-            await this.bot.sendMessage(chatId, `MCP server status:\n\n${output || "(no output)"}`);
+            await this.replyToChat(chatId, `MCP server status:\n\n${output || "(no output)"}`, threadId);
         }
         catch (err) {
-            await this.bot.sendMessage(chatId, `Failed to run claude mcp list: ${err.message}`);
+            await this.replyToChat(chatId, `Failed to run claude mcp list: ${err.message}`, threadId);
         }
     }
-    async handleMcpVersion(chatId) {
+    async handleMcpVersion(chatId, threadId) {
         let npmVersion = "unknown";
         let cacheEntries = "(unavailable)";
         try {
@@ -1000,18 +1070,14 @@ export class CcTgBot {
         catch {
             cacheEntries = "(empty or not found)";
         }
-        await this.bot.sendMessage(chatId, `cc-agent npm version: ${npmVersion}\n\nnpx cache (~/.npm/_npx/):\n${cacheEntries}`);
+        await this.replyToChat(chatId, `cc-agent npm version: ${npmVersion}\n\nnpx cache (~/.npm/_npx/):\n${cacheEntries}`, threadId);
     }
-    async handleClearNpxCache(chatId) {
+    async handleClearNpxCache(chatId, threadId) {
         const home = process.env.HOME ?? "/tmp";
-        // Use the isolated npm cache dir set in the plist (npm_config_cache), not hardcoded ~/.npm
-        const npmBase = process.env.npm_config_cache
-            ? join(process.env.npm_config_cache, "..")
-            : `${home}/.npm`;
         const cleared = [];
         const failed = [];
         // Clear both npx execution cache and full npm package cache
-        for (const dir of [`${npmBase}/_npx`, `${npmBase}/cache`]) {
+        for (const dir of [`${home}/.npm/_npx`, `${home}/.npm/cache`]) {
             try {
                 execSync(`rm -rf "${dir}"`, { encoding: "utf8", shell: "/bin/sh" });
                 cleared.push(dir.replace(home, "~"));
@@ -1029,73 +1095,169 @@ export class CcTgBot {
         const clearNote = failed.length
             ? `Cleared: ${cleared.join(", ")}. Failed: ${failed.join(", ")}.`
             : `Cleared: ${cleared.join(", ")}.`;
-        await this.bot.sendMessage(chatId, `${clearNote}${pidNote} Next call picks up latest npm version.`);
+        await this.replyToChat(chatId, `${clearNote}${pidNote} Next call picks up latest npm version.`, threadId);
     }
-    async handleRestart(chatId) {
-        await this.bot.sendMessage(chatId, "Restarting... brb.");
+    async handleRestart(chatId, threadId) {
+        await this.replyToChat(chatId, "Clearing cache and restarting... brb.", threadId);
         await new Promise(resolve => setTimeout(resolve, 300));
+        // Clear npm caches before restart so launchd brings up fresh version
+        const home = process.env.HOME ?? "/tmp";
+        for (const dir of [`${home}/.npm/_npx`, `${home}/.npm/cache`]) {
+            try {
+                execSync(`rm -rf "${dir}"`, { shell: "/bin/sh" });
+            }
+            catch { }
+        }
         // Kill all active Claude sessions cleanly
-        for (const [cid] of this.sessions) {
-            this.killSession(cid);
+        for (const session of this.sessions.values()) {
+            this.stopTyping(session);
+            session.claude.kill();
         }
+        this.sessions.clear();
         await new Promise(resolve => setTimeout(resolve, 200));
         process.exit(0);
     }
-    async handleGetFile(chatId, text) {
+    async handleCron(chatId, text, threadId) {
+        const args = text.slice("/cron".length).trim();
+        if (args === "list" || args === "") {
+            const jobs = this.cron.list(chatId);
+            if (!jobs.length) {
+                await this.replyToChat(chatId, "No cron jobs.", threadId);
+                return;
+            }
+            const lines = jobs.map((j, i) => {
+                const short = j.prompt.length > 50 ? j.prompt.slice(0, 50) + "…" : j.prompt;
+                return `#${i + 1} ${j.schedule} — "${short}"`;
+            });
+            await this.replyToChat(chatId, `Cron jobs (${jobs.length}):\n${lines.join("\n")}`, threadId);
+            return;
+        }
+        if (args === "clear") {
+            const n = this.cron.clearAll(chatId);
+            await this.replyToChat(chatId, `Cleared ${n} cron job(s).`, threadId);
+            return;
+        }
+        if (args.startsWith("remove ")) {
+            const id = args.slice("remove ".length).trim();
+            const ok = this.cron.remove(chatId, id);
+            await this.replyToChat(chatId, ok ? `Removed ${id}.` : `Not found: ${id}`, threadId);
+            return;
+        }
+        const scheduleMatch = args.match(/^(every\s+\d+[mhd])\s+(.+)$/i);
+        if (!scheduleMatch) {
+            await this.replyToChat(chatId, "Usage:\n/cron every 1h <prompt>\n/cron list\n/cron remove <id>\n/cron clear", threadId);
+            return;
+        }
+        const schedule = scheduleMatch[1];
+        const prompt = scheduleMatch[2];
+        const job = this.cron.add(chatId, schedule, prompt);
+        if (!job) {
+            await this.replyToChat(chatId, "Invalid schedule. Use: every 30m / every 2h / every 1d", threadId);
+            return;
+        }
+        await this.replyToChat(chatId, `Cron set [${job.id}]: ${schedule} — "${prompt}"`, threadId);
+    }
+    runCronTask(chatId, prompt, done = () => { }) {
+        const cronProcess = new ClaudeProcess({ cwd: this.opts.cwd ?? process.cwd() });
+        cronProcess.sendPrompt(prompt);
+        cronProcess.on("message", (msg) => {
+            const result = extractText(msg);
+            if (result) {
+                const formatted = formatForTelegram(`🕐 ${result}`);
+                const chunks = splitLongMessage(formatted);
+                for (const chunk of chunks) {
+                    this.replyToChat(chatId, chunk).catch((err) => console.error("[cron] send failed:", err.message));
+                }
+            }
+        });
+        cronProcess.on("exit", () => done());
+    }
+    async handleGetFile(chatId, text, threadId) {
         const arg = text.slice("/get_file".length).trim();
         if (!arg) {
-            await this.bot.sendMessage(chatId, "Usage: /get_file <path>");
+            await this.replyToChat(chatId, "Usage: /get_file <path>", threadId);
             return;
         }
         const filePath = resolve(arg);
         const safeDirs = ["/tmp/", "/var/folders/", os.homedir() + "/Downloads/", this.opts.cwd ?? process.cwd()];
         const inSafeDir = safeDirs.some(d => filePath.startsWith(d));
         if (!inSafeDir) {
-            await this.bot.sendMessage(chatId, "Access denied: path not in allowed directories");
+            await this.replyToChat(chatId, "Access denied: path not in allowed directories", threadId);
             return;
         }
         if (!existsSync(filePath)) {
-            await this.bot.sendMessage(chatId, `File not found: ${filePath}`);
+            await this.replyToChat(chatId, `File not found: ${filePath}`, threadId);
             return;
         }
         if (!statSync(filePath).isFile()) {
-            await this.bot.sendMessage(chatId, `Not a file: ${filePath}`);
+            await this.replyToChat(chatId, `Not a file: ${filePath}`, threadId);
             return;
         }
         if (this.isSensitiveFile(filePath)) {
-            await this.bot.sendMessage(chatId, "Access denied: sensitive file");
+            await this.replyToChat(chatId, "Access denied: sensitive file", threadId);
             return;
         }
         const MAX_TG_FILE_BYTES = 50 * 1024 * 1024;
         const fileSize = statSync(filePath).size;
         if (fileSize > MAX_TG_FILE_BYTES) {
             const mb = (fileSize / (1024 * 1024)).toFixed(1);
-            await this.bot.sendMessage(chatId, `File too large for Telegram (${mb}mb). Find it at: ${filePath}`);
+            await this.replyToChat(chatId, `File too large for Telegram (${mb}mb). Find it at: ${filePath}`, threadId);
             return;
         }
-        await this.bot.sendDocument(chatId, filePath);
+        const docOpts = threadId ? { message_thread_id: threadId } : undefined;
+        await this.bot.sendDocument(chatId, filePath, docOpts);
+    }
+    async handleDrivers(chatId, threadId) {
+        try {
+            const raw = await this.callCcAgentTool("list_drivers");
+            if (!raw) {
+                await this.replyToChat(chatId, "No drivers available or cc-agent did not respond.", threadId);
+                return;
+            }
+            // Try to pretty-print JSON array/object, fall back to raw string
+            let reply;
+            try {
+                const data = JSON.parse(raw);
+                if (Array.isArray(data)) {
+                    const current = process.env.CC_AGENT_DEFAULT_DRIVER || "claude";
+                    const lines = data.map((d) => d === current ? `• ${d} (default)` : `• ${d}`);
+                    reply = `Available drivers:\n${lines.join("\n")}`;
+                }
+                else {
+                    reply = `Available drivers:\n${raw}`;
+                }
+            }
+            catch {
+                reply = `Available drivers:\n${raw}`;
+            }
+            await this.replyToChat(chatId, reply, threadId);
+        }
+        catch (err) {
+            await this.replyToChat(chatId, `Failed to list drivers: ${err.message}`, threadId);
+        }
     }
     callCcAgentTool(toolName, args = {}) {
+        // For spawn tools, pass through the configured driver and model
+        const spawnTools = new Set(["spawn_agent", "spawn_from_profile"]);
+        if (spawnTools.has(toolName)) {
+            const driver = process.env.CC_AGENT_DEFAULT_DRIVER || "claude";
+            const model = process.env.CC_AGENT_DEFAULT_MODEL || undefined;
+            args = { agent_driver: driver, ...(model ? { agent_model: model } : {}), ...args };
+        }
         return new Promise((resolve) => {
             let settled = false;
-            let procRef = null;
             const done = (val) => {
                 if (!settled) {
                     settled = true;
-                    try {
-                        procRef?.kill();
-                    }
-                    catch { }
                     resolve(val);
                 }
             };
             let proc;
             try {
-                proc = spawn("npx", ["--prefer-online", "-y", "@gonzih/cc-agent@latest"], {
+                proc = spawn("npx", ["-y", "@gonzih/cc-agent@latest"], {
                     env: { ...process.env },
                     stdio: ["pipe", "pipe", "pipe"],
                 });
-                procRef = proc;
             }
             catch (err) {
                 console.error("[mcp] failed to spawn cc-agent:", err.message);
@@ -1152,21 +1314,25 @@ export class CcTgBot {
             proc.on("exit", () => { clearTimeout(timeout); done(null); });
         });
     }
-    killSession(chatId, keepCrons = true) {
-        const session = this.sessions.get(chatId);
+    killSession(chatId, _keepCrons = true, threadId) {
+        const key = this.sessionKey(chatId, threadId);
+        const session = this.sessions.get(key);
         if (session) {
             this.stopTyping(session);
             session.claude.kill();
-            this.sessions.delete(chatId);
+            this.sessions.delete(key);
         }
-        if (!keepCrons)
-            this.cron.clearAll(chatId);
+    }
+    getMe() {
+        return this.bot.getMe();
     }
     stop() {
         this.bot.stopPolling();
-        for (const [chatId] of this.sessions) {
-            this.killSession(chatId);
+        for (const session of this.sessions.values()) {
+            this.stopTyping(session);
+            session.claude.kill();
         }
+        this.sessions.clear();
     }
 }
 function buildPromptWithReplyContext(text, msg) {
@@ -1205,6 +1371,85 @@ function downloadToFile(url, destPath) {
         }).on("error", reject);
     });
 }
+/** Fetch URL via Jina Reader and return first maxChars characters */
+function fetchUrlViaJina(url, maxChars = 2000) {
+    const jinaUrl = `https://r.jina.ai/${url}`;
+    return new Promise((resolve, reject) => {
+        https.get(jinaUrl, (res) => {
+            const chunks = [];
+            res.on("data", (chunk) => chunks.push(chunk));
+            res.on("end", () => {
+                const text = Buffer.concat(chunks).toString("utf8");
+                resolve(text.slice(0, maxChars));
+            });
+            res.on("error", reject);
+        }).on("error", reject);
+    });
+}
+/** Detect URLs in text, fetch each via Jina Reader, and prepend content to the prompt */
+export async function enrichPromptWithUrls(text) {
+    const urlRegex = /https?:\/\/[^\s]+/g;
+    const urls = text.match(urlRegex);
+    if (!urls || urls.length === 0)
+        return text;
+    const prefixes = [];
+    for (const url of urls) {
+        // Skip jina.ai URLs to avoid recursion
+        if (url.includes("r.jina.ai"))
+            continue;
+        try {
+            const content = await fetchUrlViaJina(url);
+            if (content.trim()) {
+                prefixes.push(`[Web content from ${url}]:\n${content}`);
+            }
+        }
+        catch (err) {
+            console.warn(`[url-fetch] failed to fetch ${url}:`, err.message);
+        }
+    }
+    if (prefixes.length === 0)
+        return text;
+    return prefixes.join("\n\n") + "\n\n" + text;
+}
+/** Parse frontmatter description from a skill markdown file */
+function parseSkillDescription(content) {
+    const match = content.match(/^---\s*\n([\s\S]*?)\n---/);
+    if (!match)
+        return null;
+    const frontmatter = match[1];
+    const descMatch = frontmatter.match(/^description:\s*(.+)$/m);
+    return descMatch ? descMatch[1].trim() : null;
+}
+/** List available skills from ~/.claude/skills/ */
+export function listSkills() {
+    const skillsDir = join(os.homedir(), ".claude", "skills");
+    if (!existsSync(skillsDir)) {
+        return "No skills directory found at ~/.claude/skills/";
+    }
+    let files;
+    try {
+        files = readdirSync(skillsDir).filter((f) => f.endsWith(".md"));
+    }
+    catch {
+        return "Could not read skills directory.";
+    }
+    if (files.length === 0) {
+        return "No skills found in ~/.claude/skills/";
+    }
+    const lines = ["Available skills:"];
+    for (const file of files.sort()) {
+        const name = "/" + file.replace(/\.md$/, "");
+        try {
+            const content = readFileSync(join(skillsDir, file), "utf8");
+            const description = parseSkillDescription(content);
+            lines.push(description ? `${name} — ${description}` : name);
+        }
+        catch {
+            lines.push(name);
+        }
+    }
+    return lines.join("\n");
+}
 export function splitMessage(text, maxLen = 4096) {
     if (text.length <= maxLen)
         return [text];