@gonzih/cc-tg 0.6.2 → 0.6.3

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

@@ -4,7 +4,7 @@
  * 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
+ *   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).
@@ -19,6 +19,13 @@ export interface JobEvent {
     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;
@@ -32,8 +39,11 @@ 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>;
 }
-export declare function buildDecisionPrompt(event: JobEvent): string;
+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.
@@ -42,6 +52,21 @@ export declare function parseDecision(raw: string): DecisionResult;
 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>;
+/**
+ * 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.

package/dist/cc-agent-events.js

@@ -4,7 +4,7 @@
  * 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
+ *   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).
@@ -21,31 +21,40 @@ function log(level, ...args) {
             : console.log;
     fn("[cc-agent-events]", ...args);
 }
-export function buildDecisionPrompt(event) {
+export function buildDecisionPrompt(event, last40lines, coordinatorPlan) {
+    const scoreStr = event.score !== undefined ? String(event.score) : "n/a";
+    const planStr = coordinatorPlan ? JSON.stringify(coordinatorPlan, null, 2) : "none";
     return `A cc-agent job just completed.
 
 Job: ${event.title}
 Repo: ${event.repoUrl}
 Status: ${event.status}
-Last output:
-${event.lastLines.join("\n")}
+Score: ${scoreStr}
 
-Decide what to do next. Options:
-1. NOTIFY_ONLY — send a brief Telegram message to Maksim summarizing what completed
-2. SPAWN_FOLLOWUP — spawn a follow-up cc-agent job (provide repo_url and task)
-3. SILENT — log it, no action needed (routine/expected completion)
+Last output + LEARNINGS:
+${last40lines.join("\n")}
 
-Reply in this exact JSON format:
-{
-  "action": "NOTIFY_ONLY" | "SPAWN_FOLLOWUP" | "SILENT",
-  "message": "...",
-  "followup": {
-    "repo_url": "...",
-    "task": "..."
-  }
-}
+Coordinator plan for this job (if any):
+${planStr}
+
+Decide what to do next:
+1. SPAWN_FOLLOWUP — spawn a follow-up job (provide repo_url and task)
+2. NOTIFY_ONLY — send Telegram message, no spawn needed
+3. SILENT — routine completion, no action
+
+Rules:
+- If LEARNINGS has "Recommendations for next agent" with a clear actionable next step → consider SPAWN_FOLLOWUP
+- If coordinator plan has nextStep → SPAWN_FOLLOWUP with that task (prefer coordinator plan over LEARNINGS)
+- Failed jobs → NOTIFY_ONLY always
+- Score < 0.5 → NOTIFY_ONLY
+- Routine/expected completions → SILENT
 
-Be conservative. Only SPAWN_FOLLOWUP if clearly needed. Only NOTIFY_ONLY for important completions. Use SILENT for routine jobs.`;
+Reply in JSON:
+{
+  "action": "SPAWN_FOLLOWUP" | "NOTIFY_ONLY" | "SILENT",
+  "message": "brief telegram message (1-2 lines)",
+  "followup": { "repo_url": "...", "task": "..." } | null
+}`;
 }
 export function parseDecision(raw) {
     const match = raw.match(/\{[\s\S]*\}/);
@@ -57,6 +66,32 @@ export function parseDecision(raw) {
     }
     return parsed;
 }
+function formatSpawnMessage(event, followup, runningCount) {
+    const scoreStr = event.score !== undefined ? ` (score: ${event.score})` : "";
+    const repoShort = followup.repo_url.replace(/^https?:\/\/github\.com\//, "");
+    const lines = [
+        `✓ ${event.title} done${scoreStr}`,
+        `→ spawned: ${followup.task} (${repoShort})`,
+    ];
+    if (runningCount > 0) {
+        lines.push(`${runningCount} jobs running`);
+    }
+    return lines.join("\n");
+}
+function formatFailureMessage(event) {
+    const lastLine = event.lastLines[event.lastLines.length - 1] ?? "";
+    const repoShort = event.repoUrl.replace(/^https?:\/\/github\.com\//, "");
+    return `✗ ${event.title} failed\n${repoShort} — exit 1\nLast line: ${lastLine}`;
+}
+function getChatId() {
+    const chatIdStr = process.env.CC_AGENT_NOTIFY_CHAT_ID;
+    if (!chatIdStr)
+        return null;
+    const chatId = Number(chatIdStr);
+    if (isNaN(chatId))
+        return null;
+    return chatId;
+}
 /**
  * Ask Claude to make a decision about a completed job.
  * Returns the raw text response from Claude.
@@ -149,6 +184,65 @@ Call the spawn_agent tool now with these exact parameters. Report the job ID whe
         claude.sendPrompt(prompt);
     });
 }
+function makeRedisClient() {
+    return new Redis(process.env.REDIS_URL || "redis://localhost:6379", {
+        lazyConnect: true,
+        enableOfflineQueue: false,
+    });
+}
+export async function defaultReadJobOutput(jobId) {
+    const redis = makeRedisClient();
+    try {
+        await redis.connect();
+        const lines = await redis.lrange(`cca:job:${jobId}:output`, -40, -1);
+        return lines;
+    }
+    finally {
+        try {
+            redis.disconnect();
+        }
+        catch { }
+    }
+}
+export async function defaultReadCoordinatorPlan(jobId) {
+    const redis = makeRedisClient();
+    try {
+        await redis.connect();
+        const raw = await redis.get(`cca:coordinator:plan:${jobId}`);
+        if (!raw)
+            return null;
+        return JSON.parse(raw);
+    }
+    finally {
+        try {
+            redis.disconnect();
+        }
+        catch { }
+    }
+}
+export async function defaultGetRunningJobCount() {
+    return 0;
+}
+/**
+ * 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 async function writeCoordinatorPlan(jobId, plan) {
+    const redis = makeRedisClient();
+    try {
+        await redis.connect();
+        const key = `cca:coordinator:plan:${jobId}`;
+        const ttlSeconds = 7 * 24 * 60 * 60; // 7 days
+        await redis.set(key, JSON.stringify(plan), "EX", ttlSeconds);
+    }
+    finally {
+        try {
+            redis.disconnect();
+        }
+        catch { }
+    }
+}
 /**
  * Handle a single job event message from Redis pub/sub.
  * Exported for testability — production code passes defaultDeps.
@@ -168,29 +262,47 @@ export async function handleJobEvent(message, deps) {
         return;
     }
     log("info", `Processing ${event.status} event for job: ${event.title} (${event.jobId})`);
+    // Read job output from Redis (fall back to event.lastLines on error)
+    let last40lines = event.lastLines;
+    try {
+        const lines = await deps.readJobOutput(event.jobId);
+        if (lines.length > 0)
+            last40lines = lines;
+    }
+    catch (err) {
+        log("warn", "Failed to read job output, using event.lastLines:", err.message);
+    }
+    // Read coordinator plan from Redis (fall back to null on error)
+    let coordinatorPlan = null;
+    try {
+        coordinatorPlan = await deps.readCoordinatorPlan(event.jobId);
+    }
+    catch (err) {
+        log("warn", "Failed to read coordinator plan:", err.message);
+    }
     let decision;
     try {
-        const rawResponse = await deps.askClaude(buildDecisionPrompt(event));
+        const rawResponse = await deps.askClaude(buildDecisionPrompt(event, last40lines, coordinatorPlan));
         decision = parseDecision(rawResponse);
     }
     catch (err) {
-        log("error", "Claude decision failed:", err.message);
-        return;
+        log("error", "Claude decision failed, falling back to NOTIFY_ONLY:", err.message);
+        const fallbackMsg = event.status === "failed"
+            ? formatFailureMessage(event)
+            : `Job completed: ${event.title}`;
+        decision = { action: "NOTIFY_ONLY", message: fallbackMsg };
     }
     log("info", `Decision: ${decision.action} for job ${event.jobId}`);
+    const chatId = getChatId();
     try {
         if (decision.action === "NOTIFY_ONLY") {
-            const chatIdStr = process.env.CC_AGENT_NOTIFY_CHAT_ID;
-            if (!chatIdStr) {
+            if (!chatId) {
                 log("warn", "NOTIFY_ONLY: CC_AGENT_NOTIFY_CHAT_ID not set, skipping notification");
                 return;
             }
-            const chatId = Number(chatIdStr);
-            if (isNaN(chatId)) {
-                log("warn", `NOTIFY_ONLY: invalid CC_AGENT_NOTIFY_CHAT_ID: ${chatIdStr}`);
-                return;
-            }
-            await deps.sendTelegramMessage(chatId, decision.message ?? `Job completed: ${event.title}`);
+            const msg = decision.message
+                ?? (event.status === "failed" ? formatFailureMessage(event) : `Job completed: ${event.title}`);
+            await deps.sendTelegramMessage(chatId, msg);
         }
         else if (decision.action === "SPAWN_FOLLOWUP") {
             if (!decision.followup) {
@@ -198,6 +310,16 @@ export async function handleJobEvent(message, deps) {
                 return;
             }
             await deps.spawnFollowupAgent(decision.followup.repo_url, decision.followup.task);
+            // Send Telegram notification about the spawn
+            if (chatId) {
+                let runningCount = 0;
+                try {
+                    runningCount = await deps.getRunningJobCount();
+                }
+                catch { }
+                const spawnMsg = formatSpawnMessage(event, decision.followup, runningCount);
+                await deps.sendTelegramMessage(chatId, spawnMsg);
+            }
         }
         else {
             // SILENT — log only
@@ -213,6 +335,9 @@ function makeDefaultDeps() {
         askClaude: defaultAskClaude,
         sendTelegramMessage: defaultSendTelegramMessage,
         spawnFollowupAgent: defaultSpawnFollowupAgent,
+        readJobOutput: defaultReadJobOutput,
+        readCoordinatorPlan: defaultReadCoordinatorPlan,
+        getRunningJobCount: defaultGetRunningJobCount,
     };
 }
 let subscriberClient = null;

package/package.json

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