@gonzih/cc-discord 0.2.48 → 0.2.49

package/dist/bot.d.ts

@@ -59,6 +59,16 @@ export declare class CcDiscordBot {
     private metaAgentTypingTimers;
     /** Live Discord messages per channel — edited in-place as Claude streams output. */
     private liveMessages;
+    private liveEditQueue;
+    private liveEditTimer;
+    private nextLiveEditAt;
+    private liveEditBackoffMs;
+    private liveMessageKey;
+    private liveEditFailureDelayMs;
+    private editLiveMessageWithPacing;
+    private enqueueLiveEdit;
+    private scheduleLiveEditDrain;
+    private drainOneLiveEdit;
     /** 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. */
@@ -68,19 +78,19 @@ export declare class CcDiscordBot {
      * 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>;
+    startOrGetLiveMessage(channelId: string, initial: string, slot?: 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).
+     * Safe to call on every token/chunk — edits are coalesced behind one global
+     * paced queue. The latest `text` always wins for each live message.
      */
-    updateLiveMessage(channelId: string, text: string): void;
+    updateLiveMessage(channelId: string, text: string, slot?: 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>;
+    finalizeLiveMessage(channelId: string, text: string, slot?: string): Promise<void>;
     /** Session key: "channelId" or "channelId:threadId" for threads */
     private sessionKey;
     /** Get the channel/thread for sending messages */
@@ -128,11 +138,10 @@ export declare class CcDiscordBot {
      * Namespace is derived from the channel's registered namespace.
      */
     private handleLoopEngineCommand;
-    /**
-     * Call a cc-agent MCP tool via a dedicated ClaudeProcess.
-     * Returns the tool result as a string, or null on failure.
-     */
-    callCcAgentTool(toolName: string, args?: Record<string, unknown>): Promise<string | null>;
+    private atcEnv;
+    private integrationStatus;
+    private getWikiContent;
+    private handleAtcCommand;
     private runCronTask;
     /**
      * Create a new Discord text channel for `namespace`, register it in channelNamespaceMap,
@@ -161,7 +170,7 @@ export declare class CcDiscordBot {
      */
     handleUserMessage(channelId: string, text: string): Promise<void>;
     /**
-     * Forward a cc-agent job notification into an existing Claude session.
+     * Forward an ATC/job notification into an existing Claude session.
      * Unlike handleUserMessage, this never creates a new session.
      */
     forwardNotification(channelId: string, text: string): void;

package/dist/bot.js

@@ -8,6 +8,7 @@ import { resolve, basename, join } from "path";
 import { homedir } from "os";
 import https from "https";
 import http from "http";
+import { execFile } from "child_process";
 import { createCcWire } from "@gonzih/cc-wire";
 import { ClaudeProcess, extractText } from "./claude.js";
 import { transcribeVoice, isVoiceAvailable } from "./voice.js";
@@ -18,7 +19,7 @@ import { CronManager } from "./cron.js";
 import { CronEngine, cronPendingKey, CRON_MESSAGE_TTL } from "./cron-engine.js";
 import { LoopEngine, parseIntervalMs } from "./loop-engine.js";
 import { parseChannelCreateIntent, routeToMetaAgent } from "./router.js";
-import { createMetaAgentManager } from "./meta-agent-manager.js";
+import { createMetaAgentManager, workspacePath } from "./meta-agent-manager.js";
 /** Convert a Discord snowflake string to a safe 53-bit integer for CronManager compatibility. */
 function snowflakeToInt(id) {
     // Discord snowflakes are up to 2^63, beyond Number.MAX_SAFE_INTEGER.
@@ -32,12 +33,132 @@ const PRICING = {
     cacheReadPerM: 0.30,
     cacheWritePerM: 3.75,
 };
+function envPositiveNumber(name, fallback) {
+    const raw = process.env[name];
+    if (!raw)
+        return fallback;
+    const parsed = Number(raw);
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+const LIVE_EDIT_MAX_PER_MINUTE = envPositiveNumber("CC_DISCORD_LIVE_EDIT_MAX_PER_MINUTE", 80);
+const LIVE_EDIT_SAFETY_FACTOR = Math.min(0.95, Math.max(0.5, envPositiveNumber("CC_DISCORD_LIVE_EDIT_SAFETY_FACTOR", 0.8)));
+const LIVE_EDIT_MIN_INTERVAL_MS = Math.max(750, Math.ceil(60_000 / Math.max(1, LIVE_EDIT_MAX_PER_MINUTE * LIVE_EDIT_SAFETY_FACTOR)));
+const LIVE_EDIT_INITIAL_BACKOFF_MS = envPositiveNumber("CC_DISCORD_LIVE_EDIT_INITIAL_BACKOFF_MS", 1_500);
+const LIVE_EDIT_MAX_BACKOFF_MS = envPositiveNumber("CC_DISCORD_LIVE_EDIT_MAX_BACKOFF_MS", 60_000);
+function discordRetryAfterMs(err) {
+    const record = err;
+    const candidates = [
+        record.retryAfter,
+        record.retry_after,
+        record.rawError?.retry_after,
+        record.response?.headers?.get?.("retry-after"),
+    ];
+    for (const candidate of candidates) {
+        const value = typeof candidate === "string" ? Number(candidate) : candidate;
+        if (typeof value === "number" && Number.isFinite(value) && value > 0) {
+            return value < 1_000 ? Math.ceil(value * 1_000) : Math.ceil(value);
+        }
+    }
+    return null;
+}
+function sleepMs(ms) {
+    return new Promise((resolvePromise) => setTimeout(resolvePromise, ms));
+}
 function computeCostUsd(usage) {
     return (usage.inputTokens * PRICING.inputPerM / 1_000_000 +
         usage.outputTokens * PRICING.outputPerM / 1_000_000 +
         usage.cacheReadTokens * PRICING.cacheReadPerM / 1_000_000 +
         usage.cacheWriteTokens * PRICING.cacheWritePerM / 1_000_000);
 }
+function resolveAtcBin() {
+    if (process.env.ATC_BIN)
+        return process.env.ATC_BIN;
+    const dirs = (process.env.PATH ?? "").split(":").filter(Boolean);
+    for (const dir of dirs) {
+        const candidate = join(dir, "atc");
+        if (existsSync(candidate))
+            return candidate;
+    }
+    const fallbacks = [
+        `${homedir()}/.cargo/bin/atc`,
+        "/opt/homebrew/bin/atc",
+        "/usr/local/bin/atc",
+        "/usr/bin/atc",
+    ];
+    for (const candidate of fallbacks) {
+        if (existsSync(candidate))
+            return candidate;
+    }
+    return "atc";
+}
+function resolveGitKbBin() {
+    if (process.env.GITKB_BIN)
+        return process.env.GITKB_BIN;
+    const dirs = (process.env.PATH ?? "").split(":").filter(Boolean);
+    for (const dir of dirs) {
+        const candidate = join(dir, "git-kb");
+        if (existsSync(candidate))
+            return candidate;
+    }
+    return "/opt/homebrew/bin/git-kb";
+}
+function execText(command, args, opts) {
+    return new Promise((resolvePromise, reject) => {
+        execFile(command, args, {
+            cwd: opts.cwd,
+            env: opts.env ?? process.env,
+            timeout: opts.timeoutMs ?? 20_000,
+            maxBuffer: 512 * 1024,
+        }, (err, stdout, stderr) => {
+            if (err) {
+                const detail = stderr.toString().trim() || err.message;
+                reject(new Error(detail));
+                return;
+            }
+            resolvePromise(stdout.toString().trim());
+        });
+    });
+}
+function splitCliArgs(input) {
+    const args = [];
+    let current = "";
+    let quote = null;
+    let escaped = false;
+    for (const ch of input.trim()) {
+        if (escaped) {
+            current += ch;
+            escaped = false;
+            continue;
+        }
+        if (ch === "\\" && quote !== "'") {
+            escaped = true;
+            continue;
+        }
+        if ((ch === "'" || ch === "\"") && !quote) {
+            quote = ch;
+            continue;
+        }
+        if (quote === ch) {
+            quote = null;
+            continue;
+        }
+        if (/\s/.test(ch) && !quote) {
+            if (current) {
+                args.push(current);
+                current = "";
+            }
+            continue;
+        }
+        current += ch;
+    }
+    if (quote)
+        throw new Error("Unclosed quote in ATC args");
+    if (escaped)
+        current += "\\";
+    if (current)
+        args.push(current);
+    return args;
+}
 // Debounces streaming chunks. Resets on each chunk. Fires 800ms after last chunk.
 const FLUSH_DELAY_MS = 800;
 // Discord typing indicator: re-send every 9s (indicator expires after ~10s)
@@ -233,6 +354,73 @@ export class CcDiscordBot {
     metaAgentTypingTimers = new Map();
     /** Live Discord messages per channel — edited in-place as Claude streams output. */
     liveMessages = new Map();
+    liveEditQueue = new Map();
+    liveEditTimer = null;
+    nextLiveEditAt = 0;
+    liveEditBackoffMs = 0;
+    liveMessageKey(channelId, slot = "response") {
+        return `${channelId}:${slot}`;
+    }
+    liveEditFailureDelayMs(err) {
+        const retryAfter = discordRetryAfterMs(err);
+        const backoff = retryAfter ?? (this.liveEditBackoffMs > 0
+            ? Math.min(this.liveEditBackoffMs * 2, LIVE_EDIT_MAX_BACKOFF_MS)
+            : LIVE_EDIT_INITIAL_BACKOFF_MS);
+        const jitter = Math.floor(backoff * 0.1 * Math.random());
+        this.liveEditBackoffMs = Math.min(backoff, LIVE_EDIT_MAX_BACKOFF_MS);
+        return this.liveEditBackoffMs + jitter;
+    }
+    async editLiveMessageWithPacing(channelId, msg, text, maxAttempts = 3) {
+        for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+            const delay = Math.max(0, this.nextLiveEditAt - Date.now());
+            if (delay > 0)
+                await sleepMs(delay);
+            try {
+                await msg.edit(text);
+                this.liveEditBackoffMs = 0;
+                this.nextLiveEditAt = Date.now() + LIVE_EDIT_MIN_INTERVAL_MS;
+                return;
+            }
+            catch (err) {
+                const retryDelay = this.liveEditFailureDelayMs(err);
+                this.nextLiveEditAt = Date.now() + retryDelay;
+                console.warn(`[bot] live message edit failed (${channelId}); retrying in ${retryDelay}ms:`, err.message);
+                if (attempt === maxAttempts)
+                    throw err;
+            }
+        }
+    }
+    enqueueLiveEdit(channelId, msg, text) {
+        this.liveEditQueue.set(channelId, { msg, text: text.slice(0, 1990) });
+        this.scheduleLiveEditDrain();
+    }
+    scheduleLiveEditDrain() {
+        if (this.liveEditTimer || this.liveEditQueue.size === 0)
+            return;
+        const delay = Math.max(0, this.nextLiveEditAt - Date.now());
+        this.liveEditTimer = setTimeout(() => {
+            this.liveEditTimer = null;
+            void this.drainOneLiveEdit();
+        }, delay);
+    }
+    async drainOneLiveEdit() {
+        const next = this.liveEditQueue.entries().next();
+        if (next.done)
+            return;
+        const [key, entry] = next.value;
+        this.liveEditQueue.delete(key);
+        try {
+            await this.editLiveMessageWithPacing(key, entry.msg, entry.text, 1);
+        }
+        catch (err) {
+            if (this.liveMessages.get(key)?.msg.id === entry.msg.id) {
+                this.liveEditQueue.set(key, entry);
+            }
+        }
+        finally {
+            this.scheduleLiveEditDrain();
+        }
+    }
     /** Start (or reset) the typing indicator for a meta-agent–routed channel. */
     startMetaAgentTyping(channelId, channel) {
         this.stopMetaAgentTyping(channelId);
@@ -252,8 +440,9 @@ export class CcDiscordBot {
      * 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);
+    async startOrGetLiveMessage(channelId, initial, slot = "response") {
+        const key = this.liveMessageKey(channelId, slot);
+        const existing = this.liveMessages.get(key);
         if (existing)
             return existing.msg;
         const channel = await this.getChannel(channelId);
@@ -262,54 +451,37 @@ export class CcDiscordBot {
         this.stopMetaAgentTyping(channelId);
         try {
             const msg = await channel.send(initial || "▋");
-            this.liveMessages.set(channelId, { msg, lastEditAt: Date.now(), editTimer: null, pendingText: null });
+            this.liveMessages.set(key, { msg });
+            this.nextLiveEditAt = Math.max(this.nextLiveEditAt, Date.now() + LIVE_EDIT_MIN_INTERVAL_MS);
             return msg;
         }
         catch (err) {
-            console.warn(`[bot] startOrGetLiveMessage failed (${channelId}):`, err.message);
+            console.warn(`[bot] startOrGetLiveMessage failed (${key}):`, 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).
+     * Safe to call on every token/chunk — edits are coalesced behind one global
+     * paced queue. The latest `text` always wins for each live message.
      */
-    updateLiveMessage(channelId, text) {
-        const entry = this.liveMessages.get(channelId);
+    updateLiveMessage(channelId, text, slot = "response") {
+        const key = this.liveMessageKey(channelId, slot);
+        const entry = this.liveMessages.get(key);
         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);
+        this.enqueueLiveEdit(key, entry.msg, text);
     }
     /**
      * 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);
+    async finalizeLiveMessage(channelId, text, slot = "response") {
+        const key = this.liveMessageKey(channelId, slot);
+        const entry = this.liveMessages.get(key);
+        this.liveMessages.delete(key);
+        this.liveEditQueue.delete(key);
         if (!entry) {
             if (text.trim())
                 await this.sendWithFileDetection(channelId, text);
@@ -323,7 +495,7 @@ export class CcDiscordBot {
         const formatted = formatForDiscord(text);
         const chunks = splitLongMessage(formatted);
         try {
-            await entry.msg.edit(chunks[0]);
+            await this.editLiveMessageWithPacing(key, entry.msg, chunks[0]);
             for (const chunk of chunks.slice(1)) {
                 if (chunk.trim())
                     await this.sendToChannelById(channelId, chunk);
@@ -885,7 +1057,7 @@ export class CcDiscordBot {
         const commands = [
             new SlashCommandBuilder().setName("reset").setDescription("Reset Claude session for this channel"),
             new SlashCommandBuilder().setName("costs").setDescription("Show token usage and cost for this channel"),
-            new SlashCommandBuilder().setName("mcp_status").setDescription("Check MCP server connection status"),
+            new SlashCommandBuilder().setName("mcp_status").setDescription("Check GitKB and ATC integration status"),
             new SlashCommandBuilder()
                 .setName("crons")
                 .setDescription("Manage cron jobs")
@@ -902,6 +1074,22 @@ export class CcDiscordBot {
                 .setName("wiki")
                 .setDescription("Wiki page info (pass namespace to look up)")
                 .addStringOption((opt) => opt.setName("namespace").setDescription("Namespace to look up").setRequired(false)),
+            new SlashCommandBuilder()
+                .setName("atc")
+                .setDescription("Inspect or control ATC dispatches")
+                .addSubcommand((sub) => sub.setName("status").setDescription("Show active ATC dispatches"))
+                .addSubcommand((sub) => sub
+                .setName("dryrun")
+                .setDescription("Preview an ATC run command without dispatching")
+                .addStringOption((opt) => opt.setName("args").setDescription("Arguments after `atc`, e.g. run task tasks/foo").setRequired(true)))
+                .addSubcommand((sub) => sub
+                .setName("logs")
+                .setDescription("Show ATC logs for a task slug or dispatch ID")
+                .addStringOption((opt) => opt.setName("id").setDescription("Task slug or dispatch ID").setRequired(true)))
+                .addSubcommand((sub) => sub
+                .setName("health")
+                .setDescription("Run ATC health checks")
+                .addBooleanOption((opt) => opt.setName("auto").setDescription("Auto-dispatch review-fix for NeedsReview records"))),
             new SlashCommandBuilder()
                 .setName("channel")
                 .setDescription("Create a Discord channel for a GitHub repo meta-agent")
@@ -1022,11 +1210,11 @@ export class CcDiscordBot {
             case "mcp_status": {
                 await interaction.deferReply();
                 try {
-                    const result = await this.callCcAgentTool("get_version");
-                    await interaction.editReply(result ? `MCP connected. Version: ${result}` : "MCP connected (no version info).");
+                    const result = await this.integrationStatus();
+                    await interaction.editReply(result);
                 }
                 catch (err) {
-                    await interaction.editReply(`MCP unavailable: ${err.message}`);
+                    await interaction.editReply(`Integration check failed: ${err.message}`);
                 }
                 break;
             }
@@ -1038,7 +1226,7 @@ export class CcDiscordBot {
                 await interaction.deferReply();
                 const ns = interaction.options.getString("namespace") ?? this.namespace;
                 try {
-                    const result = await this.callCcAgentTool("get_wiki", { namespace: ns });
+                    const result = await this.getWikiContent(ns);
                     if (result) {
                         const chunks = splitLongMessage(result);
                         await interaction.editReply(chunks[0]);
@@ -1055,6 +1243,10 @@ export class CcDiscordBot {
                 }
                 break;
             }
+            case "atc": {
+                await this.handleAtcCommand(interaction);
+                break;
+            }
             case "channel": {
                 const repoUrl = interaction.options.getString("repo", true);
                 const urlMatch = repoUrl.match(/^https?:\/\/github\.com\/([\w.-]+)\/([\w.-]+)/i);
@@ -1318,40 +1510,102 @@ export class CcDiscordBot {
                 await interaction.reply("Unknown /loop subcommand.");
         }
     }
-    /**
-     * Call a cc-agent MCP tool via a dedicated ClaudeProcess.
-     * Returns the tool result as a string, or null on failure.
-     */
-    async callCcAgentTool(toolName, args = {}) {
-        return new Promise((resolve) => {
-            const prompt = `Use the ${toolName} tool with these arguments: ${JSON.stringify(args)}. Return only the raw result, no extra commentary.`;
-            const claude = new ClaudeProcess({
-                cwd: this.opts.cwd ?? process.cwd(),
-                token: this.opts.claudeToken ?? getCurrentToken(),
-            });
-            let result = "";
-            const timeout = setTimeout(() => {
-                claude.kill();
-                resolve(null);
-            }, 30_000);
-            claude.on("message", (msg) => {
-                if (msg.type === "result") {
-                    result = extractText(msg) || result;
-                }
-                else if (msg.type === "assistant") {
-                    result += extractText(msg);
-                }
-            });
-            claude.on("exit", () => {
-                clearTimeout(timeout);
-                resolve(result.trim() || null);
-            });
-            claude.on("error", () => {
-                clearTimeout(timeout);
-                resolve(null);
+    atcEnv(ns) {
+        const root = ns ? workspacePath(ns) : (this.opts.cwd ?? process.cwd());
+        return {
+            ...process.env,
+            GITKB_ROOT: process.env.GITKB_ROOT ?? root,
+            DISPATCH_KB_ROOT: process.env.DISPATCH_KB_ROOT ?? root,
+            DISPATCH_META_ROOT: process.env.DISPATCH_META_ROOT ?? root,
+            ATC_NO_PAGER: "1",
+            NO_COLOR: "1",
+        };
+    }
+    async integrationStatus() {
+        const cwd = this.opts.cwd ?? process.cwd();
+        const gitkb = await execText(resolveGitKbBin(), ["--version"], { cwd, timeoutMs: 10_000 });
+        const atc = await execText(resolveAtcBin(), ["--version"], { cwd, env: this.atcEnv(), timeoutMs: 10_000 });
+        const status = await execText(resolveAtcBin(), ["status", "--flat", "--no-pager", "--color", "never"], {
+            cwd,
+            env: this.atcEnv(),
+            timeoutMs: 15_000,
+        }).catch((err) => `ATC status unavailable: ${err.message}`);
+        return [
+            `GitKB: ${gitkb || "available"}`,
+            `ATC: ${atc || "available"}`,
+            "",
+            "ATC status:",
+            status || "No active dispatches.",
+        ].join("\n");
+    }
+    async getWikiContent(ns) {
+        const root = workspacePath(ns);
+        const candidates = [`wiki/${ns}`, `wiki/${ns}.md`, ns];
+        for (const slug of candidates) {
+            const result = await execText(resolveGitKbBin(), ["show", slug], {
+                cwd: root,
+                env: { ...process.env, GITKB_ROOT: root, NO_COLOR: "1" },
+                timeoutMs: 15_000,
+            }).catch(() => "");
+            if (result)
+                return result;
+        }
+        const list = await execText(resolveGitKbBin(), ["list", "--path", "wiki", "--format", "ids"], {
+            cwd: root,
+            env: { ...process.env, GITKB_ROOT: root, NO_COLOR: "1" },
+            timeoutMs: 15_000,
+        }).catch(() => "");
+        return list || null;
+    }
+    async handleAtcCommand(interaction) {
+        await interaction.deferReply();
+        const ns = this.resolveNamespaceForChannel(interaction.channelId);
+        const cwd = workspacePath(ns);
+        const sub = interaction.options.getSubcommand();
+        const args = ["--no-pager", "--color", "never"];
+        if (sub === "status") {
+            args.push("status", "--flat");
+        }
+        else if (sub === "dryrun") {
+            const raw = interaction.options.getString("args", true);
+            const parsed = splitCliArgs(raw);
+            if (parsed[0] === "atc")
+                parsed.shift();
+            if (parsed[0] !== "run") {
+                await interaction.editReply("Dry-run only supports `atc run ...`. Example: `/atc dryrun args:run task tasks/foo`.");
+                return;
+            }
+            args.push(...parsed);
+            if (!args.includes("--dry-run"))
+                args.push("--dry-run");
+        }
+        else if (sub === "logs") {
+            args.push("logs", interaction.options.getString("id", true));
+        }
+        else if (sub === "health") {
+            args.push("health");
+            if (interaction.options.getBoolean("auto") ?? false)
+                args.push("--auto");
+        }
+        else {
+            await interaction.editReply("Unknown /atc subcommand.");
+            return;
+        }
+        try {
+            const output = await execText(resolveAtcBin(), args, {
+                cwd,
+                env: this.atcEnv(ns),
+                timeoutMs: sub === "logs" ? 20_000 : 30_000,
             });
-            claude.sendPrompt(prompt);
-        });
+            const chunks = splitLongMessage(output || "No ATC output.");
+            await interaction.editReply(chunks[0]);
+            for (const chunk of chunks.slice(1)) {
+                await interaction.followUp(chunk);
+            }
+        }
+        catch (err) {
+            await interaction.editReply(`ATC command failed: ${err.message}`);
+        }
     }
     runCronTask(channelId, prompt, done) {
         const getChannel = this.getChannel.bind(this);
@@ -1508,7 +1762,7 @@ export class CcDiscordBot {
         }
     }
     /**
-     * Forward a cc-agent job notification into an existing Claude session.
+     * Forward an ATC/job notification into an existing Claude session.
      * Unlike handleUserMessage, this never creates a new session.
      */
     forwardNotification(channelId, text) {

package/dist/index.d.ts

@@ -1,22 +1,26 @@
 #!/usr/bin/env node
 /**
- * cc-discord — Claude Code Discord bot
+ * cc-discord — Discord bot for Claude Code or Codex routed agents
  *
  * Usage:
  *   npx @gonzih/cc-discord
  *
  * Required env:
  *   DISCORD_BOT_TOKEN          — from Discord Developer Portal
- *   CLAUDE_CODE_OAUTH_TOKEN    — your Claude Code OAuth token (or ANTHROPIC_API_KEY)
+ *   CLAUDE_CODE_OAUTH_TOKEN    — Claude Code OAuth token (or ANTHROPIC_API_KEY) when using Claude
+ *   CODEX_API_KEY              — optional Codex API key when using Codex automation
  *
  * Optional env:
  *   DISCORD_GUILD_IDS          — comma-separated Discord guild/server IDs (for instant slash command registration)
  *   DISCORD_ALLOWED_USER_IDS   — comma-separated Discord user IDs to whitelist (leave empty to allow all)
  *   DISCORD_NOTIFY_CHANNEL_ID  — Discord channel ID for job notifications
- *   CC_AGENT_NAMESPACE         — primary namespace (default: money-brain)
+ *   CC_DISCORD_NAMESPACE      — primary namespace (default: money-brain)
  *   REDIS_URL                  — Redis connection URL (default: redis://localhost:6379)
- *   CWD                        — working directory for Claude Code (default: process.cwd())
+ *   CWD                        — working directory for local sessions (default: process.cwd())
  *   DEFAULT_GITHUB_ORG         — default GitHub org for #repo routing (default: gonzih)
- *   CC_DISCORD_MCP_JSON        — JSON template for .mcp.json injection into workspaces
+ *   CC_DISCORD_AGENT_DRIVER    — claude (default) or codex for routed meta-agents
+ *   ATC_BIN                   — optional, override ATC binary path
+ *   ATC_ROOT                  — optional, ATC data directory
+ *   CC_DISCORD_MCP_JSON       — JSON template for .mcp.json injection into workspaces
  */
 export {};