@herdctl/discord 1.1.0 → 1.2.0

package/dist/__tests__/manager.test.js

@@ -133,9 +133,12 @@ describe("DiscordManager", () => {
                     tool_results: true,
                     tool_result_max_length: 900,
                     system_status: true,
-                    result_summary: false,
+                    result_summary: true,
                     typing_indicator: true,
                     errors: true,
+                    acknowledge_emoji: "eyes",
+                    assistant_messages: "answers",
+                    progress_indicator: true,
                 },
                 guilds: [],
             };
@@ -183,6 +186,140 @@ describe("DiscordManager", () => {
             expect(mockLogger.debug).toHaveBeenCalledWith("No Discord connectors to stop");
         });
     });
+    describe("retry channel run controls", () => {
+        it("routes retry through the normal handleMessage pipeline", async () => {
+            const ctx = createMockContext(null);
+            const manager = new DiscordManager(ctx);
+            const managerAny = manager;
+            const mockSend = vi.fn().mockResolvedValue({
+                edit: vi.fn().mockResolvedValue(undefined),
+                delete: vi.fn().mockResolvedValue(undefined),
+            });
+            const mockChannel = {
+                isTextBased: () => true,
+                isDMBased: () => false,
+                guildId: "guild-1",
+                send: mockSend,
+            };
+            managerAny.connectors = new Map([
+                [
+                    "agent-1",
+                    {
+                        client: {
+                            isReady: () => true,
+                            channels: { fetch: vi.fn().mockResolvedValue(mockChannel) },
+                        },
+                    },
+                ],
+            ]);
+            managerAny.lastPromptByChannel.set("agent-1:channel-1", "retry prompt");
+            const handleMessageSpy = vi
+                .spyOn(managerAny, "handleMessage")
+                .mockResolvedValue(undefined);
+            const result = await managerAny.retryChannelRun("agent-1", "channel-1");
+            await new Promise((resolve) => setTimeout(resolve, 0));
+            expect(result.success).toBe(true);
+            expect(handleMessageSpy).toHaveBeenCalledTimes(1);
+            const [, event] = handleMessageSpy.mock.calls[0];
+            expect(event.prompt).toBe("retry prompt");
+            expect(event.metadata.channelId).toBe("channel-1");
+        });
+        it("catches background retry failures and posts an error message", async () => {
+            const ctx = createMockContext(null);
+            const manager = new DiscordManager(ctx);
+            const managerAny = manager;
+            const mockSend = vi.fn().mockResolvedValue({
+                edit: vi.fn().mockResolvedValue(undefined),
+                delete: vi.fn().mockResolvedValue(undefined),
+            });
+            const mockChannel = {
+                isTextBased: () => true,
+                isDMBased: () => false,
+                guildId: "guild-1",
+                send: mockSend,
+            };
+            managerAny.connectors = new Map([
+                [
+                    "agent-1",
+                    {
+                        client: {
+                            isReady: () => true,
+                            channels: { fetch: vi.fn().mockResolvedValue(mockChannel) },
+                        },
+                    },
+                ],
+            ]);
+            managerAny.lastPromptByChannel.set("agent-1:channel-1", "retry prompt");
+            vi.spyOn(managerAny, "handleMessage").mockRejectedValue(new Error("retry boom"));
+            const result = await managerAny.retryChannelRun("agent-1", "channel-1");
+            await new Promise((resolve) => setTimeout(resolve, 0));
+            expect(result.success).toBe(true);
+            expect(mockSend).toHaveBeenCalled();
+        });
+    });
+    describe("skill discovery and validation", () => {
+        it("uses explicit chat.discord.skills when working_directory is not set", async () => {
+            const discordConfig = {
+                bot_token_env: "TEST_TOKEN",
+                session_expiry_hours: 24,
+                log_level: "standard",
+                output: {
+                    tool_results: true,
+                    tool_result_max_length: 900,
+                    system_status: true,
+                    result_summary: true,
+                    typing_indicator: true,
+                    errors: true,
+                    acknowledge_emoji: "eyes",
+                    assistant_messages: "answers",
+                    progress_indicator: true,
+                },
+                guilds: [{ id: "g1" }],
+                skills: [{ name: "pdf", description: "Work with PDFs" }],
+            };
+            const config = {
+                fleet: { name: "test-fleet" },
+                agents: [createDiscordAgent("agent1", discordConfig)],
+                configPath: "/test/herdctl.yaml",
+                configDir: "/test",
+            };
+            const manager = new DiscordManager(createMockContext(config));
+            const managerAny = manager;
+            const skills = await managerAny.discoverAgentSkills(config.agents[0]);
+            expect(skills.map((s) => s.name)).toContain("pdf");
+        });
+        it("rejects unknown /skill before attempting execution", async () => {
+            const discordConfig = {
+                bot_token_env: "TEST_TOKEN",
+                session_expiry_hours: 24,
+                log_level: "standard",
+                output: {
+                    tool_results: true,
+                    tool_result_max_length: 900,
+                    system_status: true,
+                    result_summary: true,
+                    typing_indicator: true,
+                    errors: true,
+                    acknowledge_emoji: "eyes",
+                    assistant_messages: "answers",
+                    progress_indicator: true,
+                },
+                guilds: [{ id: "g1" }],
+                skills: [{ name: "pdf" }],
+            };
+            const config = {
+                fleet: { name: "test-fleet" },
+                agents: [createDiscordAgent("agent1", discordConfig)],
+                configPath: "/test/herdctl.yaml",
+                configDir: "/test",
+            };
+            const manager = new DiscordManager(createMockContext(config));
+            const managerAny = manager;
+            const result = await managerAny.runChannelSkill("agent1", "channel-1", "nonexistent");
+            expect(result.success).toBe(false);
+            expect(result.message).toContain("Unknown skill");
+        });
+    });
     describe("getConnector", () => {
         it("returns undefined for non-existent agent", () => {
             const ctx = createMockContext(null);
@@ -330,10 +467,14 @@ describe("DiscordMessageEvent type", () => {
                 wasMentioned: true,
                 mode: "mention",
             },
-            reply: async (content) => {
-                console.log("Reply:", content);
-            },
+            reply: vi.fn().mockResolvedValue(undefined),
             startTyping: () => () => { },
+            addReaction: vi.fn().mockResolvedValue(undefined),
+            removeReaction: vi.fn().mockResolvedValue(undefined),
+            replyWithRef: vi.fn().mockResolvedValue({
+                edit: vi.fn().mockResolvedValue(undefined),
+                delete: vi.fn().mockResolvedValue(undefined),
+            }),
         };
         expect(event.agentName).toBe("test-agent");
         expect(event.prompt).toBe("Hello, how are you?");
@@ -360,6 +501,12 @@ describe("DiscordMessageEvent type", () => {
             },
             reply: async () => { },
             startTyping: () => () => { },
+            addReaction: vi.fn().mockResolvedValue(undefined),
+            removeReaction: vi.fn().mockResolvedValue(undefined),
+            replyWithRef: vi.fn().mockResolvedValue({
+                edit: vi.fn().mockResolvedValue(undefined),
+                delete: vi.fn().mockResolvedValue(undefined),
+            }),
         };
         expect(event.metadata.guildId).toBeNull();
         expect(event.metadata.mode).toBe("auto");
@@ -404,6 +551,9 @@ describe("DiscordManager typing_indicator config", () => {
                         result_summary: false,
                         typing_indicator: false,
                         errors: true,
+                        acknowledge_emoji: "👀",
+                        assistant_messages: "answers",
+                        progress_indicator: false,
                     },
                     guilds: [],
                 }),
@@ -483,6 +633,9 @@ describe("DiscordManager typing_indicator config", () => {
             },
             reply: replyMock,
             startTyping: startTypingMock,
+            addReaction: vi.fn().mockResolvedValue(undefined),
+            removeReaction: vi.fn().mockResolvedValue(undefined),
+            replyWithRef: vi.fn().mockResolvedValue({ messageId: "ref-msg" }),
         };
         mockConnector.emit("message", messageEvent);
         await new Promise((resolve) => setTimeout(resolve, 2500));
@@ -659,35 +812,743 @@ describe.skip("DiscordManager response splitting", () => {
             expect(result).toContain("/reset");
             expect(result).toContain("Please try again");
         });
-        it("handles errors with special characters", () => {
-            const error = new Error("Error with `code` and *markdown*");
-            const result = manager.formatErrorMessage(error);
-            expect(result).toContain("Error with `code` and *markdown*");
+        it("handles errors with special characters", () => {
+            const error = new Error("Error with `code` and *markdown*");
+            const result = manager.formatErrorMessage(error);
+            expect(result).toContain("Error with `code` and *markdown*");
+        });
+    });
+    describe("sendResponse", () => {
+        it("sends single message for short content", async () => {
+            const replyMock = vi.fn().mockResolvedValue(undefined);
+            await manager.sendResponse(replyMock, "Short message");
+            expect(replyMock).toHaveBeenCalledTimes(1);
+            expect(replyMock).toHaveBeenCalledWith("Short message");
+        });
+        it("sends multiple messages for long content", async () => {
+            const replyMock = vi.fn().mockResolvedValue(undefined);
+            const longText = "word ".repeat(500); // About 2500 chars
+            await manager.sendResponse(replyMock, longText);
+            expect(replyMock).toHaveBeenCalledTimes(2);
+        });
+        it("sends messages in order", async () => {
+            const calls = [];
+            const replyMock = vi.fn().mockImplementation(async (content) => {
+                calls.push(content);
+            });
+            const text = `First part.\n${"x".repeat(2000)}\nLast part.`;
+            await manager.sendResponse(replyMock, text);
+            // Verify order by checking first call starts with "First"
+            expect(calls[0]).toMatch(/^First/);
+        });
+    });
+});
+// =============================================================================
+// handleMessage pipeline tests (active)
+// =============================================================================
+/**
+ * These tests exercise the handleMessage() pipeline end-to-end by:
+ * 1. Creating a DiscordManager with a mock FleetManagerContext
+ * 2. Injecting a mock connector (EventEmitter with session manager)
+ * 3. Emitting a "message" event on the connector → triggers handleMessage()
+ * 4. The mock ctx.trigger() captures and invokes the onMessage callback
+ * 5. Assertions verify reply calls, embeds, fallback behavior
+ */
+describe("DiscordManager handleMessage pipeline", () => {
+    /**
+     * Helper: build a DiscordManager wired to a custom ctx.trigger mock.
+     * Returns { manager, connector, triggerMock } ready for emitting events.
+     */
+    function buildManagerWithTrigger(triggerImpl, agentOverrides) {
+        const discordConfig = {
+            bot_token_env: "TEST_BOT_TOKEN",
+            session_expiry_hours: 24,
+            log_level: "standard",
+            output: {
+                tool_results: true,
+                tool_result_max_length: 900,
+                system_status: true,
+                result_summary: false,
+                typing_indicator: true,
+                errors: true,
+                acknowledge_emoji: "",
+                assistant_messages: "answers",
+                progress_indicator: false, // disable for cleaner assertions
+            },
+            guilds: [],
+        };
+        const agent = {
+            ...createDiscordAgent("test-agent", discordConfig),
+            ...agentOverrides,
+        };
+        const emitter = new EventEmitter();
+        const ctx = {
+            getConfig: () => ({
+                fleet: { name: "test-fleet" },
+                agents: [agent],
+                configPath: "/test/herdctl.yaml",
+                configDir: "/test",
+            }),
+            getStateDir: () => "/tmp/test-state",
+            getStateDirInfo: () => null,
+            getLogger: () => mockLogger,
+            getScheduler: () => null,
+            getStatus: () => "running",
+            getInitializedAt: () => "2024-01-01T00:00:00.000Z",
+            getStartedAt: () => "2024-01-01T00:00:01.000Z",
+            getStoppedAt: () => null,
+            getLastError: () => null,
+            getCheckInterval: () => 1000,
+            emit: (event, ...args) => emitter.emit(event, ...args),
+            getEmitter: () => emitter,
+            trigger: triggerImpl,
+        };
+        const manager = new DiscordManager(ctx);
+        // Build mock connector
+        const connector = new EventEmitter();
+        connector.connect = vi.fn().mockResolvedValue(undefined);
+        connector.disconnect = vi.fn().mockResolvedValue(undefined);
+        connector.isConnected = vi.fn().mockReturnValue(true);
+        connector.getState = vi.fn().mockReturnValue({
+            status: "connected",
+            connectedAt: "2024-01-01T00:00:00.000Z",
+            disconnectedAt: null,
+            reconnectAttempts: 0,
+            lastError: null,
+            botUser: { id: "bot1", username: "TestBot", discriminator: "0000" },
+            rateLimits: {
+                totalCount: 0,
+                lastRateLimitAt: null,
+                isRateLimited: false,
+                currentResetTime: 0,
+            },
+            messageStats: { received: 0, sent: 0, ignored: 0 },
+        });
+        connector.uploadFile = vi.fn().mockResolvedValue({ fileId: "f1" });
+        connector.agentName = "test-agent";
+        connector.sessionManager = {
+            getOrCreateSession: vi.fn().mockResolvedValue({ sessionId: "s1", isNew: false }),
+            getSession: vi.fn().mockResolvedValue(null),
+            setSession: vi.fn().mockResolvedValue(undefined),
+            touchSession: vi.fn().mockResolvedValue(undefined),
+            getActiveSessionCount: vi.fn().mockResolvedValue(0),
+        };
+        // Inject connector
+        // @ts-expect-error - accessing private property for testing
+        manager.connectors.set("test-agent", connector);
+        // @ts-expect-error - accessing private property for testing
+        manager.initialized = true;
+        return { manager, connector, ctx };
+    }
+    /** Create a standard message event with configurable reply mock */
+    function createMessageEvent(replyMock) {
+        const replyFn = replyMock ?? vi.fn().mockResolvedValue(undefined);
+        const replyWithRefFn = vi.fn().mockResolvedValue({
+            edit: vi.fn().mockResolvedValue(undefined),
+            delete: vi.fn().mockResolvedValue(undefined),
+        });
+        const event = {
+            agentName: "test-agent",
+            prompt: "Hello bot!",
+            context: { messages: [], wasMentioned: true, prompt: "Hello bot!" },
+            metadata: {
+                guildId: "guild1",
+                channelId: "channel1",
+                messageId: "msg1",
+                userId: "user1",
+                username: "TestUser",
+                wasMentioned: true,
+                mode: "mention",
+            },
+            reply: replyFn,
+            startTyping: () => () => { },
+            addReaction: vi.fn().mockResolvedValue(undefined),
+            removeReaction: vi.fn().mockResolvedValue(undefined),
+            replyWithRef: replyWithRefFn,
+        };
+        return { event, reply: replyFn, replyWithRef: replyWithRefFn };
+    }
+    // ---- answers mode: suppresses reasoning turns, sends answer turns ----
+    it("suppresses reasoning turns (text + tool_use) in 'answers' mode", async () => {
+        const { manager, connector } = buildManagerWithTrigger(async (...args) => {
+            const options = args[2];
+            if (options?.onMessage) {
+                // Turn 1: reasoning (text + tool_use) — should be suppressed
+                await options.onMessage({
+                    type: "assistant",
+                    message: {
+                        id: "msg_1",
+                        stop_reason: "tool_use",
+                        content: [
+                            { type: "text", text: "Let me check..." },
+                            { type: "tool_use", name: "Read", id: "t1", input: { file_path: "/x.txt" } },
+                        ],
+                    },
+                });
+                // Turn 2: answer (text only) — should be sent
+                await options.onMessage({
+                    type: "assistant",
+                    message: {
+                        id: "msg_2",
+                        stop_reason: "end_turn",
+                        content: [{ type: "text", text: "Here is the answer." }],
+                    },
+                });
+                await options.onMessage({ type: "result", result: "Here is the answer." });
+            }
+            return {
+                jobId: "j1",
+                agentName: "test-agent",
+                scheduleName: null,
+                startedAt: new Date().toISOString(),
+                success: true,
+                sessionId: "sid1",
+            };
+        });
+        await manager.start();
+        const { event, reply } = createMessageEvent();
+        connector.emit("message", event);
+        await new Promise((resolve) => setTimeout(resolve, 200));
+        // Only the answer turn (no tool_use) should be delivered
+        const textCalls = reply.mock.calls.filter((call) => typeof call[0] === "string");
+        expect(textCalls).toHaveLength(1);
+        expect(textCalls[0][0]).toBe("Here is the answer.");
+    });
+    it("sends all answer turns immediately in 'answers' mode", async () => {
+        const { manager, connector } = buildManagerWithTrigger(async (...args) => {
+            const options = args[2];
+            if (options?.onMessage) {
+                // Two answer turns (text only, no tool_use) — both should be sent
+                await options.onMessage({
+                    type: "assistant",
+                    message: {
+                        id: "msg_1",
+                        stop_reason: "end_turn",
+                        content: [{ type: "text", text: "First answer." }],
+                    },
+                });
+                await options.onMessage({
+                    type: "assistant",
+                    message: {
+                        id: "msg_2",
+                        stop_reason: "end_turn",
+                        content: [{ type: "text", text: "Second answer." }],
+                    },
+                });
+                await options.onMessage({ type: "result", result: "Second answer." });
+            }
+            return {
+                jobId: "j1b",
+                agentName: "test-agent",
+                scheduleName: null,
+                startedAt: new Date().toISOString(),
+                success: true,
+                sessionId: "sid1b",
+            };
+        });
+        await manager.start();
+        const { event, reply } = createMessageEvent();
+        connector.emit("message", event);
+        await new Promise((resolve) => setTimeout(resolve, 2500)); // wait for rate limiting
+        // Both answer turns should be delivered
+        const textCalls = reply.mock.calls.filter((call) => typeof call[0] === "string");
+        expect(textCalls).toHaveLength(2);
+        expect(textCalls[0][0]).toBe("First answer.");
+        expect(textCalls[1][0]).toBe("Second answer.");
+    });
+    // ---- resultText fallback when all turns are reasoning (tool-only) ----
+    it("uses SDK result text as fallback when all turns are reasoning", async () => {
+        const { manager, connector } = buildManagerWithTrigger(async (...args) => {
+            const options = args[2];
+            if (options?.onMessage) {
+                // Assistant message with ONLY tool_use (no text blocks)
+                await options.onMessage({
+                    type: "assistant",
+                    message: {
+                        id: "msg_1",
+                        stop_reason: "tool_use",
+                        content: [{ type: "tool_use", name: "Bash", id: "t1", input: { command: "ls" } }],
+                    },
+                });
+                // Tool result
+                await options.onMessage({
+                    type: "user",
+                    message: {
+                        content: [{ type: "tool_result", tool_use_id: "t1", content: "file1 file2" }],
+                    },
+                });
+                // Result message has the final answer text
+                await options.onMessage({
+                    type: "result",
+                    result: "The directory contains file1 and file2.",
+                });
+            }
+            return {
+                jobId: "j2",
+                agentName: "test-agent",
+                scheduleName: null,
+                startedAt: new Date().toISOString(),
+                success: true,
+                sessionId: "sid2",
+            };
+        });
+        await manager.start();
+        const { event, reply } = createMessageEvent();
+        connector.emit("message", event);
+        await new Promise((resolve) => setTimeout(resolve, 200));
+        // The result text should be sent as fallback
+        const textCalls = reply.mock.calls.filter((call) => typeof call[0] === "string");
+        expect(textCalls).toHaveLength(1);
+        expect(textCalls[0][0]).toBe("The directory contains file1 and file2.");
+    });
+    // ---- Dedup: skip intermediates (stop_reason: null) ----
+    it("skips intermediate assistant snapshots (stop_reason: null)", async () => {
+        const { manager, connector } = buildManagerWithTrigger(async (...args) => {
+            const options = args[2];
+            if (options?.onMessage) {
+                // Intermediate snapshot (stop_reason: null) — should be skipped
+                await options.onMessage({
+                    type: "assistant",
+                    message: {
+                        id: "msg_1",
+                        stop_reason: null,
+                        content: [{ type: "text", text: "Partial..." }],
+                    },
+                });
+                // Final snapshot (stop_reason: "end_turn") — should be delivered
+                await options.onMessage({
+                    type: "assistant",
+                    message: {
+                        id: "msg_1",
+                        stop_reason: "end_turn",
+                        content: [{ type: "text", text: "Complete answer." }],
+                    },
+                });
+                await options.onMessage({ type: "result", result: "Complete answer." });
+            }
+            return {
+                jobId: "j3",
+                agentName: "test-agent",
+                scheduleName: null,
+                startedAt: new Date().toISOString(),
+                success: true,
+                sessionId: "sid3",
+            };
+        });
+        await manager.start();
+        const { event, reply } = createMessageEvent();
+        connector.emit("message", event);
+        await new Promise((resolve) => setTimeout(resolve, 200));
+        const textCalls = reply.mock.calls.filter((call) => typeof call[0] === "string");
+        expect(textCalls).toHaveLength(1);
+        expect(textCalls[0][0]).toBe("Complete answer.");
+    });
+    // ---- Dedup: deduplicate same message.id ----
+    it("deduplicates assistant messages by message.id", async () => {
+        const { manager, connector } = buildManagerWithTrigger(async (...args) => {
+            const options = args[2];
+            if (options?.onMessage) {
+                // Same message.id delivered twice (stop_reason not null) — second should be deduped
+                await options.onMessage({
+                    type: "assistant",
+                    message: {
+                        id: "msg_1",
+                        stop_reason: "end_turn",
+                        content: [{ type: "text", text: "First delivery." }],
+                    },
+                });
+                await options.onMessage({
+                    type: "assistant",
+                    message: {
+                        id: "msg_1",
+                        stop_reason: "end_turn",
+                        content: [{ type: "text", text: "Duplicate delivery." }],
+                    },
+                });
+                await options.onMessage({ type: "result", result: "First delivery." });
+            }
+            return {
+                jobId: "j4",
+                agentName: "test-agent",
+                scheduleName: null,
+                startedAt: new Date().toISOString(),
+                success: true,
+                sessionId: "sid4",
+            };
+        });
+        await manager.start();
+        const { event, reply } = createMessageEvent();
+        connector.emit("message", event);
+        await new Promise((resolve) => setTimeout(resolve, 200));
+        const textCalls = reply.mock.calls.filter((call) => typeof call[0] === "string");
+        expect(textCalls).toHaveLength(1);
+        // Only the first delivery should be buffered (not the duplicate)
+        expect(textCalls[0][0]).toBe("First delivery.");
+    });
+    // ---- Fallback when no output at all ----
+    it("shows fallback embed when no messages are sent", async () => {
+        const { manager, connector } = buildManagerWithTrigger(async (...args) => {
+            const options = args[2];
+            if (options?.onMessage) {
+                // Only a result message with no text
+                await options.onMessage({ type: "result", is_error: false });
+            }
+            return {
+                jobId: "j5",
+                agentName: "test-agent",
+                scheduleName: null,
+                startedAt: new Date().toISOString(),
+                success: true,
+                sessionId: "sid5",
+            };
+        });
+        await manager.start();
+        const { event, reply } = createMessageEvent();
+        connector.emit("message", event);
+        await new Promise((resolve) => setTimeout(resolve, 200));
+        // Should show the "Task completed" fallback embed
+        const embedCalls = reply.mock.calls.filter((call) => typeof call[0] === "object" && call[0].embeds);
+        expect(embedCalls.length).toBeGreaterThanOrEqual(1);
+        const lastEmbed = embedCalls[embedCalls.length - 1][0];
+        expect(lastEmbed.embeds[0].description).toContain("Task completed");
+    });
+    // ---- Error fallback ----
+    it("shows error fallback when job fails with no output", async () => {
+        const { manager, connector } = buildManagerWithTrigger(async () => {
+            return {
+                jobId: "j6",
+                agentName: "test-agent",
+                scheduleName: null,
+                startedAt: new Date().toISOString(),
+                success: false,
+                error: { message: "Agent crashed" },
+                errorDetails: { message: "Agent crashed" },
+            };
+        });
+        await manager.start();
+        const { event, reply } = createMessageEvent();
+        connector.emit("message", event);
+        await new Promise((resolve) => setTimeout(resolve, 200));
+        const embedCalls = reply.mock.calls.filter((call) => typeof call[0] === "object" && call[0].embeds);
+        expect(embedCalls.length).toBeGreaterThanOrEqual(1);
+        const lastEmbed = embedCalls[embedCalls.length - 1][0];
+        expect(lastEmbed.embeds[0].description).toContain("Agent crashed");
+    });
+    // ---- Tool result embeds ----
+    it("sends final answer without per-tool embed burst when tool results are enabled", async () => {
+        const { manager, connector } = buildManagerWithTrigger(async (...args) => {
+            const options = args[2];
+            if (options?.onMessage) {
+                // Assistant with tool_use
+                await options.onMessage({
+                    type: "assistant",
+                    message: {
+                        id: "msg_1",
+                        stop_reason: "tool_use",
+                        content: [
+                            { type: "text", text: "Let me check." },
+                            { type: "tool_use", name: "Bash", id: "t1", input: { command: "ls" } },
+                        ],
+                    },
+                });
+                // Tool result
+                await options.onMessage({
+                    type: "user",
+                    message: {
+                        content: [{ type: "tool_result", tool_use_id: "t1", content: "file1.txt\nfile2.txt" }],
+                    },
+                });
+                // Final answer
+                await options.onMessage({
+                    type: "assistant",
+                    message: {
+                        id: "msg_2",
+                        stop_reason: "end_turn",
+                        content: [{ type: "text", text: "Found 2 files." }],
+                    },
+                });
+                await options.onMessage({ type: "result", result: "Found 2 files." });
+            }
+            return {
+                jobId: "j7",
+                agentName: "test-agent",
+                scheduleName: null,
+                startedAt: new Date().toISOString(),
+                success: true,
+                sessionId: "sid7",
+            };
+        });
+        await manager.start();
+        const { event, reply } = createMessageEvent();
+        connector.emit("message", event);
+        await new Promise((resolve) => setTimeout(resolve, 200));
+        // Should have sent final text without a per-tool embed burst.
+        const embedCalls = reply.mock.calls.filter((call) => typeof call[0] === "object" && call[0].embeds);
+        const textCalls = reply.mock.calls.filter((call) => typeof call[0] === "string");
+        expect(embedCalls).toHaveLength(0);
+        expect(textCalls).toHaveLength(1);
+        expect(textCalls[0][0]).toBe("Found 2 files.");
+    });
+    // ---- No system prompt injection (concise_mode removed) ----
+    it("does not inject a systemPromptAppend", async () => {
+        let capturedSystemPrompt;
+        const { manager, connector } = buildManagerWithTrigger(async (...args) => {
+            const options = args[2];
+            capturedSystemPrompt = options?.systemPromptAppend;
+            if (options?.onMessage) {
+                await options.onMessage({
+                    type: "assistant",
+                    message: {
+                        id: "msg_1",
+                        stop_reason: "end_turn",
+                        content: [{ type: "text", text: "Done." }],
+                    },
+                });
+                await options.onMessage({ type: "result", result: "Done." });
+            }
+            return {
+                jobId: "j8",
+                agentName: "test-agent",
+                scheduleName: null,
+                startedAt: new Date().toISOString(),
+                success: true,
+                sessionId: "sid8",
+            };
+        });
+        await manager.start();
+        const { event } = createMessageEvent();
+        connector.emit("message", event);
+        await new Promise((resolve) => setTimeout(resolve, 200));
+        expect(capturedSystemPrompt).toBeUndefined();
+    });
+    // ---- Session persistence ----
+    it("stores session ID after successful job", async () => {
+        const { manager, connector } = buildManagerWithTrigger(async (...args) => {
+            const options = args[2];
+            if (options?.onMessage) {
+                await options.onMessage({
+                    type: "assistant",
+                    message: {
+                        id: "msg_1",
+                        stop_reason: "end_turn",
+                        content: [{ type: "text", text: "OK." }],
+                    },
+                });
+                await options.onMessage({ type: "result", result: "OK." });
+            }
+            return {
+                jobId: "j9",
+                agentName: "test-agent",
+                scheduleName: null,
+                startedAt: new Date().toISOString(),
+                success: true,
+                sessionId: "sdk-session-42",
+            };
         });
+        await manager.start();
+        const { event } = createMessageEvent();
+        connector.emit("message", event);
+        await new Promise((resolve) => setTimeout(resolve, 200));
+        expect(connector.sessionManager.setSession).toHaveBeenCalledWith("channel1", "sdk-session-42");
     });
-    describe("sendResponse", () => {
-        it("sends single message for short content", async () => {
-            const replyMock = vi.fn().mockResolvedValue(undefined);
-            await manager.sendResponse(replyMock, "Short message");
-            expect(replyMock).toHaveBeenCalledTimes(1);
-            expect(replyMock).toHaveBeenCalledWith("Short message");
+    // ---- Mixed: tool-only turns + final text ----
+    it("handles multi-turn tool usage with final text answer", async () => {
+        const { manager, connector } = buildManagerWithTrigger(async (...args) => {
+            const options = args[2];
+            if (options?.onMessage) {
+                // Turn 1: text + tool
+                await options.onMessage({
+                    type: "assistant",
+                    message: {
+                        id: "msg_1",
+                        stop_reason: "tool_use",
+                        content: [
+                            { type: "text", text: "Let me look." },
+                            { type: "tool_use", name: "Read", id: "t1", input: { file_path: "/x.txt" } },
+                        ],
+                    },
+                });
+                await options.onMessage({
+                    type: "user",
+                    message: {
+                        content: [{ type: "tool_result", tool_use_id: "t1", content: "contents" }],
+                    },
+                });
+                // Turn 2: tool-only (no text)
+                await options.onMessage({
+                    type: "assistant",
+                    message: {
+                        id: "msg_2",
+                        stop_reason: "tool_use",
+                        content: [{ type: "tool_use", name: "Bash", id: "t2", input: { command: "wc -l" } }],
+                    },
+                });
+                await options.onMessage({
+                    type: "user",
+                    message: {
+                        content: [{ type: "tool_result", tool_use_id: "t2", content: "42" }],
+                    },
+                });
+                // Turn 3: final text
+                await options.onMessage({
+                    type: "assistant",
+                    message: {
+                        id: "msg_3",
+                        stop_reason: "end_turn",
+                        content: [{ type: "text", text: "The file has 42 lines." }],
+                    },
+                });
+                await options.onMessage({ type: "result", result: "The file has 42 lines." });
+            }
+            return {
+                jobId: "j10",
+                agentName: "test-agent",
+                scheduleName: null,
+                startedAt: new Date().toISOString(),
+                success: true,
+                sessionId: "sid10",
+            };
         });
-        it("sends multiple messages for long content", async () => {
-            const replyMock = vi.fn().mockResolvedValue(undefined);
-            const longText = "word ".repeat(500); // About 2500 chars
-            await manager.sendResponse(replyMock, longText);
-            expect(replyMock).toHaveBeenCalledTimes(2);
+        await manager.start();
+        const { event, reply } = createMessageEvent();
+        connector.emit("message", event);
+        await new Promise((resolve) => setTimeout(resolve, 200));
+        // Only the answer turn (no tool_use) should be delivered
+        const textCalls = reply.mock.calls.filter((call) => typeof call[0] === "string");
+        expect(textCalls).toHaveLength(1);
+        expect(textCalls[0][0]).toBe("The file has 42 lines.");
+    });
+    // ---- "all" mode: sends every assistant turn with text ----
+    it("sends every assistant message immediately in 'all' mode", async () => {
+        const { manager, connector } = buildManagerWithTrigger(async (...args) => {
+            const options = args[2];
+            if (options?.onMessage) {
+                await options.onMessage({
+                    type: "assistant",
+                    message: {
+                        id: "msg_1",
+                        stop_reason: "end_turn",
+                        content: [{ type: "text", text: "First turn." }],
+                    },
+                });
+                await options.onMessage({
+                    type: "assistant",
+                    message: {
+                        id: "msg_2",
+                        stop_reason: "end_turn",
+                        content: [{ type: "text", text: "Second turn." }],
+                    },
+                });
+                await options.onMessage({ type: "result", result: "Second turn." });
+            }
+            return {
+                jobId: "j11",
+                agentName: "test-agent",
+                scheduleName: null,
+                startedAt: new Date().toISOString(),
+                success: true,
+                sessionId: "sid11",
+            };
+        }, 
+        // Override: use "all" mode to send every turn
+        {
+            chat: {
+                discord: {
+                    bot_token_env: "TEST_BOT_TOKEN",
+                    session_expiry_hours: 24,
+                    log_level: "standard",
+                    output: {
+                        tool_results: true,
+                        tool_result_max_length: 900,
+                        system_status: true,
+                        result_summary: false,
+                        typing_indicator: true,
+                        errors: true,
+                        acknowledge_emoji: "",
+                        assistant_messages: "all",
+                        progress_indicator: false,
+                    },
+                    guilds: [],
+                },
+            },
         });
-        it("sends messages in order", async () => {
-            const calls = [];
-            const replyMock = vi.fn().mockImplementation(async (content) => {
-                calls.push(content);
-            });
-            const text = `First part.\n${"x".repeat(2000)}\nLast part.`;
-            await manager.sendResponse(replyMock, text);
-            // Verify order by checking first call starts with "First"
-            expect(calls[0]).toMatch(/^First/);
+        await manager.start();
+        const { event, reply } = createMessageEvent();
+        connector.emit("message", event);
+        await new Promise((resolve) => setTimeout(resolve, 2500)); // wait for rate limiting
+        // Both messages should be sent
+        const textCalls = reply.mock.calls.filter((call) => typeof call[0] === "string");
+        expect(textCalls).toHaveLength(2);
+        expect(textCalls[0][0]).toBe("First turn.");
+        expect(textCalls[1][0]).toBe("Second turn.");
+    });
+    it("sends reasoning turns (text + tool_use) in 'all' mode", async () => {
+        const { manager, connector } = buildManagerWithTrigger(async (...args) => {
+            const options = args[2];
+            if (options?.onMessage) {
+                // Reasoning turn: text + tool_use
+                await options.onMessage({
+                    type: "assistant",
+                    message: {
+                        id: "msg_1",
+                        stop_reason: "tool_use",
+                        content: [
+                            { type: "text", text: "Let me check the file." },
+                            { type: "tool_use", name: "Read", id: "t1", input: { file_path: "/x.txt" } },
+                        ],
+                    },
+                });
+                // Answer turn: text only
+                await options.onMessage({
+                    type: "assistant",
+                    message: {
+                        id: "msg_2",
+                        stop_reason: "end_turn",
+                        content: [{ type: "text", text: "The file has 42 lines." }],
+                    },
+                });
+                await options.onMessage({ type: "result", result: "The file has 42 lines." });
+            }
+            return {
+                jobId: "j12",
+                agentName: "test-agent",
+                scheduleName: null,
+                startedAt: new Date().toISOString(),
+                success: true,
+                sessionId: "sid12",
+            };
+        }, 
+        // Override: use "all" mode to send every turn including reasoning
+        {
+            chat: {
+                discord: {
+                    bot_token_env: "TEST_BOT_TOKEN",
+                    session_expiry_hours: 24,
+                    log_level: "standard",
+                    output: {
+                        tool_results: true,
+                        tool_result_max_length: 900,
+                        system_status: true,
+                        result_summary: false,
+                        typing_indicator: true,
+                        errors: true,
+                        acknowledge_emoji: "",
+                        assistant_messages: "all",
+                        progress_indicator: false,
+                    },
+                    guilds: [],
+                },
+            },
         });
+        await manager.start();
+        const { event, reply } = createMessageEvent();
+        connector.emit("message", event);
+        await new Promise((resolve) => setTimeout(resolve, 2500)); // wait for rate limiting
+        // Both reasoning and answer turns should be sent in "all" mode
+        const textCalls = reply.mock.calls.filter((call) => typeof call[0] === "string");
+        expect(textCalls).toHaveLength(2);
+        expect(textCalls[0][0]).toBe("Let me check the file.");
+        expect(textCalls[1][0]).toBe("The file has 42 lines.");
     });
 });
 // Message handling tests are skipped pending refactor to work with the new architecture
@@ -719,6 +1580,9 @@ describe.skip("DiscordManager message handling", () => {
                         result_summary: false,
                         typing_indicator: true,
                         errors: true,
+                        acknowledge_emoji: "eyes",
+                        assistant_messages: "answers",
+                        progress_indicator: true,
                     },
                     guilds: [],
                 }),
@@ -832,6 +1696,12 @@ describe.skip("DiscordManager message handling", () => {
                 },
                 reply: replyMock,
                 startTyping: () => () => { },
+                addReaction: vi.fn().mockResolvedValue(undefined),
+                removeReaction: vi.fn().mockResolvedValue(undefined),
+                replyWithRef: vi.fn().mockResolvedValue({
+                    edit: vi.fn().mockResolvedValue(undefined),
+                    delete: vi.fn().mockResolvedValue(undefined),
+                }),
             };
             // Emit the message event
             mockConnector.emit("message", messageEvent);
@@ -873,6 +1743,9 @@ describe.skip("DiscordManager message handling", () => {
                             result_summary: false,
                             typing_indicator: true,
                             errors: true,
+                            acknowledge_emoji: "eyes",
+                            assistant_messages: "answers",
+                            progress_indicator: true,
                         },
                         guilds: [],
                     }),
@@ -958,6 +1831,12 @@ describe.skip("DiscordManager message handling", () => {
                 },
                 reply: replyMock,
                 startTyping: () => () => { },
+                addReaction: vi.fn().mockResolvedValue(undefined),
+                removeReaction: vi.fn().mockResolvedValue(undefined),
+                replyWithRef: vi.fn().mockResolvedValue({
+                    edit: vi.fn().mockResolvedValue(undefined),
+                    delete: vi.fn().mockResolvedValue(undefined),
+                }),
             };
             // Emit the message event
             mockConnector.emit("message", messageEvent);
@@ -996,6 +1875,9 @@ describe.skip("DiscordManager message handling", () => {
                             result_summary: false,
                             typing_indicator: true,
                             errors: true,
+                            acknowledge_emoji: "eyes",
+                            assistant_messages: "answers",
+                            progress_indicator: true,
                         },
                         guilds: [],
                     }),
@@ -1081,6 +1963,12 @@ describe.skip("DiscordManager message handling", () => {
                 },
                 reply: replyMock,
                 startTyping: () => () => { },
+                addReaction: vi.fn().mockResolvedValue(undefined),
+                removeReaction: vi.fn().mockResolvedValue(undefined),
+                replyWithRef: vi.fn().mockResolvedValue({
+                    edit: vi.fn().mockResolvedValue(undefined),
+                    delete: vi.fn().mockResolvedValue(undefined),
+                }),
             };
             // Emit the message event
             mockConnector.emit("message", messageEvent);
@@ -1150,6 +2038,9 @@ describe.skip("DiscordManager message handling", () => {
                             result_summary: false,
                             typing_indicator: true,
                             errors: true,
+                            acknowledge_emoji: "eyes",
+                            assistant_messages: "answers",
+                            progress_indicator: true,
                         },
                         guilds: [],
                     }),
@@ -1232,6 +2123,12 @@ describe.skip("DiscordManager message handling", () => {
                 },
                 reply: replyMock,
                 startTyping: () => () => { },
+                addReaction: vi.fn().mockResolvedValue(undefined),
+                removeReaction: vi.fn().mockResolvedValue(undefined),
+                replyWithRef: vi.fn().mockResolvedValue({
+                    edit: vi.fn().mockResolvedValue(undefined),
+                    delete: vi.fn().mockResolvedValue(undefined),
+                }),
             };
             mockConnector.emit("message", messageEvent);
             // Wait for async processing (includes rate limiting delays)
@@ -1287,6 +2184,9 @@ describe.skip("DiscordManager message handling", () => {
                             result_summary: false,
                             typing_indicator: true,
                             errors: true,
+                            acknowledge_emoji: "eyes",
+                            assistant_messages: "answers",
+                            progress_indicator: true,
                         },
                         guilds: [],
                     }),
@@ -1369,6 +2269,12 @@ describe.skip("DiscordManager message handling", () => {
                 },
                 reply: replyMock,
                 startTyping: () => () => { },
+                addReaction: vi.fn().mockResolvedValue(undefined),
+                removeReaction: vi.fn().mockResolvedValue(undefined),
+                replyWithRef: vi.fn().mockResolvedValue({
+                    edit: vi.fn().mockResolvedValue(undefined),
+                    delete: vi.fn().mockResolvedValue(undefined),
+                }),
             };
             mockConnector.emit("message", messageEvent);
             await new Promise((resolve) => setTimeout(resolve, 2000));
@@ -1469,6 +2375,12 @@ describe.skip("DiscordManager message handling", () => {
                 },
                 reply: replyMock,
                 startTyping: () => () => { },
+                addReaction: vi.fn().mockResolvedValue(undefined),
+                removeReaction: vi.fn().mockResolvedValue(undefined),
+                replyWithRef: vi.fn().mockResolvedValue({
+                    edit: vi.fn().mockResolvedValue(undefined),
+                    delete: vi.fn().mockResolvedValue(undefined),
+                }),
             };
             // Emit the message event - this will trigger handleMessage which will fail
             // because agent is not in config, and then try to reply, and that also fails
@@ -1567,6 +2479,12 @@ describe.skip("DiscordManager message handling", () => {
                 },
                 reply: replyMock,
                 startTyping: () => () => { },
+                addReaction: vi.fn().mockResolvedValue(undefined),
+                removeReaction: vi.fn().mockResolvedValue(undefined),
+                replyWithRef: vi.fn().mockResolvedValue({
+                    edit: vi.fn().mockResolvedValue(undefined),
+                    delete: vi.fn().mockResolvedValue(undefined),
+                }),
             };
             // Emit the message event
             mockConnector.emit("message", messageEvent);
@@ -1627,6 +2545,12 @@ describe.skip("DiscordManager message handling", () => {
                 },
                 reply: replyMock,
                 startTyping: () => () => { },
+                addReaction: vi.fn().mockResolvedValue(undefined),
+                removeReaction: vi.fn().mockResolvedValue(undefined),
+                replyWithRef: vi.fn().mockResolvedValue({
+                    edit: vi.fn().mockResolvedValue(undefined),
+                    delete: vi.fn().mockResolvedValue(undefined),
+                }),
             };
             // Emit the message event
             mockConnector.emit("message", messageEvent);
@@ -1684,6 +2608,12 @@ describe.skip("DiscordManager message handling", () => {
                 },
                 reply: replyMock,
                 startTyping: () => () => { },
+                addReaction: vi.fn().mockResolvedValue(undefined),
+                removeReaction: vi.fn().mockResolvedValue(undefined),
+                replyWithRef: vi.fn().mockResolvedValue({
+                    edit: vi.fn().mockResolvedValue(undefined),
+                    delete: vi.fn().mockResolvedValue(undefined),
+                }),
             };
             // Emit the message event
             mockConnector.emit("message", messageEvent);
@@ -2179,6 +3109,9 @@ describe.skip("DiscordManager session integration", () => {
                         result_summary: false,
                         typing_indicator: true,
                         errors: true,
+                        acknowledge_emoji: "eyes",
+                        assistant_messages: "answers",
+                        progress_indicator: true,
                     },
                     guilds: [],
                 }),
@@ -2259,6 +3192,12 @@ describe.skip("DiscordManager session integration", () => {
             },
             reply: replyMock,
             startTyping: () => () => { },
+            addReaction: vi.fn().mockResolvedValue(undefined),
+            removeReaction: vi.fn().mockResolvedValue(undefined),
+            replyWithRef: vi.fn().mockResolvedValue({
+                edit: vi.fn().mockResolvedValue(undefined),
+                delete: vi.fn().mockResolvedValue(undefined),
+            }),
         };
         // Emit the message event
         mockConnector.emit("message", messageEvent);
@@ -2316,6 +3255,12 @@ describe.skip("DiscordManager session integration", () => {
             },
             reply: replyMock,
             startTyping: () => () => { },
+            addReaction: vi.fn().mockResolvedValue(undefined),
+            removeReaction: vi.fn().mockResolvedValue(undefined),
+            replyWithRef: vi.fn().mockResolvedValue({
+                edit: vi.fn().mockResolvedValue(undefined),
+                delete: vi.fn().mockResolvedValue(undefined),
+            }),
         };
         // Emit the message event
         mockConnector.emit("message", messageEvent);
@@ -2374,6 +3319,12 @@ describe.skip("DiscordManager session integration", () => {
             },
             reply: replyMock,
             startTyping: () => () => { },
+            addReaction: vi.fn().mockResolvedValue(undefined),
+            removeReaction: vi.fn().mockResolvedValue(undefined),
+            replyWithRef: vi.fn().mockResolvedValue({
+                edit: vi.fn().mockResolvedValue(undefined),
+                delete: vi.fn().mockResolvedValue(undefined),
+            }),
         };
         // Emit the message event
         mockConnector.emit("message", messageEvent);
@@ -2434,6 +3385,12 @@ describe.skip("DiscordManager session integration", () => {
             },
             reply: replyMock,
             startTyping: () => () => { },
+            addReaction: vi.fn().mockResolvedValue(undefined),
+            removeReaction: vi.fn().mockResolvedValue(undefined),
+            replyWithRef: vi.fn().mockResolvedValue({
+                edit: vi.fn().mockResolvedValue(undefined),
+                delete: vi.fn().mockResolvedValue(undefined),
+            }),
         };
         // Emit the message event
         mockConnector.emit("message", messageEvent);
@@ -2705,6 +3662,9 @@ describe.skip("DiscordManager lifecycle", () => {
                         result_summary: false,
                         typing_indicator: true,
                         errors: true,
+                        acknowledge_emoji: "eyes",
+                        assistant_messages: "answers",
+                        progress_indicator: true,
                     },
                     guilds: [],
                 }),
@@ -2786,6 +3746,12 @@ describe.skip("DiscordManager lifecycle", () => {
             },
             reply: replyMock,
             startTyping: () => () => { },
+            addReaction: vi.fn().mockResolvedValue(undefined),
+            removeReaction: vi.fn().mockResolvedValue(undefined),
+            replyWithRef: vi.fn().mockResolvedValue({
+                edit: vi.fn().mockResolvedValue(undefined),
+                delete: vi.fn().mockResolvedValue(undefined),
+            }),
         };
         // Emit the message event
         mockConnector.emit("message", messageEvent);
@@ -2826,6 +3792,9 @@ describe.skip("DiscordManager lifecycle", () => {
                         result_summary: false,
                         typing_indicator: true,
                         errors: true,
+                        acknowledge_emoji: "eyes",
+                        assistant_messages: "answers",
+                        progress_indicator: true,
                     },
                     guilds: [],
                 }),
@@ -2907,6 +3876,12 @@ describe.skip("DiscordManager lifecycle", () => {
             },
             reply: replyMock,
             startTyping: () => () => { },
+            addReaction: vi.fn().mockResolvedValue(undefined),
+            removeReaction: vi.fn().mockResolvedValue(undefined),
+            replyWithRef: vi.fn().mockResolvedValue({
+                edit: vi.fn().mockResolvedValue(undefined),
+                delete: vi.fn().mockResolvedValue(undefined),
+            }),
         };
         // Emit the message event
         mockConnector.emit("message", messageEvent);
@@ -3075,6 +4050,12 @@ describe.skip("DiscordManager lifecycle", () => {
             },
             reply: replyMock,
             startTyping: () => () => { },
+            addReaction: vi.fn().mockResolvedValue(undefined),
+            removeReaction: vi.fn().mockResolvedValue(undefined),
+            replyWithRef: vi.fn().mockResolvedValue({
+                edit: vi.fn().mockResolvedValue(undefined),
+                delete: vi.fn().mockResolvedValue(undefined),
+            }),
         };
         // Emit the message event
         mockConnector.emit("message", messageEvent);
@@ -3113,6 +4094,9 @@ describe.skip("DiscordManager lifecycle", () => {
                         result_summary: false,
                         typing_indicator: true,
                         errors: true,
+                        acknowledge_emoji: "eyes",
+                        assistant_messages: "answers",
+                        progress_indicator: true,
                     },
                     guilds: [],
                 }),
