@gonzih/cc-tg 0.9.15 → 0.9.17

package/dist/cron.d.ts

@@ -11,9 +11,15 @@ export interface CronJob {
     createdAt: string;
     schedule: string;
 }
-type FireCallback = (chatId: number, prompt: string) => void;
+/** Called when a job fires. `done` must be called when the task completes so
+ *  the next scheduled tick is allowed to run. Until `done` is called, concurrent
+ *  ticks for the same job are silently skipped (prevents the resume-loop explosion
+ *  where each tick spawns more agents than the last). */
+type FireCallback = (chatId: number, prompt: string, jobId: string, done: () => void) => void;
 export declare class CronManager {
     private jobs;
+    /** Job IDs whose fire callback has been invoked but whose `done` hasn't fired yet. */
+    private activeJobs;
     private storePath;
     private fire;
     constructor(cwd: string, fire: FireCallback);

package/dist/cron.js

@@ -7,6 +7,8 @@ import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
 import { join } from "path";
 export class CronManager {
     jobs = new Map();
+    /** Job IDs whose fire callback has been invoked but whose `done` hasn't fired yet. */
+    activeJobs = new Set();
     storePath;
     fire;
     constructor(cwd, fire) {
@@ -36,8 +38,13 @@ export class CronManager {
         const id = `${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
         const job = { id, chatId, intervalMs, prompt, schedule, createdAt: new Date().toISOString() };
         const timer = setInterval(() => {
+            if (this.activeJobs.has(id)) {
+                console.log(`[cron:${id}] skipping tick — previous task still running`);
+                return;
+            }
+            this.activeJobs.add(id);
             console.log(`[cron:${id}] firing for chat=${chatId} prompt="${prompt}"`);
-            this.fire(chatId, prompt);
+            this.fire(chatId, prompt, id, () => { this.activeJobs.delete(id); });
         }, intervalMs);
         this.jobs.set(id, { ...job, timer });
         this.persist();
@@ -48,6 +55,7 @@ export class CronManager {
         if (!job || job.chatId !== chatId)
             return false;
         clearInterval(job.timer);
+        this.activeJobs.delete(id);
         this.jobs.delete(id);
         this.persist();
         return true;
@@ -57,6 +65,7 @@ export class CronManager {
         for (const [id, job] of this.jobs) {
             if (job.chatId === chatId) {
                 clearInterval(job.timer);
+                this.activeJobs.delete(id);
                 this.jobs.delete(id);
                 count++;
             }
@@ -86,9 +95,16 @@ export class CronManager {
         }
         // Recreate timer so it uses updated intervalMs and always reads latest job.prompt
         clearInterval(job.timer);
+        // Also clear any active-job lock so the updated timer can fire immediately next tick
+        this.activeJobs.delete(job.id);
         job.timer = setInterval(() => {
+            if (this.activeJobs.has(job.id)) {
+                console.log(`[cron:${job.id}] skipping tick — previous task still running`);
+                return;
+            }
+            this.activeJobs.add(job.id);
             console.log(`[cron:${job.id}] firing for chat=${job.chatId} prompt="${job.prompt}"`);
-            this.fire(job.chatId, job.prompt);
+            this.fire(job.chatId, job.prompt, job.id, () => { this.activeJobs.delete(job.id); });
         }, job.intervalMs);
         this.persist();
         const { timer: _t, ...cronJob } = job;
@@ -113,8 +129,13 @@ export class CronManager {
             const data = JSON.parse(readFileSync(this.storePath, "utf8"));
             for (const job of data) {
                 const timer = setInterval(() => {
+                    if (this.activeJobs.has(job.id)) {
+                        console.log(`[cron:${job.id}] skipping tick — previous task still running`);
+                        return;
+                    }
+                    this.activeJobs.add(job.id);
                     console.log(`[cron:${job.id}] firing for chat=${job.chatId} prompt="${job.prompt}"`);
-                    this.fire(job.chatId, job.prompt);
+                    this.fire(job.chatId, job.prompt, job.id, () => { this.activeJobs.delete(job.id); });
                 }, job.intervalMs);
                 this.jobs.set(job.id, { ...job, timer });
             }

package/dist/formatter.d.ts

@@ -1,23 +1,25 @@
 /**
- * Telegram MarkdownV2 post-processor.
- * Converts standard markdown to Telegram's MarkdownV2 format.
+ * Telegram HTML post-processor.
+ * Converts standard markdown to Telegram's HTML parse mode format.
  */
 /**
- * Convert standard markdown text to Telegram MarkdownV2 format.
+ * Convert standard markdown text to Telegram HTML format.
  *
  * Processing order:
- * 1. Extract code blocks (fenced + inline) — protect from further processing
- * 2. Strip raw HTML tags
- * 3. Convert --- → blank line
- * 4. Convert ## headings → *bold*
- * 5. Convert **bold** → *bold*
- * 6. Convert - list items → • item
- * 7. Escape MarkdownV2 special chars (outside code blocks)
- * 8. Reinsert code blocks unchanged
+ * 1. Extract fenced code blocks (``` ... ```) → <pre>, protect from further processing
+ * 2. Extract inline code (`...`) → <code>, protect from further processing
+ * 3. HTML-escape remaining text: & → &amp;  < → &lt;  > → &gt;
+ * 4. Convert --- → blank line
+ * 5. Convert ## headings → <b>Heading</b>
+ * 6. Convert **bold** → <b>bold</b>
+ * 7. Convert - item / * item → • item
+ * 8. Convert *bold* → <b>bold</b>
+ * 9. Convert _italic_ → <i>italic</i>
+ * 10. Reinsert code blocks
  */
 export declare function formatForTelegram(text: string): string;
 /**
  * Split a long message at natural boundaries (paragraph > line > word).
- * Never splits mid-word. Chunks are at most maxLen characters.
+ * Never splits mid-word or inside <pre> blocks. Chunks are at most maxLen characters.
  */
 export declare function splitLongMessage(text: string, maxLen?: number): string[];

package/dist/formatter.js

@@ -1,54 +1,82 @@
 /**
- * Telegram MarkdownV2 post-processor.
- * Converts standard markdown to Telegram's MarkdownV2 format.
+ * Telegram HTML post-processor.
+ * Converts standard markdown to Telegram's HTML parse mode format.
  */
+function htmlEscape(text) {
+    return text
+        .replace(/&/g, "&")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;");
+}
 /**
- * Convert standard markdown text to Telegram MarkdownV2 format.
+ * Convert standard markdown text to Telegram HTML format.
  *
  * Processing order:
- * 1. Extract code blocks (fenced + inline) — protect from further processing
- * 2. Strip raw HTML tags
- * 3. Convert --- → blank line
- * 4. Convert ## headings → *bold*
- * 5. Convert **bold** → *bold*
- * 6. Convert - list items → • item
- * 7. Escape MarkdownV2 special chars (outside code blocks)
- * 8. Reinsert code blocks unchanged
+ * 1. Extract fenced code blocks (``` ... ```) → <pre>, protect from further processing
+ * 2. Extract inline code (`...`) → <code>, protect from further processing
+ * 3. HTML-escape remaining text: & → &amp;  < → &lt;  > → &gt;
+ * 4. Convert --- → blank line
+ * 5. Convert ## headings → <b>Heading</b>
+ * 6. Convert **bold** → <b>bold</b>
+ * 7. Convert - item / * item → • item
+ * 8. Convert *bold* → <b>bold</b>
+ * 9. Convert _italic_ → <i>italic</i>
+ * 10. Reinsert code blocks
  */
 export function formatForTelegram(text) {
-    // Step 1: Extract code blocks and inline code to protect them
     const placeholders = [];
-    // Fenced code blocks first (``` ... ```)
-    let out = text.replace(/```[\s\S]*?```/g, (match) => {
-        placeholders.push(match);
+    // Step 1: Extract fenced code blocks (``` ... ```) → <pre>
+    let out = text.replace(/```(?:\w*)\n?([\s\S]*?)```/g, (_, content) => {
+        placeholders.push(`<pre>${htmlEscape(content)}</pre>`);
         return `\x00P${placeholders.length - 1}\x00`;
     });
-    // Inline code (`...`)
-    out = out.replace(/`[^`\n]+`/g, (match) => {
-        placeholders.push(match);
+    // Step 2: Extract inline code (`...`) → <code>
+    out = out.replace(/`([^`\n]+)`/g, (_, content) => {
+        placeholders.push(`<code>${htmlEscape(content)}</code>`);
         return `\x00P${placeholders.length - 1}\x00`;
     });
-    // Step 2: Strip raw HTML tags
-    out = out.replace(/<[^>]+>/g, "");
-    // Step 3: Convert --- → blank line
+    // Step 3: HTML-escape remaining text
+    out = htmlEscape(out);
+    // Step 4: Convert --- → blank line
     out = out.replace(/^-{3,}$/gm, "");
-    // Step 4: Convert ## headings → *bold*
-    out = out.replace(/^#{1,6}\s+(.+)$/gm, "*$1*");
-    // Step 5: Convert **bold** → *bold*
-    out = out.replace(/\*\*(.+?)\*\*/gs, "*$1*");
-    // Step 6: Convert - list items → • item (leading - or * bullet)
+    // Step 5: Convert ## headings → <b>Heading</b>
+    out = out.replace(/^#{1,6}\s+(.+)$/gm, "<b>$1</b>");
+    // Step 6: Convert **bold** → <b>bold</b>
+    out = out.replace(/\*\*(.+?)\*\*/gs, "<b>$1</b>");
+    // Step 7: Convert - item / * item → • item
     out = out.replace(/^[ \t]*[-*]\s+(.+)$/gm, "• $1");
-    // Step 7: Escape MarkdownV2 special chars outside code blocks.
-    // Per Telegram spec, these must be escaped: _ [ ] ( ) ~ > # + - = | { } . ! \
-    // * is intentionally NOT escaped — it is used for bold formatting above.
-    out = out.replace(/([_\[\]()~>#+\-=|{}.!\\])/g, "\\$1");
-    // Step 8: Reinsert code blocks unchanged (no escaping inside them)
+    // Step 8: Convert *bold* → <b>bold</b> (single asterisk, after bullets handled)
+    out = out.replace(/\*([^*\n]+)\*/g, "<b>$1</b>");
+    // Step 9: Convert _italic_ → <i>italic</i>
+    // Use word-boundary guards to avoid mangling snake_case identifiers
+    out = out.replace(/(?<![a-zA-Z0-9])_([^_\n]+?)_(?![a-zA-Z0-9])/g, "<i>$1</i>");
+    // Step 10: Reinsert code blocks
     out = out.replace(/\x00P(\d+)\x00/g, (_, i) => placeholders[parseInt(i, 10)]);
     return out;
 }
+function findPreRanges(text) {
+    const ranges = [];
+    const open = "<pre>";
+    const close = "</pre>";
+    let i = 0;
+    while (i < text.length) {
+        const start = text.indexOf(open, i);
+        if (start === -1)
+            break;
+        const end = text.indexOf(close, start);
+        if (end === -1)
+            break;
+        ranges.push([start, end + close.length]);
+        i = end + close.length;
+    }
+    return ranges;
+}
+function isInsidePre(pos, ranges) {
+    return ranges.some(([start, end]) => pos > start && pos < end);
+}
 /**
  * Split a long message at natural boundaries (paragraph > line > word).
- * Never splits mid-word. Chunks are at most maxLen characters.
+ * Never splits mid-word or inside <pre> blocks. Chunks are at most maxLen characters.
  */
 export function splitLongMessage(text, maxLen = 4096) {
     if (text.length <= maxLen)
@@ -57,6 +85,7 @@ export function splitLongMessage(text, maxLen = 4096) {
     let remaining = text;
     while (remaining.length > maxLen) {
         const slice = remaining.slice(0, maxLen);
+        const preRanges = findPreRanges(remaining);
         // Prefer paragraph boundary (\n\n)
         const lastPara = slice.lastIndexOf("\n\n");
         // Then line boundary (\n)
@@ -64,17 +93,24 @@ export function splitLongMessage(text, maxLen = 4096) {
         // Then word boundary (space)
         const lastSpace = slice.lastIndexOf(" ");
         let splitAt;
-        if (lastPara > 0) {
+        if (lastPara > 0 && !isInsidePre(lastPara, preRanges)) {
             splitAt = lastPara + 2;
         }
-        else if (lastLine > 0) {
+        else if (lastLine > 0 && !isInsidePre(lastLine, preRanges)) {
             splitAt = lastLine + 1;
         }
-        else if (lastSpace > 0) {
+        else if (lastSpace > 0 && !isInsidePre(lastSpace, preRanges)) {
             splitAt = lastSpace + 1;
         }
         else {
-            splitAt = maxLen;
+            // If all candidate split points are inside a <pre> block, split after it
+            const coveringPre = preRanges.find(([start, end]) => start < maxLen && end > maxLen);
+            if (coveringPre) {
+                splitAt = coveringPre[1];
+            }
+            else {
+                splitAt = maxLen;
+            }
         }
         chunks.push(remaining.slice(0, splitAt).trimEnd());
         remaining = remaining.slice(splitAt).trimStart();

package/dist/index.js

@@ -15,21 +15,27 @@
  *   CWD                  — working directory for Claude Code (default: process.cwd())
  */
 import { createServer, createConnection } from "net";
-import { unlinkSync } from "fs";
+import { unlinkSync, readFileSync } from "fs";
 import { tmpdir } from "os";
-import { join } from "path";
-import { createHash } from "crypto";
+import os from "os";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+import TelegramBot from "node-telegram-bot-api";
 import { CcTgBot } from "./bot.js";
-// Derive socket path from token hash so multiple instances (feral/law/simorgh)
-// never collide, and the path is stable across restarts on the same machine.
-function lockSocketPath(token) {
-    const hash = createHash("sha256").update(token).digest("hex").slice(0, 12);
-    return join(tmpdir(), `cc-tg-${hash}.sock`);
-}
-function acquireLock(socketPath) {
+import { loadTokens } from "./tokens.js";
+import { Registry, startControlServer } from "@gonzih/agent-ops";
+import { Redis } from "ioredis";
+import { startNotifier } from "./notifier.js";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const pkg = JSON.parse(readFileSync(join(__dirname, "../package.json"), "utf-8"));
+// Make lock socket unique per bot token so multiple users on the same machine don't collide
+const _tokenHash = Buffer.from(process.env.TELEGRAM_BOT_TOKEN ?? "default").toString("base64").replace(/[^a-z0-9]/gi, "").slice(0, 16);
+const LOCK_SOCKET = join(tmpdir(), `cc-tg-${_tokenHash}.sock`);
+function acquireLock() {
     return new Promise((resolve) => {
         const server = createServer();
-        server.listen(socketPath, () => {
+        server.listen(LOCK_SOCKET, () => {
             // Bound successfully — we own the lock. Socket auto-released on any exit incl. SIGKILL.
             resolve(true);
         });
@@ -39,7 +45,7 @@ function acquireLock(socketPath) {
                 return;
             }
             // Socket path exists — probe if anything is actually listening
-            const probe = createConnection(socketPath);
+            const probe = createConnection(LOCK_SOCKET);
             probe.on("connect", () => {
                 probe.destroy();
                 console.error("[cc-tg] Another instance is already running. Exiting.");
@@ -48,16 +54,20 @@ function acquireLock(socketPath) {
             probe.on("error", () => {
                 // Nothing listening — stale socket, remove and retry
                 try {
-                    unlinkSync(socketPath);
+                    unlinkSync(LOCK_SOCKET);
                 }
                 catch { }
                 const retry = createServer();
-                retry.listen(socketPath, () => resolve(true));
+                retry.listen(LOCK_SOCKET, () => resolve(true));
                 retry.on("error", () => resolve(true)); // give up on lock, just start
             });
         });
     });
 }
+const lockAcquired = await acquireLock();
+if (!lockAcquired) {
+    process.exit(1);
+}
 function required(name) {
     const val = process.env[name];
     if (!val) {
@@ -78,13 +88,6 @@ Or add to your shell profile / .env file.
     return val;
 }
 const telegramToken = required("TELEGRAM_BOT_TOKEN");
-// Acquire lock before doing anything else. Socket derived from token hash so
-// multiple instances (different bots / users) never share the same socket.
-const LOCK_SOCKET = lockSocketPath(telegramToken);
-const lockAcquired = await acquireLock(LOCK_SOCKET);
-if (!lockAcquired) {
-    process.exit(1);
-}
 // Accept CLAUDE_CODE_TOKEN, CLAUDE_CODE_OAUTH_TOKEN, or ANTHROPIC_API_KEY
 const claudeToken = process.env.CLAUDE_CODE_TOKEN ??
     process.env.CLAUDE_CODE_OAUTH_TOKEN ??
@@ -98,6 +101,11 @@ Set one and run again:
 `);
     process.exit(1);
 }
+// Load OAuth token pool (supports CLAUDE_CODE_OAUTH_TOKENS for multi-account rotation)
+const tokenPool = loadTokens();
+if (tokenPool.length > 1) {
+    console.log(`[cc-tg] Token pool loaded: ${tokenPool.length} tokens — will rotate on usage limit`);
+}
 const allowedUserIds = process.env.ALLOWED_USER_IDS
     ? process.env.ALLOWED_USER_IDS.split(",").map((s) => parseInt(s.trim(), 10)).filter(Boolean)
     : [];
@@ -105,13 +113,61 @@ const groupChatIds = process.env.GROUP_CHAT_IDS
     ? process.env.GROUP_CHAT_IDS.split(",").map((s) => parseInt(s.trim(), 10)).filter(Boolean)
     : [];
 const cwd = process.env.CWD ?? process.cwd();
+// agent-ops / chat bridge — Redis is always initialized so the chat bridge works
+// regardless of whether CC_AGENT_OPS_PORT or CC_AGENT_NOTIFY_CHAT_ID are set.
+const redisUrl = process.env.REDIS_URL || "redis://localhost:6379";
+const namespace = process.env.CC_AGENT_NAMESPACE || "default";
+const sharedRedis = new Redis(redisUrl);
+sharedRedis.on("error", (err) => {
+    // Non-fatal — Redis features (chat bridge, ops) degrade gracefully
+    console.warn("[redis] connection error:", err.message);
+});
+sharedRedis.once("ready", () => {
+    sharedRedis.set("cca:meta:cc-tg:version", pkg.version).catch((err) => {
+        console.warn("[redis] failed to write version:", err.message);
+    });
+    console.log(`[cc-tg] version:reported ${pkg.version}`);
+});
 const bot = new CcTgBot({
     telegramToken,
     claudeToken,
     cwd,
     allowedUserIds,
     groupChatIds,
+    redis: sharedRedis,
+    namespace,
 });
+if (process.env.CC_AGENT_OPS_PORT) {
+    const botInfo = await bot.getMe();
+    const registry = new Registry(sharedRedis);
+    await registry.register({
+        namespace,
+        hostname: os.hostname(),
+        user: os.userInfo().username,
+        pid: String(process.pid),
+        version: pkg.version,
+        cwd: process.env.CWD || process.cwd(),
+        control_port: process.env.CC_AGENT_OPS_PORT,
+        bot_username: botInfo.username ?? "",
+        started_at: new Date().toISOString(),
+    });
+    setInterval(() => registry.heartbeat(namespace), 60_000);
+    startControlServer(Number(process.env.CC_AGENT_OPS_PORT), {
+        namespace,
+        version: pkg.version,
+        logFile: process.env.CC_AGENT_LOG_FILE || process.env.LOG_FILE,
+    });
+    console.log(`[ops] control server on port ${process.env.CC_AGENT_OPS_PORT}`);
+}
+// Notifier — always subscribe to cca:notify and cca:chat:incoming channels.
+// CC_AGENT_NOTIFY_CHAT_ID pins a fixed Telegram chatId; without it the last
+// active chatId is used dynamically for the chat bridge.
+const notifyChatId = process.env.CC_AGENT_NOTIFY_CHAT_ID
+    ? Number(process.env.CC_AGENT_NOTIFY_CHAT_ID)
+    : null;
+const notifierBot = new TelegramBot(telegramToken, { polling: false });
+startNotifier(notifierBot, notifyChatId, namespace, sharedRedis, (cid, text) => bot.handleUserMessage(cid, text), () => bot.getLastActiveChatId());
+console.log(`[notifier] started for namespace=${namespace} chatId=${notifyChatId ?? "dynamic"}`);
 process.on("SIGINT", () => {
     console.log("\nShutting down...");
     bot.stop();

package/dist/notifier.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Notifier — subscribes to Redis pub/sub channels and bridges messages to Telegram.
+ *
+ * Channels:
+ *   cca:notify:{namespace}       — job completion notifications from cc-agent → forward to Telegram
+ *   cca:chat:incoming:{namespace} — messages from the web UI → echo to Telegram + feed into Claude session
+ *
+ * All messages (Telegram incoming, Claude responses) are also written to:
+ *   cca:chat:log:{namespace}     — LPUSH + LTRIM 0 499 (last 500 messages)
+ *   cca:chat:outgoing:{namespace} — PUBLISH for web UI to consume
+ */
+import { Redis } from "ioredis";
+import TelegramBot from "node-telegram-bot-api";
+export interface ChatMessage {
+    id: string;
+    source: "telegram" | "ui" | "claude" | "cc-tg";
+    role: "user" | "assistant" | "tool";
+    content: string;
+    timestamp: string;
+    chatId: number;
+}
+/**
+ * Write a message to the chat log in Redis.
+ * Fire-and-forget — errors are logged but not thrown.
+ */
+export declare function writeChatLog(redis: Redis, namespace: string, msg: ChatMessage): void;
+/**
+ * Start the notifier.
+ *
+ * @param bot       - Telegram bot instance (for sending messages)
+ * @param chatId    - Telegram chat ID to forward notifications to. Pass null to use getActiveChatId.
+ * @param namespace - cc-agent namespace (used to build Redis channel names)
+ * @param redis     - ioredis client in normal mode (will be duplicated for pub/sub)
+ * @param handleUserMessage - Optional callback to feed UI messages into the active Claude session
+ * @param getActiveChatId   - Optional callback to resolve chatId dynamically (used when chatId is null)
+ */
+export declare function startNotifier(bot: TelegramBot, chatId: number | null, namespace: string, redis: Redis, handleUserMessage?: (chatId: number, text: string) => void, getActiveChatId?: () => number | undefined): void;

package/dist/notifier.js

@@ -0,0 +1,154 @@
+/**
+ * Notifier — subscribes to Redis pub/sub channels and bridges messages to Telegram.
+ *
+ * Channels:
+ *   cca:notify:{namespace}       — job completion notifications from cc-agent → forward to Telegram
+ *   cca:chat:incoming:{namespace} — messages from the web UI → echo to Telegram + feed into Claude session
+ *
+ * All messages (Telegram incoming, Claude responses) are also written to:
+ *   cca:chat:log:{namespace}     — LPUSH + LTRIM 0 499 (last 500 messages)
+ *   cca:chat:outgoing:{namespace} — PUBLISH for web UI to consume
+ */
+function log(level, ...args) {
+    const fn = level === "error" ? console.error : level === "warn" ? console.warn : console.log;
+    fn("[notifier]", ...args);
+}
+/**
+ * Write a message to the chat log in Redis.
+ * Fire-and-forget — errors are logged but not thrown.
+ */
+export function writeChatLog(redis, namespace, msg) {
+    const logKey = `cca:chat:log:${namespace}`;
+    const outKey = `cca:chat:outgoing:${namespace}`;
+    const payload = JSON.stringify(msg);
+    redis.lpush(logKey, payload).catch((err) => {
+        log("warn", "writeChatLog lpush failed:", err.message);
+    });
+    redis.ltrim(logKey, 0, 499).catch((err) => {
+        log("warn", "writeChatLog ltrim failed:", err.message);
+    });
+    redis.publish(outKey, payload).catch((err) => {
+        log("warn", "writeChatLog publish failed:", err.message);
+    });
+}
+/**
+ * Start the notifier.
+ *
+ * @param bot       - Telegram bot instance (for sending messages)
+ * @param chatId    - Telegram chat ID to forward notifications to. Pass null to use getActiveChatId.
+ * @param namespace - cc-agent namespace (used to build Redis channel names)
+ * @param redis     - ioredis client in normal mode (will be duplicated for pub/sub)
+ * @param handleUserMessage - Optional callback to feed UI messages into the active Claude session
+ * @param getActiveChatId   - Optional callback to resolve chatId dynamically (used when chatId is null)
+ */
+export function startNotifier(bot, chatId, namespace, redis, handleUserMessage, getActiveChatId) {
+    const sub = redis.duplicate({
+        retryStrategy: (times) => {
+            const delay = Math.min(1000 * Math.pow(2, times - 1), 30_000);
+            log("info", `subscriber reconnecting in ${delay}ms (attempt ${times})`);
+            return delay;
+        },
+    });
+    sub.on("error", (err) => {
+        log("warn", "subscriber error:", err.message);
+    });
+    sub.on("close", () => {
+        log("info", "subscriber disconnected, will reconnect with backoff");
+    });
+    // cca:notify:{namespace} — forward job completion notifications to Telegram
+    sub.subscribe(`cca:notify:${namespace}`, (err) => {
+        if (err) {
+            log("error", `subscribe cca:notify:${namespace} failed:`, err.message);
+        }
+        else {
+            log("info", `subscribed to cca:notify:${namespace}`);
+        }
+    });
+    // cca:chat:incoming:{namespace} — messages from UI
+    sub.subscribe(`cca:chat:incoming:${namespace}`, (err) => {
+        if (err) {
+            log("error", `subscribe cca:chat:incoming:${namespace} failed:`, err.message);
+        }
+        else {
+            log("info", `subscribed to cca:chat:incoming:${namespace}`);
+        }
+    });
+    sub.on("message", (channel, message) => {
+        const notifyChannel = `cca:notify:${namespace}`;
+        const incomingChannel = `cca:chat:incoming:${namespace}`;
+        if (channel === notifyChannel) {
+            const targetId = chatId ?? getActiveChatId?.();
+            if (targetId != null) {
+                bot.sendMessage(targetId, message).catch((err) => {
+                    log("warn", "sendMessage failed:", err.message);
+                });
+            }
+            else {
+                log("warn", "notify: no chatId available, dropping notification");
+            }
+            return;
+        }
+        if (channel === incomingChannel) {
+            let content = message;
+            let originalTimestamp;
+            try {
+                const parsed = JSON.parse(message);
+                if (parsed.content)
+                    content = parsed.content;
+                if (parsed.timestamp)
+                    originalTimestamp = parsed.timestamp;
+            }
+            catch {
+                // raw string message — use as-is
+            }
+            // Resolve the target chatId: prefer the fixed chatId, fall back to last active
+            const targetChatId = chatId ?? getActiveChatId?.();
+            if (targetChatId !== undefined) {
+                // Echo to Telegram so the user sees UI messages in the chat
+                bot.sendMessage(targetChatId, `📱 [from UI]: ${content}`).catch((err) => {
+                    log("warn", "sendMessage (UI echo) failed:", err.message);
+                });
+                // Log the incoming message — preserve original timestamp from UI if present
+                const inMsg = {
+                    id: `ui-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`,
+                    source: "ui", // 'ui' distinguishes this from telegram/claude messages
+                    role: "user",
+                    content,
+                    // ISO 8601 — matches cc-agent-ui /chat/send format; preserve original if present
+                    timestamp: originalTimestamp ?? new Date().toISOString(),
+                    chatId: targetChatId,
+                };
+                writeChatLog(redis, namespace, inMsg);
+                // Check if a meta-agent is running for this namespace; if so, route there instead
+                void (async () => {
+                    let routedToMetaAgent = false;
+                    try {
+                        const statusRaw = await redis.get(`cca:meta-agent:status:${namespace}`);
+                        if (statusRaw) {
+                            const status = JSON.parse(statusRaw);
+                            if (status.status === "running") {
+                                const entry = JSON.stringify({
+                                    id: crypto.randomUUID(),
+                                    content,
+                                    timestamp: new Date().toISOString(),
+                                });
+                                await redis.lpush(`cca:meta:${namespace}:input`, entry);
+                                log("info", `cca:chat:incoming: routed to meta-agent for namespace ${namespace}`);
+                                routedToMetaAgent = true;
+                            }
+                        }
+                    }
+                    catch (err) {
+                        log("warn", "meta-agent status check failed, falling back to coordinator:", err.message);
+                    }
+                    if (!routedToMetaAgent && handleUserMessage) {
+                        handleUserMessage(targetChatId, content);
+                    }
+                })();
+            }
+            else {
+                log("warn", "cca:chat:incoming: no active chatId to route message to");
+            }
+        }
+    });
+}

package/dist/tokens.d.ts

@@ -0,0 +1,22 @@
+/**
+ * OAuth token pool management.
+ *
+ * Supports CLAUDE_CODE_OAUTH_TOKENS (comma-separated list of tokens).
+ * Falls back to CLAUDE_CODE_OAUTH_TOKEN for single-token / backwards compat.
+ */
+/**
+ * Load tokens from env vars. Called on startup; also re-callable in tests.
+ * Priority: CLAUDE_CODE_OAUTH_TOKENS > CLAUDE_CODE_OAUTH_TOKEN > (empty)
+ */
+export declare function loadTokens(): string[];
+/** Returns the current active token, or empty string if none configured. */
+export declare function getCurrentToken(): string;
+/**
+ * Advance to the next token (wraps around).
+ * Returns the new current token.
+ */
+export declare function rotateToken(): string;
+/** Zero-based index of the current token. */
+export declare function getTokenIndex(): number;
+/** Total number of tokens in the pool. */
+export declare function getTokenCount(): number;