@gonzih/cc-discord 0.2.21 → 0.2.23

package/dist/bot.d.ts

@@ -3,7 +3,6 @@
  * 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. */
@@ -40,7 +39,6 @@ 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;
@@ -69,6 +67,12 @@ export declare class CcDiscordBot {
     private sendToChannel;
     /** Send to a channel by ID — used by notifier callbacks. */
     sendToChannelById(channelId: string, text: string): Promise<void>;
+    /**
+     * After sending a Discord message on behalf of a cron, look up the pending cron ID
+     * for the channel's namespace and store cca:discord:cron-message:{messageId} = cronId.
+     * This lets the ❌/🛑 reaction handler disable the cron that fired this message.
+     */
+    private storeCronMessageMapping;
     /**
      * Send text to a channel by ID, scanning for absolute file paths and attaching them.
      * Used exclusively for Claude coordinator output (meta-agent flush).
@@ -115,18 +119,13 @@ export declare class CcDiscordBot {
     /** 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>;
+    getLoopThreadId(_channelId: string): string | undefined;
+    /** No-op stub kept for notifier compatibility — loop threads removed. */
+    postEvalEmbed(_channelId: string, _report: unknown): Promise<void>;
     /**
-     * Create a Discord thread on `msg`, register loop state, and add reaction gates.
-     * Requires MANAGE_THREADS permission. Falls back silently on failure.
+     * Handle ❌/🛑 reactions on cron-fired messages to disable the cron.
+     * Also no-ops the old loop gate reactions (🔄/✅) gracefully.
      */
-    private createLoopThread;
-    /** Handle 🔄/✅/❌ reactions on loop gate messages. */
     private handleReactionAdd;
     /**
      * Feed a text message into the active Claude session for the given channel.

package/dist/bot.js

@@ -14,9 +14,8 @@ 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 { CronEngine } from "./cron-engine.js";
+import { CronEngine, cronPendingKey, CRON_MESSAGE_TTL } from "./cron-engine.js";
 import { parseChannelCreateIntent, routeToMetaAgent } from "./router.js";
 import { createMetaAgentManager } from "./meta-agent-manager.js";
 /** Convert a Discord snowflake string to a safe 53-bit integer for CronManager compatibility. */
@@ -126,14 +125,12 @@ 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.cronEngine = new CronEngine(opts.redis);
         }
         this.metaAgentManager = createMetaAgentManager();
@@ -305,6 +302,26 @@ export class CcDiscordBot {
         }
         await this.sendToChannel(channel, text);
     }
+    /**
+     * After sending a Discord message on behalf of a cron, look up the pending cron ID
+     * for the channel's namespace and store cca:discord:cron-message:{messageId} = cronId.
+     * This lets the ❌/🛑 reaction handler disable the cron that fired this message.
+     */
+    async storeCronMessageMapping(messageId, channelId) {
+        if (!this.redis)
+            return;
+        const ns = this.resolveNamespaceForChannel(channelId);
+        try {
+            const cronId = await this.redis.get(cronPendingKey(ns));
+            if (!cronId)
+                return;
+            await this.redis.set(`cca:discord:cron-message:${messageId}`, cronId, "EX", CRON_MESSAGE_TTL);
+            console.log(`[bot] linked message ${messageId} → cron ${cronId} (ns=${ns})`);
+        }
+        catch (err) {
+            console.warn(`[bot] storeCronMessageMapping failed (ns=${ns}):`, err.message);
+        }
+    }
     /**
      * Send text to a channel by ID, scanning for absolute file paths and attaching them.
      * Used exclusively for Claude coordinator output (meta-agent flush).
@@ -346,15 +363,19 @@ export class CcDiscordBot {
             // Send first chunk with file attachments, remaining chunks as plain text
             const files = validPaths.map((p) => ({ attachment: p, name: basename(p) }));
             try {
-                await channel.send({ content: chunks[0] || undefined, files });
+                const sent = await channel.send({ content: chunks[0] || undefined, files });
+                void this.storeCronMessageMapping(sent.id, channelId);
             }
             catch (err) {
                 console.warn(`[bot] sendWithFileDetection attach failed:`, err.message);
                 // Fall back to plain text for the first chunk
                 if (chunks[0]?.trim()) {
-                    await channel.send(chunks[0]).catch((e) => {
+                    const sent = await channel.send(chunks[0]).catch((e) => {
                         console.error("[bot] sendWithFileDetection fallback failed:", e.message);
+                        return null;
                     });
+                    if (sent)
+                        void this.storeCronMessageMapping(sent.id, channelId);
                 }
             }
             for (const chunk of chunks.slice(1)) {
@@ -440,43 +461,13 @@ 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;
-                    this.startMetaAgentTyping(effectiveChannelId, msg.channel);
-                    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);
@@ -1243,74 +1234,26 @@ export class CcDiscordBot {
         return undefined;
     }
     /** Return the thread ID for an active loop on `channelId`, or undefined. */