@@ -3194,6 +4178,12 @@ describe.skip("DiscordManager lifecycle", () => {
             },
             reply: replyMock,
             startTyping: () => () => { },
+            addReaction: vi.fn().mockResolvedValue(undefined),
+            removeReaction: vi.fn().mockResolvedValue(undefined),
+            replyWithRef: vi.fn().mockResolvedValue({
+                edit: vi.fn().mockResolvedValue(undefined),
+                delete: vi.fn().mockResolvedValue(undefined),
+            }),
         };
         // Emit the message event
         mockConnector.emit("message", messageEvent);
@@ -3270,6 +4260,9 @@ describe.skip("DiscordManager output configuration", () => {
                                 result_summary: false,
                                 typing_indicator: true,
                                 errors: true,
+                                acknowledge_emoji: "eyes",
+                                assistant_messages: "answers",
+                                progress_indicator: true,
                             },
                             guilds: [],
                         },
@@ -3353,6 +4346,12 @@ describe.skip("DiscordManager output configuration", () => {
             },
             reply: replyMock,
             startTyping: () => () => { },
+            addReaction: vi.fn().mockResolvedValue(undefined),
+            removeReaction: vi.fn().mockResolvedValue(undefined),
+            replyWithRef: vi.fn().mockResolvedValue({
+                edit: vi.fn().mockResolvedValue(undefined),
+                delete: vi.fn().mockResolvedValue(undefined),
+            }),
         };
         mockConnector.emit("message", messageEvent);
         await new Promise((resolve) => setTimeout(resolve, 3000));
