muonroi-cli 1.8.1 → 1.8.4

package/dist/src/agent-harness/__tests__/spec-helpers.spec.js

@@ -1,68 +0,0 @@
-import { diffSpecs, querySpec, validateSpec } from "@muonroi/agent-harness-core/spec-helpers";
-import { describe, expect, it } from "vitest";
-describe("validateSpec", () => {
-    it("accepts a valid spec", () => {
-        const spec = {
-            mode: "design",
-            version: "0.4.0",
-            scenes: [{ id: "s", name: "S", layout: { id: "root", role: "dialog" } }],
-        };
-        expect(validateSpec(spec).ok).toBe(true);
-    });
-    it("rejects wrong mode", () => {
-        const spec = {
-            mode: "live",
-            version: "0.4.0",
-            scenes: [{ id: "s", name: "S", layout: { id: "root", role: "dialog" } }],
-        };
-        expect(validateSpec(spec).ok).toBe(false);
-    });
-});
-describe("querySpec", () => {
-    const spec = {
-        mode: "design",
-        version: "0.4.0",
-        scenes: [
-            {
-                id: "s",
-                name: "S",
-                layout: { id: "root", role: "dialog", children: [{ id: "btn", role: "button", name: "OK" }] },
-                states: [{ name: "loading", patches: [{ id: "btn", disabled: true }] }],
-            },
-        ],
-    };
-    it("returns base layout when no state", () => {
-        const t = querySpec(spec, { scene: "s" });
-        expect(t.children[0].disabled).toBeUndefined();
-    });
-    it("applies state patches", () => {
-        const t = querySpec(spec, { scene: "s", state: "loading" });
-        expect(t.children[0].disabled).toBe(true);
-    });
-    it("throws on unknown scene", () => {
-        expect(() => querySpec(spec, { scene: "missing" })).toThrow();
-    });
-});
-describe("diffSpecs", () => {
-    const a = {
-        mode: "design",
-        version: "0.4.0",
-        scenes: [{ id: "s", name: "S", layout: { id: "root", role: "dialog" } }],
-    };
-    const b = {
-        mode: "design",
-        version: "0.4.0",
-        scenes: [
-            {
-                id: "s",
-                name: "S2",
-                layout: { id: "root", role: "dialog", children: [{ id: "n", role: "button" }] },
-            },
-        ],
-    };
-    it("reports renamed scene name", () => {
-        const d = diffSpecs(a, b);
-        expect(d.scenes.modified.find((m) => m.id === "s")).toBeTruthy();
-    });
-});
-//# sourceMappingURL=spec-helpers.spec.js.map

package/dist/src/chat/__tests__/broadcast-bus.test.d.ts

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

package/dist/src/chat/__tests__/broadcast-bus.test.js

