@herdctl/core 4.1.1 → 4.2.0

package/dist/fleet-manager/__tests__/slack-manager.test.d.ts

@@ -1,8 +1,8 @@
 /**
  * Tests for SlackManager
  *
- * Tests the SlackManager class which manages a single Slack connector
- * shared across agents with chat.slack configured.
+ * Tests the SlackManager class which manages Slack connectors for agents
+ * with chat.slack configured (one connector per agent).
  *
  * Since @herdctl/slack is not a dependency of @herdctl/core, we mock the
  * dynamic import to test the full initialization and lifecycle paths.

package/dist/fleet-manager/__tests__/slack-manager.test.js

@@ -1,8 +1,8 @@
 /**
  * Tests for SlackManager
  *
- * Tests the SlackManager class which manages a single Slack connector
- * shared across agents with chat.slack configured.
+ * Tests the SlackManager class which manages Slack connectors for agents
+ * with chat.slack configured (one connector per agent).
  *
  * Since @herdctl/slack is not a dependency of @herdctl/core, we mock the
  * dynamic import to test the full initialization and lifecycle paths.
@@ -76,8 +76,10 @@ function createConfigWithAgents(...agents) {
 // ---------------------------------------------------------------------------
 // Mock SlackConnector and SessionManager
 // ---------------------------------------------------------------------------
-function createMockConnector() {
+function createMockConnector(agentName, sessionManager) {
     const connector = new EventEmitter();
+    connector.agentName = agentName;
+    connector.sessionManager = sessionManager;
     connector.connect = vi.fn().mockResolvedValue(undefined);
     connector.disconnect = vi.fn().mockResolvedValue(undefined);
     connector.isConnected = vi.fn().mockReturnValue(false);
@@ -90,6 +92,7 @@ function createMockConnector() {
         botUser: null,
         messageStats: { received: 0, sent: 0, ignored: 0 },
     });
+    connector.uploadFile = vi.fn().mockResolvedValue({ fileId: "file-123" });
     return connector;
 }
 function createMockSessionManager(agentName) {
@@ -146,7 +149,7 @@ describe("SlackManager (no @herdctl/slack)", () => {
             const ctx = createMockContext(config);
             const manager = new SlackManager(ctx);
             await manager.initialize();
-            expect(mockLogger.debug).toHaveBeenCalledWith("@herdctl/slack not installed, skipping Slack connector");
+            expect(mockLogger.debug).toHaveBeenCalledWith("@herdctl/slack not installed, skipping Slack connectors");
         });
         it("skips when @herdctl/slack is not installed (with slack agents)", async () => {
             const SlackManager = await getSlackManager();
@@ -154,7 +157,7 @@ describe("SlackManager (no @herdctl/slack)", () => {
             const ctx = createMockContext(config);
             const manager = new SlackManager(ctx);
             await manager.initialize();
-            expect(mockLogger.debug).toHaveBeenCalledWith("@herdctl/slack not installed, skipping Slack connector");
+            expect(mockLogger.debug).toHaveBeenCalledWith("@herdctl/slack not installed, skipping Slack connectors");
         });
         it("allows retry when no config (initialized not set)", async () => {
             const SlackManager = await getSlackManager();
@@ -173,7 +176,7 @@ describe("SlackManager (no @herdctl/slack)", () => {
             const manager = new SlackManager(ctx);
             await manager.initialize();
             await manager.start();
-            expect(mockLogger.debug).toHaveBeenCalledWith("No Slack connector to start");
+            expect(mockLogger.debug).toHaveBeenCalledWith("No Slack connectors to start");
         });
     });
     describe("stop", () => {
@@ -183,7 +186,7 @@ describe("SlackManager (no @herdctl/slack)", () => {
             const manager = new SlackManager(ctx);
             await manager.initialize();
             await manager.stop();
-            expect(mockLogger.debug).toHaveBeenCalledWith("No Slack connector to stop");
+            expect(mockLogger.debug).toHaveBeenCalledWith("No Slack connectors to stop");
         });
     });
     describe("hasAgent", () => {
@@ -195,35 +198,35 @@ describe("SlackManager (no @herdctl/slack)", () => {
         });
     });
     describe("getState", () => {
-        it("returns null when no connector", async () => {
+        it("returns null when no connector for agent", async () => {
             const SlackManager = await getSlackManager();
             const ctx = createMockContext(null);
             const manager = new SlackManager(ctx);
-            expect(manager.getState()).toBeNull();
+            expect(manager.getState("test-agent")).toBeNull();
         });
     });
-    describe("isConnected", () => {
-        it("returns false when no connector", async () => {
+    describe("getConnectedCount", () => {
+        it("returns 0 when no connectors", async () => {
             const SlackManager = await getSlackManager();
             const ctx = createMockContext(null);
             const manager = new SlackManager(ctx);
-            expect(manager.isConnected()).toBe(false);
+            expect(manager.getConnectedCount()).toBe(0);
         });
     });
     describe("getConnector", () => {
-        it("returns null when no connector", async () => {
+        it("returns undefined when no connector for agent", async () => {
             const SlackManager = await getSlackManager();
             const ctx = createMockContext(null);
             const manager = new SlackManager(ctx);
-            expect(manager.getConnector()).toBeNull();
+            expect(manager.getConnector("test-agent")).toBeUndefined();
         });
     });
-    describe("getChannelAgentMap", () => {
-        it("returns empty map when not initialized", async () => {
+    describe("getConnectorNames", () => {
+        it("returns empty array when not initialized", async () => {
             const SlackManager = await getSlackManager();
             const ctx = createMockContext(null);
             const manager = new SlackManager(ctx);
-            expect(manager.getChannelAgentMap().size).toBe(0);
+            expect(manager.getConnectorNames()).toEqual([]);
         });
     });
     describe("splitResponse", () => {
@@ -298,7 +301,8 @@ describe("SlackManager (no @herdctl/slack)", () => {
 // Tests – With Mocked @herdctl/slack (full initialization paths)
 // ---------------------------------------------------------------------------
 describe("SlackManager (mocked @herdctl/slack)", () => {
-    let mockConnector;
+    let mockConnectors;
+    let mockSessionManagers;
     let MockSlackConnector;
     let MockSessionManager;
     let originalEnv;
@@ -309,14 +313,19 @@ describe("SlackManager (mocked @herdctl/slack)", () => {
         // Set required env vars
         process.env.SLACK_BOT_TOKEN = "xoxb-test-bot-token";
         process.env.SLACK_APP_TOKEN = "xapp-test-app-token";
-        // Create mock implementations
-        mockConnector = createMockConnector();
+        // Create mock implementations - per-agent connectors
+        mockConnectors = new Map();
+        mockSessionManagers = new Map();
         // Must use function expressions (not arrows) so they work with `new`
-        MockSlackConnector = vi.fn().mockImplementation(function () {
-            return mockConnector;
-        });
         MockSessionManager = vi.fn().mockImplementation(function (opts) {
-            return createMockSessionManager(opts.agentName);
+            const sessionMgr = createMockSessionManager(opts.agentName);
+            mockSessionManagers.set(opts.agentName, sessionMgr);
+            return sessionMgr;
+        });
+        MockSlackConnector = vi.fn().mockImplementation(function (opts) {
+            const connector = createMockConnector(opts.agentName, opts.sessionManager);
+            mockConnectors.set(opts.agentName, connector);
+            return connector;
         });
     });
     afterEach(() => {
@@ -347,14 +356,15 @@ describe("SlackManager (mocked @herdctl/slack)", () => {
                 sessionExpiryHours: 24,
             }));
             expect(MockSlackConnector).toHaveBeenCalledWith(expect.objectContaining({
+                agentName: "agent1",
                 botToken: "xoxb-test-bot-token",
                 appToken: "xapp-test-app-token",
-                stateDir: "/tmp/test-state",
+                channels: [{ id: "C0123456789", mode: "mention" }],
             }));
             expect(manager.hasAgent("agent1")).toBe(true);
-            expect(manager.getConnector()).toBe(mockConnector);
+            expect(manager.getConnector("agent1")).toBe(mockConnectors.get("agent1"));
         });
-        it("builds channel→agent routing map", async () => {
+        it("creates separate connectors for multiple agents", async () => {
             const SlackManager = await getSlackManagerWithMock();
             const config = createConfigWithAgents(createSlackAgent("agent1", {
                 ...defaultSlackConfig,
@@ -366,27 +376,10 @@ describe("SlackManager (mocked @herdctl/slack)", () => {
             const ctx = createMockContext(config);
             const manager = new SlackManager(ctx);
             await manager.initialize();
-            const channelMap = manager.getChannelAgentMap();
-            expect(channelMap.get("C001")).toBe("agent1");
-            expect(channelMap.get("C002")).toBe("agent1");
-            expect(channelMap.get("C003")).toBe("agent2");
-            expect(channelMap.size).toBe(3);
-        });
-        it("warns about overlapping channel mappings", async () => {
-            const SlackManager = await getSlackManagerWithMock();
-            const config = createConfigWithAgents(createSlackAgent("agent1", {
-                ...defaultSlackConfig,
-                channels: [{ id: "C001", mode: "mention", context_messages: 10 }],
-            }), createSlackAgent("agent2", {
-                ...defaultSlackConfig,
-                channels: [{ id: "C001", mode: "mention", context_messages: 10 }], // Same channel as agent1
-            }));
-            const ctx = createMockContext(config);
-            const manager = new SlackManager(ctx);
-            await manager.initialize();
-            expect(mockLogger.warn).toHaveBeenCalledWith(expect.stringContaining("Channel C001 is already mapped"));
-            // Second agent wins
-            expect(manager.getChannelAgentMap().get("C001")).toBe("agent2");
+            expect(manager.getConnectorNames()).toEqual(["agent1", "agent2"]);
+            expect(MockSlackConnector).toHaveBeenCalledTimes(2);
+            expect(manager.getConnector("agent1")).toBeDefined();
+            expect(manager.getConnector("agent2")).toBeDefined();
         });
         it("skips when no agents have Slack configured", async () => {
             const SlackManager = await getSlackManagerWithMock();
@@ -397,7 +390,7 @@ describe("SlackManager (mocked @herdctl/slack)", () => {
             expect(mockLogger.debug).toHaveBeenCalledWith("No agents with Slack configured");
             expect(MockSlackConnector).not.toHaveBeenCalled();
         });
-        it("warns and skips when bot token env var is missing", async () => {
+        it("warns and skips agent when bot token env var is missing", async () => {
             delete process.env.SLACK_BOT_TOKEN;
             const SlackManager = await getSlackManagerWithMock();
             const config = createConfigWithAgents(createSlackAgent("agent1", defaultSlackConfig));
@@ -407,7 +400,7 @@ describe("SlackManager (mocked @herdctl/slack)", () => {
             expect(mockLogger.warn).toHaveBeenCalledWith(expect.stringContaining("Slack bot token not found"));
             expect(MockSlackConnector).not.toHaveBeenCalled();
         });
-        it("warns and skips when app token env var is missing", async () => {
+        it("warns and skips agent when app token env var is missing", async () => {
             delete process.env.SLACK_APP_TOKEN;
             const SlackManager = await getSlackManagerWithMock();
             const config = createConfigWithAgents(createSlackAgent("agent1", defaultSlackConfig));
@@ -443,10 +436,10 @@ describe("SlackManager (mocked @herdctl/slack)", () => {
             const ctx = createMockContext(config);
             const manager = new SlackManager(ctx);
             await manager.initialize();
-            expect(mockLogger.debug).toHaveBeenCalledWith(expect.stringContaining("Slack manager initialized with 1 agent(s)"));
+            expect(mockLogger.debug).toHaveBeenCalledWith(expect.stringContaining("Slack manager initialized with 1 connector(s)"));
         });
-        it("handles connector creation failure", async () => {
-            MockSlackConnector.mockImplementation(() => {
+        it("handles connector creation failure for one agent", async () => {
+            MockSlackConnector.mockImplementationOnce(() => {
                 throw new Error("Failed to create Bolt app");
             });
             const SlackManager = await getSlackManagerWithMock();
@@ -454,10 +447,10 @@ describe("SlackManager (mocked @herdctl/slack)", () => {
             const ctx = createMockContext(config);
             const manager = new SlackManager(ctx);
             await manager.initialize();
-            expect(mockLogger.error).toHaveBeenCalledWith(expect.stringContaining("Failed to create Slack connector"));
-            expect(manager.getConnector()).toBeNull();
+            expect(mockLogger.error).toHaveBeenCalledWith(expect.stringContaining("Failed to create Slack connector for agent 'agent1'"));
+            expect(manager.getConnector("agent1")).toBeUndefined();
         });
-        it("creates multiple session managers for multiple agents", async () => {
+        it("creates connectors for multiple agents", async () => {
             const SlackManager = await getSlackManagerWithMock();
             const config = createConfigWithAgents(createSlackAgent("agent1", {
                 ...defaultSlackConfig,
@@ -470,6 +463,7 @@ describe("SlackManager (mocked @herdctl/slack)", () => {
             const manager = new SlackManager(ctx);
             await manager.initialize();
             expect(MockSessionManager).toHaveBeenCalledTimes(2);
+            expect(MockSlackConnector).toHaveBeenCalledTimes(2);
             expect(manager.hasAgent("agent1")).toBe(true);
             expect(manager.hasAgent("agent2")).toBe(true);
             expect(manager.hasAgent("agent3")).toBe(false);
@@ -483,90 +477,92 @@ describe("SlackManager (mocked @herdctl/slack)", () => {
             const manager = new SlackManager(ctx);
             await manager.initialize();
             await manager.start();
-            expect(mockConnector.connect).toHaveBeenCalledTimes(1);
-            expect(mockLogger.info).toHaveBeenCalledWith("Slack connector started");
+            const connector = mockConnectors.get("agent1");
+            expect(connector?.connect).toHaveBeenCalledTimes(1);
+            expect(mockLogger.info).toHaveBeenCalledWith(expect.stringContaining("Slack connectors started"));
         });
-        it("handles connection failure", async () => {
-            mockConnector.connect.mockRejectedValue(new Error("Connection refused"));
+        it("handles connection failure for one agent", async () => {
             const SlackManager = await getSlackManagerWithMock();
             const config = createConfigWithAgents(createSlackAgent("agent1", defaultSlackConfig));
             const ctx = createMockContext(config);
             const manager = new SlackManager(ctx);
             await manager.initialize();
+            // Make the connector fail to connect
+            const connector = mockConnectors.get("agent1");
+            connector?.connect.mockRejectedValue(new Error("Connection refused"));
             await manager.start();
-            expect(mockLogger.error).toHaveBeenCalledWith(expect.stringContaining("Failed to connect Slack"));
+            expect(mockLogger.error).toHaveBeenCalledWith(expect.stringContaining("Failed to connect Slack for agent 'agent1'"));
         });
-        it("logs debug message when no connector to start", async () => {
+        it("logs debug message when no connectors to start", async () => {
             const SlackManager = await getSlackManagerWithMock();
             const ctx = createMockContext(null);
             const manager = new SlackManager(ctx);
             await manager.start();
-            expect(mockLogger.debug).toHaveBeenCalledWith("No Slack connector to start");
+            expect(mockLogger.debug).toHaveBeenCalledWith("No Slack connectors to start");
         });
     });
     describe("stop", () => {
-        it("disconnects the connector", async () => {
+        it("disconnects all connectors", async () => {
             const SlackManager = await getSlackManagerWithMock();
             const config = createConfigWithAgents(createSlackAgent("agent1", defaultSlackConfig));
             const ctx = createMockContext(config);
             const manager = new SlackManager(ctx);
             await manager.initialize();
             await manager.stop();
-            expect(mockConnector.disconnect).toHaveBeenCalledTimes(1);
-            expect(mockLogger.debug).toHaveBeenCalledWith("Slack connector stopped");
+            const connector = mockConnectors.get("agent1");
+            expect(connector?.disconnect).toHaveBeenCalledTimes(1);
+            expect(mockLogger.debug).toHaveBeenCalledWith("All Slack connectors stopped");
         });
-        it("handles disconnect failure", async () => {
-            mockConnector.disconnect.mockRejectedValue(new Error("Disconnect timeout"));
+        it("handles disconnect failure for one agent", async () => {
             const SlackManager = await getSlackManagerWithMock();
             const config = createConfigWithAgents(createSlackAgent("agent1", defaultSlackConfig));
             const ctx = createMockContext(config);
             const manager = new SlackManager(ctx);
             await manager.initialize();
+            const connector = mockConnectors.get("agent1");
+            connector?.disconnect.mockRejectedValue(new Error("Disconnect timeout"));
             await manager.stop();
-            expect(mockLogger.error).toHaveBeenCalledWith(expect.stringContaining("Error disconnecting Slack"));
+            expect(mockLogger.error).toHaveBeenCalledWith(expect.stringContaining("Error disconnecting Slack for agent 'agent1'"));
         });
         it("logs active session counts before stopping", async () => {
-            const mockSessionMgr = createMockSessionManager("agent1");
-            mockSessionMgr.getActiveSessionCount.mockResolvedValue(3);
-            MockSessionManager.mockImplementation(function () {
-                return mockSessionMgr;
-            });
             const SlackManager = await getSlackManagerWithMock();
             const config = createConfigWithAgents(createSlackAgent("agent1", defaultSlackConfig));
             const ctx = createMockContext(config);
             const manager = new SlackManager(ctx);
             await manager.initialize();
+            // Update the session manager to return 3 active sessions
+            const connector = mockConnectors.get("agent1");
+            connector?.sessionManager.getActiveSessionCount.mockResolvedValue(3);
             await manager.stop();
             expect(mockLogger.debug).toHaveBeenCalledWith(expect.stringContaining("Preserving 3 active Slack session(s)"));
         });
         it("handles session count query failure gracefully", async () => {
-            const mockSessionMgr = createMockSessionManager("agent1");
-            mockSessionMgr.getActiveSessionCount.mockRejectedValue(new Error("File read error"));
-            MockSessionManager.mockImplementation(function () {
-                return mockSessionMgr;
-            });
             const SlackManager = await getSlackManagerWithMock();
             const config = createConfigWithAgents(createSlackAgent("agent1", defaultSlackConfig));
             const ctx = createMockContext(config);
             const manager = new SlackManager(ctx);
             await manager.initialize();
+            // Make the session manager fail
+            const connector = mockConnectors.get("agent1");
+            connector?.sessionManager.getActiveSessionCount.mockRejectedValue(new Error("File read error"));
             await manager.stop();
             expect(mockLogger.warn).toHaveBeenCalledWith(expect.stringContaining("Failed to get Slack session count"));
         });
     });
-    describe("isConnected", () => {
-        it("delegates to connector.isConnected()", async () => {
-            mockConnector.isConnected.mockReturnValue(true);
+    describe("getConnectedCount", () => {
+        it("returns count of connected connectors", async () => {
             const SlackManager = await getSlackManagerWithMock();
             const config = createConfigWithAgents(createSlackAgent("agent1", defaultSlackConfig));
             const ctx = createMockContext(config);
             const manager = new SlackManager(ctx);
             await manager.initialize();
-            expect(manager.isConnected()).toBe(true);
+            const connector = mockConnectors.get("agent1");
+            connector?.isConnected.mockReturnValue(true);
+            expect(manager.getConnectedCount()).toBe(1);
         });
     });
     describe("getState", () => {
-        it("delegates to connector.getState()", async () => {
+        it("delegates to connector.getState() for specific agent", async () => {
             const state = {
                 status: "connected",
                 connectedAt: "2026-01-01T00:00:00Z",
@@ -576,13 +572,14 @@ describe("SlackManager (mocked @herdctl/slack)", () => {
                 botUser: { id: "U123", username: "testbot" },
                 messageStats: { received: 5, sent: 3, ignored: 1 },
             };
-            mockConnector.getState.mockReturnValue(state);
             const SlackManager = await getSlackManagerWithMock();
             const config = createConfigWithAgents(createSlackAgent("agent1", defaultSlackConfig));
             const ctx = createMockContext(config);
             const manager = new SlackManager(ctx);
             await manager.initialize();
-            expect(manager.getState()).toBe(state);
+            const connector = mockConnectors.get("agent1");
+            connector?.getState.mockReturnValue(state);
+            expect(manager.getState("agent1")).toBe(state);
         });
     });
     describe("message handling (via connector events)", () => {
@@ -594,43 +591,18 @@ describe("SlackManager (mocked @herdctl/slack)", () => {
             const manager = new SlackManager(ctx);
             await manager.initialize();
             await manager.start();
-            // Simulate error from connector (no agentName — connector is shared)
-            mockConnector.emit("error", {
+            // Simulate error from connector (with agentName)
+            const connector = mockConnectors.get("agent1");
+            connector?.emit("error", {
+                agentName: "agent1",
                 error: new Error("Socket closed"),
             });
-            expect(mockLogger.error).toHaveBeenCalledWith(expect.stringContaining("Slack connector error for agent 'slack'"));
+            expect(mockLogger.error).toHaveBeenCalledWith(expect.stringContaining("Slack connector error for agent 'agent1'"));
             expect(emitter.emit).toHaveBeenCalledWith("slack:error", expect.objectContaining({
-                agentName: "slack",
+                agentName: "agent1",
                 error: "Socket closed",
             }));
         });
-        it("handles message for unknown agent", async () => {
-            const SlackManager = await getSlackManagerWithMock();
-            const emitter = createMockEmitter();
-            const config = createConfigWithAgents(createSlackAgent("agent1", defaultSlackConfig));
-            const ctx = createMockContext(config, emitter);
-            const manager = new SlackManager(ctx);
-            await manager.initialize();
-            await manager.start();
-            const replyFn = vi.fn().mockResolvedValue(undefined);
-            // Simulate message for an agent not in config
-            mockConnector.emit("message", {
-                agentName: "unknown-agent",
-                prompt: "Hello there",
-                metadata: {
-                    channelId: "C0123456789",
-                    messageTs: "1707930001.000000",
-                    userId: "U0123456789",
-                    wasMentioned: true,
-                },
-                reply: replyFn,
-                startProcessingIndicator: () => () => { },
-            });
-            // Give time for the async handler to run
-            await new Promise((r) => setTimeout(r, 50));
-            expect(mockLogger.error).toHaveBeenCalledWith("Agent 'unknown-agent' not found in configuration");
-            expect(replyFn).toHaveBeenCalledWith(expect.stringContaining("not properly configured"));
-        });
         it("handles message with successful trigger", async () => {
             const SlackManager = await getSlackManagerWithMock();
             const emitter = createMockEmitter();
@@ -648,7 +620,8 @@ describe("SlackManager (mocked @herdctl/slack)", () => {
             await manager.start();
             const replyFn = vi.fn().mockResolvedValue(undefined);
             const stopIndicator = vi.fn();
-            mockConnector.emit("message", {
+            const connector = mockConnectors.get("agent1");
+            connector?.emit("message", {
                 agentName: "agent1",
                 prompt: "Help me with coding",
                 metadata: {
@@ -685,7 +658,8 @@ describe("SlackManager (mocked @herdctl/slack)", () => {
             await manager.initialize();
             await manager.start();
             const replyFn = vi.fn().mockResolvedValue(undefined);
-            mockConnector.emit("message", {
+            const connector = mockConnectors.get("agent1");
+            connector?.emit("message", {
                 agentName: "agent1",
                 prompt: "Do something",
                 metadata: {
@@ -717,7 +691,8 @@ describe("SlackManager (mocked @herdctl/slack)", () => {
             await manager.initialize();
             await manager.start();
             const replyFn = vi.fn().mockResolvedValue(undefined);
-            mockConnector.emit("message", {
+            const connector = mockConnectors.get("agent1");
+            connector?.emit("message", {
                 agentName: "agent1",
                 prompt: "Do something",
                 metadata: {
@@ -743,7 +718,8 @@ describe("SlackManager (mocked @herdctl/slack)", () => {
             await manager.initialize();
             await manager.start();
             const replyFn = vi.fn().mockResolvedValue(undefined);
-            mockConnector.emit("message", {
+            const connector = mockConnectors.get("agent1");
+            connector?.emit("message", {
                 agentName: "agent1",
                 prompt: "Do something",
                 metadata: {
@@ -764,14 +740,6 @@ describe("SlackManager (mocked @herdctl/slack)", () => {
             }));
         });
         it("resumes existing session when one exists", async () => {
-            const mockSessionMgr = createMockSessionManager("agent1");
-            mockSessionMgr.getSession.mockResolvedValue({
-                sessionId: "existing-session-456",
-                lastMessageAt: "2026-02-15T10:00:00Z",
-            });
-            MockSessionManager.mockImplementation(function () {
-                return mockSessionMgr;
-            });
             const SlackManager = await getSlackManagerWithMock();
             const emitter = createMockEmitter();
             const config = createConfigWithAgents(createSlackAgent("agent1", defaultSlackConfig));
@@ -784,9 +752,15 @@ describe("SlackManager (mocked @herdctl/slack)", () => {
             const ctx = createMockContext(config, emitter);
             const manager = new SlackManager(ctx);
             await manager.initialize();
+            // Set up the session manager to return an existing session
+            const connector = mockConnectors.get("agent1");
+            connector?.sessionManager.getSession.mockResolvedValue({
+                sessionId: "existing-session-456",
+                lastMessageAt: "2026-02-15T10:00:00Z",
+            });
             await manager.start();
             const replyFn = vi.fn().mockResolvedValue(undefined);
-            mockConnector.emit("message", {
+            connector?.emit("message", {
                 agentName: "agent1",
                 prompt: "Continue our conversation",
                 metadata: {
@@ -804,7 +778,7 @@ describe("SlackManager (mocked @herdctl/slack)", () => {
                 resume: "existing-session-456",
             }));
             // Should store the new session
-            expect(mockSessionMgr.setSession).toHaveBeenCalledWith("C0123456789", "new-session-789");
+            expect(connector?.sessionManager.setSession).toHaveBeenCalledWith("C0123456789", "new-session-789");
         });
         it("streams assistant messages via onMessage callback", async () => {
             const SlackManager = await getSlackManagerWithMock();
@@ -825,7 +799,8 @@ describe("SlackManager (mocked @herdctl/slack)", () => {
             await manager.initialize();
             await manager.start();
             const replyFn = vi.fn().mockResolvedValue(undefined);
-            mockConnector.emit("message", {
+            const connector = mockConnectors.get("agent1");
+            connector?.emit("message", {
                 agentName: "agent1",
                 prompt: "Say hello",
                 metadata: {
@@ -850,10 +825,12 @@ describe("SlackManager (mocked @herdctl/slack)", () => {
             await manager.initialize();
             await manager.start();
             // Simulate non-Error (string) error from connector
-            mockConnector.emit("error", {
+            const connector = mockConnectors.get("agent1");
+            connector?.emit("error", {
+                agentName: "agent1",
                 error: "string error",
             });
-            expect(mockLogger.error).toHaveBeenCalledWith(expect.stringContaining("Slack connector error for agent 'slack': string error"));
+            expect(mockLogger.error).toHaveBeenCalledWith(expect.stringContaining("Slack connector error for agent 'agent1': string error"));
         });
         it("handles reply failure during error handling gracefully", async () => {
             const SlackManager = await getSlackManagerWithMock();
@@ -866,7 +843,8 @@ describe("SlackManager (mocked @herdctl/slack)", () => {
             await manager.initialize();
             await manager.start();
             const replyFn = vi.fn().mockRejectedValue(new Error("Reply failed too"));
-            mockConnector.emit("message", {
+            const connector = mockConnectors.get("agent1");
+            connector?.emit("message", {
                 agentName: "agent1",
                 prompt: "Do something",
                 metadata: {
@@ -883,31 +861,6 @@ describe("SlackManager (mocked @herdctl/slack)", () => {
             expect(mockLogger.error).toHaveBeenCalledWith(expect.stringContaining("Slack message handling failed"));
             expect(mockLogger.error).toHaveBeenCalledWith(expect.stringContaining("Failed to send error reply"));
         });
-        it("handles error from reply during agent-not-found", async () => {
-            const SlackManager = await getSlackManagerWithMock();
-            const emitter = createMockEmitter();
-            const config = createConfigWithAgents(createSlackAgent("agent1", defaultSlackConfig));
-            const ctx = createMockContext(config, emitter);
-            const manager = new SlackManager(ctx);
-            await manager.initialize();
-            await manager.start();
-            const replyFn = vi.fn().mockRejectedValue(new Error("Reply error"));
-            mockConnector.emit("message", {
-                agentName: "nonexistent",
-                prompt: "Hello",
-                metadata: {
-                    channelId: "C0123456789",
-                    messageTs: "1707930001.000000",
-                    userId: "U0123456789",
-                    wasMentioned: true,
-                },
-                reply: replyFn,
-                startProcessingIndicator: () => () => { },
-            });
-            await new Promise((r) => setTimeout(r, 50));
-            expect(mockLogger.error).toHaveBeenCalledWith(expect.stringContaining("Agent 'nonexistent' not found"));
-            expect(mockLogger.error).toHaveBeenCalledWith(expect.stringContaining("Failed to send error reply"));
-        });
         it("extracts text from message.message.content array", async () => {
             const SlackManager = await getSlackManagerWithMock();
             const emitter = createMockEmitter();
@@ -935,7 +888,8 @@ describe("SlackManager (mocked @herdctl/slack)", () => {
             await manager.initialize();
             await manager.start();
             const replyFn = vi.fn().mockResolvedValue(undefined);
-            mockConnector.emit("message", {
+            const connector = mockConnectors.get("agent1");
+            connector?.emit("message", {
                 agentName: "agent1",
                 prompt: "Test",
                 metadata: {
@@ -971,7 +925,8 @@ describe("SlackManager (mocked @herdctl/slack)", () => {
             await manager.initialize();
             await manager.start();
             const replyFn = vi.fn().mockResolvedValue(undefined);
-            mockConnector.emit("message", {
+            const connector = mockConnectors.get("agent1");
+            connector?.emit("message", {
                 agentName: "agent1",
                 prompt: "Test",
                 metadata: {
@@ -1005,7 +960,8 @@ describe("SlackManager (mocked @herdctl/slack)", () => {
             await manager.initialize();
             await manager.start();
             const replyFn = vi.fn().mockResolvedValue(undefined);
-            mockConnector.emit("message", {
+            const connector = mockConnectors.get("agent1");
+            connector?.emit("message", {
                 agentName: "agent1",
                 prompt: "Test",
                 metadata: {