@@ -3403,6 +4402,9 @@ describe.skip("DiscordManager output configuration", () => {
                                 result_summary: false,
                                 typing_indicator: true,
                                 errors: true,
+                                acknowledge_emoji: "eyes",
+                                assistant_messages: "answers",
+                                progress_indicator: true,
                             },
                             guilds: [],
                         },
@@ -3486,6 +4488,12 @@ describe.skip("DiscordManager output configuration", () => {
             },
             reply: replyMock,
             startTyping: () => () => { },
+            addReaction: vi.fn().mockResolvedValue(undefined),
+            removeReaction: vi.fn().mockResolvedValue(undefined),
+            replyWithRef: vi.fn().mockResolvedValue({
+                edit: vi.fn().mockResolvedValue(undefined),
+                delete: vi.fn().mockResolvedValue(undefined),
+            }),
         };
         mockConnector.emit("message", messageEvent);
         await new Promise((resolve) => setTimeout(resolve, 2000));
@@ -3535,6 +4543,9 @@ describe.skip("DiscordManager output configuration", () => {
                                 result_summary: false,
                                 typing_indicator: true,
                                 errors: true,
+                                acknowledge_emoji: "eyes",
+                                assistant_messages: "answers",
+                                progress_indicator: true,
                             },
                             guilds: [],
                         },
