@gonzih/cc-discord 0.2.5 → 0.2.6

package/dist/bot.d.ts

@@ -3,6 +3,7 @@
  * One ClaudeProcess per channel (or channel:thread) — sessions are isolated per channel.
  */
 import { Redis } from "ioredis";
+import { type EvalReport } from "./loop-manager.js";
 /** Returns true if the attachment name/contentType indicates an audio file. */
 export declare function isAudioAttachment(name: string, contentType: string): boolean;
 /** Build the prompt text for a file/document attachment, optionally with caption. */
@@ -36,6 +37,7 @@ export declare class CcDiscordBot {
     private metaAgentManager;
     /** ClaudeProcess running the MCP tool bridge (for callCcAgentTool) */
     private mcpSession?;
+    private loopManager?;
     constructor(opts: DiscordBotOptions);
     /** Reverse-lookup: find the channelId string for a cron-stored integer */
     private snowflakeMap;
@@ -98,6 +100,20 @@ export declare class CcDiscordBot {
     getLastActiveChannelId(): string | undefined;
     /** Reverse lookup: find the Discord channelId registered for a given namespace. */
     getChannelIdForNamespace(ns: string): string | undefined;
+    /** Return the thread ID for an active loop on `channelId`, or undefined. */
+    getLoopThreadId(channelId: string): string | undefined;
+    /**
+     * Post a structured eval-report embed to the loop thread for `channelId`.
+     * Also records gate failures in the LoopManager if the gate did not pass.
+     */
+    postEvalEmbed(channelId: string, report: EvalReport): Promise<void>;
+    /**
+     * Create a Discord thread on `msg`, register loop state, and add reaction gates.
+     * Requires MANAGE_THREADS permission. Falls back silently on failure.
+     */
+    private createLoopThread;
+    /** Handle 🔄/✅/❌ reactions on loop gate messages. */
+    private handleReactionAdd;
     /**
      * Feed a text message into the active Claude session for the given channel.
      * Called by the notifier when a UI message arrives via Redis pub/sub.

package/dist/bot.js

@@ -13,6 +13,7 @@ import { transcribeVoice, isVoiceAvailable } from "./voice.js";
 import { formatForDiscord, splitLongMessage, stripAnsi } from "./formatter.js";
 import { getCurrentToken } from "./tokens.js";
 import { writeChatLog } from "./notifier.js";
+import { LoopManager, isGoalMessage } from "./loop-manager.js";
 import { CronManager } from "./cron.js";
 import { parseChannelCreateIntent, routeToMetaAgent } from "./router.js";
 import { createMetaAgentManager } from "./meta-agent-manager.js";
@@ -122,12 +123,14 @@ export class CcDiscordBot {
     metaAgentManager;
     /** ClaudeProcess running the MCP tool bridge (for callCcAgentTool) */
     mcpSession;
+    loopManager;
     constructor(opts) {
         this.opts = opts;
         this.redis = opts.redis;
         this.namespace = opts.namespace ?? "default";
         if (opts.redis) {
             this.wire = createCcWire(opts.redis);
+            this.loopManager = new LoopManager(opts.redis);
         }
         this.metaAgentManager = createMetaAgentManager();
         this.client = new Client({
@@ -136,6 +139,7 @@ export class CcDiscordBot {
                 GatewayIntentBits.GuildMessages,
                 GatewayIntentBits.MessageContent,
                 GatewayIntentBits.DirectMessages,
+                GatewayIntentBits.GuildMessageReactions,
             ],
         });
         this.cron = new CronManager(opts.cwd ?? process.cwd(), (chatIdNum, prompt, _jobId, done) => {
@@ -168,6 +172,9 @@ export class CcDiscordBot {
                 return;
             void this.handleSlashCommand(interaction);
         });
+        this.client.on(Events.MessageReactionAdd, (reaction, user) => {
+            void this.handleReactionAdd(reaction, user);
+        });
         this.client.on("error", (err) => {
             console.error("[discord] client error:", err.message);
         });
@@ -365,13 +372,42 @@ export class CcDiscordBot {
                 return;
             }
         }
+        // Handle messages sent inside a loop thread — route to the running meta-agent session
+        if (msg.channel.isThread() && this.redis && this.loopManager) {
+            const parentId = msg.channel.parentId;
+            if (parentId) {
+                const loopState = this.loopManager.getState(parentId);
+                if (loopState && loopState.threadId === effectiveChannelId) {
+                    const username = msg.member?.displayName ?? msg.author.username;
+                    try {
+                        await routeToMetaAgent(loopState.namespace, stampPrompt(text, username, msg.createdAt), this.redis);
+                    }
+                    catch (err) {
+                        await msg.channel.send(`Failed to route: ${err.message}`).catch(() => { });
+                    }
+                    return;
+                }
+            }
+        }
         // Channel registered via createChannelForRepo or /channel — route directly to its meta-agent
         const mappedNs = this.channelNamespaceMap.get(effectiveChannelId);
         if (mappedNs && this.redis) {
+            // If a loop is already running for this channel, point the user to the thread
+            if (this.loopManager?.isActive(effectiveChannelId)) {
+                const loopState = this.loopManager.getState(effectiveChannelId);
+                await msg.channel.send(`Loop in progress → <#${loopState.threadId}>\nSend messages in the thread to interact with the running loop.`).catch(() => { });
+                return;
+            }
             this.writeChatMessage("user", "discord", text, effectiveChannelId, mappedNs.namespace);
             this.opts.registerRoutedChannelId?.(mappedNs.namespace, effectiveChannelId);
             this.persistChannelMapping(effectiveChannelId, mappedNs.namespace, mappedNs.repoUrl);
             this.startMetaAgentTyping(effectiveChannelId, msg.channel);
+            // Detect goal messages → create a thread for loop tracking
+            if (this.loopManager && msg.guild && !msg.channel.isThread()) {
+                if (isGoalMessage(text)) {
+                    await this.createLoopThread(msg, effectiveChannelId, mappedNs.namespace, text);
+                }
+            }
             const username = msg.member?.displayName ?? msg.author.username;
             try {
                 await routeToMetaAgent(mappedNs.namespace, stampPrompt(text, username, msg.createdAt), this.redis);
@@ -1008,6 +1044,121 @@ export class CcDiscordBot {
         }
         return undefined;
     }
+    /** Return the thread ID for an active loop on `channelId`, or undefined. */
+    getLoopThreadId(channelId) {
+        return this.loopManager?.getThreadId(channelId);
+    }
+    /**
+     * Post a structured eval-report embed to the loop thread for `channelId`.
+     * Also records gate failures in the LoopManager if the gate did not pass.
+     */
+    async postEvalEmbed(channelId, report) {
+        const threadId = this.loopManager?.getThreadId(channelId);
+        if (!threadId)
+            return;
+        const channel = await this.getChannel(threadId);
+        if (!channel)
+            return;
+        const color = report.passed ? 0x57F287 : 0xED4245; // green / red
+        const embed = new EmbedBuilder()
+            .setTitle(`${report.passed ? "✅" : "❌"} Gate: ${report.gate}`)
+            .setColor(color)
+            .addFields({ name: "Result", value: report.passed ? "PASSED" : "FAILED", inline: true }, { name: "Confidence", value: `${(report.confidence * 100).toFixed(0)}%`, inline: true }, { name: "Iteration", value: `${report.iteration} / ${report.maxIterations}`, inline: true }, { name: "Feedback", value: report.feedback || "(none)", inline: false })
+            .setTimestamp();
+        await channel.send({ embeds: [embed] }).catch((err) => {
+            console.warn(`[bot] postEvalEmbed send failed:`, err.message);
+        });
+        if (!report.passed && this.loopManager) {
+            await this.loopManager.addGateFailure(channelId, {
+                gate: report.gate,
+                feedback: report.feedback,
+                iteration: report.iteration,
+                confidence: report.confidence,
+                timestamp: new Date().toISOString(),
+            });
+        }
+    }
+    /**
+     * Create a Discord thread on `msg`, register loop state, and add reaction gates.
+     * Requires MANAGE_THREADS permission. Falls back silently on failure.
+     */
+    async createLoopThread(msg, channelId, namespace, goal) {
+        try {
+            const shortGoal = goal.slice(0, 48).replace(/\s+/g, " ");
+            const threadName = `Goal: ${shortGoal}${goal.length > 48 ? "…" : ""}`;
+            const thread = await msg.channel.threads.create({
+                name: threadName,
+                autoArchiveDuration: 10080, // 1 week
+                startMessage: msg,
+                reason: "Loop observability thread",
+            });
+            const firstMsg = await thread.send(`🎯 **Loop tracking thread**\n> ${goal.slice(0, 200)}\n\nReact to control the loop:\n` +
+                `🔄 Retry current iteration  ✅ Accept & exit  ❌ Kill loop`);
+            await firstMsg.react("🔄");
+            await firstMsg.react("✅");
+            await firstMsg.react("❌");
+            await this.loopManager.startLoop(channelId, thread.id, firstMsg.id, namespace, goal);
+            console.log(`[bot] loop thread created: channelId=${channelId} threadId=${thread.id}`);
+        }
+        catch (err) {
+            console.warn(`[bot] createLoopThread failed:`, err.message);
+        }
+    }
+    /** Handle 🔄/✅/❌ reactions on loop gate messages. */
+    async handleReactionAdd(reaction, user) {
+        if (user.bot)
+            return;
+        if (!this.isAllowed(user.id))
+            return;
+        if (!this.loopManager || !this.redis)
+            return;
+        // Fetch full reaction object if partial (bot doesn't have it cached)
+        let fullReaction = reaction;
+        if (reaction.partial) {
+            try {
+                fullReaction = await reaction.fetch();
+            }
+            catch {
+                return;
+            }
+        }
+        const emoji = fullReaction.emoji.name;
+        if (emoji !== "🔄" && emoji !== "✅" && emoji !== "❌")
+            return;
+        const messageId = fullReaction.message.id;
+        const channelId = this.loopManager.getChannelIdByReactionMessage(messageId);
+        if (!channelId)
+            return;
+        const loopState = this.loopManager.getState(channelId);
+        if (!loopState)
+            return;
+        const thread = await this.getChannel(loopState.threadId);
+        if (emoji === "🔄") {
+            if (thread) {
+                await thread.send(`🔄 Retry requested — re-running iteration ${loopState.iteration + 1}`).catch(() => { });
+            }
+            try {
+                await routeToMetaAgent(loopState.namespace, `Please retry the previous goal: ${loopState.goal}`, this.redis);
+            }
+            catch (err) {
+                console.warn(`[bot] retry routeToMetaAgent failed:`, err.message);
+            }
+        }
+        else if (emoji === "✅") {
+            if (thread) {
+                await thread.send("✅ Loop accepted — marking complete").catch(() => { });
+            }
+            await this.sendToChannelById(channelId, `✅ Goal completed: ${loopState.goal.slice(0, 100)}`);
+            await this.loopManager.endLoop(channelId);
+        }
+        else if (emoji === "❌") {
+            if (thread) {
+                await thread.send("❌ Loop killed by user").catch(() => { });
+            }
+            await this.sendToChannelById(channelId, `❌ Loop killed: ${loopState.goal.slice(0, 100)}`);
+            await this.loopManager.endLoop(channelId);
+        }
+    }
     /**
      * Feed a text message into the active Claude session for the given channel.
      * Called by the notifier when a UI message arrives via Redis pub/sub.

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.d.ts

@@ -11,6 +11,7 @@
  *   cca:discord:chat:outgoing:{ns}      — PUBLISH for web UI to consume
  */
 import { Redis } from "ioredis";
+import { type EvalReport } from "./loop-manager.js";
 import type { CcDiscordBot } from "./bot.js";
 export interface ChatMessage {
     id: string;
@@ -23,6 +24,8 @@ export interface ChatMessage {
 export interface ParsedNotification {
     text: string;
     chatId?: number;
+    /** Populated when the notification JSON contains an `eval_report` object. */
+    evalReport?: EvalReport;
 }
 /**
  * Parse a notification payload.

package/dist/notifier.js

@@ -12,6 +12,7 @@
  */
 import { discordChatLog, discordChatOutgoing, discordNotify, notifyChannel, chatIncomingChannel, createCcWire, TIMING, } from "@gonzih/cc-wire";
 import { splitLongMessage, stripAnsi } from "./formatter.js";
+import { parseEvalReport } from "./loop-manager.js";
 function log(level, ...args) {
     const fn = level === "error" ? console.error : level === "warn" ? console.warn : console.log;
     fn("[notifier]", ...args);
@@ -61,12 +62,14 @@ export function parseNotification(raw) {
     catch {
         return { text };
     }
+    // Parse eval_report if present — this field is non-standard and not in NotificationPayload type
+    const evalReport = parseEvalReport(raw);
     if (!driver)
-        return { text, chatId };
+        return { text, chatId, evalReport: evalReport ?? undefined };
     const shortModel = shortenModelName(model ?? "", driver);
     const badge = shortModel ? `${driver}:${shortModel}` : driver;
     const costStr = cost != null ? ` cost: $${cost.toFixed(3)}` : "";
-    return { text: `${text}\n[${badge}]${costStr}`, chatId };
+    return { text: `${text}\n[${badge}]${costStr}`, chatId, evalReport: evalReport ?? undefined };
 }
 /**
  * Write a message to the chat log in Redis.
@@ -204,9 +207,11 @@ export function startNotifier(bot, notifyChannelId, namespace, redis, handleUser
         const text = `← [${ns}] ` + stripAnsi(buf.text.trim());
         buf.text = "";
         buf.timer = null;
+        // During an active loop, route meta-agent output to the thread rather than main channel
+        const deliverTo = bot.getLoopThreadId(targetChannelId) ?? targetChannelId;
         const chunks = splitLongMessage(text);
         for (const chunk of chunks) {
-            bot.sendToChannelById(targetChannelId, chunk).catch((err) => {
+            bot.sendToChannelById(deliverTo, chunk).catch((err) => {
                 log("warn", `meta-agent flush sendToChannelById failed (ns=${ns}):`, err.message);
             });
         }
@@ -279,14 +284,22 @@ export function startNotifier(bot, notifyChannelId, namespace, redis, handleUser
             // Primary namespace: honour chatId-based per-channel routing via reverseSnowflakeLookup,
             // then namespace → channelId lookup, then notifyChannelId / active channel.
             // Routed namespaces: always deliver to the registered Discord channelId — no leakage.
-            const destChannelId = ns === namespace
+            const mainChannelId = ns === namespace
                 ? (resolveNotifyChannel(notification.chatId, notifyChannelId, getActiveChannelId, reverseSnowflakeLookup, ns, getChannelIdForNamespace) ?? targetChannelId)
                 : targetChannelId;
+            // If a loop is active for this channel, route to its thread
+            const destChannelId = bot.getLoopThreadId(mainChannelId) ?? mainChannelId;
+            // When an eval report is embedded, post a structured embed to the thread
+            if (notification.evalReport) {
+                bot.postEvalEmbed(mainChannelId, notification.evalReport).catch((err) => {
+                    log("warn", `postEvalEmbed failed (ns=${ns}):`, err.message);
+                });
+            }
             bot.sendToChannelById(destChannelId, notification.text).catch((err) => {
                 log("warn", `notify list send failed (ns=${ns}):`, err.message);
             });
             if (forwardNotification) {
-                forwardNotification(destChannelId, notification.text);
+                forwardNotification(mainChannelId, notification.text);
             }
         }
         if (remaining > 0) {
@@ -324,22 +337,29 @@ export function startNotifier(bot, notifyChannelId, namespace, redis, handleUser
             const notification = parseNotification(message);
             if (notification === null)
                 return; // routing excludes discord
-            let targetId;
+            let mainChannelId;
             if (isPrimary) {
-                targetId = resolveNotifyChannel(notification.chatId, notifyChannelId, getActiveChannelId, reverseSnowflakeLookup, ns, getChannelIdForNamespace);
+                mainChannelId = resolveNotifyChannel(notification.chatId, notifyChannelId, getActiveChannelId, reverseSnowflakeLookup, ns, getChannelIdForNamespace);
             }
             else {
                 // For routed namespaces, only use the registered channelId — no fallback to primary
-                targetId = notification.chatId != null && reverseSnowflakeLookup
+                mainChannelId = notification.chatId != null && reverseSnowflakeLookup
                     ? (reverseSnowflakeLookup(notification.chatId) ?? routedChannelIds.get(ns))
                     : routedChannelIds.get(ns);
             }
-            if (targetId != null) {
-                bot.sendToChannelById(targetId, notification.text).catch((err) => {
+            if (mainChannelId != null) {
+                // If a loop is active, route notification text to the thread
+                const deliverTo = bot.getLoopThreadId(mainChannelId) ?? mainChannelId;
+                if (notification.evalReport) {
+                    bot.postEvalEmbed(mainChannelId, notification.evalReport).catch((err) => {
+                        log("warn", `postEvalEmbed failed (ns=${ns}):`, err.message);
+                    });
+                }
+                bot.sendToChannelById(deliverTo, notification.text).catch((err) => {
                     log("warn", `notify send failed (ns=${ns}):`, err.message);
                 });
                 if (forwardNotification) {
-                    forwardNotification(targetId, notification.text);
+                    forwardNotification(mainChannelId, notification.text);
                 }
             }
             else {

package/package.json

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