@@ -1,81 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { publish } from "../broadcast-bus.js";
-import { DISCORD_CONTENT_BUDGET } from "../verdict-constants.js";
-function makeClient(over = {}) {
-    return {
-        createChannel: vi.fn(),
-        getChannelMessages: vi.fn().mockResolvedValue([]),
-        postMessage: vi.fn().mockResolvedValue({ id: "m1" }),
-        addChannelPermission: vi.fn(),
-        getCurrentUserId: vi.fn().mockResolvedValue("bot"),
-        listGuildChannels: vi.fn().mockResolvedValue([]),
-        ...over,
-    };
-}
-describe("publish", () => {
-    it("posts content under budget unchanged", async () => {
-        const client = makeClient();
-        const out = await publish({ client, channelId: "c1", type: "phase-event", content: "hello" });
-        expect(out?.messageId).toBe("m1");
-        expect(client.postMessage).toHaveBeenCalledWith("c1", "hello");
-    });
-    it("returns null on empty content (no API call)", async () => {
-        const client = makeClient();
-        const out = await publish({ client, channelId: "c1", type: "phase-event", content: "" });
-        expect(out).toBeNull();
-        expect(client.postMessage).not.toHaveBeenCalled();
-    });
-    it("splits content over budget at newline boundary", async () => {
-        const long = `para1\n\n${"x".repeat(DISCORD_CONTENT_BUDGET)}\n\npara3`;
-        const client = makeClient({
-            postMessage: vi
-                .fn()
-                .mockResolvedValueOnce({ id: "m1" })
-                .mockResolvedValueOnce({ id: "m2" })
-                .mockResolvedValueOnce({ id: "m3" }),
-        });
-        const out = await publish({ client, channelId: "c1", type: "phase-event", content: long });
-        const calls = client.postMessage.mock.calls;
-        expect(calls.length).toBeGreaterThanOrEqual(2);
-        expect(out?.messageId).toBe(`m${calls.length}`);
-        for (const [, msg] of calls) {
-            expect(msg.length).toBeLessThanOrEqual(DISCORD_CONTENT_BUDGET + 30);
-        }
-    });
-    it("returns null on 403 with warning", async () => {
-        const err = new Error("403");
-        err.status = 403;
-        const client = makeClient({ postMessage: vi.fn().mockRejectedValue(err) });
-        const out = await publish({ client, channelId: "c1", type: "phase-event", content: "hi" });
-        expect(out).toBeNull();
-    });
-    it("returns null on 404 with warning", async () => {
-        const err = new Error("404");
-        err.status = 404;
-        const client = makeClient({ postMessage: vi.fn().mockRejectedValue(err) });
-        const out = await publish({ client, channelId: "c1", type: "phase-event", content: "hi" });
-        expect(out).toBeNull();
-    });
-    it("preserves unicode/emoji in content", async () => {
-        const client = makeClient();
-        await publish({ client, channelId: "c1", type: "phase-event", content: "Sprint 🚀 done ✅" });
-        expect(client.postMessage).toHaveBeenCalledWith("c1", "Sprint 🚀 done ✅");
-    });
-    it("split parts include continuation markers", async () => {
-        const long = "x".repeat(DISCORD_CONTENT_BUDGET + 500);
-        const client = makeClient({
-            postMessage: vi.fn().mockResolvedValueOnce({ id: "m1" }).mockResolvedValueOnce({ id: "m2" }),
-        });
-        await publish({ client, channelId: "c1", type: "phase-event", content: long });
-        const calls = client.postMessage.mock.calls;
-        expect(calls[0][1]).toContain("(continued)");
-        expect(calls[1][1]).toContain("(continued)");
-    });
-    it("re-throws non-403/404 errors from postMessage", async () => {
-        const err = new Error("500 Internal Server Error");
-        err.status = 500;
-        const client = makeClient({ postMessage: vi.fn().mockRejectedValue(err) });
-        await expect(publish({ client, channelId: "c1", type: "phase-event", content: "hi" })).rejects.toThrow("500");
-    });
-});
-//# sourceMappingURL=broadcast-bus.test.js.map

package/dist/src/chat/__tests__/channel-manager.test.d.ts

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

package/dist/src/chat/__tests__/channel-manager.test.js