@@ -3618,6 +4629,12 @@ describe.skip("DiscordManager output configuration", () => {
             },
             reply: replyMock,
             startTyping: () => () => { },
+            addReaction: vi.fn().mockResolvedValue(undefined),
+            removeReaction: vi.fn().mockResolvedValue(undefined),
+            replyWithRef: vi.fn().mockResolvedValue({
+                edit: vi.fn().mockResolvedValue(undefined),
+                delete: vi.fn().mockResolvedValue(undefined),
+            }),
         };
         mockConnector.emit("message", messageEvent);
         await new Promise((resolve) => setTimeout(resolve, 2000));
@@ -3668,6 +4685,9 @@ describe.skip("DiscordManager output configuration", () => {
                                 result_summary: true,
                                 typing_indicator: true,
                                 errors: true,
+                                acknowledge_emoji: "eyes",
+                                assistant_messages: "answers",
+                                progress_indicator: true,
                             },
                             guilds: [],
                         },
@@ -3751,6 +4771,12 @@ describe.skip("DiscordManager output configuration", () => {
             },
             reply: replyMock,
             startTyping: () => () => { },
+            addReaction: vi.fn().mockResolvedValue(undefined),
+            removeReaction: vi.fn().mockResolvedValue(undefined),
+            replyWithRef: vi.fn().mockResolvedValue({
+                edit: vi.fn().mockResolvedValue(undefined),
+                delete: vi.fn().mockResolvedValue(undefined),
+            }),
         };
         mockConnector.emit("message", messageEvent);
         await new Promise((resolve) => setTimeout(resolve, 2000));
