@gonzih/cc-discord 0.2.23 → 0.2.25

package/dist/loop-manager.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Loop observability for cc-discord meta-agent channels.
+ *
+ * When a user sends a goal-oriented message to a meta-agent channel the bot
+ * creates a Discord thread on that message, tracks iteration state in Redis,
+ * and lets human operators steer the loop via 🔄/✅/❌ reactions.
+ *
+ * Redis layout:
+ *   cca:discord:loop:{channelId}:{threadId}  HASH  TTL 24h
+ *     goal            → string
+ *     namespace       → string
+ *     iteration       → stringified number
+ *     max_iterations  → stringified number
+ *     thread_id       → string
+ *     gate_failures   → JSON array of GateFailure
+ */
+import type { Redis } from "ioredis";
+export interface GateFailure {
+    gate: string;
+    feedback: string;
+    iteration: number;
+    confidence: number;
+    timestamp: string;
+}
+export interface LoopState {
+    channelId: string;
+    threadId: string;
+    /** ID of the first message posted inside the thread (reactions live here). */
+    goalMessageId: string;
+    namespace: string;
+    goal: string;
+    iteration: number;
+    maxIterations: number;
+    gateFailures: GateFailure[];
+}
+export interface EvalReport {
+    gate: string;
+    passed: boolean;
+    feedback: string;
+    iteration: number;
+    maxIterations: number;
+    confidence: number;
+}
+/** Return true when `text` looks like an action goal rather than a question or chat. */
+export declare function isGoalMessage(text: string): boolean;
+/**
+ * Parse an `eval_report` object embedded in a raw notification JSON string.
+ * Returns null when the field is absent, malformed, or the input is not JSON.
+ */
+export declare function parseEvalReport(raw: string): EvalReport | null;
+export declare class LoopManager {
+    private redis;
+    /** channelId → LoopState */
+    private activeLoops;
+    /** reactionMessageId → channelId — for O(1) lookup on reaction events */
+    private reactionMessageMap;
+    constructor(redis: Redis);
+    startLoop(channelId: string, threadId: string, goalMessageId: string, namespace: string, goal: string, maxIterations?: number): Promise<LoopState>;
+    isActive(channelId: string): boolean;
+    getState(channelId: string): LoopState | undefined;
+    getThreadId(channelId: string): string | undefined;
+    /** Look up the main channel ID from a reaction message ID. */
+    getChannelIdByReactionMessage(messageId: string): string | undefined;
+    addGateFailure(channelId: string, failure: GateFailure): Promise<void>;
+    endLoop(channelId: string): Promise<void>;
+}

package/dist/loop-manager.js