@@ -1,133 +0,0 @@
-import { promises as fs } from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { clearChannelCreatedHooks, ensureChannel, registerChannelCreatedHook } from "../channel-manager.js";
-function makeClient(over = {}) {
-    return {
-        createChannel: vi.fn().mockResolvedValue({ id: "newc" }),
-        getChannelMessages: vi.fn().mockResolvedValue([]),
-        postMessage: vi.fn().mockResolvedValue({ id: "m" }),
-        addChannelPermission: vi.fn().mockResolvedValue(undefined),
-        getCurrentUserId: vi.fn().mockResolvedValue("bot"),
-        listGuildChannels: vi.fn().mockResolvedValue([]),
-        ...over,
-    };
-}
-describe("ensureChannel", () => {
-    let tmpHome;
-    let prevHome;
-    beforeEach(async () => {
-        tmpHome = path.join(os.tmpdir(), `cmgr-${Math.random().toString(36).slice(2)}`);
-        await fs.mkdir(tmpHome, { recursive: true });
-        prevHome = process.env.MUONROI_CLI_HOME;
-        process.env.MUONROI_CLI_HOME = tmpHome;
-        clearChannelCreatedHooks();
-    });
-    afterEach(() => {
-        if (prevHome === undefined)
-            delete process.env.MUONROI_CLI_HOME;
-        else
-            process.env.MUONROI_CLI_HOME = prevHome;
-        clearChannelCreatedHooks();
-    });
-    it("creates channel on first call (cache miss + name miss)", async () => {
-        const client = makeClient();
-        const out = await ensureChannel({ client, guildId: "g1", slug: "abc", displayName: "Demo" });
-        expect(out).toEqual({ channelId: "newc", created: true });
-        expect(client.createChannel).toHaveBeenCalledOnce();
-    });
-    it("cache hit on second call", async () => {
-        const client = makeClient({
-            listGuildChannels: vi
-                .fn()
-                .mockResolvedValueOnce([])
-                .mockResolvedValue([{ id: "newc", name: "muonroi-abc" }]),
-        });
-        await ensureChannel({ client, guildId: "g1", slug: "abc", displayName: "Demo" });
-        const second = await ensureChannel({ client, guildId: "g1", slug: "abc", displayName: "Demo" });
-        expect(second).toEqual({ channelId: "newc", created: false });
-        expect(client.createChannel).toHaveBeenCalledOnce();
-    });
-    it("finds existing channel by name when cache missing", async () => {
-        const client = makeClient({
-            listGuildChannels: vi.fn().mockResolvedValue([{ id: "existing", name: "muonroi-abc" }]),
-        });
-        const out = await ensureChannel({ client, guildId: "g1", slug: "abc", displayName: "Demo" });
-        expect(out).toEqual({ channelId: "existing", created: false });
-        expect(client.createChannel).not.toHaveBeenCalled();
-    });
-    it("in-process dedup: concurrent calls share one create", async () => {
-        const client = makeClient();
-        const [a, b] = await Promise.all([
-            ensureChannel({ client, guildId: "g1", slug: "abc", displayName: "Demo" }),
-            ensureChannel({ client, guildId: "g1", slug: "abc", displayName: "Demo" }),
-        ]);
-        expect(a?.channelId).toBe(b?.channelId);
-        expect(client.createChannel).toHaveBeenCalledOnce();
-    });
-    it("returns null on 401 token error", async () => {
-        const err = new Error("401");
-        err.status = 401;
-        const client = makeClient({ listGuildChannels: vi.fn().mockRejectedValue(err) });
-        const out = await ensureChannel({ client, guildId: "g1", slug: "abc", displayName: "Demo" });
-        expect(out).toBeNull();
-    });
-    it("returns null on 403 perm error", async () => {
-        const err = new Error("403");
-        err.status = 403;
-        const client = makeClient({ createChannel: vi.fn().mockRejectedValue(err) });
-        const out = await ensureChannel({ client, guildId: "g1", slug: "abc", displayName: "Demo" });
-        expect(out).toBeNull();
-    });
-    it("syncs permissions from stakeholder-acl after create", async () => {
-        const { addStakeholder } = await import("../../product-loop/stakeholder-acl.js");
-        await addStakeholder("abc", {
-            discordUserId: "u1",
-            displayName: "alice",
-            addedAtUtc: "t",
-            addedBy: "cli",
-        });
-        const client = makeClient();
-        await ensureChannel({ client, guildId: "g1", slug: "abc", displayName: "Demo" });
-        expect(client.addChannelPermission).toHaveBeenCalledWith("newc", "u1", expect.any(Number), 0);
-    });
-    it("fires onChannelCreated hooks after create", async () => {
-        const client = makeClient();
-        const hook = vi.fn().mockResolvedValue(undefined);
-        registerChannelCreatedHook(hook);
-        await ensureChannel({ client, guildId: "g1", slug: "abc", displayName: "Demo" });
-        expect(hook).toHaveBeenCalledWith("abc", "newc");
-    });
-    it("clearChannelCreatedHooks isolates tests", async () => {
-        const hook = vi.fn().mockResolvedValue(undefined);
-        registerChannelCreatedHook(hook);
-        clearChannelCreatedHooks();
-        const client = makeClient();
-        await ensureChannel({ client, guildId: "g1", slug: "abc", displayName: "Demo" });
-        expect(hook).not.toHaveBeenCalled();
-    });
-    it("persists mapping to discord-channels.json", async () => {
-        const client = makeClient();
-        await ensureChannel({ client, guildId: "g1", slug: "abc", displayName: "Demo" });
-        const raw = await fs.readFile(path.join(tmpHome, "discord-channels.json"), "utf8");
-        const parsed = JSON.parse(raw);
-        expect(parsed.items.abc.channelId).toBe("newc");
-    });
-    it("retries create on cached-channel 404 verification", async () => {
-        const cachePath = path.join(tmpHome, "discord-channels.json");
-        await fs.writeFile(cachePath, JSON.stringify({
-            version: 1,
-            items: {
-                abc: { productSlug: "abc", channelId: "stale", guildId: "g1", createdAtUtc: "t", displayName: "x" },
-            },
-        }));
-        const client = makeClient({
-            listGuildChannels: vi.fn().mockResolvedValue([]),
-        });
-        const out = await ensureChannel({ client, guildId: "g1", slug: "abc", displayName: "Demo" });
-        expect(out?.channelId).toBe("newc");
-        expect(client.createChannel).toHaveBeenCalledOnce();
-    });
-});
-//# sourceMappingURL=channel-manager.test.js.map