@@ -3804,6 +4830,9 @@ describe.skip("DiscordManager output configuration", () => {
                                 result_summary: false,
                                 typing_indicator: true,
                                 errors: true,
+                                acknowledge_emoji: "eyes",
+                                assistant_messages: "answers",
+                                progress_indicator: true,
                             },
                             guilds: [],
                         },
@@ -3887,6 +4916,12 @@ describe.skip("DiscordManager output configuration", () => {
             },
             reply: replyMock,
             startTyping: () => () => { },
+            addReaction: vi.fn().mockResolvedValue(undefined),
+            removeReaction: vi.fn().mockResolvedValue(undefined),
+            replyWithRef: vi.fn().mockResolvedValue({
+                edit: vi.fn().mockResolvedValue(undefined),
+                delete: vi.fn().mockResolvedValue(undefined),
+            }),
         };
         mockConnector.emit("message", messageEvent);
         await new Promise((resolve) => setTimeout(resolve, 2000));
@@ -3935,6 +4970,9 @@ describe.skip("DiscordManager output configuration", () => {
                                 result_summary: false,
                                 typing_indicator: true,
                                 errors: false,
+                                acknowledge_emoji: "eyes",
+                                assistant_messages: "answers",
+                                progress_indicator: true,
                             },
                             guilds: [],
                         },
