@gonzih/cc-discord 0.2.39 → 0.2.41

package/dist/bot.d.ts

@@ -2,6 +2,7 @@
  * Discord bot that routes messages to/from a Claude Code subprocess.
  * One ClaudeProcess per channel (or channel:thread) — sessions are isolated per channel.
  */
+import { Message } from "discord.js";
 import { Redis } from "ioredis";
 /** Returns true if the attachment name/contentType indicates an audio file. */
 export declare function isAudioAttachment(name: string, contentType: string): boolean;
@@ -56,10 +57,30 @@ export declare class CcDiscordBot {
     loadChannelMappings(): Promise<void>;
     /** Typing intervals for meta-agent routed channels — keyed by channelId. */
     private metaAgentTypingTimers;
+    /** Live Discord messages per channel — edited in-place as Claude streams output. */
+    private liveMessages;
     /** Start (or reset) the typing indicator for a meta-agent–routed channel. */
     private startMetaAgentTyping;
     /** Stop the typing indicator for a meta-agent–routed channel. Called by the notifier on flush. */
     stopMetaAgentTyping(channelId: string): void;
+    /**
+     * Get or create a live Discord message for `channelId`.
+     * If a live message already exists (e.g. from a tool_start), returns it (for reuse).
+     * Otherwise sends `initial` to create the placeholder and stops the typing indicator.
+     */
+    startOrGetLiveMessage(channelId: string, initial: string): Promise<Message | null>;
+    /**
+     * Throttled edit of the live message for `channelId`.
+     * Safe to call on every token/chunk — edits are coalesced at 750ms intervals.
+     * The latest `text` always wins (older pending updates are replaced).
+     */
+    updateLiveMessage(channelId: string, text: string): void;
+    /**
+     * Final edit of the live message — applies `text` without cursor, clears tracker.
+     * If no live message exists, falls back to sendWithFileDetection (new message).
+     * Overflow past 2000 chars spawns continuation messages via sendToChannelById.
+     */
+    finalizeLiveMessage(channelId: string, text: string): Promise<void>;
     /** Session key: "channelId" or "channelId:threadId" for threads */
     private sessionKey;
     /** Get the channel/thread for sending messages */

package/dist/bot.js

@@ -231,6 +231,8 @@ export class CcDiscordBot {
     }
     /** Typing intervals for meta-agent routed channels — keyed by channelId. */
     metaAgentTypingTimers = new Map();
+    /** Live Discord messages per channel — edited in-place as Claude streams output. */
+    liveMessages = new Map();
     /** Start (or reset) the typing indicator for a meta-agent–routed channel. */
     startMetaAgentTyping(channelId, channel) {
         this.stopMetaAgentTyping(channelId);
@@ -245,6 +247,96 @@ export class CcDiscordBot {
             this.metaAgentTypingTimers.delete(channelId);
         }
     }
+    /**
+     * Get or create a live Discord message for `channelId`.
+     * If a live message already exists (e.g. from a tool_start), returns it (for reuse).
+     * Otherwise sends `initial` to create the placeholder and stops the typing indicator.
+     */
+    async startOrGetLiveMessage(channelId, initial) {
+        const existing = this.liveMessages.get(channelId);
+        if (existing)
+            return existing.msg;
+        const channel = await this.getChannel(channelId);
+        if (!channel)
+            return null;
+        this.stopMetaAgentTyping(channelId);
+        try {
+            const msg = await channel.send(initial || "▋");
+            this.liveMessages.set(channelId, { msg, lastEditAt: Date.now(), editTimer: null, pendingText: null });
+            return msg;
+        }
+        catch (err) {
+            console.warn(`[bot] startOrGetLiveMessage failed (${channelId}):`, err.message);
+            return null;
+        }
+    }
+    /**
+     * Throttled edit of the live message for `channelId`.
+     * Safe to call on every token/chunk — edits are coalesced at 750ms intervals.
+     * The latest `text` always wins (older pending updates are replaced).
+     */
+    updateLiveMessage(channelId, text) {
+        const entry = this.liveMessages.get(channelId);
+        if (!entry)
+            return;
+        entry.pendingText = text;
+        if (entry.editTimer)
+            return; // timer already scheduled; will pick up pendingText when it fires
+        const msUntilSafe = Math.max(0, 750 - (Date.now() - entry.lastEditAt));
+        entry.editTimer = setTimeout(async () => {
+            entry.editTimer = null;
+            const t = entry.pendingText;
+            if (t == null)
+                return;
+            entry.pendingText = null;
+            try {
+                await entry.msg.edit(t.slice(0, 1990));
+                entry.lastEditAt = Date.now();
+            }
+            catch {
+                this.liveMessages.delete(channelId); // message deleted or perms lost — give up
+            }
+        }, msUntilSafe);
+    }
+    /**
+     * Final edit of the live message — applies `text` without cursor, clears tracker.
+     * If no live message exists, falls back to sendWithFileDetection (new message).
+     * Overflow past 2000 chars spawns continuation messages via sendToChannelById.
+     */
+    async finalizeLiveMessage(channelId, text) {
+        const entry = this.liveMessages.get(channelId);
+        if (entry?.editTimer) {
+            clearTimeout(entry.editTimer);
+            entry.editTimer = null;
+        }
+        this.liveMessages.delete(channelId);
+        if (!entry) {
+            if (text.trim())
+                await this.sendWithFileDetection(channelId, text);
+            return;
+        }
+        if (!text.trim()) {
+            // Nothing to show — delete the placeholder message
+            entry.msg.delete().catch(() => { });
+            return;
+        }
+        const formatted = formatForDiscord(text);
+        const chunks = splitLongMessage(formatted);
+        try {
+            await entry.msg.edit(chunks[0]);
+            for (const chunk of chunks.slice(1)) {
+                if (chunk.trim())
+                    await this.sendToChannelById(channelId, chunk);
+            }
+        }
+        catch {
+            // Message was deleted or edit failed — send as new messages
+            for (const chunk of chunks) {
+                if (chunk.trim())
+                    await this.sendWithFileDetection(channelId, chunk).catch(() => { });
+            }
+        }
+    }
     /** Session key: "channelId" or "channelId:threadId" for threads */
     sessionKey(channelId, threadId) {
         return threadId ? `${channelId}:${threadId}` : channelId;

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

@@ -65,21 +65,6 @@ export interface MetaAgentManager {
     /** Write a raw line to the stdin of the running session, if any. */
     sendToSession: (ns: string, line: string) => void;
 }
-/**
- * Create a MetaAgentManager that maintains one persistent Claude process per namespace.
- *
- * On first message for a namespace:
- *   1. ensureWorkspace + injectMcp
- *   2. Drain any pending Redis queue entries to stdin
- *   3. Write the new message to stdin
- *
- * On subsequent messages: write directly to stdin of the running process.
- *
- * On process exit: remove from sessions map. Next message triggers a respawn.
- *
- * The 3-second poll loop drains any messages that arrived while a session was
- * starting up or temporarily unavailable.
- */
 export declare function createMetaAgentManager(): MetaAgentManager;
 /**
  * Migrate the old cc-agent meta input key to the new cc-discord key.

package/dist/meta-agent-manager.js

@@ -16,7 +16,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, DISCORD_INSTANCE_KEY, discordMetaInputKey, metaStreamChannel as ccWireMetaStreamChannel, metaLogKey as ccWireMetaLogKey, } from "@gonzih/cc-wire";
+import { CC_DISCORD_WORKSPACE_ROOT, TIMING, DISCORD_INSTANCE_KEY, discordMetaInputKey, discordChatOutgoing, 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.
@@ -193,17 +193,28 @@ function wireStdoutToRedis(proc, ns, wire) {
                 }
             }
             else if (type === "tool_use") {
+                const toolName = parsed.name ?? "tool";
                 structuredEvent = {
                     type: "tool_use",
-                    name: parsed.name ?? "",
+                    name: toolName,
                     input: parsed.input ?? {},
                 };
+                // Ephemeral signal: notifier shows tool activity overlay in the live message
+                rawRedis.publish(discordChatOutgoing(ns), JSON.stringify({
+                    id: crypto.randomUUID(), source: "claude", role: "assistant",
+                    content: toolName, event: "tool_start", timestamp: new Date().toISOString(), chatId: 0,
+                })).catch(() => { });
             }
             else if (type === "tool_result") {
                 structuredEvent = {
                     type: "tool_result",
                     content: parsed.content ?? "",
                 };
+                // Ephemeral signal: tool finished, notifier can restart finalize timer
+                rawRedis.publish(discordChatOutgoing(ns), JSON.stringify({
+                    id: crypto.randomUUID(), source: "claude", role: "assistant",
+                    content: "", event: "tool_end", timestamp: new Date().toISOString(), chatId: 0,
+                })).catch(() => { });
             }
             else if (type === "result") {
                 const resultText = typeof parsed.result === "string" ? parsed.result : JSON.stringify(parsed.result ?? "");
@@ -212,7 +223,7 @@ function wireStdoutToRedis(proc, ns, wire) {
                     result: resultText,
                     is_error: parsed.is_error ?? false,
                 };
-                if (resultText) {
+                if (resultText && !parsed.is_error) {
                     const msg = {
                         id: crypto.randomUUID(),
                         source: "claude",
@@ -221,10 +232,44 @@ function wireStdoutToRedis(proc, ns, wire) {
                         timestamp: new Date().toISOString(),
                         chatId: 0,
                     };
-                    wire.discord.publishOutgoing(ns, msg).catch((err) => {
+                    // Publish text first (logs to chat history), then signal done for immediate finalization
+                    wire.discord.publishOutgoing(ns, msg).then(() => {
+                        rawRedis.publish(discordChatOutgoing(ns), JSON.stringify({
+                            id: crypto.randomUUID(), source: "claude", role: "assistant",
+                            content: "", event: "done", timestamp: new Date().toISOString(), chatId: 0,
+                        })).catch(() => { });
+                    }).catch((err) => {
                         console.warn(`[meta-agent-manager] publishOutgoing (result) failed (ns=${ns}):`, err.message);
+                        // Still signal done even if text publish failed
+                        rawRedis.publish(discordChatOutgoing(ns), JSON.stringify({
+                            id: crypto.randomUUID(), source: "claude", role: "assistant",
+                            content: "", event: "done", timestamp: new Date().toISOString(), chatId: 0,
+                        })).catch(() => { });
                     });
                 }
+                else if (parsed.is_error) {
+                    // Error result: publish error text and signal done
+                    const errMsg = {
+                        id: crypto.randomUUID(),
+                        source: "claude",
+                        role: "assistant",
+                        content: `⚠️ Error: ${resultText || "unknown error"}`,
+                        timestamp: new Date().toISOString(),
+                        chatId: 0,
+                    };
+                    wire.discord.publishOutgoing(ns, errMsg).catch(() => { });
+                    rawRedis.publish(discordChatOutgoing(ns), JSON.stringify({
+                        id: crypto.randomUUID(), source: "claude", role: "assistant",
+                        content: "", event: "done", timestamp: new Date().toISOString(), chatId: 0,
+                    })).catch(() => { });
+                }
+                else {
+                    // Empty result — just signal done
+                    rawRedis.publish(discordChatOutgoing(ns), JSON.stringify({
+                        id: crypto.randomUUID(), source: "claude", role: "assistant",
+                        content: "", event: "done", timestamp: new Date().toISOString(), chatId: 0,
+                    })).catch(() => { });
+                }
             }
             else {
                 structuredEvent = parsed;
@@ -293,7 +338,7 @@ export function spawnSession(ns, message, token, wire) {
  * Stdout is wired to Redis via wireStdoutToRedis.
  * Returns the ChildProcess.
  */
-function spawnPersistentSession(ns, token, wire, onExit) {
+function spawnPersistentSession(ns, token, wire, onExit, onOutput) {
     const wsPath = workspacePath(ns);
     const claudeBin = resolveClaude();
     const env = buildEnv(token);
@@ -312,6 +357,9 @@ function spawnPersistentSession(ns, token, wire, onExit) {
     ], { cwd: wsPath, env, stdio: ["pipe", "pipe", "pipe"] });
     proc.stdin.setDefaultEncoding("utf8");
     wireStdoutToRedis(proc, ns, wire);
+    if (onOutput) {
+        proc.stdout.on("data", onOutput);
+    }
     proc.on("exit", (code) => {
         console.log(`[meta-agent-manager] persistent session exited (ns=${ns}, code=${code})`);
         onExit();
@@ -337,15 +385,22 @@ function spawnPersistentSession(ns, token, wire, onExit) {
  * The 3-second poll loop drains any messages that arrived while a session was
  * starting up or temporarily unavailable.
  */
+/** Kill a session after this many ms of no stdout (or no new stdin). */
+const SESSION_INACTIVITY_MS = 5 * 60_000; // 5 minutes
 export function createMetaAgentManager() {
     let pollInterval = null;
+    let watchdogInterval = null;
     /** One persistent ChildProcess per namespace. */
     const sessions = new Map();
     /** Namespaces currently being set up (workspace clone / first spawn). */
     const startingUp = new Set();
+    /** Wire reference needed for watchdog notifications. Set in startPolling. */
+    let wireRef = null;
     /**
      * Write a line to the stdin of the persistent session for ns.
      * Silently no-ops if no session exists.
+     * Resets the inactivity timer so the watchdog doesn't kill a session
+     * that just received a message but hasn't responded yet.
      */
     function writeToStdin(ns, line) {
         const session = sessions.get(ns);
@@ -354,11 +409,54 @@ export function createMetaAgentManager() {
         try {
             // Interactive mode: plain text line, Claude reads it as user input
             session.proc.stdin.write(`${line}\n`);
+            // Reset inactivity timer — the session now has SESSION_INACTIVITY_MS to respond
+            session.lastOutputAt = Date.now();
         }
         catch (err) {
             console.warn(`[meta-agent-manager] stdin write failed (ns=${ns}):`, err.message);
         }
     }
+    /**
+     * Watchdog: scan all sessions every 60s. If any session has been silent
+     * (no stdout and no new stdin) for SESSION_INACTIVITY_MS, kill it and
+     * notify Discord so the user can see why the session went quiet.
+     */
+    function startWatchdog() {
+        if (watchdogInterval)
+            return;
+        watchdogInterval = setInterval(() => {
+            if (!wireRef)
+                return;
+            const now = Date.now();
+            for (const [ns, session] of sessions) {
+                const idleMs = now - session.lastOutputAt;
+                if (idleMs < SESSION_INACTIVITY_MS)
+                    continue;
+                const idleMin = Math.round(idleMs / 60_000);
+                console.warn(`[meta-agent-manager] watchdog: ns=${ns} idle ${idleMin}m, killing stuck session`);
+                // Notify Discord before killing so the user knows what happened
+                const alertMsg = {
+                    id: crypto.randomUUID(),
+                    source: "claude",
+                    role: "assistant",
+                    content: `⚠️ Session for **${ns}** was idle for ${idleMin} minutes (likely stuck on a tool call). Killed and removed — send any message to restart.`,
+                    timestamp: new Date().toISOString(),
+                    chatId: 0,
+                };
+                wireRef.discord.publishOutgoing(ns, alertMsg).catch((err) => {
+                    console.warn(`[meta-agent-manager] watchdog publishOutgoing failed (ns=${ns}):`, err.message);
+                });
+                try {
+                    session.proc.stdin.end();
+                    session.proc.kill("SIGTERM");
+                }
+                catch {
+                    // ignore kill errors
+                }
+                sessions.delete(ns);
+            }
+        }, 60_000);
+    }
     /**
      * Drain all pending messages from the Redis input queue into the session's stdin.
      */
@@ -405,12 +503,19 @@ export function createMetaAgentManager() {
             const wsPath = workspacePath(ns);
             await ensureWorkspace(ns, repoUrl);
             injectMcp(ns, wsPath, token);
+            // Placeholder — filled in after proc is known so the onOutput closure can update it
+            let session;
             const proc = spawnPersistentSession(ns, token, wire, () => {
                 // On exit: remove from map so next message triggers a respawn
                 sessions.delete(ns);
                 console.log(`[meta-agent-manager] session removed from map (ns=${ns})`);
+            }, () => {
+                // Reset inactivity timer on any stdout data
+                if (session)
+                    session.lastOutputAt = Date.now();
             });
-            sessions.set(ns, { proc, ns });
+            session = { proc, ns, lastOutputAt: Date.now() };
+            sessions.set(ns, session);
             // Drain any messages that arrived before this session started
             await drainQueue(ns, wire);
             // Write the triggering message last (after queue drain, in order)
@@ -443,6 +548,8 @@ export function createMetaAgentManager() {
         startPolling(wire, getNamespaces, instanceId) {
             if (pollInterval)
                 return; // already running
+            wireRef = wire;
+            startWatchdog();
             pollInterval = setInterval(() => {
                 const namespaces = getNamespaces();
                 if (namespaces.length === 0)
@@ -499,6 +606,10 @@ export function createMetaAgentManager() {
                 pollInterval = null;
                 console.log("[meta-agent-manager] polling stopped");
             }
+            if (watchdogInterval) {
+                clearInterval(watchdogInterval);
+                watchdogInterval = null;
+            }
             // Kill all active sessions
             for (const [ns, session] of sessions) {
                 try {

package/dist/notifier.js

@@ -12,7 +12,7 @@
  */
 import { createHash } from "crypto";
 import { discordChatLog, discordChatOutgoing, discordNotify, notifyChannel, chatIncomingChannel, createCcWire, TIMING, dedupKey, } from "@gonzih/cc-wire";
-import { splitLongMessage, stripAnsi } from "./formatter.js";
+import { stripAnsi } from "./formatter.js";
 /**
  * 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.
@@ -270,30 +270,37 @@ export function startNotifier(bot, notifyChannelId, namespace, redis, handleUser
             log("info", `psubscribed to ${outgoingPattern}`);
         }
     });
-    // Buffer for meta-agent streaming output — debounced before sending to Discord
-    const metaAgentBuffers = new Map();
-    function flushMetaAgentBuffer(ns, targetChannelId) {
-        const loopThreadId = bot.getLoopThreadId(targetChannelId);
-        bot.stopMetaAgentTyping(loopThreadId ?? targetChannelId);
-        const buf = metaAgentBuffers.get(ns);
-        if (!buf || !buf.text.trim())
-            return;
-        const text = `← [${ns}] ` + stripAnsi(buf.text.trim());
-        if (text.length < 30) {
-            buf.text = "";
-            buf.timer = null;
-            return;
+    const liveStates = new Map();
+    function getLiveState(ns, targetChannelId) {
+        let state = liveStates.get(ns);
+        if (!state) {
+            state = { text: "", toolStatus: "", targetChannelId, starting: false, liveStarted: false, finalTimer: null };
+            liveStates.set(ns, state);
         }
-        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.sendWithFileDetection(deliverTo, chunk).catch((err) => {
-                log("warn", `meta-agent flush sendWithFileDetection failed (ns=${ns}):`, err.message);
-            });
+        return state;
+    }
+    async function finalizeState(ns, state) {
+        if (state.finalTimer) {
+            clearTimeout(state.finalTimer);
+            state.finalTimer = null;
         }
+        liveStates.delete(ns);
+        const deliverTo = bot.getLoopThreadId(state.targetChannelId) ?? state.targetChannelId;
+        bot.stopMetaAgentTyping(deliverTo);
+        const trimmed = state.text.trim();
+        if (!trimmed && !state.liveStarted)
+            return;
+        const fullText = trimmed ? `← [${ns}]\n${stripAnsi(trimmed)}` : "";
+        await bot.finalizeLiveMessage(deliverTo, fullText);
+    }
+    function scheduleFinal(ns, state) {
+        if (state.finalTimer)
+            clearTimeout(state.finalTimer);
+        state.finalTimer = setTimeout(() => {
+            finalizeState(ns, state).catch((err) => {
+                log("warn", `meta-agent finalize failed (ns=${ns}):`, err.message);
+            });
+        }, TIMING.META_AGENT_FLUSH_DELAY_MS);
     }
     sub.on("pmessage", (pattern, channel, message) => {
         void pattern;
@@ -305,28 +312,78 @@ export function startNotifier(bot, notifyChannelId, namespace, redis, handleUser
         catch {
             return;
         }
-        if (parsed.source !== "claude")
+        if (parsed?.source !== "claude")
             return;
-        const content = parsed.content;
-        if (!content)
-            return;
-        // For the primary namespace: deliver to the primary Discord channel.
-        // For other (routed) namespaces: only deliver to explicitly registered channelIds.
         const targetChannelId = routedChannelIds.get(ns) ??
             (ns === namespace ? (notifyChannelId ?? getActiveChannelId?.()) : undefined);
         if (targetChannelId == null) {
-            log("warn", `meta-agent output: no channelId for namespace=${ns}, dropping line`);
+            log("warn", `meta-agent output: no channelId for namespace=${ns}, dropping`);
             return;
         }
-        let buf = metaAgentBuffers.get(ns);
-        if (!buf) {
-            buf = { text: "", timer: null };
-            metaAgentBuffers.set(ns, buf);
+        const deliverTo = bot.getLoopThreadId(targetChannelId) ?? targetChannelId;
+        const state = getLiveState(ns, targetChannelId);
+        const event = parsed.event;
+        // tool_start: show activity overlay, suspend finalize timer
+        if (event === "tool_start") {
+            const toolName = parsed.content || "tool";
+            state.toolStatus = toolName;
+            if (state.finalTimer) {
+                clearTimeout(state.finalTimer);
+                state.finalTimer = null;
+            }
+            if (state.liveStarted) {
+                const textPart = state.text.trim() ? `← [${ns}]\n${stripAnsi(state.text.trim())}\n\n` : "";
+                bot.updateLiveMessage(deliverTo, `${textPart}⚙️ \`${toolName}\`...`);
+            }
+            else if (!state.starting) {
+                state.starting = true;
+                bot.startOrGetLiveMessage(deliverTo, `⚙️ \`${toolName}\`...`).then((msg) => {
+                    state.starting = false;
+                    if (msg)
+                        state.liveStarted = true;
+                }).catch(() => { state.starting = false; });
+            }
+            return;
+        }
+        // tool_end: clear overlay, resume finalize timer if text is pending
+        if (event === "tool_end") {
+            state.toolStatus = "";
+            if (state.text.trim())
+                scheduleFinal(ns, state);
+            return;
+        }
+        // done: immediate finalization (fired by meta-agent-manager after result event)
+        if (event === "done") {
+            finalizeState(ns, state).catch((err) => {
+                log("warn", `meta-agent done finalize failed (ns=${ns}):`, err.message);
+            });
+            return;
+        }
+        // Regular text chunk: accumulate, update live message
+        const content = parsed.content;
+        if (!content)
+            return;
+        state.toolStatus = ""; // text arrived — clear any tool overlay
+        state.text += (state.text ? "\n" : "") + content;
+        const textDisplay = `← [${ns}]\n${stripAnsi(state.text)} ▋`;
+        if (!state.liveStarted) {
+            if (!state.starting) {
+                state.starting = true;
+                // startOrGetLiveMessage reuses existing message if tool_start created one
+                bot.startOrGetLiveMessage(deliverTo, textDisplay).then((msg) => {
+                    state.starting = false;
+                    if (msg) {
+                        state.liveStarted = true;
+                        bot.updateLiveMessage(deliverTo, textDisplay);
+                    }
+                }).catch(() => { state.starting = false; });
+            }
+            // Text is buffered in state.text; applied when startOrGetLiveMessage resolves
+        }
+        else {
+            bot.updateLiveMessage(deliverTo, textDisplay);
         }
-        buf.text += (buf.text ? "\n" : "") + content;
-        if (buf.timer)
-            clearTimeout(buf.timer);
-        buf.timer = setTimeout(() => flushMetaAgentBuffer(ns, targetChannelId), TIMING.META_AGENT_FLUSH_DELAY_MS);
+        scheduleFinal(ns, state);
     });
     // Poll discordNotify(ns) LIST every 5 seconds — covers primary + all routed namespaces.
     const MAX_PER_CYCLE = 20;

package/package.json

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