@@ -0,0 +1,118 @@
+/**
+ * Loop observability for cc-discord meta-agent channels.
+ *
+ * When a user sends a goal-oriented message to a meta-agent channel the bot
+ * creates a Discord thread on that message, tracks iteration state in Redis,
+ * and lets human operators steer the loop via 🔄/✅/❌ reactions.
+ *
+ * Redis layout:
+ *   cca:discord:loop:{channelId}:{threadId}  HASH  TTL 24h
+ *     goal            → string
+ *     namespace       → string
+ *     iteration       → stringified number
+ *     max_iterations  → stringified number
+ *     thread_id       → string
+ *     gate_failures   → JSON array of GateFailure
+ */
+const LOOP_TTL = 86_400; // 24h in seconds
+function loopKey(channelId, threadId) {
+    return `cca:discord:loop:${channelId}:${threadId}`;
+}
+// Action-verb heuristic: messages that start with one of these words are treated as goals.
+const GOAL_RE = /^(create|build|write|implement|fix|add|make|generate|refactor|set\s+up|update|deploy|run|test|check|migrate|convert|analyze|summarize|extract|draft|scaffold|configure|install|delete|remove|optimize|debug|review|audit|plan|design|port|bump|release)\b/i;
+/** Return true when `text` looks like an action goal rather than a question or chat. */
+export function isGoalMessage(text) {
+    return GOAL_RE.test(text.trim());
+}
+/**
+ * Parse an `eval_report` object embedded in a raw notification JSON string.
+ * Returns null when the field is absent, malformed, or the input is not JSON.
+ */
+export function parseEvalReport(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        const r = parsed.eval_report;
+        if (!r || typeof r.gate !== "string" || typeof r.passed !== "boolean")
+            return null;
+        return {
+            gate: r.gate,
+            passed: r.passed,
+            feedback: typeof r.feedback === "string" ? r.feedback : "",
+            iteration: typeof r.iteration === "number" ? r.iteration : 0,
+            maxIterations: typeof r.max_iterations === "number" ? r.max_iterations : 0,
+            confidence: typeof r.confidence === "number" ? r.confidence : 0,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export class LoopManager {
+    redis;
+    /** channelId → LoopState */
+    activeLoops = new Map();
+    /** reactionMessageId → channelId — for O(1) lookup on reaction events */
+    reactionMessageMap = new Map();
+    constructor(redis) {
+        this.redis = redis;
+    }
+    async startLoop(channelId, threadId, goalMessageId, namespace, goal, maxIterations = 10) {
+        const state = {
+            channelId,
+            threadId,
+            goalMessageId,
+            namespace,
+            goal,
+            iteration: 0,
+            maxIterations,
+            gateFailures: [],
+        };
+        this.activeLoops.set(channelId, state);
+        this.reactionMessageMap.set(goalMessageId, channelId);
+        const key = loopKey(channelId, threadId);
+        await this.redis.hset(key, {
+            goal,
+            namespace,
+            iteration: "0",
+            max_iterations: String(maxIterations),
+            thread_id: threadId,
+            gate_failures: "[]",
+        });
+        await this.redis.expire(key, LOOP_TTL);
+        return state;
+    }
+    isActive(channelId) {
+        return this.activeLoops.has(channelId);
+    }
+    getState(channelId) {
+        return this.activeLoops.get(channelId);
+    }
+    getThreadId(channelId) {
+        return this.activeLoops.get(channelId)?.threadId;
+    }
+    /** Look up the main channel ID from a reaction message ID. */
+    getChannelIdByReactionMessage(messageId) {
+        return this.reactionMessageMap.get(messageId);
+    }
+    async addGateFailure(channelId, failure) {
+        const state = this.activeLoops.get(channelId);
+        if (!state)
+            return;
+        state.gateFailures.push(failure);
+        state.iteration++;
+        const key = loopKey(channelId, state.threadId);
+        await this.redis.hset(key, {
+            iteration: String(state.iteration),
+            gate_failures: JSON.stringify(state.gateFailures),
+        });
+        await this.redis.expire(key, LOOP_TTL);
+    }
+    async endLoop(channelId) {
+        const state = this.activeLoops.get(channelId);
+        if (state) {
+            this.reactionMessageMap.delete(state.goalMessageId);
+            await this.redis.del(loopKey(channelId, state.threadId));
+        }
+        this.activeLoops.delete(channelId);
+    }
+}

package/dist/notifier.js

@@ -101,6 +101,9 @@ function shortenModelName(model, driver) {
  * Appends " cost: $X.XXX" if a numeric cost field is present.
  */
 export function parseNotification(raw) {
+    // Filter cron-fire noise before any parsing — catches plain-text and JSON-wrapped ⏰ cron notifications
+    if (raw.startsWith("⏰") || raw.includes('"⏰'))
+        return null;
     let text = raw;
     let driver;
     let model;
@@ -127,10 +130,8 @@ export function parseNotification(raw) {
             isCron = parsed.is_cron;
     }
     catch {
-        // non-JSON: fall through to text-based check below
+        // non-JSON: fall through
     }
-    if (text.startsWith("⏰"))
-        return null;
     // Parse eval_report if present — this field is non-standard and not in NotificationPayload type
     const evalReport = parseEvalReport(raw);
     if (!driver)
@@ -356,23 +357,24 @@ export function startNotifier(bot, notifyChannelId, namespace, redis, handleUser
             const notification = parseNotification(raw);
             if (notification === null)
                 continue; // routing excludes discord
-            // Dedup: skip if this notification was already forwarded recently
-            // Uses Redis when available; falls back to in-memory dedup on Redis errors.
+            // Dedup: skip if this notification was already forwarded recently.
+            // Check in-memory first (catches pub/sub-delivered notifications in the same process).
+            if (checkAndMarkSentSync(ns, raw)) {
+                log("info", `dedup: skipping already-sent notification (ns=${ns})`);
+                continue;
+            }
+            // Also check Redis for cross-restart/cross-process dedup.
             let isDup = false;
             try {
                 if (typeof redis.sadd === "function") {
                     isDup = await checkAndMarkSent(redis, ns, raw);
                 }
-                else {
-                    isDup = checkAndMarkSentSync(ns, raw);
-                }
             }
             catch (err) {
-                log("warn", `dedup check failed (ns=${ns}), falling back to in-memory:`, err.message);
-                isDup = checkAndMarkSentSync(ns, raw);
+                log("warn", `dedup Redis check failed (ns=${ns}):`, err.message);
             }
             if (isDup) {
-                log("info", `dedup: skipping already-sent notification (ns=${ns})`);
+                log("info", `dedup: skipping already-sent notification (ns=${ns}) [redis]`);
                 continue;
             }
             // Primary namespace: honour chatId-based per-channel routing via reverseSnowflakeLookup,
@@ -436,6 +438,8 @@ export function startNotifier(bot, notifyChannelId, namespace, redis, handleUser
                 log("info", `dedup: skipping already-sent pub/sub notification (ns=${ns})`);
                 return;
             }
+            // Also mark in Redis so list-poller dedup sees it (prevents cross-path duplicates)
+            checkAndMarkSent(redis, ns, message).catch(() => { });
             let mainChannelId;
             if (isPrimary) {
                 mainChannelId = resolveNotifyChannel(notification.chatId, notifyChannelId, getActiveChannelId, reverseSnowflakeLookup, ns, getChannelIdForNamespace);
@@ -483,10 +487,13 @@ export function startNotifier(bot, notifyChannelId, namespace, redis, handleUser
                 ? (notifyChannelId ?? getActiveChannelId?.())
                 : routedChannelIds.get(ns);
             if (targetChannelId !== undefined) {
-                // Echo to Discord so the user sees UI messages
-                bot.sendToChannelById(targetChannelId, `[from UI]: ${content}`).catch((err) => {
-                    log("warn", `sendToChannelById (UI echo) failed (ns=${ns}):`, err.message);
-                });
+                // Echo to Discord so the user sees UI messages (suppress cron-fire noise)
+                const isCronMessage = content.startsWith("⏰") || content.includes("[cron]");
+                if (!isCronMessage) {
+                    bot.sendToChannelById(targetChannelId, `[from UI]: ${content}`).catch((err) => {
+                        log("warn", `sendToChannelById (UI echo) failed (ns=${ns}):`, err.message);
+                    });
+                }
                 // Log the incoming message
                 const inMsg = {
                     id: crypto.randomUUID(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gonzih/cc-discord",
-  "version": "0.2.23",
+  "version": "0.2.25",
   "description": "Claude Code Discord bot — chat with Claude Code via Discord",
   "type": "module",
   "bin": {