@@ -4018,6 +5056,12 @@ describe.skip("DiscordManager output configuration", () => {
             },
             reply: replyMock,
             startTyping: () => () => { },
+            addReaction: vi.fn().mockResolvedValue(undefined),
+            removeReaction: vi.fn().mockResolvedValue(undefined),
+            replyWithRef: vi.fn().mockResolvedValue({
+                edit: vi.fn().mockResolvedValue(undefined),
+                delete: vi.fn().mockResolvedValue(undefined),
+            }),
         };
         mockConnector.emit("message", messageEvent);
         await new Promise((resolve) => setTimeout(resolve, 2000));
@@ -4028,6 +5072,127 @@ describe.skip("DiscordManager output configuration", () => {
         });
         expect(embedCalls.length).toBe(0);
     }, 10000);
+    describe("file sender MCP injection", () => {
+        it("passes injectedMcpServers to trigger when agent has working_directory", async () => {
+            const triggerMock = vi.fn().mockResolvedValue({
+                jobId: "job-file",
+                agentName: "test",
+                scheduleName: null,
+                startedAt: new Date().toISOString(),
+                success: true,
+            });
+            const agentWithWorkDir = {
+                ...createDiscordAgent("file-agent", {
+                    bot_token_env: "TEST_BOT_TOKEN",
+                    session_expiry_hours: 24,
+                    log_level: "standard",
+                    output: {
+                        tool_results: true,
+                        tool_result_max_length: 900,
+                        system_status: true,
+                        result_summary: false,
+                        typing_indicator: true,
+                        errors: true,
+                        acknowledge_emoji: "",
+                        assistant_messages: "answers",
+                        progress_indicator: true,
+                    },
+                    guilds: [],
+                }),
+                working_directory: "/tmp/test-workspace",
+            };
+            const config = {
+                fleet: { name: "test-fleet" },
+                agents: [agentWithWorkDir],
+                configPath: "/test/herdctl.yaml",
+                configDir: "/test",
+            };
+            const mockContext = {
+                getConfig: () => config,
+                getStateDir: () => "/tmp/test-state",
+                getStateDirInfo: () => null,
+                getLogger: () => mockLogger,
+                getScheduler: () => null,
+                getStatus: () => "running",
+                getInitializedAt: () => "2024-01-01T00:00:00.000Z",
+                getStartedAt: () => "2024-01-01T00:00:01.000Z",
+                getStoppedAt: () => null,
+                getLastError: () => null,
+                getCheckInterval: () => 1000,
+                emit: vi.fn(),
+                getEmitter: () => new EventEmitter(),
+                trigger: triggerMock,
+            };
+            const manager = new DiscordManager(mockContext);
+            const mockConnector = new EventEmitter();
+            mockConnector.connect = vi.fn().mockResolvedValue(undefined);
+            mockConnector.disconnect = vi.fn().mockResolvedValue(undefined);
+            mockConnector.isConnected = vi.fn().mockReturnValue(true);
+            mockConnector.getState = vi.fn().mockReturnValue({
+                status: "connected",
+                connectedAt: "2024-01-01T00:00:00.000Z",
+                disconnectedAt: null,
+                reconnectAttempts: 0,
+                lastError: null,
+                botUser: { id: "bot1", username: "TestBot", discriminator: "0000" },
+                rateLimits: {
+                    totalCount: 0,
+                    lastRateLimitAt: null,
+                    isRateLimited: false,
+                    currentResetTime: 0,
+                },
+                messageStats: { received: 0, sent: 0, ignored: 0 },
+            });
+            mockConnector.uploadFile = vi.fn().mockResolvedValue({ fileId: "file-123" });
+            mockConnector.agentName = "file-agent";
+            mockConnector.sessionManager = {
+                getSession: vi.fn().mockResolvedValue(null),
+                setSession: vi.fn().mockResolvedValue(undefined),
+                touchSession: vi.fn().mockResolvedValue(undefined),
+                getActiveSessionCount: vi.fn().mockResolvedValue(0),
+            };
+            // @ts-expect-error - accessing private property for testing
+            manager.connectors.set("file-agent", mockConnector);
+            // @ts-expect-error - accessing private property for testing
+            manager.initialized = true;
+            await manager.start();
+            const messageEvent = {
+                agentName: "file-agent",
+                prompt: "Send me the file",
+                context: { messages: [], wasMentioned: true, prompt: "Send me the file" },
+                metadata: {
+                    guildId: "guild1",
+                    channelId: "channel1",
+                    messageId: "msg1",
+                    userId: "user1",
+                    username: "TestUser",
+                    wasMentioned: true,
+                    mode: "mention",
+                },
+                reply: vi.fn().mockResolvedValue(undefined),
+                startTyping: () => () => { },
+                addReaction: vi.fn().mockResolvedValue(undefined),
+                removeReaction: vi.fn().mockResolvedValue(undefined),
+                replyWithRef: vi.fn().mockResolvedValue({
+                    edit: vi.fn().mockResolvedValue(undefined),
+                    delete: vi.fn().mockResolvedValue(undefined),
+                }),
+            };
+            mockConnector.emit("message", messageEvent);
+            await new Promise((resolve) => setTimeout(resolve, 100));
+            // Verify trigger was called with injectedMcpServers
+            expect(triggerMock).toHaveBeenCalledWith("file-agent", undefined, expect.objectContaining({
+                injectedMcpServers: expect.objectContaining({
+                    "herdctl-file-sender": expect.objectContaining({
+                        name: "herdctl-file-sender",
+                        tools: expect.arrayContaining([
+                            expect.objectContaining({ name: "herdctl_send_file" }),
+                        ]),
+                    }),
+                }),
+            }));
+        }, 10000);
+    });
     describe("buildToolEmbed with custom maxOutputChars", () => {
         it("respects custom maxOutputChars parameter", () => {
             const ctx = createMockContext(null);