package/dist/src/chat/__tests__/client.test.d.ts

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

package/dist/src/chat/__tests__/client.test.js

@@ -1,109 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { DiscordChatProvider } from "../providers/discord/client.js";
-describe("DiscordChatProvider", () => {
-    function mockFetch(impl) {
-        return vi.fn(impl);
-    }
-    function jsonResponse(body, init = {}) {
-        return new Response(JSON.stringify(body), {
-            ...init,
-            headers: { "Content-Type": "application/json", ...(init.headers ?? {}) },
-        });
-    }
-    it("createChannel POSTs to /guilds/<id>/channels with auth header", async () => {
-        const fetch = mockFetch(async (url, init) => {
-            expect(url).toBe("https://discord.com/api/v10/guilds/g1/channels");
-            expect(init.method).toBe("POST");
-            expect(init.headers.Authorization).toBe("Bot tok");
-            const body = JSON.parse(init.body);
-            expect(body.name).toBe("muonroi-test");
-            return jsonResponse({ id: "c1" });
-        });
-        const client = new DiscordChatProvider("tok", fetch);
-        const out = await client.createChannel("g1", "muonroi-test", { topic: "t", isPrivate: true });
-        expect(out.id).toBe("c1");
-    });
-    it("postMessage sends content as JSON", async () => {
-        const fetch = mockFetch(async (url, init) => {
-            expect(url).toBe("https://discord.com/api/v10/channels/c1/messages");
-            const body = JSON.parse(init.body);
-            expect(body.content).toBe("hello 🚀");
-            return jsonResponse({ id: "m1" });
-        });
-        const client = new DiscordChatProvider("tok", fetch);
-        const out = await client.postMessage("c1", "hello 🚀");
-        expect(out.id).toBe("m1");
-    });
-    it("getChannelMessages includes after + limit query params", async () => {
-        const fetch = mockFetch(async (url) => {
-            expect(url).toContain("?after=m0&limit=50");
-            return jsonResponse([{ id: "m1", author: { id: "u1", username: "alice" }, content: "hi", timestamp: "t" }]);
-        });
-        const client = new DiscordChatProvider("tok", fetch);
-        const msgs = await client.getChannelMessages("c1", { afterId: "m0", limit: 50 });
-        expect(msgs).toHaveLength(1);
-    });
-    it("honors Retry-After on 429", async () => {
-        let calls = 0;
-        const fetch = mockFetch(async () => {
-            calls += 1;
-            if (calls === 1)
-                return new Response("rate limit", { status: 429, headers: { "Retry-After": "0" } });
-            return jsonResponse({ id: "m1" });
-        });
-        const client = new DiscordChatProvider("tok", fetch);
-        const out = await client.postMessage("c1", "hi");
-        expect(out.id).toBe("m1");
-        expect(calls).toBe(2);
-    });
-    it("throws on 401 with status attached", async () => {
-        const fetch = mockFetch(async () => new Response("unauthorized", { status: 401 }));
-        const client = new DiscordChatProvider("tok", fetch);
-        await expect(client.postMessage("c1", "hi")).rejects.toMatchObject({ status: 401 });
-    });
-    it("addChannelPermission uses PUT to /channels/<id>/permissions/<userId>", async () => {
-        const fetch = mockFetch(async (url, init) => {
-            expect(url).toBe("https://discord.com/api/v10/channels/c1/permissions/u1");
-            expect(init.method).toBe("PUT");
-            const body = JSON.parse(init.body);
-            expect(body.type).toBe(1);
-            expect(body.allow).toBe("1024");
-            return new Response(null, { status: 204 });
-        });
-        const client = new DiscordChatProvider("tok", fetch);
-        await client.addChannelPermission("c1", "u1", 1024, 0);
-    });
-    it("getCurrentUserId caches result after first call", async () => {
-        let calls = 0;
-        const fetch = mockFetch(async () => {
-            calls += 1;
-            return jsonResponse({ id: "me-123" });
-        });
-        const client = new DiscordChatProvider("tok", fetch);
-        const first = await client.getCurrentUserId();
-        const second = await client.getCurrentUserId();
-        expect(first).toBe("me-123");
-        expect(second).toBe("me-123");
-        expect(calls).toBe(1);
-    });
-    it("listGuildChannels returns array of channel stubs", async () => {
-        const fetch = mockFetch(async (url) => {
-            expect(url).toContain("/guilds/g1/channels");
-            return jsonResponse([{ id: "c1", name: "general" }]);
-        });
-        const client = new DiscordChatProvider("tok", fetch);
-        const channels = await client.listGuildChannels("g1");
-        expect(channels).toHaveLength(1);
-        expect(channels[0].id).toBe("c1");
-    });
-    it("getChannelMessages without params omits query string", async () => {
-        const fetch = mockFetch(async (url) => {
-            expect(url).not.toContain("?");
-            return jsonResponse([]);
-        });
-        const client = new DiscordChatProvider("tok", fetch);
-        const msgs = await client.getChannelMessages("c1", {});
-        expect(msgs).toHaveLength(0);
-    });
-});
-//# sourceMappingURL=client.test.js.map

