@wingman-ai/gateway 0.1.0

package/dist/tests/cli-config-loader.test.js

@@ -0,0 +1,358 @@
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { WingmanConfigLoader } from "../cli/config/loader.js";
+import { existsSync, mkdirSync, rmSync, writeFileSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+describe("CLI Config Loader", ()=>{
+    let testDir;
+    let configDir;
+    let originalGatewayToken;
+    beforeEach(()=>{
+        originalGatewayToken = process.env.WINGMAN_GATEWAY_TOKEN;
+        delete process.env.WINGMAN_GATEWAY_TOKEN;
+        testDir = join(tmpdir(), `wingman-test-${Date.now()}`);
+        configDir = join(testDir, ".wingman");
+        mkdirSync(configDir, {
+            recursive: true
+        });
+    });
+    afterEach(()=>{
+        if ("string" == typeof originalGatewayToken) process.env.WINGMAN_GATEWAY_TOKEN = originalGatewayToken;
+        else delete process.env.WINGMAN_GATEWAY_TOKEN;
+        if (existsSync(testDir)) rmSync(testDir, {
+            recursive: true,
+            force: true
+        });
+    });
+    describe("Default config", ()=>{
+        it("should return default config when file doesn't exist", ()=>{
+            const loader = new WingmanConfigLoader(".wingman", testDir);
+            const config = loader.loadConfig();
+            expect(config).toEqual({
+                logLevel: "info",
+                recursionLimit: 5000,
+                search: {
+                    provider: "duckduckgo",
+                    maxResults: 5
+                },
+                voice: {
+                    provider: "web_speech",
+                    defaultPolicy: "off",
+                    webSpeech: {},
+                    elevenlabs: {}
+                },
+                cli: {
+                    theme: "default",
+                    outputMode: "auto"
+                },
+                skills: {
+                    repositoryOwner: "anthropics",
+                    repositoryName: "skills",
+                    skillsDirectory: "skills"
+                },
+                gateway: {
+                    host: "127.0.0.1",
+                    port: 18789,
+                    fsRoots: [],
+                    auth: {
+                        mode: "none",
+                        allowTailscale: false
+                    },
+                    controlUi: {
+                        enabled: true,
+                        port: 18790,
+                        pairingRequired: true,
+                        allowInsecureAuth: false
+                    },
+                    adapters: {}
+                },
+                agents: {
+                    list: [],
+                    bindings: []
+                }
+            });
+        });
+        it("should have default log level of info", ()=>{
+            const loader = new WingmanConfigLoader(".wingman", testDir);
+            const config = loader.loadConfig();
+            expect(config.logLevel).toBe("info");
+        });
+        it("should have default recursion limit of 5000", ()=>{
+            const loader = new WingmanConfigLoader(".wingman", testDir);
+            const config = loader.loadConfig();
+            expect(config.recursionLimit).toBe(5000);
+        });
+        it("should have default search provider as duckduckgo", ()=>{
+            const loader = new WingmanConfigLoader(".wingman", testDir);
+            const config = loader.loadConfig();
+            expect(config.search?.provider).toBe("duckduckgo");
+        });
+        it("should have default CLI output mode as auto", ()=>{
+            const loader = new WingmanConfigLoader(".wingman", testDir);
+            const config = loader.loadConfig();
+            expect(config.cli?.outputMode).toBe("auto");
+        });
+    });
+    describe("Valid configuration", ()=>{
+        it("should load valid minimal config", ()=>{
+            const configData = {
+                logLevel: "debug"
+            };
+            writeFileSync(join(configDir, "wingman.config.json"), JSON.stringify(configData));
+            const loader = new WingmanConfigLoader(".wingman", testDir);
+            const config = loader.loadConfig();
+            expect(config.logLevel).toBe("debug");
+        });
+        it("should load complete config", ()=>{
+            const configData = {
+                logLevel: "debug",
+                defaultAgent: "coder",
+                recursionLimit: 5,
+                search: {
+                    provider: "perplexity",
+                    maxResults: 10
+                },
+                cli: {
+                    theme: "dark",
+                    outputMode: "json"
+                },
+                skills: {
+                    repositoryOwner: "myorg",
+                    repositoryName: "myskills",
+                    skillsDirectory: "custom-skills"
+                }
+            };
+            writeFileSync(join(configDir, "wingman.config.json"), JSON.stringify(configData));
+            const loader = new WingmanConfigLoader(".wingman", testDir);
+            const config = loader.loadConfig();
+            expect(config).toMatchObject(configData);
+        });
+        it("should handle all valid log levels", ()=>{
+            const levels = [
+                "debug",
+                "info",
+                "warn",
+                "error",
+                "silent"
+            ];
+            for (const level of levels){
+                const configData = {
+                    logLevel: level
+                };
+                writeFileSync(join(configDir, "wingman.config.json"), JSON.stringify(configData));
+                const loader = new WingmanConfigLoader(".wingman", testDir);
+                const config = loader.loadConfig();
+                expect(config.logLevel).toBe(level);
+            }
+        });
+        it("should handle all valid search providers", ()=>{
+            const providers = [
+                "duckduckgo",
+                "perplexity"
+            ];
+            for (const provider of providers){
+                const configData = {
+                    search: {
+                        provider,
+                        maxResults: 5
+                    }
+                };
+                writeFileSync(join(configDir, "wingman.config.json"), JSON.stringify(configData));
+                const loader = new WingmanConfigLoader(".wingman", testDir);
+                const config = loader.loadConfig();
+                expect(config.search?.provider).toBe(provider);
+            }
+        });
+        it("should handle all valid CLI output modes", ()=>{
+            const modes = [
+                "auto",
+                "interactive",
+                "json"
+            ];
+            for (const mode of modes){
+                const configData = {
+                    cli: {
+                        outputMode: mode,
+                        theme: "default"
+                    }
+                };
+                writeFileSync(join(configDir, "wingman.config.json"), JSON.stringify(configData));
+                const loader = new WingmanConfigLoader(".wingman", testDir);
+                const config = loader.loadConfig();
+                expect(config.cli?.outputMode).toBe(mode);
+            }
+        });
+    });
+    describe("Invalid configuration", ()=>{
+        it("should return default config for invalid JSON", ()=>{
+            writeFileSync(join(configDir, "wingman.config.json"), "{ invalid json }");
+            const loader = new WingmanConfigLoader(".wingman", testDir);
+            const config = loader.loadConfig();
+            expect(config.logLevel).toBe("info");
+        });
+        it("should return default config for invalid log level", ()=>{
+            const configData = {
+                logLevel: "invalid"
+            };
+            writeFileSync(join(configDir, "wingman.config.json"), JSON.stringify(configData));
+            const loader = new WingmanConfigLoader(".wingman", testDir);
+            const config = loader.loadConfig();
+            expect(config.logLevel).toBe("info");
+        });
+        it("should return default config for invalid recursion limit (too low)", ()=>{
+            const configData = {
+                recursionLimit: 0
+            };
+            writeFileSync(join(configDir, "wingman.config.json"), JSON.stringify(configData));
+            const loader = new WingmanConfigLoader(".wingman", testDir);
+            const config = loader.loadConfig();
+            expect(config.recursionLimit).toBe(5000);
+        });
+        it("should return default config for invalid recursion limit (too high)", ()=>{
+            const configData = {
+                recursionLimit: 1000001
+            };
+            writeFileSync(join(configDir, "wingman.config.json"), JSON.stringify(configData));
+            const loader = new WingmanConfigLoader(".wingman", testDir);
+            const config = loader.loadConfig();
+            expect(config.recursionLimit).toBe(5000);
+        });
+        it("should return default config for invalid search provider", ()=>{
+            const configData = {
+                search: {
+                    provider: "invalid",
+                    maxResults: 5
+                }
+            };
+            writeFileSync(join(configDir, "wingman.config.json"), JSON.stringify(configData));
+            const loader = new WingmanConfigLoader(".wingman", testDir);
+            const config = loader.loadConfig();
+            expect(config.search?.provider).toBe("duckduckgo");
+        });
+    });
+    describe("Partial configuration", ()=>{
+        it("should merge partial config with defaults", ()=>{
+            const configData = {
+                logLevel: "debug"
+            };
+            writeFileSync(join(configDir, "wingman.config.json"), JSON.stringify(configData));
+            const loader = new WingmanConfigLoader(".wingman", testDir);
+            const config = loader.loadConfig();
+            expect(config.logLevel).toBe("debug");
+            expect(config.recursionLimit).toBeDefined();
+            expect(config.search).toBeDefined();
+        });
+        it("should handle partial search config", ()=>{
+            const configData = {
+                search: {
+                    provider: "perplexity"
+                }
+            };
+            writeFileSync(join(configDir, "wingman.config.json"), JSON.stringify(configData));
+            const loader = new WingmanConfigLoader(".wingman", testDir);
+            const config = loader.loadConfig();
+            expect(config.search?.provider).toBe("perplexity");
+            expect(config.search?.maxResults).toBeDefined();
+        });
+        it("should handle partial CLI config", ()=>{
+            const configData = {
+                cli: {
+                    outputMode: "json"
+                }
+            };
+            writeFileSync(join(configDir, "wingman.config.json"), JSON.stringify(configData));
+            const loader = new WingmanConfigLoader(".wingman", testDir);
+            const config = loader.loadConfig();
+            expect(config.cli?.outputMode).toBe("json");
+            expect(config.cli?.theme).toBeDefined();
+        });
+    });
+    describe("Custom config directory", ()=>{
+        it("should support custom config directory name", ()=>{
+            const customDir = join(testDir, ".custom-config");
+            mkdirSync(customDir, {
+                recursive: true
+            });
+            const configData = {
+                logLevel: "debug"
+            };
+            writeFileSync(join(customDir, "wingman.config.json"), JSON.stringify(configData));
+            const loader = new WingmanConfigLoader(".custom-config", testDir);
+            const config = loader.loadConfig();
+            expect(config.logLevel).toBe("debug");
+        });
+    });
+    describe("Edge cases", ()=>{
+        it("should handle empty JSON object", ()=>{
+            writeFileSync(join(configDir, "wingman.config.json"), "{}");
+            const loader = new WingmanConfigLoader(".wingman", testDir);
+            const config = loader.loadConfig();
+            expect(config).toBeDefined();
+            expect(config.logLevel).toBeDefined();
+        });
+        it("should handle config file with extra fields", ()=>{
+            const configData = {
+                logLevel: "debug",
+                extraField: "should be ignored",
+                nested: {
+                    extra: "fields"
+                }
+            };
+            writeFileSync(join(configDir, "wingman.config.json"), JSON.stringify(configData));
+            const loader = new WingmanConfigLoader(".wingman", testDir);
+            const config = loader.loadConfig();
+            expect(config.logLevel).toBe("debug");
+        });
+        it("should handle empty file", ()=>{
+            writeFileSync(join(configDir, "wingman.config.json"), "");
+            const loader = new WingmanConfigLoader(".wingman", testDir);
+            const config = loader.loadConfig();
+            expect(config.logLevel).toBe("info");
+        });
+    });
+    describe("Environment overrides", ()=>{
+        it("should apply WINGMAN_GATEWAY_TOKEN when auth mode is token", ()=>{
+            process.env.WINGMAN_GATEWAY_TOKEN = "env-token";
+            const configData = {
+                gateway: {
+                    auth: {
+                        mode: "token"
+                    }
+                }
+            };
+            writeFileSync(join(configDir, "wingman.config.json"), JSON.stringify(configData));
+            const loader = new WingmanConfigLoader(".wingman", testDir);
+            const config = loader.loadConfig();
+            expect(config.gateway.auth.token).toBe("env-token");
+        });
+        it("should not override token when auth mode is none", ()=>{
+            process.env.WINGMAN_GATEWAY_TOKEN = "env-token";
+            const configData = {
+                gateway: {
+                    auth: {
+                        mode: "none"
+                    }
+                }
+            };
+            writeFileSync(join(configDir, "wingman.config.json"), JSON.stringify(configData));
+            const loader = new WingmanConfigLoader(".wingman", testDir);
+            const config = loader.loadConfig();
+            expect(config.gateway.auth.token).toBeUndefined();
+        });
+        it("should prefer config token over environment token", ()=>{
+            process.env.WINGMAN_GATEWAY_TOKEN = "env-token";
+            const configData = {
+                gateway: {
+                    auth: {
+                        mode: "token",
+                        token: "config-token"
+                    }
+                }
+            };
+            writeFileSync(join(configDir, "wingman.config.json"), JSON.stringify(configData));
+            const loader = new WingmanConfigLoader(".wingman", testDir);
+            const config = loader.loadConfig();
+            expect(config.gateway.auth.token).toBe("config-token");
+        });
+    });
+});

package/dist/tests/cli-init.test.cjs

@@ -0,0 +1,82 @@
+"use strict";
+var __webpack_exports__ = {};
+const external_vitest_namespaceObject = require("vitest");
+const init_cjs_namespaceObject = require("../cli/commands/init.cjs");
+const external_node_fs_namespaceObject = require("node:fs");
+const external_node_path_namespaceObject = require("node:path");
+const external_node_os_namespaceObject = require("node:os");
+(0, external_vitest_namespaceObject.describe)("CLI init", ()=>{
+    let workspace;
+    (0, external_vitest_namespaceObject.beforeEach)(()=>{
+        workspace = (0, external_node_fs_namespaceObject.mkdtempSync)((0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "wingman-init-"));
+    });
+    (0, external_vitest_namespaceObject.afterEach)(()=>{
+        if ((0, external_node_fs_namespaceObject.existsSync)(workspace)) (0, external_node_fs_namespaceObject.rmSync)(workspace, {
+            recursive: true,
+            force: true
+        });
+    });
+    (0, external_vitest_namespaceObject.it)("creates config and agent with defaults", async ()=>{
+        await (0, init_cjs_namespaceObject.executeInitCommand)({
+            subcommand: "",
+            args: [],
+            verbosity: "silent",
+            outputMode: "json",
+            options: {
+                yes: true,
+                "skip-provider": true
+            },
+            agent: "wingman"
+        }, {
+            workspace
+        });
+        const configPath = (0, external_node_path_namespaceObject.join)(workspace, ".wingman", "wingman.config.json");
+        (0, external_vitest_namespaceObject.expect)((0, external_node_fs_namespaceObject.existsSync)(configPath)).toBe(true);
+        const config = JSON.parse((0, external_node_fs_namespaceObject.readFileSync)(configPath, "utf-8"));
+        (0, external_vitest_namespaceObject.expect)(config.defaultAgent).toBe("wingman");
+        (0, external_vitest_namespaceObject.expect)(config.gateway.fsRoots).toContain(".");
+        const agentPath = (0, external_node_path_namespaceObject.join)(workspace, ".wingman", "agents", "wingman", "agent.json");
+        (0, external_vitest_namespaceObject.expect)((0, external_node_fs_namespaceObject.existsSync)(agentPath)).toBe(true);
+        const agent = JSON.parse((0, external_node_fs_namespaceObject.readFileSync)(agentPath, "utf-8"));
+        (0, external_vitest_namespaceObject.expect)(agent.name).toBe("wingman");
+    });
+    (0, external_vitest_namespaceObject.it)("merges existing config when --merge is set", async ()=>{
+        const configDir = (0, external_node_path_namespaceObject.join)(workspace, ".wingman");
+        (0, external_node_fs_namespaceObject.mkdirSync)(configDir, {
+            recursive: true
+        });
+        const configPath = (0, external_node_path_namespaceObject.join)(configDir, "wingman.config.json");
+        (0, external_node_fs_namespaceObject.writeFileSync)(configPath, JSON.stringify({
+            logLevel: "debug",
+            gateway: {
+                fsRoots: [
+                    "./existing"
+                ]
+            }
+        }, null, 2));
+        await (0, init_cjs_namespaceObject.executeInitCommand)({
+            subcommand: "",
+            args: [],
+            verbosity: "silent",
+            outputMode: "json",
+            options: {
+                merge: true,
+                "skip-provider": true
+            },
+            agent: "wingman"
+        }, {
+            workspace
+        });
+        const updated = JSON.parse((0, external_node_fs_namespaceObject.readFileSync)(configPath, "utf-8"));
+        (0, external_vitest_namespaceObject.expect)(updated.logLevel).toBe("debug");
+        (0, external_vitest_namespaceObject.expect)(updated.defaultAgent).toBe("wingman");
+        (0, external_vitest_namespaceObject.expect)(updated.gateway.fsRoots).toEqual(external_vitest_namespaceObject.expect.arrayContaining([
+            "./existing",
+            "."
+        ]));
+    });
+});
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/tests/cli-init.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/cli-init.test.js

@@ -0,0 +1,76 @@
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { executeInitCommand } from "../cli/commands/init.js";
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+describe("CLI init", ()=>{
+    let workspace;
+    beforeEach(()=>{
+        workspace = mkdtempSync(join(tmpdir(), "wingman-init-"));
+    });
+    afterEach(()=>{
+        if (existsSync(workspace)) rmSync(workspace, {
+            recursive: true,
+            force: true
+        });
+    });
+    it("creates config and agent with defaults", async ()=>{
+        await executeInitCommand({
+            subcommand: "",
+            args: [],
+            verbosity: "silent",
+            outputMode: "json",
+            options: {
+                yes: true,
+                "skip-provider": true
+            },
+            agent: "wingman"
+        }, {
+            workspace
+        });
+        const configPath = join(workspace, ".wingman", "wingman.config.json");
+        expect(existsSync(configPath)).toBe(true);
+        const config = JSON.parse(readFileSync(configPath, "utf-8"));
+        expect(config.defaultAgent).toBe("wingman");
+        expect(config.gateway.fsRoots).toContain(".");
+        const agentPath = join(workspace, ".wingman", "agents", "wingman", "agent.json");
+        expect(existsSync(agentPath)).toBe(true);
+        const agent = JSON.parse(readFileSync(agentPath, "utf-8"));
+        expect(agent.name).toBe("wingman");
+    });
+    it("merges existing config when --merge is set", async ()=>{
+        const configDir = join(workspace, ".wingman");
+        mkdirSync(configDir, {
+            recursive: true
+        });
+        const configPath = join(configDir, "wingman.config.json");
+        writeFileSync(configPath, JSON.stringify({
+            logLevel: "debug",
+            gateway: {
+                fsRoots: [
+                    "./existing"
+                ]
+            }
+        }, null, 2));
+        await executeInitCommand({
+            subcommand: "",
+            args: [],
+            verbosity: "silent",
+            outputMode: "json",
+            options: {
+                merge: true,
+                "skip-provider": true
+            },
+            agent: "wingman"
+        }, {
+            workspace
+        });
+        const updated = JSON.parse(readFileSync(configPath, "utf-8"));
+        expect(updated.logLevel).toBe("debug");
+        expect(updated.defaultAgent).toBe("wingman");
+        expect(updated.gateway.fsRoots).toEqual(expect.arrayContaining([
+            "./existing",
+            "."
+        ]));
+    });
+});

package/dist/tests/discord-adapter.test.cjs

@@ -0,0 +1,55 @@
+"use strict";
+var __webpack_exports__ = {};
+const external_vitest_namespaceObject = require("vitest");
+const discord_cjs_namespaceObject = require("../gateway/adapters/discord.cjs");
+(0, external_vitest_namespaceObject.describe)("discord adapter helpers", ()=>{
+    (0, external_vitest_namespaceObject.it)("extracts session override when command matches", ()=>{
+        const result = (0, discord_cjs_namespaceObject.extractSessionOverride)("!session agent:main:cli hello", "!session");
+        (0, external_vitest_namespaceObject.expect)(result.matched).toBe(true);
+        (0, external_vitest_namespaceObject.expect)(result.sessionKey).toBe("agent:main:cli");
+        (0, external_vitest_namespaceObject.expect)(result.content).toBe("hello");
+    });
+    (0, external_vitest_namespaceObject.it)("returns no match when command does not match", ()=>{
+        const result = (0, discord_cjs_namespaceObject.extractSessionOverride)("hello there", "!session");
+        (0, external_vitest_namespaceObject.expect)(result.matched).toBe(false);
+        (0, external_vitest_namespaceObject.expect)(result.sessionKey).toBeUndefined();
+        (0, external_vitest_namespaceObject.expect)(result.content).toBe("hello there");
+    });
+    (0, external_vitest_namespaceObject.it)("handles session command without key", ()=>{
+        const result = (0, discord_cjs_namespaceObject.extractSessionOverride)("!session", "!session");
+        (0, external_vitest_namespaceObject.expect)(result.matched).toBe(true);
+        (0, external_vitest_namespaceObject.expect)(result.sessionKey).toBeUndefined();
+        (0, external_vitest_namespaceObject.expect)(result.content).toBe("");
+    });
+    (0, external_vitest_namespaceObject.it)("resolves channel session mapping with thread fallback", ()=>{
+        const map = {
+            123: "session-a",
+            "parent-1": "session-parent"
+        };
+        (0, external_vitest_namespaceObject.expect)((0, discord_cjs_namespaceObject.resolveDiscordChannelSessionKey)("123", map)).toBe("session-a");
+        (0, external_vitest_namespaceObject.expect)((0, discord_cjs_namespaceObject.resolveDiscordChannelSessionKey)("missing", map, "parent-1")).toBe("session-parent");
+        (0, external_vitest_namespaceObject.expect)((0, discord_cjs_namespaceObject.resolveDiscordChannelSessionKey)("missing", map)).toBeUndefined();
+    });
+    (0, external_vitest_namespaceObject.it)("parses agent id from session key", ()=>{
+        (0, external_vitest_namespaceObject.expect)((0, discord_cjs_namespaceObject.parseAgentIdFromSessionKey)("agent:main:webui:thread:abc")).toBe("main");
+        (0, external_vitest_namespaceObject.expect)((0, discord_cjs_namespaceObject.parseAgentIdFromSessionKey)("agent:stock-trader:discord:channel:1")).toBe("stock-trader");
+        (0, external_vitest_namespaceObject.expect)((0, discord_cjs_namespaceObject.parseAgentIdFromSessionKey)("session-plain")).toBeUndefined();
+        (0, external_vitest_namespaceObject.expect)((0, discord_cjs_namespaceObject.parseAgentIdFromSessionKey)(void 0)).toBeUndefined();
+    });
+    (0, external_vitest_namespaceObject.it)("strips bot mention variants", ()=>{
+        const content = "<@123> hello <@!123>";
+        (0, external_vitest_namespaceObject.expect)((0, discord_cjs_namespaceObject.stripDiscordBotMention)(content, "123")).toBe("hello");
+    });
+    (0, external_vitest_namespaceObject.it)("splits long responses into chunks", ()=>{
+        const input = "a".repeat(4500);
+        const chunks = (0, discord_cjs_namespaceObject.splitDiscordMessage)(input, 1900);
+        (0, external_vitest_namespaceObject.expect)(chunks.length).toBeGreaterThan(1);
+        for (const chunk of chunks)(0, external_vitest_namespaceObject.expect)(chunk.length).toBeLessThanOrEqual(1900);
+        const rebuilt = chunks.join("");
+        (0, external_vitest_namespaceObject.expect)(rebuilt).toBe(input);
+    });
+});
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/tests/discord-adapter.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/discord-adapter.test.js

@@ -0,0 +1,49 @@
+import { describe, expect, it } from "vitest";
+import { extractSessionOverride, parseAgentIdFromSessionKey, resolveDiscordChannelSessionKey, splitDiscordMessage, stripDiscordBotMention } from "../gateway/adapters/discord.js";
+describe("discord adapter helpers", ()=>{
+    it("extracts session override when command matches", ()=>{
+        const result = extractSessionOverride("!session agent:main:cli hello", "!session");
+        expect(result.matched).toBe(true);
+        expect(result.sessionKey).toBe("agent:main:cli");
+        expect(result.content).toBe("hello");
+    });
+    it("returns no match when command does not match", ()=>{
+        const result = extractSessionOverride("hello there", "!session");
+        expect(result.matched).toBe(false);
+        expect(result.sessionKey).toBeUndefined();
+        expect(result.content).toBe("hello there");
+    });
+    it("handles session command without key", ()=>{
+        const result = extractSessionOverride("!session", "!session");
+        expect(result.matched).toBe(true);
+        expect(result.sessionKey).toBeUndefined();
+        expect(result.content).toBe("");
+    });
+    it("resolves channel session mapping with thread fallback", ()=>{
+        const map = {
+            123: "session-a",
+            "parent-1": "session-parent"
+        };
+        expect(resolveDiscordChannelSessionKey("123", map)).toBe("session-a");
+        expect(resolveDiscordChannelSessionKey("missing", map, "parent-1")).toBe("session-parent");
+        expect(resolveDiscordChannelSessionKey("missing", map)).toBeUndefined();
+    });
+    it("parses agent id from session key", ()=>{
+        expect(parseAgentIdFromSessionKey("agent:main:webui:thread:abc")).toBe("main");
+        expect(parseAgentIdFromSessionKey("agent:stock-trader:discord:channel:1")).toBe("stock-trader");
+        expect(parseAgentIdFromSessionKey("session-plain")).toBeUndefined();
+        expect(parseAgentIdFromSessionKey(void 0)).toBeUndefined();
+    });
+    it("strips bot mention variants", ()=>{
+        const content = "<@123> hello <@!123>";
+        expect(stripDiscordBotMention(content, "123")).toBe("hello");
+    });
+    it("splits long responses into chunks", ()=>{
+        const input = "a".repeat(4500);
+        const chunks = splitDiscordMessage(input, 1900);
+        expect(chunks.length).toBeGreaterThan(1);
+        for (const chunk of chunks)expect(chunk.length).toBeLessThanOrEqual(1900);
+        const rebuilt = chunks.join("");
+        expect(rebuilt).toBe(input);
+    });
+});