@herdctl/discord 1.1.1 → 1.2.0

package/dist/manager.js

@@ -9,9 +9,16 @@
  *
  * @module manager
  */
-import { ChatSessionManager, extractMessageContent, StreamingResponder, splitMessage, } from "@herdctl/chat";
-import { extractToolResults, extractToolUseBlocks, getToolInputSummary, TOOL_EMOJIS, } from "@herdctl/core";
+import { randomUUID } from "node:crypto";
+import { mkdir, readdir, readFile, rm, writeFile } from "node:fs/promises";
+import { basename, dirname, join, resolve } from "node:path";
+import { ChatSessionManager, StreamingResponder, splitMessage, } from "@herdctl/chat";
+import { createFileSenderDef, getToolInputSummary, TOOL_EMOJIS, } from "@herdctl/core";
 import { DiscordConnector } from "./discord-connector.js";
+import { buildErrorEmbed, buildResultSummaryEmbed, buildRunCardEmbed, buildStatusEmbed, buildToolResultEmbed, } from "./embeds.js";
+import { formatContextForPrompt } from "./mention-handler.js";
+import { normalizeDiscordMessage } from "./message-normalizer.js";
+import { transcribeAudio } from "./voice-transcriber.js";
 /**
  * DiscordManager handles Discord connections for agents
  *
@@ -24,6 +31,10 @@ import { DiscordConnector } from "./discord-connector.js";
 export class DiscordManager {
     ctx;
     connectors = new Map();
+    activeJobsByChannel = new Map();
+    lastPromptByChannel = new Map();
+    lastUsageByChannel = new Map();
+    cumulativeUsageByAgent = new Map();
     initialized = false;
     constructor(ctx) {
         this.ctx = ctx;
@@ -93,6 +104,22 @@ export class DiscordManager {
                     sessionManager,
                     stateDir,
                     logger: createAgentLogger(`[discord:${agent.qualifiedName}]`),
+                    commandActions: {
+                        stopRun: (channelId) => this.stopChannelRun(agent.qualifiedName, channelId),
+                        retryRun: (channelId) => this.retryChannelRun(agent.qualifiedName, channelId),
+                        runSkill: (channelId, skillName, input) => this.runChannelSkill(agent.qualifiedName, channelId, skillName, input),
+                        listSkills: async () => this.discoverAgentSkills(agent),
+                        getUsage: async (channelId) => this.getChannelUsage(agent.qualifiedName, channelId),
+                        getCumulativeUsage: async () => this.getAgentCumulativeUsage(agent.qualifiedName),
+                        getAgentConfig: async () => this.getAgentConfigSummary(agent),
+                        getSessionInfo: async (channelId) => this.getChannelRunInfo(agent.qualifiedName, channelId),
+                    },
+                    commandRegistration: discordConfig.command_registration
+                        ? {
+                            scope: discordConfig.command_registration.scope,
+                            guildId: discordConfig.command_registration.guild_id,
+                        }
+                        : { scope: "global" },
                 });
                 this.connectors.set(agent.qualifiedName, connector);
                 logger.debug(`Created Discord connector for agent '${agent.qualifiedName}'`);
@@ -270,6 +297,7 @@ export class DiscordManager {
         const logger = this.ctx.getLogger();
         const emitter = this.ctx.getEmitter();
         logger.info(`Discord message for agent '${qualifiedName}': ${event.prompt.substring(0, 50)}...`);
+        this.lastPromptByChannel.set(this.getChannelKey(qualifiedName, event.metadata.channelId), event.prompt);
         // Get the agent configuration (lookup by qualifiedName)
         const config = this.ctx.getConfig();
         const agent = config?.agents.find((a) => a.qualifiedName === qualifiedName);
@@ -291,7 +319,13 @@ export class DiscordManager {
             result_summary: false,
             errors: true,
             typing_indicator: true,
+            acknowledge_emoji: "👀",
+            assistant_messages: "answers",
+            progress_indicator: true,
         };
+        // Resolve output modes
+        const assistantMessages = outputConfig.assistant_messages ?? "answers";
+        const showProgressIndicator = outputConfig.progress_indicator !== false;
         // Get existing session for this channel (for conversation continuity)
         const connector = this.connectors.get(qualifiedName);
         let existingSessionId;
@@ -312,156 +346,446 @@ export class DiscordManager {
                 // Continue processing - session failure shouldn't block message handling
             }
         }
-        // Create streaming responder for incremental message delivery
+        // Buffer for files uploaded by the agent via MCP tool.
+        // Files are queued here and attached to the next answer message,
+        // so they appear below the text (not as standalone messages above it).
+        const pendingFiles = [];
+        // Create file sender definition for this message context
+        let injectedMcpServers;
+        const workingDir = this.resolveWorkingDirectory(agent);
+        if (connector && workingDir) {
+            const fileSenderContext = {
+                workingDirectory: workingDir,
+                uploadFile: async (params) => {
+                    // Queue the file — it will be attached to the next answer message
+                    pendingFiles.push({
+                        buffer: params.fileBuffer,
+                        filename: params.filename,
+                    });
+                    const fileId = `buffered-${randomUUID()}`;
+                    logger.debug(`Buffered file '${params.filename}' for attachment to next answer message`);
+                    return { fileId };
+                },
+            };
+            const fileSenderDef = createFileSenderDef(fileSenderContext);
+            injectedMcpServers = { [fileSenderDef.name]: fileSenderDef };
+        }
+        // Create streaming responder for incremental message delivery.
+        // The reply closure drains pending files and attaches them to the message.
         const streamer = new StreamingResponder({
-            reply: (content) => event.reply(content),
+            reply: async (content) => {
+                if (pendingFiles.length > 0) {
+                    const files = pendingFiles.splice(0);
+                    await event.reply({
+                        content,
+                        files: files.map((f) => ({ attachment: f.buffer, name: f.filename })),
+                    });
+                }
+                else {
+                    await event.reply(content);
+                }
+            },
             logger: logger,
             agentName: qualifiedName,
             maxMessageLength: 2000, // Discord's limit
             maxBufferSize: 1500,
             platformName: "Discord",
         });
-        // Start typing indicator while processing (configurable via output.typing_indicator)
-        const stopTyping = outputConfig.typing_indicator ? event.startTyping() : () => { };
+        // Start typing indicator while processing (if not disabled via output.typing_indicator)
+        const stopTyping = outputConfig.typing_indicator !== false ? event.startTyping() : () => { };
         // Track if we've stopped typing to avoid multiple calls
         let typingStopped = false;
+        // Add acknowledgement reaction if configured (non-fatal — don't abort message handling)
+        const ackEmoji = outputConfig.acknowledge_emoji;
+        if (ackEmoji) {
+            try {
+                await event.addReaction(ackEmoji);
+            }
+            catch (reactionError) {
+                logger.warn(`Failed to add ack reaction: ${reactionError.message}`);
+            }
+        }
+        // Attachment state — declared here so the finally block can clean up
+        let attachmentDownloadedPaths = [];
+        const attachmentConfig = agent.chat?.discord?.attachments;
+        // Progress embed state — declared here so the finally block can clean up
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const progressState = { handle: null };
+        const traceLines = [];
+        const pushTraceLine = (line) => {
+            traceLines.push(line);
+            if (traceLines.length > 24) {
+                traceLines.splice(0, traceLines.length - 24);
+            }
+        };
         try {
+            // Handle voice messages: transcribe audio before triggering the agent
+            let prompt = event.prompt;
+            if (!existingSessionId && event.context.messages.length > 0) {
+                const priorContext = formatContextForPrompt(event.context);
+                if (priorContext) {
+                    prompt = [
+                        "Recent conversation context from this Discord channel:",
+                        priorContext,
+                        "",
+                        `Current user message: ${prompt}`,
+                    ].join("\n");
+                }
+            }
+            const voiceConfig = agent.chat?.discord?.voice;
+            if (event.metadata.isVoiceMessage) {
+                if (!voiceConfig?.enabled) {
+                    await event.reply("Voice messages are not enabled for this agent. Please send a text message instead.");
+                    return;
+                }
+                const apiKey = process.env[voiceConfig.api_key_env ?? "OPENAI_API_KEY"];
+                if (!apiKey) {
+                    logger.error(`Voice transcription API key not found in env var '${voiceConfig.api_key_env}'`);
+                    await event.reply("Voice transcription is misconfigured. Please contact an administrator.");
+                    return;
+                }
+                if (!event.metadata.voiceAttachmentUrl) {
+                    await event.reply("Could not find audio attachment in voice message.");
+                    return;
+                }
+                try {
+                    logger.debug("Downloading voice message audio...");
+                    const audioResponse = await fetch(event.metadata.voiceAttachmentUrl, {
+                        signal: AbortSignal.timeout(30_000),
+                    });
+                    if (!audioResponse.ok) {
+                        throw new Error(`Failed to download audio: ${audioResponse.status}`);
+                    }
+                    const audioBuffer = Buffer.from(await audioResponse.arrayBuffer());
+                    const filename = event.metadata.voiceAttachmentName ?? "voice-message.ogg";
+                    logger.debug("Transcribing voice message...");
+                    const transcription = await transcribeAudio(audioBuffer, filename, {
+                        apiKey,
+                        model: voiceConfig.model,
+                        language: voiceConfig.language,
+                    });
+                    prompt = `[Voice message transcription]: ${transcription.text}`;
+                    logger.info(`Voice message transcribed: "${prompt.substring(0, 80)}..."`);
+                    // Echo the transcription to the channel so everyone can read the voice message
+                    await event.reply({
+                        embeds: [
+                            {
+                                description: transcription.text,
+                                color: 0x95a5a6, // subtle grey
+                                footer: { text: "Voice transcription" },
+                            },
+                        ],
+                    });
+                }
+                catch (transcribeError) {
+                    const errMsg = transcribeError instanceof Error ? transcribeError.message : String(transcribeError);
+                    logger.error(`Voice transcription failed: ${errMsg}`);
+                    await event.reply(`Failed to transcribe voice message: ${errMsg}`);
+                    return;
+                }
+            }
+            // Handle file attachments: download, process, and prepend to prompt
+            if (event.metadata.attachments &&
+                event.metadata.attachments.length > 0 &&
+                attachmentConfig?.enabled) {
+                const result = await DiscordManager.processAttachments(event.metadata.attachments, attachmentConfig, workingDir, logger);
+                attachmentDownloadedPaths = result.downloadedPaths;
+                if (result.skippedFiles.length > 0) {
+                    for (const skipped of result.skippedFiles) {
+                        logger.debug(`Skipped attachment ${skipped.name}: ${skipped.reason}`);
+                    }
+                }
+                if (result.promptSections.length > 0) {
+                    // When agent runs in Docker, translate host paths to container paths
+                    // (working_directory is mounted at /workspace inside the container)
+                    let sections = result.promptSections;
+                    if (agent.docker?.enabled && workingDir) {
+                        sections = sections.map((s) => s.replaceAll(workingDir, "/workspace"));
+                    }
+                    const attachmentBlock = [
+                        "The user sent the following file attachment(s) with their message:",
+                        "",
+                        ...sections,
+                        "",
+                        "---",
+                        "",
+                        `User message: ${prompt}`,
+                    ].join("\n");
+                    prompt = attachmentBlock;
+                }
+            }
             // Track pending tool_use blocks so we can pair them with results
             const pendingToolUses = new Map();
             let embedsSent = 0;
+            // Deduplicate assistant messages by finalized snapshot. Claude Code can emit
+            // intermediate snapshots (stop_reason: null) before the final assistant message.
+            // We skip intermediates and deliver the first finalized snapshot per message.id.
+            const deliveredAssistantIds = new Set();
+            // Capture the result text from the SDK's "result" message as a fallback
+            // When all assistant messages are tool-only (no text), this is the last resort
+            let resultText;
+            let sentAnswer = false;
+            let streamedDeltaSinceFinal = false;
+            // Progress indicator: track tool names for in-place-updating embed
+            const toolNamesRun = [];
+            let lastProgressUpdate = 0;
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            let liveAnswerHandle = null;
+            let liveAnswerText = "";
+            let latestStatusText = "Preparing run…";
+            const refreshRunCard = async (status) => {
+                if (!showProgressIndicator) {
+                    return;
+                }
+                const now = Date.now();
+                if (status === "running" && now - lastProgressUpdate < 1500) {
+                    return;
+                }
+                lastProgressUpdate = now;
+                const header = toolNamesRun.length > 0 ? `Running · ${toolNamesRun.join("  →  ")}` : "Running";
+                const message = status === "running" ? `${header}\n${latestStatusText}` : latestStatusText;
+                const embedPayload = {
+                    embeds: [
+                        buildRunCardEmbed({
+                            agentName: qualifiedName,
+                            status,
+                            message: message.length > 4000 ? `…${message.slice(-3997)}` : message,
+                            traceLines,
+                        }),
+                    ],
+                };
+                try {
+                    if (!progressState.handle) {
+                        progressState.handle = await event.replyWithRef(embedPayload);
+                    }
+                    else {
+                        await progressState.handle.edit(embedPayload);
+                    }
+                }
+                catch (progressError) {
+                    logger.warn(`Failed to update run card: ${progressError.message}`);
+                }
+            };
+            const showToolResults = outputConfig.tool_results;
+            const enableDeltaStreaming = assistantMessages === "all";
             // Execute job via FleetManager.trigger() through the context
             // Pass resume option for conversation continuity
             // The onMessage callback streams output incrementally to Discord
             const result = await this.ctx.trigger(qualifiedName, undefined, {
                 triggerType: "discord",
-                prompt: event.prompt,
+                prompt,
                 resume: existingSessionId,
+                injectedMcpServers,
+                onJobCreated: async (jobId) => {
+                    this.activeJobsByChannel.set(this.getChannelKey(qualifiedName, event.metadata.channelId), jobId);
+                },
                 onMessage: async (message) => {
-                    // Extract text content from assistant messages and stream to Discord
-                    if (message.type === "assistant") {
-                        // Cast to the SDKMessage shape expected by extractMessageContent
-                        // The chat package's SDKMessage type expects a specific structure
-                        const sdkMessage = message;
-                        const content = extractMessageContent(sdkMessage);
-                        if (content) {
-                            // Each assistant message is a complete turn - send immediately
-                            await streamer.addMessageAndSend(content);
+                    for (const normalized of normalizeDiscordMessage(message)) {
+                        if (normalized.kind === "assistant_delta") {
+                            if (!enableDeltaStreaming) {
+                                continue;
+                            }
+                            streamedDeltaSinceFinal = true;
+                            liveAnswerText += normalized.delta;
+                            if (!liveAnswerText.trim()) {
+                                continue;
+                            }
+                            const payload = { content: liveAnswerText };
+                            try {
+                                if (!liveAnswerHandle) {
+                                    liveAnswerHandle = await event.replyWithRef(payload);
+                                }
+                                else {
+                                    await liveAnswerHandle.edit(payload);
+                                }
+                                sentAnswer = true;
+                            }
+                            catch (deltaError) {
+                                logger.warn(`Failed delta streaming update: ${deltaError.message}`);
+                            }
+                            continue;
                         }
-                        // Track tool_use blocks for pairing with results later
-                        const toolUseBlocks = extractToolUseBlocks(sdkMessage);
-                        for (const block of toolUseBlocks) {
-                            if (block.id) {
-                                pendingToolUses.set(block.id, {
-                                    name: block.name,
-                                    input: block.input,
-                                    startTime: Date.now(),
-                                });
+                        if (normalized.kind === "assistant_final") {
+                            for (const block of normalized.toolUses) {
+                                if (block.id) {
+                                    pendingToolUses.set(block.id, {
+                                        name: block.name,
+                                        input: block.input,
+                                        startTime: Date.now(),
+                                    });
+                                }
+                                if (block.name && showProgressIndicator) {
+                                    const emoji = TOOL_EMOJIS[block.name] ?? "\u{1F527}";
+                                    const displayName = `${emoji} ${block.name}`;
+                                    toolNamesRun.push(displayName);
+                                    if (toolNamesRun.length > 50) {
+                                        toolNamesRun.splice(0, toolNamesRun.length - 50);
+                                    }
+                                    const inputSummary = getToolInputSummary(block.name, block.input);
+                                    pushTraceLine(`${emoji} ${block.name}${inputSummary ? ` · ${inputSummary.slice(0, 60)}` : ""}`);
+                                    latestStatusText = `Executing ${block.name}`;
+                                    await refreshRunCard("running");
+                                }
+                            }
+                            if (normalized.messageId && normalized.stopReason === null) {
+                                continue;
+                            }
+                            if (normalized.messageId) {
+                                if (deliveredAssistantIds.has(normalized.messageId)) {
+                                    continue;
+                                }
+                                deliveredAssistantIds.add(normalized.messageId);
+                            }
+                            const content = normalized.content;
+                            if (!content) {
+                                streamedDeltaSinceFinal = false;
+                                continue;
                             }
+                            if (assistantMessages === "answers") {
+                                if (normalized.toolUses.length === 0) {
+                                    await streamer.addMessageAndSend(content);
+                                    sentAnswer = true;
+                                }
+                            }
+                            else if (streamedDeltaSinceFinal && enableDeltaStreaming) {
+                                // Sync final content into the live delta message to avoid duplicates.
+                                liveAnswerText = content;
+                                try {
+                                    if (!liveAnswerHandle) {
+                                        liveAnswerHandle = await event.replyWithRef({ content });
+                                    }
+                                    else {
+                                        await liveAnswerHandle.edit({ content });
+                                    }
+                                    sentAnswer = true;
+                                }
+                                catch (syncError) {
+                                    logger.warn(`Failed to sync final streamed answer: ${syncError.message}`);
+                                    await streamer.addMessageAndSend(content);
+                                    sentAnswer = true;
+                                }
+                            }
+                            else {
+                                await streamer.addMessageAndSend(content);
+                                sentAnswer = true;
+                            }
+                            streamedDeltaSinceFinal = false;
+                            continue;
                         }
-                    }
-                    // Build and send embeds for tool results
-                    if (message.type === "user" && outputConfig.tool_results) {
-                        // Cast to the shape expected by extractToolResults
-                        const userMessage = message;
-                        const toolResults = extractToolResults(userMessage);
-                        for (const toolResult of toolResults) {
-                            // Look up the matching tool_use for name, input, and timing
-                            const toolUse = toolResult.toolUseId
-                                ? pendingToolUses.get(toolResult.toolUseId)
-                                : undefined;
-                            if (toolResult.toolUseId) {
-                                pendingToolUses.delete(toolResult.toolUseId);
+                        if (normalized.kind === "tool_results" && showToolResults) {
+                            for (const toolResult of normalized.results) {
+                                const toolUse = toolResult.toolUseId
+                                    ? pendingToolUses.get(toolResult.toolUseId)
+                                    : undefined;
+                                if (toolResult.toolUseId) {
+                                    pendingToolUses.delete(toolResult.toolUseId);
+                                }
+                                const toolName = toolUse?.name ?? "Tool";
+                                const output = toolResult.output.trim();
+                                const preview = output.length > 0 ? output.replace(/\s+/g, " ").slice(0, 90) : "";
+                                pushTraceLine(`${toolResult.isError ? "✖" : "✓"} ${toolName}${preview ? ` · ${preview}` : ""}`);
+                                latestStatusText = `${toolResult.isError ? "Error from" : "Completed"} ${toolName}`;
+                                await refreshRunCard("running");
+                                // Oversized output is attached as a file instead of flooding chat.
+                                const maxOutputChars = outputConfig.tool_result_max_length ?? 900;
+                                if (output.length > maxOutputChars) {
+                                    await streamer.flush();
+                                    const filename = `${toolName.toLowerCase().replace(/[^a-z0-9_-]+/g, "-") || "tool"}-output.txt`;
+                                    const previewEmbed = buildToolResultEmbed({
+                                        toolUse: toolUse ?? null,
+                                        toolResult: {
+                                            output: output.slice(0, Math.min(300, maxOutputChars)),
+                                            isError: toolResult.isError,
+                                        },
+                                        agentName: qualifiedName,
+                                        maxOutputChars: Math.min(300, maxOutputChars),
+                                    });
+                                    await event.reply({
+                                        embeds: [previewEmbed],
+                                        files: [{ attachment: Buffer.from(output, "utf8"), name: filename }],
+                                    });
+                                    embedsSent++;
+                                }
                             }
-                            const embed = this.buildToolEmbed(toolUse ?? null, toolResult, outputConfig.tool_result_max_length);
-                            // Flush any buffered text before sending embed to preserve ordering
-                            await streamer.flush();
-                            await event.reply({ embeds: [embed] });
-                            embedsSent++;
+                            continue;
                         }
-                    }
-                    // Show system status messages (e.g., "compacting context...")
-                    if (message.type === "system" && outputConfig.system_status) {
-                        const sysMessage = message;
-                        if (sysMessage.subtype === "status" && sysMessage.status) {
-                            const statusText = sysMessage.status === "compacting"
-                                ? "Compacting context..."
-                                : `Status: ${sysMessage.status}`;
-                            await streamer.flush();
-                            await event.reply({
-                                embeds: [
-                                    {
-                                        title: "\u2699\uFE0F System",
-                                        description: statusText,
-                                        color: DiscordManager.EMBED_COLOR_SYSTEM,
-                                    },
-                                ],
-                            });
-                            embedsSent++;
+                        if (normalized.kind === "system_status" && outputConfig.system_status) {
+                            latestStatusText =
+                                normalized.status === "compacting" ? "Compacting context…" : normalized.status;
+                            pushTraceLine(`ℹ ${latestStatusText}`);
+                            await refreshRunCard("running");
+                            continue;
                         }
-                    }
-                    // Show result summary embed (cost, tokens, turns)
-                    if (message.type === "result" && outputConfig.result_summary) {
-                        const resultMessage = message;
-                        const fields = [];
-                        if (resultMessage.duration_ms !== undefined) {
-                            fields.push({
-                                name: "Duration",
-                                value: DiscordManager.formatDuration(resultMessage.duration_ms),
-                                inline: true,
-                            });
+                        if (normalized.kind === "tool_progress" && outputConfig.system_status) {
+                            latestStatusText = normalized.content;
+                            pushTraceLine(`ℹ ${normalized.content}`);
+                            await refreshRunCard("running");
+                            continue;
                         }
-                        if (resultMessage.num_turns !== undefined) {
-                            fields.push({
-                                name: "Turns",
-                                value: String(resultMessage.num_turns),
-                                inline: true,
-                            });
+                        if (normalized.kind === "auth_status" && outputConfig.system_status) {
+                            latestStatusText = normalized.content;
+                            pushTraceLine(`${normalized.isError ? "✖" : "ℹ"} ${normalized.content}`);
+                            if (normalized.isError) {
+                                await streamer.flush();
+                                await event.reply({
+                                    embeds: [buildStatusEmbed(normalized.content, "error", qualifiedName)],
+                                });
+                                embedsSent++;
+                            }
+                            else {
+                                await refreshRunCard("running");
+                            }
+                            continue;
                         }
-                        if (resultMessage.total_cost_usd !== undefined) {
-                            fields.push({
-                                name: "Cost",
-                                value: `$${resultMessage.total_cost_usd.toFixed(4)}`,
-                                inline: true,
+                        if (normalized.kind === "result") {
+                            if (normalized.resultText) {
+                                resultText = normalized.resultText;
+                            }
+                            const now = new Date().toISOString();
+                            this.lastUsageByChannel.set(this.getChannelKey(qualifiedName, event.metadata.channelId), {
+                                timestamp: now,
+                                numTurns: normalized.numTurns,
+                                durationMs: normalized.durationMs,
+                                totalCostUsd: normalized.totalCostUsd,
+                                inputTokens: normalized.usage?.input_tokens,
+                                outputTokens: normalized.usage?.output_tokens,
+                                isError: normalized.isError,
                             });
+                            this.accumulateUsage(qualifiedName, {
+                                durationMs: normalized.durationMs,
+                                totalCostUsd: normalized.totalCostUsd,
+                                inputTokens: normalized.usage?.input_tokens,
+                                outputTokens: normalized.usage?.output_tokens,
+                                isError: normalized.isError,
+                                timestamp: now,
+                            });
+                            latestStatusText = normalized.isError ? "Task failed" : "Task complete";
+                            await refreshRunCard(normalized.isError ? "error" : "success");
+                            if (outputConfig.result_summary) {
+                                await streamer.flush();
+                                await event.reply({
+                                    embeds: [
+                                        buildResultSummaryEmbed({
+                                            agentName: qualifiedName,
+                                            isError: normalized.isError,
+                                            durationMs: normalized.durationMs,
+                                            numTurns: normalized.numTurns,
+                                            totalCostUsd: normalized.totalCostUsd,
+                                            usage: normalized.usage,
+                                        }),
+                                    ],
+                                });
+                                embedsSent++;
+                            }
+                            continue;
                         }
-                        if (resultMessage.usage) {
-                            const inputTokens = resultMessage.usage.input_tokens ?? 0;
-                            const outputTokens = resultMessage.usage.output_tokens ?? 0;
-                            fields.push({
-                                name: "Tokens",
-                                value: `${inputTokens.toLocaleString()} in / ${outputTokens.toLocaleString()} out`,
-                                inline: true,
+                        if (normalized.kind === "error" && outputConfig.errors) {
+                            await streamer.flush();
+                            await event.reply({
+                                embeds: [buildErrorEmbed(normalized.message, qualifiedName)],
                             });
+                            embedsSent++;
                         }
-                        const isError = resultMessage.is_error === true;
-                        await streamer.flush();
-                        await event.reply({
-                            embeds: [
-                                {
-                                    title: isError ? "\u274C Task Failed" : "\u2705 Task Complete",
-                                    color: isError
-                                        ? DiscordManager.EMBED_COLOR_ERROR
-                                        : DiscordManager.EMBED_COLOR_SUCCESS,
-                                    fields,
-                                },
-                            ],
-                        });
-                        embedsSent++;
-                    }
-                    // Show SDK error messages
-                    if (message.type === "error" && outputConfig.errors) {
-                        const errorText = typeof message.content === "string" ? message.content : "An unknown error occurred";
-                        await streamer.flush();
-                        await event.reply({
-                            embeds: [
-                                {
-                                    title: "\u274C Error",
-                                    description: errorText.length > 4000 ? `${errorText.substring(0, 4000)}...` : errorText,
-                                    color: DiscordManager.EMBED_COLOR_ERROR,
-                                },
-                            ],
-                        });
-                        embedsSent++;
                     }
                 },
             });
@@ -471,18 +795,60 @@ export class DiscordManager {
                 stopTyping();
                 typingStopped = true;
             }
+            // Fall back to SDK result text if no answer turns produced text
+            if (!sentAnswer && !streamer.hasSentMessages() && resultText) {
+                logger.debug("No answer turns produced text — using SDK result text as fallback");
+                await streamer.addMessageAndSend(resultText);
+                sentAnswer = true;
+            }
             // Flush any remaining buffered content
             await streamer.flush();
+            // Send any remaining buffered files that weren't attached to an answer.
+            // This handles the case where the agent uploaded files but produced no text answer.
+            if (pendingFiles.length > 0) {
+                const files = pendingFiles.splice(0);
+                logger.debug(`Sending ${files.length} remaining buffered file(s) as standalone message`);
+                await event.reply({
+                    files: files.map((f) => ({ attachment: f.buffer, name: f.filename })),
+                });
+            }
             logger.debug(`Discord job completed: ${result.jobId} for agent '${qualifiedName}'${result.sessionId ? ` (session: ${result.sessionId})` : ""}`);
-            // If no messages were sent (text or embeds), send an appropriate fallback
-            if (!streamer.hasSentMessages() && embedsSent === 0) {
+            if (progressState.handle) {
+                try {
+                    await progressState.handle.edit({
+                        embeds: [
+                            buildRunCardEmbed({
+                                agentName: qualifiedName,
+                                status: result.success ? "success" : "error",
+                                message: result.success ? "Task complete" : "Task failed",
+                                traceLines,
+                            }),
+                        ],
+                    });
+                }
+                catch (progressError) {
+                    logger.warn(`Failed to finalize run card: ${progressError.message}`);
+                }
+            }
+            // If no text messages were sent, send an appropriate fallback.
+            // When embedsSent > 0 but no text was delivered, the user saw tool/result embeds
+            // but may have missed the final answer. Show a brief completion indicator.
+            if (!sentAnswer && !streamer.hasSentMessages() && embedsSent === 0) {
                 if (result.success) {
-                    await event.reply("I've completed the task, but I don't have a specific response to share.");
+                    await event.reply({
+                        embeds: [
+                            buildStatusEmbed("Task completed — no additional output to share.", "info", qualifiedName),
+                        ],
+                    });
                 }
                 else {
                     // Job failed without streaming any messages - send error details
                     const errorMessage = result.errorDetails?.message ?? result.error?.message ?? "An unknown error occurred";
-                    await event.reply(`\u274C **Error:** ${errorMessage}\n\nThe task could not be completed. Please check the logs for more details.`);
+                    await event.reply({
+                        embeds: [
+                            buildErrorEmbed(`${errorMessage}\n\nThe task could not be completed.`, qualifiedName),
+                        ],
+                    });
                 }
                 // Stop typing after sending fallback message (if not already stopped)
                 if (!typingStopped) {
@@ -518,9 +884,26 @@ export class DiscordManager {
         catch (error) {
             const err = error instanceof Error ? error : new Error(String(error));
             logger.error(`Discord message handling failed for agent '${qualifiedName}': ${err.message}`);
+            if (progressState.handle) {
+                try {
+                    await progressState.handle.edit({
+                        embeds: [
+                            buildRunCardEmbed({
+                                agentName: qualifiedName,
+                                status: "error",
+                                message: `Task failed · ${err.message}`,
+                                traceLines,
+                            }),
+                        ],
+                    });
+                }
+                catch (progressError) {
+                    logger.warn(`Failed to finalize failed run card: ${progressError.message}`);
+                }
+            }
             // Send user-friendly error message using the formatted error method
             try {
-                await event.reply(this.formatErrorMessage(err));
+                await event.reply(this.formatErrorMessage(err, qualifiedName));
             }
             catch (replyError) {
                 logger.error(`Failed to send error reply: ${replyError.message}`);
@@ -535,102 +918,33 @@ export class DiscordManager {
             });
         }
         finally {
+            this.activeJobsByChannel.delete(this.getChannelKey(qualifiedName, event.metadata.channelId));
             // Safety net: stop typing indicator if not already stopped
             // (Should already be stopped after sending messages, but this ensures cleanup on errors)
             if (!typingStopped) {
                 stopTyping();
             }
+            // Remove acknowledgement reaction now that processing is complete
+            if (ackEmoji) {
+                try {
+                    await event.removeReaction(ackEmoji);
+                }
+                catch (reactionError) {
+                    logger.warn(`Failed to remove ack reaction: ${reactionError.message}`);
+                }
+            }
+            // Clean up downloaded attachment files if configured
+            if (attachmentDownloadedPaths.length > 0 &&
+                attachmentConfig?.cleanup_after_processing !== false) {
+                try {
+                    await DiscordManager.cleanupAttachments(attachmentDownloadedPaths, logger);
+                }
+                catch (cleanupError) {
+                    logger.warn(`Failed to cleanup attachments: ${cleanupError.message}`);
+                }
+            }
         }
     }
-    // =============================================================================
-    // Tool Embed Support
-    // =============================================================================
-    /** Maximum characters for tool output in Discord embed fields */
-    static TOOL_OUTPUT_MAX_CHARS = 900;
-    /** Embed colors */
-    static EMBED_COLOR_DEFAULT = 0x5865f2; // Discord blurple
-    static EMBED_COLOR_ERROR = 0xef4444; // Red
-    static EMBED_COLOR_SYSTEM = 0x95a5a6; // Gray
-    static EMBED_COLOR_SUCCESS = 0x57f287; // Green
-    /**
-     * Format duration in milliseconds to a human-readable string
-     */
-    static formatDuration(ms) {
-        if (ms < 1000)
-            return `${ms}ms`;
-        const seconds = Math.floor(ms / 1000);
-        if (seconds < 60)
-            return `${seconds}s`;
-        const minutes = Math.floor(seconds / 60);
-        const remainingSeconds = seconds % 60;
-        return remainingSeconds > 0 ? `${minutes}m ${remainingSeconds}s` : `${minutes}m`;
-    }
-    /**
-     * Build a Discord embed for a tool call result
-     *
-     * Combines the tool_use info (name, input) with the tool_result
-     * (output, error status) into a compact Discord embed.
-     *
-     * @param toolUse - The tool_use block info (name, input, startTime)
-     * @param toolResult - The tool result (output, isError)
-     * @param maxOutputChars - Maximum characters for output (defaults to TOOL_OUTPUT_MAX_CHARS)
-     */
-    buildToolEmbed(toolUse, toolResult, maxOutputChars) {
-        const toolName = toolUse?.name ?? "Tool";
-        const emoji = TOOL_EMOJIS[toolName] ?? "\u{1F527}"; // wrench fallback
-        const isError = toolResult.isError;
-        // Build description from input summary
-        const inputSummary = toolUse ? getToolInputSummary(toolUse.name, toolUse.input) : undefined;
-        let description;
-        if (inputSummary) {
-            if (toolName === "Bash" || toolName === "bash") {
-                description = `\`> ${inputSummary}\``;
-            }
-            else {
-                description = `\`${inputSummary}\``;
-            }
-        }
-        // Build inline fields
-        const fields = [];
-        if (toolUse) {
-            const durationMs = Date.now() - toolUse.startTime;
-            fields.push({
-                name: "Duration",
-                value: DiscordManager.formatDuration(durationMs),
-                inline: true,
-            });
-        }
-        const outputLength = toolResult.output.length;
-        fields.push({
-            name: "Output",
-            value: outputLength >= 1000
-                ? `${(outputLength / 1000).toFixed(1)}k chars`
-                : `${outputLength} chars`,
-            inline: true,
-        });
-        // Add truncated output as a field if non-empty
-        const trimmedOutput = toolResult.output.trim();
-        if (trimmedOutput.length > 0) {
-            const maxChars = maxOutputChars ?? DiscordManager.TOOL_OUTPUT_MAX_CHARS;
-            let outputText = trimmedOutput;
-            if (outputText.length > maxChars) {
-                outputText =
-                    outputText.substring(0, maxChars) +
-                        `\n... (${outputLength.toLocaleString()} chars total)`;
-            }
-            fields.push({
-                name: isError ? "Error" : "Result",
-                value: `\`\`\`\n${outputText}\n\`\`\``,
-                inline: false,
-            });
-        }
-        return {
-            title: `${emoji} ${toolName}`,
-            description,
-            color: isError ? DiscordManager.EMBED_COLOR_ERROR : DiscordManager.EMBED_COLOR_DEFAULT,
-            fields,
-        };
-    }
     /**
      * Handle errors from Discord connectors
      *
@@ -651,6 +965,345 @@ export class DiscordManager {
             timestamp: new Date().toISOString(),
         });
     }
+    getChannelKey(qualifiedName, channelId) {
+        return `${qualifiedName}:${channelId}`;
+    }
+    async stopChannelRun(qualifiedName, channelId) {
+        const key = this.getChannelKey(qualifiedName, channelId);
+        const jobId = this.activeJobsByChannel.get(key);
+        if (!jobId) {
+            return {
+                success: false,
+                message: "No active run found for this channel.",
+            };
+        }
+        try {
+            const fleetManager = this.ctx.getEmitter();
+            await fleetManager.cancelJob(jobId);
+            this.activeJobsByChannel.delete(key);
+            return {
+                success: true,
+                message: `Stop requested for job \`${jobId}\`.`,
+                jobId,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                message: `Failed to stop active run: ${error.message}`,
+                jobId,
+            };
+        }
+    }
+    async retryChannelRun(qualifiedName, channelId) {
+        const key = this.getChannelKey(qualifiedName, channelId);
+        const lastPrompt = this.lastPromptByChannel.get(key);
+        if (!lastPrompt) {
+            return {
+                success: false,
+                message: "No previous prompt found to retry in this channel.",
+            };
+        }
+        return this.runChannelPrompt(qualifiedName, channelId, lastPrompt);
+    }
+    // ===========================================================================
+    // Synthetic Event Helpers
+    // ===========================================================================
+    toTextChannel(channel) {
+        return channel;
+    }
+    /**
+     * Build a DiscordMessageEvent from scratch for programmatic triggers
+     * (e.g. /retry). This keeps the boilerplate in one place so any new
+     * fields on DiscordMessageEvent only need updating here.
+     */
+    createSyntheticMessageEvent(params) {
+        const { qualifiedName, prompt, channelId, channel, textChannel, logger } = params;
+        return {
+            agentName: qualifiedName,
+            prompt,
+            context: {
+                messages: [],
+                prompt,
+                wasMentioned: false,
+            },
+            metadata: {
+                guildId: typeof channel.isDMBased === "function" && channel.isDMBased()
+                    ? null
+                    : typeof channel.guildId === "string"
+                        ? channel.guildId
+                        : null,
+                channelId,
+                messageId: `synthetic-${randomUUID()}`,
+                userId: "system",
+                username: "system",
+                wasMentioned: false,
+                mode: "auto",
+            },
+            reply: async (content) => {
+                await textChannel.send(content);
+            },
+            replyWithRef: async (content) => {
+                const sent = await textChannel.send(content);
+                return {
+                    edit: async (c) => {
+                        await sent.edit(c);
+                    },
+                    delete: async () => {
+                        await sent.delete();
+                    },
+                };
+            },
+            startTyping: () => {
+                let typingInterval = null;
+                if (textChannel.sendTyping) {
+                    void textChannel.sendTyping().catch((err) => {
+                        logger.debug(`Synthetic typing indicator failed: ${err.message}`);
+                    });
+                    typingInterval = setInterval(() => {
+                        void textChannel.sendTyping?.().catch((err) => {
+                            logger.debug(`Synthetic typing refresh failed: ${err.message}`);
+                        });
+                    }, 8000);
+                }
+                return () => {
+                    if (typingInterval) {
+                        clearInterval(typingInterval);
+                        typingInterval = null;
+                    }
+                };
+            },
+            addReaction: async () => { },
+            removeReaction: async () => { },
+        };
+    }
+    async getChannelRunInfo(qualifiedName, channelId) {
+        const key = this.getChannelKey(qualifiedName, channelId);
+        return {
+            activeJobId: this.activeJobsByChannel.get(key),
+            lastPrompt: this.lastPromptByChannel.get(key),
+        };
+    }
+    async getChannelUsage(qualifiedName, channelId) {
+        return this.lastUsageByChannel.get(this.getChannelKey(qualifiedName, channelId)) ?? null;
+    }
+    accumulateUsage(qualifiedName, run) {
+        const existing = this.cumulativeUsageByAgent.get(qualifiedName);
+        if (existing) {
+            existing.totalRuns++;
+            if (run.isError)
+                existing.totalFailures++;
+            else
+                existing.totalSuccesses++;
+            existing.totalCostUsd += run.totalCostUsd ?? 0;
+            existing.totalInputTokens += run.inputTokens ?? 0;
+            existing.totalOutputTokens += run.outputTokens ?? 0;
+            existing.totalDurationMs += run.durationMs ?? 0;
+            existing.lastRunAt = run.timestamp;
+        }
+        else {
+            this.cumulativeUsageByAgent.set(qualifiedName, {
+                totalRuns: 1,
+                totalSuccesses: run.isError ? 0 : 1,
+                totalFailures: run.isError ? 1 : 0,
+                totalCostUsd: run.totalCostUsd ?? 0,
+                totalInputTokens: run.inputTokens ?? 0,
+                totalOutputTokens: run.outputTokens ?? 0,
+                totalDurationMs: run.durationMs ?? 0,
+                firstRunAt: run.timestamp,
+                lastRunAt: run.timestamp,
+            });
+        }
+    }
+    async getAgentCumulativeUsage(qualifiedName) {
+        return (this.cumulativeUsageByAgent.get(qualifiedName) ?? {
+            totalRuns: 0,
+            totalSuccesses: 0,
+            totalFailures: 0,
+            totalCostUsd: 0,
+            totalInputTokens: 0,
+            totalOutputTokens: 0,
+            totalDurationMs: 0,
+            firstRunAt: "",
+            lastRunAt: "",
+        });
+    }
+    async runChannelSkill(qualifiedName, channelId, skillName, input) {
+        const agent = this.getAgentByQualifiedName(qualifiedName);
+        if (!agent) {
+            return {
+                success: false,
+                message: `Agent '${qualifiedName}' is not available.`,
+            };
+        }
+        const availableSkills = await this.discoverAgentSkills(agent);
+        if (availableSkills.length === 0) {
+            return {
+                success: false,
+                message: "No skills are configured/discovered for this agent. Configure `chat.discord.skills` or ensure skills exist in the agent working directory.",
+            };
+        }
+        const matchedSkill = availableSkills.find((s) => s.name === skillName);
+        if (!matchedSkill) {
+            return {
+                success: false,
+                message: `Unknown skill \`${skillName}\`. Use \`/skills\` to see available skills.`,
+            };
+        }
+        const instruction = [
+            `Use the "${matchedSkill.name}" skill to handle this request.`,
+            "",
+            input?.trim() ? input.trim() : "No additional input was provided.",
+        ].join("\n");
+        const result = await this.runChannelPrompt(qualifiedName, channelId, instruction);
+        if (result.success) {
+            return {
+                ...result,
+                message: `Skill \`${matchedSkill.name}\` started. Output will be posted in this channel.`,
+            };
+        }
+        return result;
+    }
+    async runChannelPrompt(qualifiedName, channelId, prompt) {
+        const logger = this.ctx.getLogger();
+        const key = this.getChannelKey(qualifiedName, channelId);
+        const activeJobId = this.activeJobsByChannel.get(key);
+        if (activeJobId) {
+            return {
+                success: false,
+                message: `A run is already active in this channel (\`${activeJobId}\`).`,
+                jobId: activeJobId,
+            };
+        }
+        const connector = this.connectors.get(qualifiedName);
+        if (!connector?.client?.isReady()) {
+            return {
+                success: false,
+                message: "Run cannot start because the Discord connector is not connected.",
+            };
+        }
+        const channel = await connector.client.channels.fetch(channelId);
+        if (!channel ||
+            !("isTextBased" in channel) ||
+            typeof channel.isTextBased !== "function" ||
+            !channel.isTextBased() ||
+            !("send" in channel) ||
+            typeof channel.send !== "function") {
+            return {
+                success: false,
+                message: "Run failed because this channel is not text-capable.",
+            };
+        }
+        const textChannel = this.toTextChannel(channel);
+        const syntheticEvent = this.createSyntheticMessageEvent({
+            qualifiedName,
+            prompt,
+            channelId,
+            channel,
+            textChannel,
+            logger,
+        });
+        this.lastPromptByChannel.set(key, prompt);
+        void this.handleMessage(qualifiedName, syntheticEvent)
+            .catch(async (error) => {
+            const err = error instanceof Error ? error : new Error(String(error));
+            logger.error(`Background slash run failed for '${qualifiedName}': ${err.message}`);
+            try {
+                await textChannel.send(this.formatErrorMessage(err, qualifiedName));
+            }
+            catch (replyError) {
+                logger.error(`Failed to send slash failure message: ${replyError.message}`);
+            }
+        })
+            .finally(() => {
+            this.activeJobsByChannel.delete(key);
+        });
+        return {
+            success: true,
+            message: "Run started. Output will be posted in this channel.",
+        };
+    }
+    async discoverAgentSkills(agent) {
+        const discovered = new Map();
+        // Step 1: if skills are explicitly configured, use them as-is.
+        // - undefined → not configured, fall through to auto-discovery
+        // - [] → explicitly disabled, return empty
+        // - [...] → use exactly those skills
+        const configuredSkills = this.getConfiguredDiscordSkills(agent);
+        if (configuredSkills !== undefined) {
+            return configuredSkills
+                .filter((s) => s.name.trim().length > 0)
+                .sort((a, b) => a.name.localeCompare(b.name));
+        }
+        // Step 2: auto-discover from agent working directory paths.
+        const workingDir = typeof agent.working_directory === "string"
+            ? agent.working_directory
+            : agent.working_directory?.root;
+        if (!workingDir) {
+            return Array.from(discovered.values()).sort((a, b) => a.name.localeCompare(b.name));
+        }
+        const candidateDirs = [
+            join(workingDir, ".claude", "skills"),
+            join(workingDir, ".codex", "skills"),
+            join(workingDir, "skills"),
+        ];
+        for (const dir of candidateDirs) {
+            try {
+                const entries = await readdir(resolve(dir), { withFileTypes: true });
+                for (const entry of entries) {
+                    if (!entry.isDirectory())
+                        continue;
+                    const skillName = entry.name;
+                    const skillPath = join(dir, skillName, "SKILL.md");
+                    try {
+                        const raw = await readFile(skillPath, "utf8");
+                        const lines = raw.split("\n").map((line) => line.trim());
+                        const description = lines.find((line) => line.length > 0 && !line.startsWith("#"))?.slice(0, 120) ??
+                            undefined;
+                        discovered.set(skillName, { name: skillName, description });
+                    }
+                    catch {
+                        // Ignore directories without readable SKILL.md
+                    }
+                }
+            }
+            catch {
+                // Directory does not exist or is unreadable; skip.
+            }
+        }
+        return Array.from(discovered.values()).sort((a, b) => a.name.localeCompare(b.name));
+    }
+    getAgentByQualifiedName(qualifiedName) {
+        const config = this.ctx.getConfig();
+        return config?.agents.find((agent) => agent.qualifiedName === qualifiedName);
+    }
+    getConfiguredDiscordSkills(agent) {
+        const discord = agent.chat?.discord;
+        if (!discord || !("skills" in discord)) {
+            return undefined; // not configured → auto-discover
+        }
+        const skills = discord.skills;
+        if (!Array.isArray(skills)) {
+            return undefined;
+        }
+        // [] → explicitly empty (no skills); [...] → those exact skills
+        return skills
+            .filter((skill) => typeof skill?.name === "string")
+            .map((skill) => ({ name: skill.name, description: skill.description }));
+    }
+    async getAgentConfigSummary(agent) {
+        return {
+            runtime: agent.runtime,
+            model: agent.model,
+            permissionMode: agent.permission_mode,
+            workingDirectory: typeof agent.working_directory === "string"
+                ? agent.working_directory
+                : agent.working_directory?.root,
+            allowedTools: agent.allowed_tools,
+            deniedTools: agent.denied_tools,
+            mcpServers: agent.mcp_servers ? Object.keys(agent.mcp_servers) : [],
+        };
+    }
     // ===========================================================================
     // Response Formatting and Splitting
     // ===========================================================================