package/dist/src/chat/__tests__/discord-integration.test.d.ts

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

package/dist/src/chat/__tests__/discord-integration.test.js

@@ -1,153 +0,0 @@
-import { promises as fs } from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { productSlug } from "../../product-loop/product-identity.js";
-import { addStakeholder } from "../../product-loop/stakeholder-acl.js";
-import { publish } from "../broadcast-bus.js";
-import { clearChannelCreatedHooks, ensureChannel } from "../channel-manager.js";
-import { discordAwaitVerdict } from "../verdict-resolver.js";
-function makeClient(over = {}) {
-    return {
-        createChannel: vi.fn().mockResolvedValue({ id: "newc" }),
-        getChannelMessages: vi.fn().mockResolvedValue([]),
-        postMessage: vi.fn().mockResolvedValue({ id: "bot-msg" }),
-        addChannelPermission: vi.fn().mockResolvedValue(undefined),
-        getCurrentUserId: vi.fn().mockResolvedValue("bot"),
-        listGuildChannels: vi.fn().mockResolvedValue([]),
-        ...over,
-    };
-}
-function customerMsg(id, content) {
-    return { id, content, author: { id: "u1", username: "alice" }, timestamp: new Date().toISOString() };
-}
-describe("chat-integration (subsystem F)", () => {
-    let tmpHome;
-    let flowDir;
-    let prevHome;
-    beforeEach(async () => {
-        tmpHome = path.join(os.tmpdir(), `int-${Math.random().toString(36).slice(2)}`);
-        flowDir = path.join(tmpHome, "flow");
-        await fs.mkdir(flowDir, { recursive: true });
-        prevHome = process.env.MUONROI_CLI_HOME;
-        process.env.MUONROI_CLI_HOME = tmpHome;
-        clearChannelCreatedHooks();
-    });
-    afterEach(() => {
-        if (prevHome === undefined)
-            delete process.env.MUONROI_CLI_HOME;
-        else
-            process.env.MUONROI_CLI_HOME = prevHome;
-        clearChannelCreatedHooks();
-    });
-    it("E2E: stakeholder added before channel exists inherits perms on creation", async () => {
-        const slug = productSlug("Demo Product");
-        await addStakeholder(slug, {
-            discordUserId: "111",
-            displayName: "alice",
-            addedAtUtc: "t",
-            addedBy: "cli",
-        });
-        const client = makeClient();
-        const ch = await ensureChannel({ client, guildId: "g1", slug, displayName: "Demo Product" });
-        expect(ch).not.toBeNull();
-        expect(client.addChannelPermission).toHaveBeenCalledWith("newc", "111", expect.any(Number), 0);
-    });
-    it("E2E: broadcast posts content under budget verbatim", async () => {
-        const slug = productSlug("Demo Product");
-        const client = makeClient();
-        const ch = await ensureChannel({ client, guildId: "g1", slug, displayName: "Demo Product" });
-        expect(ch).not.toBeNull();
-        const out = await publish({ client, channelId: ch.channelId, type: "phase-event", content: "Sprint 1 done" });
-        expect(out?.messageId).toBe("bot-msg");
-    });
-    it("E2E: verdict capture loop returns accept after one customer message", async () => {
-        const runId = "r-int";
-        await fs.mkdir(path.join(flowDir, "runs", runId), { recursive: true });
-        const slug = productSlug("Demo Product");
-        const client = makeClient({
-            getChannelMessages: vi
-                .fn()
-                .mockResolvedValueOnce([customerMsg("m1", "I accept")])
-                .mockResolvedValue([]),
-        });
-        const ch = await ensureChannel({ client, guildId: "g1", slug, displayName: "Demo Product" });
-        const leader = {
-            generate: vi.fn().mockResolvedValue({
-                content: JSON.stringify({ intent: "accept", reply: "Great!" }),
-                costUsd: 0.01,
-            }),
-        };
-        const out = await discordAwaitVerdict({
-            flowDir,
-            runId,
-            phaseId: "phase-1",
-            sprintN: 1,
-            productSlug: slug,
-            channelId: ch.channelId,
-            client,
-            leader,
-            capUsd: 10,
-            remainingUsd: async () => 5,
-            reviewSummary: "Sprint 1 complete.",
-            pollIntervalMs: 1,
-            timeoutMs: 60_000,
-            sleep: async () => { },
-            now: () => Date.now(),
-            backoffDelays: [1],
-            fallback: async () => ({ verdict: "abort", feedback: "no" }),
-        });
-        expect(out.verdict).toBe("accept");
-    });
-    it("E2E: bot kicked mid-verdict → falls back to terminal path", async () => {
-        const runId = "r-int2";
-        await fs.mkdir(path.join(flowDir, "runs", runId), { recursive: true });
-        const slug = productSlug("Demo Product");
-        const err = new Error("404");
-        err.status = 404;
-        const client = makeClient({ getChannelMessages: vi.fn().mockRejectedValue(err) });
-        const ch = await ensureChannel({ client, guildId: "g1", slug, displayName: "Demo Product" });
-        const leader = { generate: vi.fn() };
-        const fallback = vi.fn().mockResolvedValue({ verdict: "reject", feedback: "via-fallback" });
-        const out = await discordAwaitVerdict({
-            flowDir,
-            runId,
-            phaseId: "phase-1",
-            sprintN: 1,
-            productSlug: slug,
-            channelId: ch.channelId,
-            client,
-            leader,
-            capUsd: 10,
-            remainingUsd: async () => 5,
-            reviewSummary: "",
-            pollIntervalMs: 1,
-            timeoutMs: 60_000,
-            sleep: async () => { },
-            now: () => Date.now(),
-            backoffDelays: [1],
-            fallback,
-        });
-        expect(fallback).toHaveBeenCalled();
-        expect(out.feedback).toBe("via-fallback");
-    });
-    it("E2E: empty content broadcast → null, no API call", async () => {
-        const client = makeClient();
-        const out = await publish({ client, channelId: "c1", type: "phase-event", content: "" });
-        expect(out).toBeNull();
-        expect(client.postMessage).not.toHaveBeenCalled();
-    });
-    it("E2E: concurrent ensureChannel for same slug creates once", async () => {
-        const slug = productSlug("Demo Product");
-        const client = makeClient();
-        const [a, b, c] = await Promise.all([
-            ensureChannel({ client, guildId: "g1", slug, displayName: "Demo Product" }),
-            ensureChannel({ client, guildId: "g1", slug, displayName: "Demo Product" }),
-            ensureChannel({ client, guildId: "g1", slug, displayName: "Demo Product" }),
-        ]);
-        expect(a?.channelId).toBe(b?.channelId);
-        expect(b?.channelId).toBe(c?.channelId);
-        expect(client.createChannel).toHaveBeenCalledOnce();
-    });
-});
-//# sourceMappingURL=discord-integration.test.js.map

