@gonzih/cc-discord 0.2.37 → 0.2.39

package/dist/bot.js

@@ -911,8 +911,15 @@ export class CcDiscordBot {
         this.lastActiveChannelId = channelId;
         switch (interaction.commandName) {
             case "reset": {
+                // Kill local DM session if any
                 this.killSession(channelId);
-                await interaction.reply("Session reset. Send a message to start.");
+                // Kill persistent meta-agent session if this is a routed channel.
+                // Unlike /clear, we do NOT delete the JSONL — context is preserved.
+                // Next message will respawn with --continue, picking up the same history.
+                const resetNs = this.resolveNamespaceForChannel(channelId);
+                this.metaAgentManager.killSession(resetNs);
+                await interaction.reply(`Session process killed for \`${resetNs}\`. Next message respawns with existing context intact.\n` +
+                    `Use \`/clear\` to also wipe conversation history.`);
                 break;
             }
             case "costs": {

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

@@ -4,12 +4,13 @@
  * Flow per namespace:
  *   1. ensureWorkspace: git clone repo to ~/cc-discord-workspace/{ns}
  *   2. injectMcp: write .mcp.json so the claude subprocess has MCP tool access
- *   3. ensureSession: add message to per-namespace queue, start processQueue
- *   4. processQueue: spawn `claude --continue -p` (stdin+EOF) per message, one at a time
- *   5. Context is maintained via --continue (JSONL session file in workspace)
+ *   3. ensureSession: spawn one persistent `claude --continue` process per namespace
+ *      (no -p flag — messages go via stdin)
+ *   4. On new message: write "${message}\n" to stdin of the running process
+ *   5. On process exit: remove from sessions map; next message respawns
  *
- * Spawn-per-message with --continue maintains full conversation history.
- * Messages queue up and process sequentially per namespace.
+ * The polling loop now just drains any queued Redis messages into stdin.
+ * No more per-message process spawn — Claude receives messages in sequence.
  */
 import type { createCcWire } from "@gonzih/cc-wire";
 type Wire = ReturnType<typeof createCcWire>;
@@ -43,9 +44,12 @@ export declare function injectMcp(ns: string, wsPath: string, token: string): vo
 export declare const metaStreamChannel: (ns: string) => string;
 export declare const metaLogKey: (ns: string) => string;
 /**
- * Spawn `claude --continue -p` with message written to stdin, then close stdin (EOF).
- * Claude responds and exits. Context is maintained via --continue (JSONL session file).
+ * Spawn `claude --continue -p "{message}" --dangerously-skip-permissions` in the
+ * namespace workspace. Pipes stdout line-by-line → wire.discord.publishOutgoing.
+ * Also streams each chunk to Redis: PUBLISH cca:meta:{ns}:stream and LPUSH cca:meta:{ns}:log.
  * Returns a Promise that resolves when the process exits.
+ *
+ * Kept for backwards-compat and direct integration-test usage.
  */
 export declare function spawnSession(ns: string, message: string, token: string, wire: Wire): Promise<void>;
 export interface MetaAgentManager {
@@ -56,20 +60,25 @@ export interface MetaAgentManager {
         repoUrl: string;
     }>, instanceId?: string) => void;
     stop: () => void;
-    /** Clear the message queue for a namespace (e.g. on /clear). */
+    /** Kill and remove the persistent session for a namespace (e.g. on /clear). */
     killSession: (ns: string) => void;
-    /** Queue a message for a namespace. */
+    /** Write a raw line to the stdin of the running session, if any. */
     sendToSession: (ns: string, line: string) => void;
 }
 /**
- * Create a MetaAgentManager that processes Discord messages via spawn-per-message.
+ * 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.
  *
- * Each message spawns `claude --continue -p` with the message written to stdin,
- * then stdin is closed (EOF) so Claude processes and exits. --continue maintains
- * conversation history via the JSONL session file in the workspace.
+ * On process exit: remove from sessions map. Next message triggers a respawn.
  *
- * Messages queue per namespace and process sequentially — no concurrent spawns
- * for the same namespace.
+ * The 3-second poll loop drains any messages that arrived while a session was
+ * starting up or temporarily unavailable.
  */
 export declare function createMetaAgentManager(): MetaAgentManager;
 /**

package/dist/meta-agent-manager.js

@@ -4,12 +4,13 @@
  * Flow per namespace:
  *   1. ensureWorkspace: git clone repo to ~/cc-discord-workspace/{ns}
  *   2. injectMcp: write .mcp.json so the claude subprocess has MCP tool access
- *   3. ensureSession: add message to per-namespace queue, start processQueue
- *   4. processQueue: spawn `claude --continue -p` (stdin+EOF) per message, one at a time
- *   5. Context is maintained via --continue (JSONL session file in workspace)
+ *   3. ensureSession: spawn one persistent `claude --continue` process per namespace
+ *      (no -p flag — messages go via stdin)
+ *   4. On new message: write "${message}\n" to stdin of the running process
+ *   5. On process exit: remove from sessions map; next message respawns
  *
- * Spawn-per-message with --continue maintains full conversation history.
- * Messages queue up and process sequentially per namespace.
+ * The polling loop now just drains any queued Redis messages into stdin.
+ * No more per-message process spawn — Claude receives messages in sequence.
  */
 import { spawn, execSync } from "child_process";
 import { existsSync, mkdirSync, writeFileSync } from "fs";
@@ -211,7 +212,19 @@ function wireStdoutToRedis(proc, ns, wire) {
                     result: resultText,
                     is_error: parsed.is_error ?? false,
                 };
-                // Do not re-publish result text — assistant event already published it
+                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 {
                 structuredEvent = parsed;
@@ -244,9 +257,12 @@ function wireStdoutToRedis(proc, ns, wire) {
     });
 }
 /**
- * Spawn `claude --continue -p` with message written to stdin, then close stdin (EOF).
- * Claude responds and exits. Context is maintained via --continue (JSONL session file).
+ * Spawn `claude --continue -p "{message}" --dangerously-skip-permissions` in the
+ * namespace workspace. Pipes stdout line-by-line → wire.discord.publishOutgoing.
+ * Also streams each chunk to Redis: PUBLISH cca:meta:{ns}:stream and LPUSH cca:meta:{ns}:log.
  * Returns a Promise that resolves when the process exits.
+ *
+ * Kept for backwards-compat and direct integration-test usage.
  */
 export function spawnSession(ns, message, token, wire) {
     return new Promise((resolve, reject) => {
@@ -255,15 +271,11 @@ export function spawnSession(ns, message, token, wire) {
         const env = buildEnv(token);
         const proc = spawn(claudeBin, [
             "--continue",
-            "-p",
+            "-p", message,
             "--output-format", "stream-json",
             "--verbose",
             "--dangerously-skip-permissions",
-        ], { cwd: wsPath, env, stdio: ["pipe", "pipe", "pipe"] });
-        // Write message to stdin, then close (EOF triggers Claude to process and respond)
-        proc.stdin.write(message + "\n", () => {
-            proc.stdin.end();
-        });
+        ], { cwd: wsPath, env, stdio: ["ignore", "pipe", "pipe"] });
         wireStdoutToRedis(proc, ns, wire);
         proc.on("exit", (code) => {
             console.log(`[meta-agent-manager] session exited (ns=${ns}, code=${code})`);
@@ -276,75 +288,149 @@ export function spawnSession(ns, message, token, wire) {
     });
 }
 /**
- * Create a MetaAgentManager that processes Discord messages via spawn-per-message.
+ * Spawn a persistent `claude --continue` process for a namespace.
+ * No -p flag — messages are delivered via stdin.
+ * Stdout is wired to Redis via wireStdoutToRedis.
+ * Returns the ChildProcess.
+ */
+function spawnPersistentSession(ns, token, wire, onExit) {
+    const wsPath = workspacePath(ns);
+    const claudeBin = resolveClaude();
+    const env = buildEnv(token);
+    console.log(`[meta-agent-manager] spawning persistent session (ns=${ns})`);
+    // DO NOT ADD -p OR --input-format stream-json HERE.
+    // With -p + --input-format stream-json, Claude buffers all stdin until EOF before responding.
+    // Since the stdin pipe is never closed (it stays open for subsequent messages), Claude
+    // waits forever and never produces output. Interactive mode (no -p) reads one line at a
+    // time and responds immediately. Verified by direct test: `echo msg | claude --continue
+    // --output-format stream-json ...` responds correctly; the -p variant does not.
+    const proc = spawn(claudeBin, [
+        "--continue",
+        "--output-format", "stream-json",
+        "--verbose",
+        "--dangerously-skip-permissions",
+    ], { cwd: wsPath, env, stdio: ["pipe", "pipe", "pipe"] });
+    proc.stdin.setDefaultEncoding("utf8");
+    wireStdoutToRedis(proc, ns, wire);
+    proc.on("exit", (code) => {
+        console.log(`[meta-agent-manager] persistent session exited (ns=${ns}, code=${code})`);
+        onExit();
+    });
+    proc.on("error", (err) => {
+        console.error(`[meta-agent-manager] persistent session spawn error (ns=${ns}):`, err.message);
+        onExit();
+    });
+    return proc;
+}
+/**
+ * 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.
  *
- * Each message spawns `claude --continue -p` with the message written to stdin,
- * then stdin is closed (EOF) so Claude processes and exits. --continue maintains
- * conversation history via the JSONL session file in the workspace.
+ * On process exit: remove from sessions map. Next message triggers a respawn.
  *
- * Messages queue per namespace and process sequentially — no concurrent spawns
- * for the same namespace.
+ * The 3-second poll loop drains any messages that arrived while a session was
+ * starting up or temporarily unavailable.
  */
 export function createMetaAgentManager() {
     let pollInterval = null;
-    // Per-namespace message queue (local, drained by processQueue)
-    const queues = new Map();
-    // Namespaces currently running a spawnSession (blocks concurrent spawns)
-    const processing = new Set();
-    // Cached session metadata (token, wire, repoUrl) per namespace
-    const sessionMeta = new Map();
+    /** One persistent ChildProcess per namespace. */
+    const sessions = new Map();
+    /** Namespaces currently being set up (workspace clone / first spawn). */
+    const startingUp = new Set();
     /**
-     * Drain the local queue for a namespace, spawning one session per message.
-     * No-ops if already processing or queue is empty.
+     * Write a line to the stdin of the persistent session for ns.
+     * Silently no-ops if no session exists.
      */
-    async function processQueue(ns) {
-        if (processing.has(ns))
-            return;
-        const queue = queues.get(ns);
-        if (!queue || queue.length === 0)
-            return;
-        const meta = sessionMeta.get(ns);
-        if (!meta)
+    function writeToStdin(ns, line) {
+        const session = sessions.get(ns);
+        if (!session)
             return;
-        processing.add(ns);
-        console.log(`[meta-agent-manager] processQueue started (ns=${ns})`);
         try {
-            while (true) {
-                const q = queues.get(ns);
-                if (!q || q.length === 0)
-                    break;
-                const message = q.shift();
-                const { token, wire } = sessionMeta.get(ns) ?? meta;
-                console.log(`[meta-agent-manager] spawning session for message (ns=${ns})`);
-                try {
-                    await spawnSession(ns, message, token, wire);
-                }
-                catch (err) {
-                    console.error(`[meta-agent-manager] spawnSession error (ns=${ns}):`, err.message);
-                }
-            }
+            // Interactive mode: plain text line, Claude reads it as user input
+            session.proc.stdin.write(`${line}\n`);
         }
-        finally {
-            processing.delete(ns);
-            console.log(`[meta-agent-manager] processQueue done (ns=${ns})`);
+        catch (err) {
+            console.warn(`[meta-agent-manager] stdin write failed (ns=${ns}):`, err.message);
+        }
+    }
+    /**
+     * Drain all pending messages from the Redis input queue into the session's stdin.
+     */
+    async function drainQueue(ns, wire) {
+        const inputKey = discordMetaInputKey(ns);
+        for (;;) {
+            let raw;
+            try {
+                raw = await wire._redis.lpop(inputKey);
+            }
+            catch {
+                break;
+            }
+            if (!raw)
+                break;
+            let content;
+            try {
+                content = JSON.parse(raw).content ?? raw;
+            }
+            catch {
+                content = raw;
+            }
+            writeToStdin(ns, content);
         }
     }
     /**
-     * Ensure workspace + MCP are ready, add message to queue, start processing.
+     * Ensure a persistent session exists for ns.
+     * If one already exists, returns immediately.
+     * If not, spawns one, drains any queued messages, then writes `firstMessage` if provided.
      */
     async function ensureSession(ns, repoUrl, token, wire, firstMessage) {
-        sessionMeta.set(ns, { token, wire, repoUrl });
-        const wsPath = workspacePath(ns);
-        await ensureWorkspace(ns, repoUrl);
-        injectMcp(ns, wsPath, token);
-        if (!queues.has(ns))
-            queues.set(ns, []);
-        if (firstMessage !== undefined) {
-            queues.get(ns).push(firstMessage);
+        if (sessions.has(ns)) {
+            if (firstMessage !== undefined)
+                writeToStdin(ns, firstMessage);
+            return;
+        }
+        if (startingUp.has(ns)) {
+            // Already spinning up — queue the message so drainQueue picks it up
+            return;
+        }
+        startingUp.add(ns);
+        try {
+            // Ensure workspace exists
+            const wsPath = workspacePath(ns);
+            await ensureWorkspace(ns, repoUrl);
+            injectMcp(ns, wsPath, token);
+            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})`);
+            });
+            sessions.set(ns, { proc, ns });
+            // Drain any messages that arrived before this session started
+            await drainQueue(ns, wire);
+            // Write the triggering message last (after queue drain, in order)
+            if (firstMessage !== undefined)
+                writeToStdin(ns, firstMessage);
+            await wire.discord.setStatus(ns, {
+                namespace: ns,
+                status: "running",
+                isTyping: true,
+                turnCount: 0,
+                updatedAt: new Date().toISOString(),
+            });
+        }
+        catch (err) {
+            console.error(`[meta-agent-manager] ensureSession failed (ns=${ns}):`, err.message);
+            sessions.delete(ns);
+        }
+        finally {
+            startingUp.delete(ns);
         }
-        processQueue(ns).catch((err) => {
-            console.error(`[meta-agent-manager] processQueue error (ns=${ns}):`, err.message);
-        });
     }
     return {
         async ensureWorkspace(ns, repoUrl) {
@@ -356,7 +442,7 @@ export function createMetaAgentManager() {
         },
         startPolling(wire, getNamespaces, instanceId) {
             if (pollInterval)
-                return;
+                return; // already running
             pollInterval = setInterval(() => {
                 const namespaces = getNamespaces();
                 if (namespaces.length === 0)
@@ -371,21 +457,25 @@ export function createMetaAgentManager() {
                             }
                         }).catch(() => { });
                     }
-                    // Skip if already processing
-                    if (processing.has(ns))
+                    // If session exists, drain any queued messages
+                    if (sessions.has(ns)) {
+                        drainQueue(ns, wire).catch((err) => {
+                            console.warn(`[meta-agent-manager] drainQueue error (ns=${ns}):`, err.message);
+                        });
                         continue;
-                    // Check Redis queue for pending messages
+                    }
+                    // Check if anything is queued for this namespace
                     const inputKey = discordMetaInputKey(ns);
                     wire._redis.llen(inputKey).then(async (queueLen) => {
                         if (queueLen === 0)
                             return;
+                        // Resolve token
                         let token;
                         try {
                             token = await wire.token.getMaster();
                         }
                         catch {
-                            token = sessionMeta.get(ns)?.token
-                                ?? process.env.CLAUDE_CODE_OAUTH_TOKEN
+                            token = process.env.CLAUDE_CODE_OAUTH_TOKEN
                                 ?? process.env.CLAUDE_CODE_TOKEN
                                 ?? process.env.ANTHROPIC_API_KEY
                                 ?? "";
@@ -394,31 +484,8 @@ export function createMetaAgentManager() {
                             console.warn(`[meta-agent-manager] no token available, skipping session for ns=${ns}`);
                             return;
                         }
-                        // Drain Redis queue into local queue
-                        if (!queues.has(ns))
-                            queues.set(ns, []);
-                        for (;;) {
-                            const raw = await wire._redis.lpop(inputKey).catch(() => null);
-                            if (!raw)
-                                break;
-                            let content;
-                            try {
-                                content = JSON.parse(raw).content ?? raw;
-                            }
-                            catch {
-                                content = raw;
-                            }
-                            queues.get(ns).push(content);
-                        }
-                        if (!sessionMeta.has(ns)) {
-                            sessionMeta.set(ns, { token, wire, repoUrl });
-                        }
-                        const wsPath = workspacePath(ns);
-                        await ensureWorkspace(ns, repoUrl);
-                        injectMcp(ns, wsPath, token);
-                        processQueue(ns).catch((err) => {
-                            console.error(`[meta-agent-manager] processQueue error (ns=${ns}):`, err.message);
-                        });
+                        // ensureSession will drain the queue itself
+                        await ensureSession(ns, repoUrl, token, wire);
                     }).catch((err) => {
                         console.warn(`[meta-agent-manager] llen error (ns=${ns}):`, err.message);
                     });
@@ -432,20 +499,35 @@ export function createMetaAgentManager() {
                 pollInterval = null;
                 console.log("[meta-agent-manager] polling stopped");
             }
-            queues.clear();
+            // Kill all active sessions
+            for (const [ns, session] of sessions) {
+                try {
+                    session.proc.stdin.end();
+                    session.proc.kill();
+                }
+                catch {
+                    // ignore errors during shutdown
+                }
+                sessions.delete(ns);
+                console.log(`[meta-agent-manager] killed session on stop (ns=${ns})`);
+            }
         },
         killSession(ns) {
-            // Clear local queue — any in-flight spawn will complete naturally
-            queues.delete(ns);
-            console.log(`[meta-agent-manager] killed session queue (ns=${ns})`);
+            const session = sessions.get(ns);
+            if (!session)
+                return;
+            try {
+                session.proc.stdin.end();
+                session.proc.kill();
+            }
+            catch {
+                // ignore
+            }
+            sessions.delete(ns);
+            console.log(`[meta-agent-manager] killed session (ns=${ns})`);
         },
         sendToSession(ns, line) {
-            if (!queues.has(ns))
-                queues.set(ns, []);
-            queues.get(ns).push(line);
-            processQueue(ns).catch((err) => {
-                console.error(`[meta-agent-manager] processQueue error (ns=${ns}):`, err.message);
-            });
+            writeToStdin(ns, line);
         },
     };
 }

package/dist/voice.d.ts

@@ -1,9 +1,10 @@
 /**
  * Voice message transcription via whisper.cpp.
- * Flow: Telegram OGG → ffmpeg convert to 16kHz WAV → whisper-cpp → text
+ * Flow: Discord voice memo (OGG/M4A) → ffmpeg convert to 16kHz WAV → whisper-cpp → text
  */
 /**
- * Transcribe a voice message from a Telegram file URL.
+ * Transcribe a voice message from a Discord CDN URL.
+ * Accepts OGG, M4A, MP3, or any audio format ffmpeg can decode.
  * Returns the transcribed text, or throws if whisper/ffmpeg not available.
  */
 export declare function transcribeVoice(fileUrl: string): Promise<string>;

package/dist/voice.js

@@ -1,40 +1,40 @@
 /**
  * Voice message transcription via whisper.cpp.
- * Flow: Telegram OGG → ffmpeg convert to 16kHz WAV → whisper-cpp → text
+ * Flow: Discord voice memo (OGG/M4A) → ffmpeg convert to 16kHz WAV → whisper-cpp → text
  */
 import { execFile } from "child_process";
 import { promisify } from "util";
-import { existsSync } from "fs";
-import { unlink, readFile } from "fs/promises";
+import { existsSync, createWriteStream } from "fs";
+import { unlink, readFile, access } from "fs/promises";
 import { tmpdir } from "os";
 import { join } from "path";
 import https from "https";
 import http from "http";
-import { createWriteStream } from "fs";
 const execFileAsync = promisify(execFile);
-// Whisper model — small.en is fast and accurate enough for commands
-// Falls back to base.en if small not found
+// Env var overrides allow test injection: WHISPER_BIN, FFMPEG_BIN, WHISPER_MODEL
 const WHISPER_MODELS = [
+    process.env.WHISPER_MODEL,
     "/opt/homebrew/share/whisper-cpp/ggml-small.en.bin",
     "/opt/homebrew/share/whisper-cpp/ggml-small.bin",
     "/opt/homebrew/share/whisper-cpp/ggml-base.en.bin",
     "/opt/homebrew/share/whisper-cpp/ggml-base.bin",
-    // user-local
     `${process.env.HOME}/.local/share/whisper-cpp/ggml-small.en.bin`,
     `${process.env.HOME}/.local/share/whisper-cpp/ggml-base.en.bin`,
-];
+].filter(Boolean);
 const WHISPER_BIN_CANDIDATES = [
-    "/opt/homebrew/bin/whisper-cli", // whisper-cpp brew formula installs as whisper-cli
+    process.env.WHISPER_BIN,
+    "/opt/homebrew/bin/whisper-cli",
     "/opt/homebrew/bin/whisper-cpp",
     "/usr/local/bin/whisper-cli",
     "/usr/local/bin/whisper-cpp",
     "/opt/homebrew/bin/whisper",
-];
+].filter(Boolean);
 const FFMPEG_CANDIDATES = [
+    process.env.FFMPEG_BIN,
     "/opt/homebrew/bin/ffmpeg",
     "/usr/local/bin/ffmpeg",
     "/usr/bin/ffmpeg",
-];
+].filter(Boolean);
 function findBin(candidates) {
     for (const p of candidates) {
         if (existsSync(p))
@@ -49,15 +49,34 @@ function findModel() {
     }
     return null;
 }
-function downloadFile(url, dest) {
+/**
+ * Download a file from a URL to dest.
+ * Supports file:// (copies local file), and https/http with redirect following.
+ */
+async function downloadFile(url, dest, redirectsLeft = 5) {
+    if (url.startsWith("file://")) {
+        const { copyFile } = await import("fs/promises");
+        await copyFile(url.slice("file://".length), dest);
+        return;
+    }
     return new Promise((resolve, reject) => {
-        const file = createWriteStream(dest);
+        if (redirectsLeft <= 0) {
+            reject(new Error(`Too many redirects downloading ${url}`));
+            return;
+        }
         const getter = url.startsWith("https") ? https : http;
         getter.get(url, (res) => {
+            if (res.statusCode && res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+                res.resume();
+                downloadFile(res.headers.location, dest, redirectsLeft - 1).then(resolve).catch(reject);
+                return;
+            }
             if (res.statusCode !== 200) {
+                res.resume();
                 reject(new Error(`HTTP ${res.statusCode} downloading ${url}`));
                 return;
             }
+            const file = createWriteStream(dest);
             res.pipe(file);
             file.on("finish", () => file.close(() => resolve()));
             file.on("error", reject);
@@ -65,7 +84,8 @@ function downloadFile(url, dest) {
     });
 }
 /**
- * Transcribe a voice message from a Telegram file URL.
+ * Transcribe a voice message from a Discord CDN URL.
+ * Accepts OGG, M4A, MP3, or any audio format ffmpeg can decode.
  * Returns the transcribed text, or throws if whisper/ffmpeg not available.
  */
 export async function transcribeVoice(fileUrl) {
@@ -78,58 +98,82 @@ export async function transcribeVoice(fileUrl) {
     const model = findModel();
     if (!model)
         throw new Error("No whisper model found — run: whisper-cpp-download-ggml-model small.en");
-    const tmp = join(tmpdir(), `cc-tg-voice-${Date.now()}`);
-    const oggPath = `${tmp}.ogg`;
+    const tmp = join(tmpdir(), `cc-discord-voice-${Date.now()}`);
+    // Preserve original extension so ffmpeg auto-detects format
+    const urlPath = new URL(fileUrl).pathname;
+    const ext = urlPath.includes(".") ? "." + urlPath.split(".").pop().split("?")[0] : ".ogg";
+    const audioPath = `${tmp}${ext}`;
     const wavPath = `${tmp}.wav`;
     try {
-        // 1. Download OGG from Telegram
-        await downloadFile(fileUrl, oggPath);
-        // 2. Convert OGG → 16kHz mono WAV (whisper requirement)
-        await execFileAsync(ffmpegBin, [
-            "-y", "-i", oggPath,
-            "-ar", "16000",
-            "-ac", "1",
-            "-c:a", "pcm_s16le",
-            wavPath,
-        ]);
+        // 1. Download audio from Discord CDN (follows redirects)
+        await downloadFile(fileUrl, audioPath);
+        // 2. Convert to 16kHz mono WAV (whisper requirement)
+        try {
+            await execFileAsync(ffmpegBin, [
+                "-y", "-i", audioPath,
+                "-ar", "16000",
+                "-ac", "1",
+                "-c:a", "pcm_s16le",
+                wavPath,
+            ]);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            throw new Error(`ffmpeg conversion failed: ${msg}`);
+        }
         // 3. Run whisper-cpp
-        // --output-txt writes to ${wavPath}.txt (NOT stdout)
-        // -l auto fails with .en models — detect and use -l en instead
+        // -l auto fails with .en models — use -l en for those
         const isEnModel = model.includes(".en.");
         const langArgs = isEnModel ? ["-l", "en"] : ["-l", "auto"];
+        let whisperStderr = "";
         try {
-            await execFileAsync(whisperBin, [
+            const result = await execFileAsync(whisperBin, [
                 "-m", model,
                 "-f", wavPath,
                 "--no-timestamps",
                 ...langArgs,
-                "--output-txt", // writes to wavPath + ".txt"
+                "--output-txt",
             ]);
+            whisperStderr = result.stderr ?? "";
         }
         catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            throw new Error(`whisper-cpp failed: ${msg}`);
+            const e = err;
+            whisperStderr = e.stderr ?? "";
+            const msg = e.message ?? String(err);
+            throw new Error(`whisper-cpp failed: ${msg}\nstderr: ${whisperStderr}`);
         }
-        // Read the output file whisper-cpp wrote
-        const txtPath = `${wavPath}.txt`;
+        // 4. Find output file — whisper-cpp versions differ on suffix:
+        //    some write {wavPath}.txt, others write {baseName}.txt (strip .wav)
+        const txtPathFull = `${wavPath}.txt`; // /tmp/foo.wav.txt
+        const txtPathStripped = wavPath.replace(/\.wav$/, ".txt"); // /tmp/foo.txt
         let raw = "";
-        try {
-            raw = await readFile(txtPath, "utf-8");
+        for (const candidate of [txtPathFull, txtPathStripped]) {
+            try {
+                await access(candidate);
+                raw = await readFile(candidate, "utf-8");
+                await unlink(candidate).catch(() => { });
+                break;
+            }
+            catch {
+                // try next
+            }
+        }
+        if (!raw && !whisperStderr) {
+            throw new Error("whisper-cpp ran but produced no output file (tried .wav.txt and .txt)");
         }
-        catch {
-            throw new Error("whisper-cpp ran but produced no output file");
+        // Use stdout text if file wasn't found but whisper printed to stderr (some versions do)
+        if (!raw) {
+            raw = whisperStderr;
         }
         const text = raw
             .replace(/\[BLANK_AUDIO\]/gi, "")
-            .replace(/\[.*?\]/g, "") // remove timestamp artifacts
+            .replace(/\[.*?\]/g, "")
             .trim();
         return text || "[empty transcription]";
     }
     finally {
-        // Cleanup temp files
-        await unlink(oggPath).catch(() => { });
+        await unlink(audioPath).catch(() => { });
         await unlink(wavPath).catch(() => { });
-        await unlink(`${wavPath}.txt`).catch(() => { });
     }
 }
 /**

package/package.json

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