@gonzih/cc-discord 0.2.4 → 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;
@@ -64,7 +66,6 @@ export declare class CcDiscordBot {
     private sendToChannel;
     /** Send to a channel by ID — used by notifier callbacks. */
     sendToChannelById(channelId: string, text: string): Promise<void>;
-    sendAttachmentToChannelById(channelId: string, filePath: string): Promise<void>;
     private isAllowed;
     private handleMessage;
     private handleVoice;
@@ -97,6 +98,22 @@ export declare class CcDiscordBot {
     private writeChatMessage;
     /** Returns the last channelId that sent a message. */
     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);
         });
@@ -294,15 +301,6 @@ export class CcDiscordBot {
         }
         await this.sendToChannel(channel, text);
     }
-    async sendAttachmentToChannelById(channelId, filePath) {
-        const channel = await this.getChannel(channelId);
-        if (!channel) {
-            console.warn(`[bot] sendAttachmentToChannelById: channel ${channelId} not found`);
-            return;
-        }
-        const attachment = new AttachmentBuilder(filePath, { name: basename(filePath) });
-        await channel.send({ files: [attachment] });
-    }
     isAllowed(userId) {
         if (!this.opts.allowedUserIds?.length)
             return true;
@@ -374,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);
@@ -1009,6 +1036,129 @@ export class CcDiscordBot {
     getLastActiveChannelId() {
         return this.lastActiveChannelId;
     }
+    /** Reverse lookup: find the Discord channelId registered for a given namespace. */
+    getChannelIdForNamespace(ns) {
+        for (const [channelId, mapping] of this.channelNamespaceMap) {
+            if (mapping.namespace === ns)
+                return channelId;
+        }
+        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.
@@ -1072,7 +1222,7 @@ export class CcDiscordBot {
     startMetaAgentPolling() {
         if (!this.wire)
             return;
-        this.metaAgentManager.startPolling(this.wire, () => Array.from(this.channelNamespaceMap.values()));
+        this.metaAgentManager.startPolling(this.wire, () => Array.from(this.channelNamespaceMap.values()).map((v) => v.namespace));
     }
     stop() {
         for (const [key, session] of this.sessions) {

package/dist/index.js

@@ -142,7 +142,7 @@ const bot = new CcDiscordBot({
     namespace,
     registerRoutedChannelId: (ns, channelId) => notifier.registerRoutedChannelId(ns, channelId),
 });
-const notifier = startNotifier(bot, notifyChannelId, namespace, sharedRedis, (channelId, text) => handleUserMessageFn?.(channelId, text), (channelId, text) => forwardNotificationFn?.(channelId, text), () => getLastActiveChannelIdFn(), (n) => bot.reverseSnowflakeLookup(n));
+const notifier = startNotifier(bot, notifyChannelId, namespace, sharedRedis, (channelId, text) => handleUserMessageFn?.(channelId, text), (channelId, text) => forwardNotificationFn?.(channelId, text), () => getLastActiveChannelIdFn(), (n) => bot.reverseSnowflakeLookup(n), (ns) => bot.getChannelIdForNamespace(ns));
 console.log(`[notifier] started for namespace=${namespace} notifyChannelId=${notifyChannelId ?? "dynamic"}`);
 // Restore persisted channel→namespace mappings so routing survives restarts
 bot.loadChannelMappings().catch((err) => {

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/meta-agent-manager.d.ts

@@ -36,14 +36,10 @@ export declare function injectMcp(ns: string, wsPath: string, token: string): vo
  * Returns a Promise that resolves when the process exits.
  */
 export declare function spawnSession(ns: string, message: string, token: string, wire: Wire): Promise<void>;
-export interface NamespaceEntry {
-    namespace: string;
-    repoUrl: string;
-}
 export interface MetaAgentManager {
     ensureWorkspace: (ns: string, repoUrl: string) => Promise<void>;
     injectMcp: (ns: string, token: string) => void;
-    startPolling: (wire: Wire, getNamespaceEntries: () => NamespaceEntry[]) => void;
+    startPolling: (wire: Wire, getNamespaces: () => string[]) => void;
     stop: () => void;
 }
 /**

package/dist/meta-agent-manager.js

@@ -8,7 +8,7 @@
  *   4. spawnSession: claude --continue -p "{message}" pipes stdout → wire.discord.publishOutgoing
  */
 import { spawn, execSync } from "child_process";
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { existsSync, mkdirSync, writeFileSync } from "fs";
 import { join } from "path";
 import { homedir } from "os";
 import { CC_DISCORD_WORKSPACE_ROOT, TIMING, discordMetaInputKey, } from "@gonzih/cc-wire";
@@ -59,55 +59,25 @@ export function injectMcp(ns, wsPath, token) {
     const npmCache = process.env.npm_config_cache ?? `${homedir()}/.npm`;
     const trustedOwners = process.env.CC_AGENT_TRUSTED_OWNERS ?? "";
     const systemPath = process.env.PATH ?? "/usr/local/bin:/usr/bin:/bin";
-    const servers = {
-        "cc-agent": {
-            command: "/opt/homebrew/bin/npx",
-            args: ["-y", "--prefer-online", "@gonzih/cc-agent"],
-            env: {
-                CC_AGENT_NAMESPACE: ns,
-                CWD: wsPath,
-                CLAUDE_CODE_OAUTH_TOKEN: token,
-                CLAUDE_TOKENS: token,
-                CC_AGENT_TRUSTED_OWNERS: trustedOwners,
-                PATH: systemPath,
-                npm_config_cache: npmCache,
+    const config = {
+        mcpServers: {
+            "cc-agent": {
+                command: "/opt/homebrew/bin/npx",
+                args: ["-y", "--prefer-online", "@gonzih/cc-agent"],
+                env: {
+                    CC_AGENT_NAMESPACE: ns,
+                    CWD: wsPath,
+                    CLAUDE_CODE_OAUTH_TOKEN: token,
+                    CLAUDE_TOKENS: token,
+                    CC_AGENT_TRUSTED_OWNERS: trustedOwners,
+                    PATH: systemPath,
+                    npm_config_cache: npmCache,
+                },
             },
         },
     };
-    // Merge extra MCP servers from ~/.config/cc-discord-mcp.json (credentials file, not in source)
-    const extraMcpPath = join(homedir(), ".config", "cc-discord-mcp.json");
-    if (existsSync(extraMcpPath)) {
-        try {
-            const extra = JSON.parse(readFileSync(extraMcpPath, "utf8"));
-            Object.assign(servers, extra);
-            console.log(`[meta-agent-manager] merged extra MCP servers from ${extraMcpPath}: ${Object.keys(extra).join(", ")}`);
-        }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            console.warn(`[meta-agent-manager] failed to read extra MCP config: ${msg}`);
-        }
-    }
-    // Also check env vars as fallback for gmail and github
-    const gmailEmail = process.env.GMAIL_EMAIL;
-    const gmailPass = process.env.GMAIL_APP_PASSWORD;
-    if (gmailEmail && gmailPass && !servers["gmail-personal"]) {
-        servers["gmail-personal"] = {
-            command: "/opt/homebrew/bin/npx",
-            args: ["-y", "gmail-mcp-imap"],
-            env: { GMAIL_EMAIL: gmailEmail, GMAIL_APP_PASSWORD: gmailPass, npm_config_cache: npmCache },
-        };
-    }
-    const ghToken = process.env.GITHUB_PERSONAL_ACCESS_TOKEN;
-    if (ghToken && !servers["github"]) {
-        servers["github"] = {
-            command: "docker",
-            args: ["run", "-i", "--rm", "-e", "GITHUB_PERSONAL_ACCESS_TOKEN", "ghcr.io/github/github-mcp-server"],
-            env: { GITHUB_PERSONAL_ACCESS_TOKEN: ghToken },
-        };
-    }
-    const config = { mcpServers: servers };
     writeFileSync(mcpPath, JSON.stringify(config, null, 2), "utf8");
-    console.log(`[meta-agent-manager] injected MCP config for namespace=${ns} (servers: ${Object.keys(servers).join(", ")})`);
+    console.log(`[meta-agent-manager] injected MCP config for namespace=${ns}`);
 }
 /**
  * Resolve claude binary — same logic as claude.ts resolveClaude.
@@ -213,14 +183,14 @@ export function createMetaAgentManager() {
             const wsPath = workspacePath(ns);
             injectMcp(ns, wsPath, token);
         },
-        startPolling(wire, getNamespaceEntries) {
+        startPolling(wire, getNamespaces) {
             if (pollInterval)
                 return; // already running
             pollInterval = setInterval(() => {
-                const entries = getNamespaceEntries();
-                if (entries.length === 0)
+                const namespaces = getNamespaces();
+                if (namespaces.length === 0)
                     return;
-                for (const { namespace: ns, repoUrl } of entries) {
+                for (const ns of namespaces) {
                     if (activeNamespaces.has(ns))
                         continue;
                     wire.discord.dequeue(ns)
@@ -258,24 +228,6 @@ export function createMetaAgentManager() {
                             });
                             return;
                         }
-                        // Ensure workspace exists before spawning — clone happens once, no-op on repeat.
-                        try {
-                            await ensureWorkspace(ns, repoUrl);
-                            injectMcp(ns, workspacePath(ns), token);
-                        }
-                        catch (wsErr) {
-                            const msg = wsErr instanceof Error ? wsErr.message : String(wsErr);
-                            console.error(`[meta-agent-manager] workspace setup failed (ns=${ns}):`, msg);
-                            activeNamespaces.delete(ns);
-                            await wire.discord.setStatus(ns, {
-                                namespace: ns,
-                                status: "idle",
-                                isTyping: false,
-                                turnCount: 0,
-                                updatedAt: new Date().toISOString(),
-                            }).catch(() => { });
-                            return;
-                        }
                         spawnSession(ns, content, token, wire)
                             .catch((err) => {
                             console.error(`[meta-agent-manager] session error (ns=${ns}):`, err.message);

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.
@@ -40,10 +43,13 @@ export declare function parseNotification(raw: string): ParsedNotification | nul
 export declare function writeChatLog(redis: Redis, namespace: string, msg: ChatMessage): void;
 /**
  * Resolve the target Discord channelId for a notification.
- * When chatId is set and a reverse-lookup function is available, prefer the originating channel.
- * Falls back to notifyChannelId, then getActiveChannelId.
+ * Priority:
+ *   1. chatId → reverseSnowflakeLookup (originating channel from the notification payload)
+ *   2. ns → getChannelIdForNamespace (registered Discord channel for this namespace)
+ *   3. notifyChannelId (static env var — may be stale/dead)
+ *   4. getActiveChannelId (last channel that sent a message)
  */
-export declare function resolveNotifyChannel(chatId: number | undefined, notifyChannelId: string | null, getActiveChannelId?: () => string | undefined, reverseSnowflakeLookup?: (n: number) => string | undefined): string | undefined;
+export declare function resolveNotifyChannel(chatId: number | undefined, notifyChannelId: string | null, getActiveChannelId?: () => string | undefined, reverseSnowflakeLookup?: (n: number) => string | undefined, ns?: string, getChannelIdForNamespace?: (ns: string) => string | undefined): string | undefined;
 export interface NotifierHandle {
     /**
      * Register the originating Discord channel ID for a routed namespace.
@@ -57,13 +63,14 @@ export interface NotifierHandle {
 /**
  * Start the Discord notifier.
  *
- * @param bot                     - CcDiscordBot instance (for sending messages)
- * @param notifyChannelId         - Discord channel ID to forward notifications to. Pass null to use getActiveChannelId.
- * @param namespace               - primary 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 forwardNotification     - Optional callback to forward job notifications
- * @param getActiveChannelId      - Optional callback to resolve channelId dynamically
- * @param reverseSnowflakeLookup  - Optional callback to resolve a chatId integer to a Discord channelId
+ * @param bot                       - CcDiscordBot instance (for sending messages)
+ * @param notifyChannelId           - Discord channel ID to forward notifications to. Pass null to use getActiveChannelId.
+ * @param namespace                 - primary 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 forwardNotification       - Optional callback to forward job notifications
+ * @param getActiveChannelId        - Optional callback to resolve channelId dynamically
+ * @param reverseSnowflakeLookup    - Optional callback to resolve a chatId integer to a Discord channelId
+ * @param getChannelIdForNamespace  - Optional callback to resolve a namespace to its registered Discord channelId
  */
-export declare function startNotifier(bot: CcDiscordBot, notifyChannelId: string | null, namespace: string, redis: Redis, handleUserMessage?: (channelId: string, text: string) => void, forwardNotification?: (channelId: string, text: string) => void, getActiveChannelId?: () => string | undefined, reverseSnowflakeLookup?: (n: number) => string | undefined): NotifierHandle;
+export declare function startNotifier(bot: CcDiscordBot, notifyChannelId: string | null, namespace: string, redis: Redis, handleUserMessage?: (channelId: string, text: string) => void, forwardNotification?: (channelId: string, text: string) => void, getActiveChannelId?: () => string | undefined, reverseSnowflakeLookup?: (n: number) => string | undefined, getChannelIdForNamespace?: (ns: string) => string | undefined): NotifierHandle;

package/dist/notifier.js

@@ -11,22 +11,8 @@
  *   cca:discord:chat:outgoing:{ns}      — PUBLISH for web UI to consume
  */
 import { discordChatLog, discordChatOutgoing, discordNotify, notifyChannel, chatIncomingChannel, createCcWire, TIMING, } from "@gonzih/cc-wire";
-import { existsSync, statSync } from "fs";
 import { splitLongMessage, stripAnsi } from "./formatter.js";
-const SAFE_DIRS = ["/tmp/", "/var/folders/"];
-const MAX_DISCORD_BYTES = 25 * 1024 * 1024; // 25 MB Discord file limit
-/** Extract /tmp/ or /var/folders/ file paths mentioned in text that actually exist on disk. */
-function extractAttachablePaths(text) {
-    const pattern = /(?:^|[\s`'"(])(\/(?:tmp|var\/folders)\/[\w.\-/]+\.[\w]{1,10})(?:[\s`'")\n]|$)/gm;
-    const quoted = /"(\/(?:tmp|var\/folders)\/[^"]+\.[a-zA-Z0-9]{1,10})"|'(\/(?:tmp|var\/folders)\/[^']+\.[a-zA-Z0-9]{1,10})'/g;
-    const candidates = new Set();
-    let m;
-    while ((m = pattern.exec(text)) !== null)
-        candidates.add(m[1]);
-    while ((m = quoted.exec(text)) !== null)
-        candidates.add(m[1] ?? m[2]);
-    return [...candidates].filter(p => SAFE_DIRS.some(d => p.startsWith(d)) && existsSync(p));
-}
+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);
@@ -76,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.
@@ -104,30 +92,39 @@ export function writeChatLog(redis, namespace, msg) {
 }
 /**
  * Resolve the target Discord channelId for a notification.
- * When chatId is set and a reverse-lookup function is available, prefer the originating channel.
- * Falls back to notifyChannelId, then getActiveChannelId.
+ * Priority:
+ *   1. chatId → reverseSnowflakeLookup (originating channel from the notification payload)
+ *   2. ns → getChannelIdForNamespace (registered Discord channel for this namespace)
+ *   3. notifyChannelId (static env var — may be stale/dead)
+ *   4. getActiveChannelId (last channel that sent a message)
  */
-export function resolveNotifyChannel(chatId, notifyChannelId, getActiveChannelId, reverseSnowflakeLookup) {
+export function resolveNotifyChannel(chatId, notifyChannelId, getActiveChannelId, reverseSnowflakeLookup, ns, getChannelIdForNamespace) {
     if (chatId != null && reverseSnowflakeLookup) {
         const resolved = reverseSnowflakeLookup(chatId);
         if (resolved)
             return resolved;
     }
+    if (ns && getChannelIdForNamespace) {
+        const resolved = getChannelIdForNamespace(ns);
+        if (resolved)
+            return resolved;
+    }
     return notifyChannelId ?? getActiveChannelId?.();
 }
 /**
  * Start the Discord notifier.
  *
- * @param bot                     - CcDiscordBot instance (for sending messages)
- * @param notifyChannelId         - Discord channel ID to forward notifications to. Pass null to use getActiveChannelId.
- * @param namespace               - primary 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 forwardNotification     - Optional callback to forward job notifications
- * @param getActiveChannelId      - Optional callback to resolve channelId dynamically
- * @param reverseSnowflakeLookup  - Optional callback to resolve a chatId integer to a Discord channelId
+ * @param bot                       - CcDiscordBot instance (for sending messages)
+ * @param notifyChannelId           - Discord channel ID to forward notifications to. Pass null to use getActiveChannelId.
+ * @param namespace                 - primary 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 forwardNotification       - Optional callback to forward job notifications
+ * @param getActiveChannelId        - Optional callback to resolve channelId dynamically
+ * @param reverseSnowflakeLookup    - Optional callback to resolve a chatId integer to a Discord channelId
+ * @param getChannelIdForNamespace  - Optional callback to resolve a namespace to its registered Discord channelId
  */
-export function startNotifier(bot, notifyChannelId, namespace, redis, handleUserMessage, forwardNotification, getActiveChannelId, reverseSnowflakeLookup) {
+export function startNotifier(bot, notifyChannelId, namespace, redis, handleUserMessage, forwardNotification, getActiveChannelId, reverseSnowflakeLookup, getChannelIdForNamespace) {
     const wire = createCcWire(redis);
     // Per-namespace channelId registry — maps routed namespace → Discord channelId
     const routedChannelIds = new Map();
@@ -152,8 +149,8 @@ export function startNotifier(bot, notifyChannelId, namespace, redis, handleUser
         if (subscribedNamespaces.has(ns))
             return;
         subscribedNamespaces.add(ns);
-        const notifyCh = discordNotify(ns); // cca:discord:notify:{ns} — new cc-wire path
-        const legacyNotifyCh = notifyChannel(ns); // cca:notify:{ns} — cc-agent still publishes here
+        const notifyCh = discordNotify(ns);
+        const legacyNotifyCh = notifyChannel(ns);
         const incomingCh = chatIncomingChannel(ns);
         channelToNamespace.set(notifyCh, ns);
         channelToNamespace.set(legacyNotifyCh, ns);
@@ -166,13 +163,12 @@ export function startNotifier(bot, notifyChannelId, namespace, redis, handleUser
                 log("info", `subscribed to ${notifyCh}`);
             }
         });
-        // Also subscribe to legacy cc-agent notification channel
         sub.subscribe(legacyNotifyCh, (err) => {
             if (err) {
                 log("error", `subscribe ${legacyNotifyCh} failed:`, err.message);
             }
             else {
-                log("info", `subscribed to ${legacyNotifyCh} (legacy cc-agent)`);
+                log("info", `subscribed to ${legacyNotifyCh}`);
             }
         });
         sub.subscribe(incomingCh, (err) => {
@@ -208,35 +204,17 @@ export function startNotifier(bot, notifyChannelId, namespace, redis, handleUser
         const buf = metaAgentBuffers.get(ns);
         if (!buf || !buf.text.trim())
             return;
-        const rawText = stripAnsi(buf.text.trim());
-        const text = `← [${ns}] ` + rawText;
+        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);
             });
         }
-        // Attach any /tmp/ files mentioned in the response
-        const paths = extractAttachablePaths(rawText);
-        for (const filePath of paths) {
-            let size;
-            try {
-                size = statSync(filePath).size;
-            }
-            catch {
-                continue;
-            }
-            if (size > MAX_DISCORD_BYTES) {
-                bot.sendToChannelById(targetChannelId, `File too large for Discord (${(size / 1024 / 1024).toFixed(1)} MB): ${filePath}`).catch(() => { });
-                continue;
-            }
-            log("info", `attaching file to Discord (ns=${ns}): ${filePath}`);
-            bot.sendAttachmentToChannelById(targetChannelId, filePath).catch((err) => {
-                log("warn", `attachment send failed (ns=${ns}, path=${filePath}):`, err.message);
-            });
-        }
     }
     sub.on("pmessage", (pattern, channel, message) => {
         void pattern;
@@ -303,16 +281,25 @@ export function startNotifier(bot, notifyChannelId, namespace, redis, handleUser
             const notification = parseNotification(raw);
             if (notification === null)
                 continue; // routing excludes discord
-            // Primary namespace: honour chatId-based per-channel routing via reverseSnowflakeLookup.
+            // 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
-                ? (resolveNotifyChannel(notification.chatId, notifyChannelId, getActiveChannelId, reverseSnowflakeLookup) ?? targetChannelId)
+            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) {
@@ -322,8 +309,8 @@ export function startNotifier(bot, notifyChannelId, namespace, redis, handleUser
         }
     };
     const pollNotifyList = async () => {
-        // Primary namespace
-        const primaryTargetId = notifyChannelId ?? getActiveChannelId?.();
+        // Primary namespace: prefer registered channel for this namespace, then env var, then active channel
+        const primaryTargetId = getChannelIdForNamespace?.(namespace) ?? notifyChannelId ?? getActiveChannelId?.();
         if (primaryTargetId != null) {
             await pollOneNamespace(namespace, primaryTargetId);
         }
@@ -344,27 +331,35 @@ export function startNotifier(bot, notifyChannelId, namespace, redis, handleUser
             return;
         const isPrimary = ns === namespace;
         const notifyCh = discordNotify(ns);
+        const legacyNotifyCh = notifyChannel(ns);
         const incomingCh = chatIncomingChannel(ns);
-        if (channel === notifyCh) {
+        if (channel === notifyCh || channel === legacyNotifyCh) {
             const notification = parseNotification(message);
             if (notification === null)
                 return; // routing excludes discord
-            let targetId;
+            let mainChannelId;
             if (isPrimary) {
-                targetId = resolveNotifyChannel(notification.chatId, notifyChannelId, getActiveChannelId, reverseSnowflakeLookup);
+                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.4",
+  "version": "0.2.6",
   "description": "Claude Code Discord bot — chat with Claude Code via Discord",
   "type": "module",
   "bin": {