-    getLoopThreadId(channelId) {
-        return this.loopManager?.getThreadId(channelId);
+    getLoopThreadId(_channelId) {
+        // Loop-as-threads removed — cron engine is the loop mechanism.
+        return 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.
-     */
-    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(),
-            });
-        }
+    /** No-op stub kept for notifier compatibility — loop threads removed. */
+    async postEvalEmbed(_channelId, _report) {
+        return;
     }
     /**
-     * Create a Discord thread on `msg`, register loop state, and add reaction gates.
-     * Requires MANAGE_THREADS permission. Falls back silently on failure.
+     * Handle ❌/🛑 reactions on cron-fired messages to disable the cron.
+     * Also no-ops the old loop gate reactions (🔄/✅) gracefully.
      */
-    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)
+        if (!this.redis || !this.cronEngine)
             return;
-        // Fetch full reaction object if partial (bot doesn't have it cached)
+        // Fetch full reaction object if partial
         let fullReaction = reaction;
         if (reaction.partial) {
             try {
@@ -1321,46 +1264,20 @@ export class CcDiscordBot {
             }
         }
         const emoji = fullReaction.emoji.name;
-        if (emoji !== "🔄" && emoji !== "✅" && emoji !== "❌")
+        if (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)
+        // Look up which cron fired this message
+        const cronId = await this.redis.get(`cca:discord:cron-message:${messageId}`).catch(() => null);
+        if (!cronId)
             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);
-            if (thread && thread.isThread()) {
-                await thread.setArchived(true).catch(() => { });
-            }
+        // Disable the cron by setting enabled="false" in its hash
+        try {
+            await this.redis.hset(`cca:discord:cron:${cronId}`, "enabled", "0");
+            console.log(`[bot] cron ${cronId} disabled via ${emoji} reaction on message ${messageId}`);
         }
-        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);
-            if (thread && thread.isThread()) {
-                await thread.setArchived(true).catch(() => { });
-            }
+        catch (err) {
+            console.warn(`[bot] failed to disable cron ${cronId}:`, err.message);
         }
     }
     /**

package/dist/cron-engine.d.ts

@@ -17,6 +17,18 @@
  *   5. Update last_fired_at
  */
 import type { Redis } from "ioredis";