package/dist/src/chat/__tests__/intent-prompt.test.d.ts

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

package/dist/src/chat/__tests__/intent-prompt.test.js

@@ -1,80 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { buildConvoPrompt, parseConvoReply, SYSTEM_PROMPT } from "../intent-prompt.js";
-describe("intent-prompt", () => {
-    it("SYSTEM_PROMPT contains intent semantics", () => {
-        expect(SYSTEM_PROMPT).toContain("accept");
-        expect(SYSTEM_PROMPT).toContain("reject");
-        expect(SYSTEM_PROMPT).toContain("abort");
-        expect(SYSTEM_PROMPT).toContain("discuss");
-    });
-    it("SYSTEM_PROMPT instructs language match (default Vietnamese)", () => {
-        expect(SYSTEM_PROMPT.toLowerCase()).toMatch(/vietnamese|language/);
-    });
-    it("SYSTEM_PROMPT forbids keyword matching", () => {
-        expect(SYSTEM_PROMPT.toLowerCase()).toMatch(/keyword|negation|conservative/);
-    });
-    it("buildConvoPrompt includes review summary, prior turns, new msg", () => {
-        const out = buildConvoPrompt({
-            reviewSummary: "Sprint done.",
-            productName: "Demo",
-            priorTurns: [
-                { role: "customer", content: "looks good?" },
-                { role: "bot", content: "yes" },
-            ],
-            newMessage: "I accept",
-        });
-        expect(out).toContain("Sprint done.");
-        expect(out).toContain("looks good?");
-        expect(out).toContain("yes");
-        expect(out).toContain("I accept");
-    });
-    it("buildConvoPrompt truncates reviewSummary to 1500 chars", () => {
-        const out = buildConvoPrompt({
-            reviewSummary: "x".repeat(3000),
-            productName: "Demo",
-            priorTurns: [],
-            newMessage: "hi",
-        });
-        expect(out.length).toBeLessThan(3000);
-    });
-    it("parseConvoReply parses bare JSON", () => {
-        const out = parseConvoReply('{"intent":"accept","reply":"Great!"}');
-        expect(out.intent).toBe("accept");
-        expect(out.reply).toBe("Great!");
-    });
-    it("parseConvoReply strips ```json code fence", () => {
-        const out = parseConvoReply('```json\n{"intent":"reject","reply":"fix it"}\n```');
-        expect(out.intent).toBe("reject");
-    });
-    it("parseConvoReply returns intent='discuss' + reply on malformed JSON", () => {
-        const out = parseConvoReply("not json at all");
-        expect(out.intent).toBe("discuss");
-        expect(out.reply.length).toBeGreaterThan(0);
-    });
-    it("parseConvoReply caps reply at 500 chars", () => {
-        const out = parseConvoReply(JSON.stringify({ intent: "discuss", reply: "x".repeat(800) }));
-        expect(out.reply.length).toBe(500);
-    });
-    it("parseConvoReply preserves unknown intent string for caller classification", () => {
-        const out = parseConvoReply(JSON.stringify({ intent: "maybe", reply: "..." }));
-        expect(out.intent).toBe("maybe");
-    });
-    it("buildConvoPrompt with empty priorTurns renders (none) placeholder", () => {
-        const out = buildConvoPrompt({
-            reviewSummary: "Done.",
-            productName: "Test",
-            priorTurns: [],
-            newMessage: "ok?",
-        });
-        expect(out).toContain("(none)");
-    });
-    it("parseConvoReply falls back to discuss when intent field is missing", () => {
-        const out = parseConvoReply(JSON.stringify({ reply: "hi" }));
-        expect(out.intent).toBe("discuss");
-    });
-    it("parseConvoReply falls back to FALLBACK_REPLY when reply field is missing", () => {
-        const out = parseConvoReply(JSON.stringify({ intent: "accept" }));
-        expect(out.reply.length).toBeGreaterThan(0);
-    });
-});
-//# sourceMappingURL=intent-prompt.test.js.map

package/dist/src/chat/__tests__/verdict-resolver.test.d.ts

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