@@ -660,12 +1313,21 @@ export class DiscordManager {
      * Format an error message for Discord display
      *
      * Creates a user-friendly error message with guidance on how to proceed.
+     * Returns an embed when agentName is provided, plain text otherwise.
      *
      * @param error - The error that occurred
-     * @returns Formatted error message string
+     * @param agentName - Optional agent name for embed footer
+     * @returns Formatted error message string or embed payload
      */
-    formatErrorMessage(error) {
-        return `\u274C **Error**: ${error.message}\n\nPlease try again or use \`/reset\` to start a new session.`;
+    formatErrorMessage(error, agentName) {
+        if (agentName) {
+            return {
+                embeds: [
+                    buildErrorEmbed(`${error.message}\n\nTry again or use \`/reset\` to start a new session.`, agentName),
+                ],
+            };
+        }
+        return `**Error:** ${error.message}\n\nTry again or use \`/reset\` to start a new session.`;
     }
     /**
      * Split a response into chunks that fit Discord's 2000 character limit
@@ -691,5 +1353,157 @@ export class DiscordManager {
             await reply(chunk);
         }
     }
+    // ===========================================================================
+    // Utility Methods
+    // ===========================================================================
+    /**
+     * Resolve the agent's working directory to an absolute path string
+     */
+    resolveWorkingDirectory(agent) {
+        if (!agent.working_directory) {
+            return undefined;
+        }
+        if (typeof agent.working_directory === "string") {
+            return agent.working_directory;
+        }
+        return agent.working_directory.root;
+    }
+    // ===========================================================================
+    // Attachment Processing
+    // ===========================================================================
+    /** Maximum characters to inline for text/code file content */
+    static TEXT_INLINE_MAX_CHARS = 50_000;
+    /**
+     * Check if a content type matches a MIME pattern (supports wildcards like "image/*")
+     */
+    static matchesMimePattern(contentType, pattern) {
+        const ct = contentType.toLowerCase().split(";")[0].trim();
+        const pat = pattern.toLowerCase().trim();
+        if (pat === ct)
+            return true;
+        if (pat.endsWith("/*")) {
+            const prefix = pat.slice(0, -1); // "image/*" → "image/"
+            return ct.startsWith(prefix);
+        }
+        return false;
+    }
+    /**
+     * Process file attachments: download, categorize, and prepare prompt sections.
+     *
+     * - Text/code files are inlined directly into the prompt
+     * - Images and PDFs are saved to disk so the agent can use its Read tool
+     *
+     * Returns prompt sections to prepend, paths of downloaded files for cleanup,
+     * and a list of skipped files with reasons.
+     */
+    static async processAttachments(attachments, config, workingDir, logger) {
+        const promptSections = [];
+        const downloadedPaths = [];
+        const skippedFiles = [];
+        const maxBytes = config.max_file_size_mb * 1024 * 1024;
+        // Limit to max_files_per_message
+        const toProcess = attachments.slice(0, config.max_files_per_message);
+        if (attachments.length > config.max_files_per_message) {
+            const skipped = attachments.slice(config.max_files_per_message);
+            for (const a of skipped) {
+                skippedFiles.push({ name: a.name, reason: "exceeded max_files_per_message" });
+            }
+        }
+        // Create one collision-resistant directory per message processing run.
+        const messageDownloadDir = randomUUID();
+        for (const attachment of toProcess) {
+            // Check allowed types
+            const allowed = config.allowed_types.some((pattern) => DiscordManager.matchesMimePattern(attachment.contentType, pattern));
+            if (!allowed) {
+                skippedFiles.push({
+                    name: attachment.name,
+                    reason: `type ${attachment.contentType} not in allowed_types`,
+                });
+                continue;
+            }
+            // Check file size
+            if (attachment.size > maxBytes) {
+                skippedFiles.push({
+                    name: attachment.name,
+                    reason: `size ${attachment.size} exceeds ${config.max_file_size_mb}MB limit`,
+                });
+                continue;
+            }
+            try {
+                if (attachment.category === "text") {
+                    // Text/code: download and inline
+                    const response = await fetch(attachment.url, { signal: AbortSignal.timeout(30_000) });
+                    if (!response.ok) {
+                        throw new Error(`HTTP ${response.status}`);
+                    }
+                    let text = await response.text();
+                    if (text.length > DiscordManager.TEXT_INLINE_MAX_CHARS) {
+                        text = `${text.substring(0, DiscordManager.TEXT_INLINE_MAX_CHARS)}\n... [truncated at ${DiscordManager.TEXT_INLINE_MAX_CHARS} chars]`;
+                    }
+                    promptSections.push(`--- File: ${attachment.name} (${attachment.contentType}) ---\n${text}\n--- End of ${attachment.name} ---`);
+                }
+                else {
+                    // Image/PDF: download to disk
+                    if (!workingDir) {
+                        skippedFiles.push({
+                            name: attachment.name,
+                            reason: "no working_directory configured for binary attachments",
+                        });
+                        continue;
+                    }
+                    const response = await fetch(attachment.url, { signal: AbortSignal.timeout(30_000) });
+                    if (!response.ok) {
+                        throw new Error(`HTTP ${response.status}`);
+                    }
+                    const buffer = Buffer.from(await response.arrayBuffer());
+                    const downloadDir = join(workingDir, config.download_dir, messageDownloadDir);
+                    await mkdir(downloadDir, { recursive: true });
+                    const filePath = join(downloadDir, `${attachment.id}-${basename(attachment.name)}`);
+                    await writeFile(filePath, buffer);
+                    downloadedPaths.push(filePath);
+                    const typeLabel = attachment.category === "image" ? "Image" : "PDF";
+                    promptSections.push(`[${typeLabel} attached: ${filePath}] (Use the Read tool to view this file)`);
+                }
+            }
+            catch (err) {
+                const errMsg = err instanceof Error ? err.message : String(err);
+                logger.warn(`Failed to process attachment ${attachment.name}: ${errMsg}`);
+                skippedFiles.push({
+                    name: attachment.name,
+                    reason: `download/processing failed: ${errMsg}`,
+                });
+            }
+        }
+        return { promptSections, downloadedPaths, skippedFiles };
+    }
+    /**
+     * Clean up downloaded attachment files after processing
+     */
+    static async cleanupAttachments(paths, logger) {
+        const parentDirs = new Set();
+        for (const filePath of paths) {
+            try {
+                await rm(filePath);
+                // Track parent directory for cleanup
+                const parent = dirname(filePath);
+                if (parent !== filePath && parent !== ".") {
+                    parentDirs.add(parent);
+                }
+            }
+            catch (err) {
+                const errMsg = err instanceof Error ? err.message : String(err);
+                logger.debug(`Failed to clean up attachment file ${filePath}: ${errMsg}`);
+            }
+        }
+        // Try to remove empty timestamp directories
+        for (const dir of parentDirs) {
+            try {
+                await rm(dir, { recursive: true });
+            }
+            catch {
+                // Directory may not be empty or already removed — ignore
+            }
+        }
+    }
 }
 //# sourceMappingURL=manager.js.map