+/**
+ * Temporary key written by the cron engine when it fires a cron.
+ * Value is the cronId that fired. TTL 300s.
+ * The bot reads this after sending a Discord message to link the message to the cron.
+ */
+export declare const cronPendingKey: (ns: string) => string;
+/**
+ * Key that maps a sent Discord messageId → cronId.
+ * Used by the reaction handler to look up which cron to disable.
+ * TTL 86400s (24h).
+ */
+export declare const CRON_MESSAGE_TTL = 86400;
 export interface CronRecord {
     id: string;
     namespace: string;

package/dist/cron-engine.js

@@ -18,10 +18,21 @@
  */
 import { randomUUID } from "crypto";
 import { schedule, validate } from "node-cron";
+import { cronListKey, cronHashKey, discordMetaInputKey as metaInputKey, } from "@gonzih/cc-wire";
 // ─── Redis key helpers ────────────────────────────────────────────────────────
-const CRON_LIST_KEY = "cca:discord:cron:list";
-const cronHashKey = (id) => `cca:discord:cron:${id}`;
-const metaInputKey = (ns) => `cca:discord:meta:${ns}:input`;
+const CRON_LIST_KEY = cronListKey();
+/**
+ * Temporary key written by the cron engine when it fires a cron.
+ * Value is the cronId that fired. TTL 300s.
+ * The bot reads this after sending a Discord message to link the message to the cron.
+ */
+export const cronPendingKey = (ns) => `cca:discord:cron-pending:${ns}`;
+/**
+ * Key that maps a sent Discord messageId → cronId.
+ * Used by the reaction handler to look up which cron to disable.
+ * TTL 86400s (24h).
+ */
+export const CRON_MESSAGE_TTL = 86400;
 // ─── CronEngine ──────────────────────────────────────────────────────────────
 export class CronEngine {
     redis;
@@ -230,6 +241,9 @@ export class CronEngine {
             await this.redis.rpush(inputKey, entry);
             rec.last_fired_at = new Date().toISOString();
             console.log(`[cron-engine] fire: pushed message (id=${id} ns=${ns} fire_count=${rec.fire_count})`);
+            // Record which cron fired for this namespace — the bot reads this after
+            // sending the Discord message to store the cca:discord:cron-message:{msgId} mapping.
+            await this.redis.set(cronPendingKey(ns), id, "EX", 300);
         }
         catch (err) {
             console.warn(`[cron-engine] fire: push failed (id=${id}):`, err.message);

package/dist/index.js

@@ -22,7 +22,7 @@
 import { createRequire } from "node:module";
 import { randomUUID } from "crypto";
 import { Redis } from "ioredis";
-import { createCcWire } from "@gonzih/cc-wire";
+import { createCcWire, DISCORD_INSTANCE_KEY } from "@gonzih/cc-wire";
 import { CcDiscordBot } from "./bot.js";
 import { startNotifier } from "./notifier.js";
 import { loadTokens } from "./tokens.js";
@@ -80,7 +80,6 @@ sharedRedis.on("error", (err) => {
 const wire = createCcWire(sharedRedis);
 // Singleton instance ID — used to detect stale processes after a restart
 const instanceId = randomUUID();
-const INSTANCE_KEY = "cca:discord:instance";
 const INSTANCE_TTL_MS = 30_000;
 const INSTANCE_REFRESH_MS = 10_000;
 sharedRedis.once("ready", () => {
@@ -90,13 +89,13 @@ sharedRedis.once("ready", () => {
     });
     console.log(`[cc-discord] version:reported ${version}`);
     // Write singleton instance ID with 30s TTL
-    sharedRedis.set(INSTANCE_KEY, instanceId, "PX", INSTANCE_TTL_MS).catch((err) => {
+    sharedRedis.set(DISCORD_INSTANCE_KEY, instanceId, "PX", INSTANCE_TTL_MS).catch((err) => {
         console.warn("[cc-discord] failed to write instance ID:", err.message);
     });
     console.log(`[cc-discord] instance:${instanceId}`);
     // Refresh TTL every 10s so launchd-respawned processes displace old ones
     setInterval(() => {
-        sharedRedis.set(INSTANCE_KEY, instanceId, "PX", INSTANCE_TTL_MS).catch((err) => {
+        sharedRedis.set(DISCORD_INSTANCE_KEY, instanceId, "PX", INSTANCE_TTL_MS).catch((err) => {
             console.warn("[cc-discord] instance refresh failed:", err.message);
         });
     }, INSTANCE_REFRESH_MS);

package/dist/meta-agent-manager.d.ts

@@ -34,9 +34,10 @@ export declare function injectMcp(ns: string, wsPath: string, token: string): vo
  * Redis keys for meta-agent stdout streaming.
  * cca:meta:{ns}:stream — pub/sub channel (live streaming)
  * cca:meta:{ns}:log    — list (history, capped at 2000)
+ * Re-exported from cc-wire for backwards-compat with callers in this package.
  */
-export declare function metaStreamChannel(ns: string): string;
-export declare function metaLogKey(ns: string): string;
+export declare const metaStreamChannel: (ns: string) => string;
+export declare const metaLogKey: (ns: string) => string;
 /**
  * Spawn `claude --continue -p "{message}" --dangerously-skip-permissions` in the
  * namespace workspace. Pipes stdout line-by-line → wire.discord.publishOutgoing.

package/dist/meta-agent-manager.js

@@ -11,7 +11,7 @@ import { spawn, execSync } from "child_process";
 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";
+import { CC_DISCORD_WORKSPACE_ROOT, TIMING, DISCORD_INSTANCE_KEY, discordMetaInputKey, metaStreamChannel as ccWireMetaStreamChannel, metaLogKey as ccWireMetaLogKey, } from "@gonzih/cc-wire";
 const WORKSPACE_ROOT = join(homedir(), CC_DISCORD_WORKSPACE_ROOT);
 /**
  * Returns the path to the workspace for the given namespace.
@@ -120,13 +120,10 @@ function resolveClaude() {
  * Redis keys for meta-agent stdout streaming.
  * cca:meta:{ns}:stream — pub/sub channel (live streaming)
  * cca:meta:{ns}:log    — list (history, capped at 2000)
+ * Re-exported from cc-wire for backwards-compat with callers in this package.
  */
-export function metaStreamChannel(ns) {
-    return `cca:meta:${ns}:stream`;
-}
-export function metaLogKey(ns) {
-    return `cca:meta:${ns}:log`;
-}
+export const metaStreamChannel = ccWireMetaStreamChannel;
+export const metaLogKey = ccWireMetaLogKey;
 /**
  * Spawn `claude --continue -p "{message}" --dangerously-skip-permissions` in the
  * namespace workspace. Pipes stdout line-by-line → wire.discord.publishOutgoing.
@@ -149,52 +146,113 @@ export function spawnSession(ns, message, token, wire) {
         const proc = spawn(claudeBin, [
             "--continue",
             "-p", message,
-            "--output-format", "text",
+            "--output-format", "stream-json",
             "--verbose",
             "--dangerously-skip-permissions",
         ], { cwd: wsPath, env, stdio: ["ignore", "pipe", "pipe"] });
         let lineBuffer = "";
-        const publishLine = (line) => {
-            const trimmed = line.trim();
-            if (!trimmed)
-                return;
-            const msg = {
-                id: crypto.randomUUID(),
-                source: "claude",
-                role: "assistant",
-                content: trimmed,
-                timestamp: new Date().toISOString(),
-                chatId: 0,
-            };
-            wire.discord.publishOutgoing(ns, msg).catch((err) => {
-                console.warn(`[meta-agent-manager] publishOutgoing failed (ns=${ns}):`, err.message);
-            });
-        };
+        /**
+         * Parse a JSONL line from claude's stream-json stdout into a structured event.
+         * For lines that fail JSON.parse, emit { type: "text", text: line }.
+         * Forward each event as a JSON string to Redis:
+         *   PUBLISH cca:meta:{ns}:stream
+         *   LPUSH   cca:meta:{ns}:log  (capped at 2000)
+         */
         const rawRedis = wire._redis;
-        const streamToRedis = (chunk) => {
-            const entry = JSON.stringify({ ts: Date.now(), ns, text: chunk });
-            const streamCh = metaStreamChannel(ns);
-            const logKey = metaLogKey(ns);
-            // Publish for live consumers (fire-and-forget)
-            rawRedis.publish(streamCh, entry).catch((err) => {
+        const streamCh = metaStreamChannel(ns);
+        const logKey = metaLogKey(ns);
+        const forwardEventToRedis = (eventJson) => {
+            rawRedis.publish(streamCh, eventJson).catch((err) => {
                 console.warn(`[meta-agent-manager] stream publish failed (ns=${ns}):`, err.message);
             });
-            // Persist to log list, cap at 2000
-            rawRedis.lpush(logKey, entry).then(() => {
+            rawRedis.lpush(logKey, eventJson).then(() => {
                 rawRedis.ltrim(logKey, 0, 1999).catch(() => { });
             }).catch((err) => {
                 console.warn(`[meta-agent-manager] log lpush failed (ns=${ns}):`, err.message);
             });
         };
+        const processLine = (line) => {
+            const trimmed = line.trim();
+            if (!trimmed)
+                return;
+            let structuredEvent;
+            try {
+                const parsed = JSON.parse(trimmed);
+                // Map claude stream-json event shapes to our canonical structured event format
+                const type = parsed.type;
+                if (type === "assistant") {
+                    // Extract text from content blocks
+                    const content = parsed.message;
+                    const textBlock = content?.content?.find((b) => b.type === "text");
+                    const text = textBlock?.text ?? "";
+                    structuredEvent = { type: "assistant", text };
+                    // Also publish to Discord outgoing channel
+                    if (text) {
+                        const msg = {
+                            id: crypto.randomUUID(),
+                            source: "claude",
+                            role: "assistant",
+                            content: text,
+                            timestamp: new Date().toISOString(),
+                            chatId: 0,
+                        };
+                        wire.discord.publishOutgoing(ns, msg).catch((err) => {
+                            console.warn(`[meta-agent-manager] publishOutgoing failed (ns=${ns}):`, err.message);
+                        });
+                    }
+                }
+                else if (type === "tool_use") {
+                    structuredEvent = {
+                        type: "tool_use",
+                        name: parsed.name ?? "",
+                        input: parsed.input ?? {},
+                    };
+                }
+                else if (type === "tool_result") {
+                    structuredEvent = {
+                        type: "tool_result",
+                        content: parsed.content ?? "",
+                    };
+                }
+                else if (type === "result") {
+                    const resultText = typeof parsed.result === "string" ? parsed.result : JSON.stringify(parsed.result ?? "");
+                    structuredEvent = {
+                        type: "result",
+                        result: resultText,
+                        is_error: parsed.is_error ?? false,
+                    };
+                    // Publish result text to Discord as final assistant message
+                    if (resultText) {
+                        const msg = {
+                            id: crypto.randomUUID(),
+                            source: "claude",
+                            role: "assistant",
+                            content: resultText,
+                            timestamp: new Date().toISOString(),
+                            chatId: 0,
+                        };
+                        wire.discord.publishOutgoing(ns, msg).catch((err) => {
+                            console.warn(`[meta-agent-manager] publishOutgoing (result) failed (ns=${ns}):`, err.message);
+                        });
+                    }
+                }
+                else {
+                    // Forward other event types as-is
+                    structuredEvent = parsed;
+                }
+            }
+            catch {
+                // Non-JSON line — wrap as text event
+                structuredEvent = { type: "text", text: trimmed };
+            }
+            forwardEventToRedis(JSON.stringify(structuredEvent));
+        };
         proc.stdout.on("data", (chunk) => {
-            const chunkStr = chunk.toString();
-            // Stream raw chunk to Redis (before line-splitting)
-            streamToRedis(chunkStr);
-            lineBuffer += chunkStr;
+            lineBuffer += chunk.toString();
             const lines = lineBuffer.split("\n");
             lineBuffer = lines.pop() ?? "";
             for (const line of lines) {
-                publishLine(line);
+                processLine(line);
             }
         });
         proc.stderr.on("data", (chunk) => {
@@ -205,7 +263,7 @@ export function spawnSession(ns, message, token, wire) {
         proc.on("exit", (code) => {
             // Flush any remaining buffered content
             if (lineBuffer.trim())
-                publishLine(lineBuffer);
+                processLine(lineBuffer);
             lineBuffer = "";
             console.log(`[meta-agent-manager] session exited (ns=${ns}, code=${code})`);
             resolve();
@@ -233,7 +291,6 @@ export function createMetaAgentManager() {
         startPolling(wire, getNamespaces, instanceId) {
             if (pollInterval)
                 return; // already running
-            const INSTANCE_KEY = "cca:discord:instance";
             pollInterval = setInterval(() => {
                 const namespaces = getNamespaces();
                 if (namespaces.length === 0)
@@ -248,7 +305,7 @@ export function createMetaAgentManager() {
                         // Staleness check: if a newer instance has registered, this process is stale — exit.
                         if (instanceId) {
                             try {
-                                const current = await wire._redis.get(INSTANCE_KEY);
+                                const current = await wire._redis.get(DISCORD_INSTANCE_KEY);
                                 if (current && current !== instanceId) {
                                     console.log(`[meta-agent-manager] stale instance detected (current=${current}, ours=${instanceId}) — exiting`);
                                     process.exit(0);

package/dist/notifier.d.ts

@@ -11,7 +11,15 @@
  *   cca:discord:chat:outgoing:{ns}      — PUBLISH for web UI to consume
  */
 import { Redis } from "ioredis";
-import { type EvalReport } from "./loop-manager.js";
+/** Eval report from a meta-agent notification. */
+export interface EvalReport {
+    gate: string;
+    passed: boolean;
+    feedback: string;
+    iteration: number;
+    maxIterations: number;
+    confidence: number;
+}
 import type { CcDiscordBot } from "./bot.js";
 export interface ChatMessage {
     id: string;

package/dist/notifier.js

@@ -11,12 +11,30 @@
  *   cca:discord:chat:outgoing:{ns}      — PUBLISH for web UI to consume
  */
 import { createHash } from "crypto";
-import { discordChatLog, discordChatOutgoing, discordNotify, notifyChannel, chatIncomingChannel, createCcWire, TIMING, } from "@gonzih/cc-wire";
+import { discordChatLog, discordChatOutgoing, discordNotify, notifyChannel, chatIncomingChannel, createCcWire, TIMING, dedupKey, } from "@gonzih/cc-wire";
 import { splitLongMessage, stripAnsi } from "./formatter.js";
-import { parseEvalReport } from "./loop-manager.js";
-/** Redis key for per-namespace notification dedup set */
-function dedupKey(ns) {
-    return `cca:discord:sent:${ns}`;
+/**
+ * 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.
+ */
+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;
+    }
 }
 /** Compute a short stable dedup fingerprint for a raw notification string */
 function notifFingerprint(raw) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gonzih/cc-discord",
-  "version": "0.2.21",
+  "version": "0.2.23",
   "description": "Claude Code Discord bot — chat with Claude Code via Discord",
   "type": "module",
   "bin": {
@@ -19,7 +19,7 @@
     "dist/"
   ],
   "dependencies": {
-    "@gonzih/cc-wire": "^0.3.0",
+    "@gonzih/cc-wire": "^0.4.0",
     "@types/node-cron": "^3.0.11",
     "discord.js": "^14.0.0",
     "ioredis": "^5.0.0",

package/dist/loop-manager.d.ts

@@ -1,66 +0,0 @@
-/**
- * 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

@@ -1,118 +0,0 @@
-/**
- * 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);
-    }
-}