@gonzih/cc-tg 0.6.5 → 0.7.0

package/dist/bot.d.ts

@@ -15,7 +15,6 @@ export declare class CcTgBot {
     private sessions;
     private pendingRetries;
     private opts;
-    private cron;
     private costStore;
     private botUsername;
     private botId;
@@ -45,9 +44,6 @@ export declare class CcTgBot {
     private isSensitiveFile;
     private uploadMentionedFiles;
     private extractToolName;
-    private runCronTask;
-    private handleCron;
-    private handleCronEdit;
     /** Find cc-agent PIDs via pgrep. Returns array of numeric PIDs. */
     private findCcAgentPids;
     /** Kill cc-agent PIDs with SIGTERM. Returns the list of killed PIDs. */

package/dist/bot.js

@@ -11,7 +11,6 @@ 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";
@@ -21,7 +20,6 @@ const BOT_COMMANDS = [
     { 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" },
@@ -66,10 +64,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);
@@ -156,7 +150,6 @@ export class CcTgBot {
     sessions = new Map();
     pendingRetries = new Map();
     opts;
-    cron;
     costStore;
     botUsername = "";
     botId = 0;
@@ -170,12 +163,6 @@ 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.
-        // The `done` callback is passed through to runCronTask so the cron manager
-        // knows when a task finishes and can allow the next tick to run.
-        this.cron = new CronManager(opts.cwd ?? process.cwd(), (chatId, prompt, jobId, done) => {
-            this.runCronTask(chatId, prompt, done);
-        });
         this.costStore = new CostStore(opts.cwd ?? process.cwd());
         this.registerBotCommands();
         console.log("cc-tg bot started");
@@ -305,11 +292,6 @@ export class CcTgBot {
             await this.replyToChat(chatId, status, threadId);
             return;
         }
-        // /cron <schedule> <prompt> | /cron list | /cron clear | /cron remove <id>
-        if (text.startsWith("/cron")) {
-            await this.handleCron(chatId, text, threadId);
-            return;
-        }
         // /reload_mcp — kill cc-agent process so Claude Code auto-restarts it
         if (text === "/reload_mcp") {
             await this.handleReloadMcp(chatId, threadId);
@@ -814,210 +796,6 @@ export class CcTgBot {
         const toolUse = content.find((b) => b.type === "tool_use");
         return toolUse?.name ?? "";
     }
-    runCronTask(chatId, prompt, done = () => { }) {
-        // 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.",
-            "DEDUP RULE: If this task involves resuming or restarting interrupted agents/jobs,",
-            "  skip any job whose task description already starts with 'RESUMING' (it is already",
-            "  a resume attempt). Also skip any job that has a non-empty 'resumed_by' field.",
-            "  Only spawn a resume agent for a job if resume_count < 2 (when that field exists).",
-            "  This prevents exponential job growth when a cron re-discovers its own spawned agents.",
-            "",
-            `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: "HTML" });
-                            }
-                            catch {
-                                // HTML 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();
-            done();
-        });
-        cronProcess.on("exit", () => {
-            console.log(`[cron] task complete for chat=${chatId}`);
-            done();
-        });
-        cronProcess.sendPrompt(taskPrompt);
-    }
-    async handleCron(chatId, text, threadId) {
-        const args = text.slice("/cron".length).trim();
-        // /cron list
-        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;
-        }
-        // /cron clear
-        if (args === "clear") {
-            const n = this.cron.clearAll(chatId);
-            await this.replyToChat(chatId, `Cleared ${n} cron job(s).`, threadId);
-            return;
-        }
-        // /cron remove <id>
-        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;
-        }
-        // /cron edit [<#> ...]
-        if (args === "edit" || args.startsWith("edit ")) {
-            await this.handleCronEdit(chatId, args.slice("edit".length).trim(), threadId);
-            return;
-        }
-        // /cron every 1h <prompt>
-        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 edit\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);
-    }
-    async handleCronEdit(chatId, editArgs, threadId) {
-        const jobs = this.cron.list(chatId);
-        // No args — show numbered list with edit instructions
-        if (!editArgs) {
-            if (!jobs.length) {
-                await this.replyToChat(chatId, "No cron jobs to edit.", 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:\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>", threadId);
-            return;
-        }
-        // Expect: <index> <rest>
-        const indexMatch = editArgs.match(/^(\d+)\s+(.+)$/);
-        if (!indexMatch) {
-            await this.replyToChat(chatId, "Usage: /cron edit <#> every <N><unit> <new prompt>", threadId);
-            return;
-        }
-        const index = parseInt(indexMatch[1], 10) - 1;
-        if (index < 0 || index >= jobs.length) {
-            await this.replyToChat(chatId, `Invalid job number. Use /cron edit to see the list.`, threadId);
-            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.replyToChat(chatId, "Invalid schedule. Use: every 30m / every 2h / every 1d", threadId);
-            }
-            else if (result === false) {
-                await this.replyToChat(chatId, "Job not found.", threadId);
-            }
-            else {
-                await this.replyToChat(chatId, `#${index + 1} schedule updated to ${newSchedule}.`, threadId);
-            }
-            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.replyToChat(chatId, "Job not found.", threadId);
-            }
-            else {
-                await this.replyToChat(chatId, `#${index + 1} prompt updated to "${newPrompt}".`, threadId);
-            }
-            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.replyToChat(chatId, "Invalid schedule. Use: every 30m / every 2h / every 1d", threadId);
-            }
-            else if (result === false) {
-                await this.replyToChat(chatId, "Job not found.", threadId);
-            }
-            else {
-                await this.replyToChat(chatId, `#${index + 1} updated: ${newSchedule} — "${newPrompt}"`, threadId);
-            }
-            return;
-        }
-        await this.replyToChat(chatId, "Edit options:\n" +
-            "/cron edit <#> every <N><unit> <new prompt>\n" +
-            "/cron edit <#> schedule every <N><unit>\n" +
-            "/cron edit <#> prompt <new prompt>", threadId);
-    }
     /** Find cc-agent PIDs via pgrep. Returns array of numeric PIDs. */
     findCcAgentPids() {
         try {
@@ -1239,7 +1017,7 @@ export class CcTgBot {
             proc.on("exit", () => { clearTimeout(timeout); done(null); });
         });
     }
-    killSession(chatId, keepCrons = true, threadId) {
+    killSession(chatId, _keepCrons = true, threadId) {
         const key = this.sessionKey(chatId, threadId);
         const session = this.sessions.get(key);
         if (session) {
@@ -1247,8 +1025,6 @@ export class CcTgBot {
             session.claude.kill();
             this.sessions.delete(key);
         }
-        if (!keepCrons)
-            this.cron.clearAll(chatId);
     }
     getMe() {
         return this.bot.getMe();

package/dist/index.js

@@ -20,11 +20,12 @@ import { tmpdir } from "os";
 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";
 import { loadTokens } from "./tokens.js";
 import { Registry, startControlServer } from "@gonzih/agent-ops";
 import { Redis } from "ioredis";
-import { connectEventSubscriber } from "./cc-agent-events.js";
+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"));
@@ -120,11 +121,13 @@ const bot = new CcTgBot({
     groupChatIds,
 });
 // agent-ops: optional self-registration + HTTP control endpoint
+const redisUrl = process.env.REDIS_URL || "redis://localhost:6379";
+const namespace = process.env.CC_AGENT_NAMESPACE || "default";
+let sharedRedis = null;
 if (process.env.CC_AGENT_OPS_PORT) {
     const botInfo = await bot.getMe();
-    const redis = new Redis(process.env.REDIS_URL || "redis://localhost:6379");
-    const registry = new Registry(redis);
-    const namespace = process.env.CC_AGENT_NAMESPACE || "default";
+    sharedRedis = new Redis(redisUrl);
+    const registry = new Registry(sharedRedis);
     await registry.register({
         namespace,
         hostname: os.hostname(),
@@ -144,10 +147,17 @@ if (process.env.CC_AGENT_OPS_PORT) {
     });
     console.log(`[ops] control server on port ${process.env.CC_AGENT_OPS_PORT}`);
 }
-// cc-agent event subscriber — watches Redis cca:events for job completions
-connectEventSubscriber().catch((err) => {
-    console.error("[cc-agent-events] startup error:", err.message);
-});
+// Notifier — subscribe to cca:notify:{namespace} and cca:chat:incoming:{namespace}
+const notifyChatId = process.env.CC_AGENT_NOTIFY_CHAT_ID
+    ? Number(process.env.CC_AGENT_NOTIFY_CHAT_ID)
+    : null;
+if (notifyChatId) {
+    if (!sharedRedis)
+        sharedRedis = new Redis(redisUrl);
+    const notifierBot = new TelegramBot(telegramToken, { polling: false });
+    startNotifier(notifierBot, notifyChatId, namespace, sharedRedis);
+    console.log(`[notifier] started for namespace=${namespace} chatId=${notifyChatId}`);
+}
 process.on("SIGINT", () => {
     console.log("\nShutting down...");
     bot.stop();

package/dist/notifier.d.ts

@@ -0,0 +1,36 @@
+/**
+ * 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";
+    role: "user" | "assistant";
+    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
+ * @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
+ */
+export declare function startNotifier(bot: TelegramBot, chatId: number, namespace: string, redis: Redis, handleUserMessage?: (chatId: number, text: string) => void): void;

package/dist/notifier.js

@@ -0,0 +1,105 @@
+/**
+ * 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
+ * @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
+ */
+export function startNotifier(bot, chatId, namespace, redis, handleUserMessage) {
+    const sub = redis.duplicate();
+    sub.on("error", (err) => {
+        log("warn", "subscriber error:", err.message);
+    });
+    // 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) {
+            bot.sendMessage(chatId, message).catch((err) => {
+                log("warn", "sendMessage failed:", err.message);
+            });
+            return;
+        }
+        if (channel === incomingChannel) {
+            let content = message;
+            try {
+                const parsed = JSON.parse(message);
+                if (parsed.content)
+                    content = parsed.content;
+            }
+            catch {
+                // raw string message — use as-is
+            }
+            // Echo to Telegram so the user sees UI messages in the chat
+            bot.sendMessage(chatId, `📱 [from UI]: ${content}`).catch((err) => {
+                log("warn", "sendMessage (UI echo) failed:", err.message);
+            });
+            // Log the incoming message
+            const inMsg = {
+                id: `ui-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`,
+                source: "ui",
+                role: "user",
+                content,
+                timestamp: new Date().toISOString(),
+                chatId,
+            };
+            writeChatLog(redis, namespace, inMsg);
+            // Feed into active Claude session as if user typed it
+            if (handleUserMessage) {
+                handleUserMessage(chatId, content);
+            }
+        }
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gonzih/cc-tg",
-  "version": "0.6.5",
+  "version": "0.7.0",
   "description": "Claude Code Telegram bot — chat with Claude Code via Telegram",
   "type": "module",
   "bin": {

package/dist/cc-agent-events.d.ts

@@ -1,98 +0,0 @@
-/**
- * cc-agent Redis event subscriber.
- *
- * Listens to the `cca:events` pub/sub channel for job completion events,
- * asks Claude to decide what to do, and acts accordingly:
- *   NOTIFY_ONLY    — send a Telegram message to the configured chat
- *   SPAWN_FOLLOWUP — spawn a follow-up cc-agent job via MCP + notify Telegram
- *   SILENT         — log and do nothing
- *
- * Controlled via CC_AGENT_EVENTS_ENABLED env var (default: true).
- * Requires CC_AGENT_NOTIFY_CHAT_ID to send Telegram notifications.
- */
-import { Redis } from "ioredis";
-export interface JobEvent {
-    jobId: string;
-    status: "done" | "failed" | "interrupted" | "running" | "cancelled";
-    title: string;
-    repoUrl: string;
-    lastLines: string[];
-    score?: number;
-    timestamp: number;
-}
-export interface CoordinatorPlan {
-    nextStep?: {
-        repo_url: string;
-        task: string;
-    };
-    summary: string;
-}
-export interface DecisionResult {
-    action: "NOTIFY_ONLY" | "SPAWN_FOLLOWUP" | "SILENT";
-    message?: string;
-    followup?: {
-        repo_url: string;
-        task: string;
-    };
-}
-/** Injectable dependencies for testability */
-export interface HandlerDeps {
-    askClaude: (prompt: string) => Promise<string>;
-    sendTelegramMessage: (chatId: number, text: string) => Promise<void>;
-    spawnFollowupAgent: (repoUrl: string, task: string) => Promise<void>;
-    readJobOutput: (jobId: string) => Promise<string[]>;
-    readCoordinatorPlan: (jobId: string) => Promise<CoordinatorPlan | null>;
-    getRunningJobCount: () => Promise<number>;
-    getActiveChatIds: () => Promise<number[]>;
-}
-export declare function buildDecisionPrompt(event: JobEvent, last40lines: string[], coordinatorPlan: CoordinatorPlan | null): string;
-export declare function parseDecision(raw: string): DecisionResult;
-/**
- * Ask Claude to make a decision about a completed job.
- * Returns the raw text response from Claude.
- */
-export declare function defaultAskClaude(prompt: string): Promise<string>;
-export declare function defaultSendTelegramMessage(chatId: number, text: string): Promise<void>;
-export declare function defaultSpawnFollowupAgent(repoUrl: string, task: string): Promise<void>;
-export declare function defaultReadJobOutput(jobId: string): Promise<string[]>;
-export declare function defaultReadCoordinatorPlan(jobId: string): Promise<CoordinatorPlan | null>;
-export declare function defaultGetRunningJobCount(): Promise<number>;
-/**
- * Returns chat IDs to notify about job events.
- * Reads unique chatIds from the cron jobs file (same users who set up cron jobs).
- * Falls back to CC_AGENT_NOTIFY_CHAT_ID env var for backward compatibility.
- */
-export declare function defaultGetActiveChatIds(): Promise<number[]>;
-/**
- * Write a coordinator plan for a job, so cc-tg knows what follow-up to spawn.
- * Call this when spawning a job that has a planned follow-up.
- * TTL: 7 days.
- */
-export declare function writeCoordinatorPlan(jobId: string, plan: {
-    nextStep?: {
-        repo_url: string;
-        task: string;
-    };
-    summary: string;
-}): Promise<void>;
-/**
- * Handle a single job event message from Redis pub/sub.
- * Exported for testability — production code passes defaultDeps.
- */
-export declare function handleJobEvent(message: string, deps: HandlerDeps): Promise<void>;
-/** Parse flat key-value field array from a Redis Stream entry into a record. */
-export declare function parseStreamFields(fields: string[]): Record<string, string>;
-/** Convert stream entry fields to a JobEvent JSON string for handleJobEvent. */
-export declare function streamEntryToMessage(fields: Record<string, string>): string | null;
-/**
- * Replay events from the Redis Stream that were missed since last-seen ID.
- * Uses `cca:event-stream:last-id:{botName}` in Redis to track position.
- * Exported for testability — pass a real or mock Redis instance.
- */
-export declare function replayStreamEvents(redis: Redis, deps: HandlerDeps, botName?: string): Promise<void>;
-/**
- * Connect to Redis and subscribe to cca:events.
- * Reconnects automatically on disconnect.
- * Call once at startup.
- */
-export declare function connectEventSubscriber(): Promise<void>;