muonroi-cli 1.8.0 → 1.8.3

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 {};

package/dist/src/chat/__tests__/verdict-resolver.test.js

@@ -1,308 +0,0 @@
-import { promises as fs } from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import { discordAwaitVerdict } from "../verdict-resolver.js";
-function makeClient(over = {}) {
-    return {
-        createChannel: vi.fn(),
-        getChannelMessages: vi.fn().mockResolvedValue([]),
-        postMessage: vi.fn().mockResolvedValue({ id: "bot-msg" }),
-        addChannelPermission: vi.fn(),
-        getCurrentUserId: vi.fn().mockResolvedValue("bot"),
-        listGuildChannels: vi.fn(),
-        ...over,
-    };
-}
-function msg(id, content, authorId = "user") {
-    return { id, content, author: { id: authorId, username: "u" }, timestamp: new Date().toISOString() };
-}
-describe("discordAwaitVerdict", () => {
-    let flowDir;
-    const runId = "r-v";
-    beforeEach(async () => {
-        flowDir = path.join(os.tmpdir(), `vr-${Math.random().toString(36).slice(2)}`);
-        await fs.mkdir(path.join(flowDir, "runs", runId), { recursive: true });
-    });
-    function baseArgs(over = {}) {
-        return {
-            flowDir,
-            runId,
-            phaseId: "phase-1",
-            sprintN: 1,
-            productSlug: "abc",
-            channelId: "c1",
-            client: makeClient(),
-            leader: { generate: vi.fn() },
-            capUsd: 10,
-            remainingUsd: async () => 5,
-            reviewSummary: "Sprint 1 complete.",
-            backoffDelays: [1, 1, 1],
-            pollIntervalMs: 1,
-            timeoutMs: 60_000,
-            sleep: async () => { },
-            now: () => Date.now(),
-            fallback: vi.fn().mockResolvedValue({ verdict: "accept" }),
-            ...over,
-        };
-    }
-    it("happy accept: single customer message classified accept", async () => {
-        const client = makeClient({
-            getChannelMessages: vi
-                .fn()
-                .mockResolvedValueOnce([msg("m1", "OK accept it")])
-                .mockResolvedValue([]),
-        });
-        const leader = {
-            generate: vi.fn().mockResolvedValue({
-                content: JSON.stringify({ intent: "accept", reply: "Great!" }),
-                costUsd: 0.01,
-            }),
-        };
-        const out = await discordAwaitVerdict(baseArgs({ client, leader }));
-        expect(out.verdict).toBe("accept");
-        expect(out.feedback).toBeUndefined();
-    });
-    it("reject returns customer message as feedback", async () => {
-        const client = makeClient({
-            getChannelMessages: vi
-                .fn()
-                .mockResolvedValueOnce([msg("m1", "Please fix the auth flow")])
-                .mockResolvedValue([]),
-        });
-        const leader = {
-            generate: vi.fn().mockResolvedValue({
-                content: JSON.stringify({ intent: "reject", reply: "noted" }),
-                costUsd: 0.01,
-            }),
-        };
-        const out = await discordAwaitVerdict(baseArgs({ client, leader }));
-        expect(out.verdict).toBe("reject");
-        expect(out.feedback).toContain("auth flow");
-    });
-    it("abort returns abort verdict", async () => {
-        const client = makeClient({
-            getChannelMessages: vi
-                .fn()
-                .mockResolvedValueOnce([msg("m1", "Stop the whole thing")])
-                .mockResolvedValue([]),
-        });
-        const leader = {
-            generate: vi.fn().mockResolvedValue({
-                content: JSON.stringify({ intent: "abort", reply: "OK stopping" }),
-                costUsd: 0.01,
-            }),
-        };
-        const out = await discordAwaitVerdict(baseArgs({ client, leader }));
-        expect(out.verdict).toBe("abort");
-    });
-    it("timeout returns abort with [timeout-24h]", async () => {
-        let nowVal = 0;
-        const client = makeClient({ getChannelMessages: vi.fn().mockResolvedValue([]) });
-        const out = await discordAwaitVerdict(baseArgs({
-            client,
-            timeoutMs: 100,
-            now: () => {
-                nowVal += 200;
-                return nowVal;
-            },
-        }));
-        expect(out.verdict).toBe("abort");
-        expect(out.feedback).toBe("[timeout-24h]");
-    });
-    it("VERDICT_FLOOR boundary aborts with budget-exhausted", async () => {
-        const out = await discordAwaitVerdict(baseArgs({
-            capUsd: 10,
-            remainingUsd: async () => 0.05,
-        }));
-        expect(out.verdict).toBe("abort");
-        expect(out.feedback).toBe("budget-exhausted");
-    });
-    it("cap_usd=0 immediately aborts", async () => {
-        const out = await discordAwaitVerdict(baseArgs({ capUsd: 0, remainingUsd: async () => 0 }));
-        expect(out.verdict).toBe("abort");
-        expect(out.feedback).toBe("budget-exhausted");
-    });
-    it("MAX_VERDICT_MESSAGES cap → fallback", async () => {
-        const messages = Array.from({ length: 25 }, (_, i) => msg(`m${i}`, "discuss please"));
-        const client = makeClient({
-            getChannelMessages: vi.fn().mockResolvedValueOnce(messages).mockResolvedValue([]),
-        });
-        const leader = {
-            generate: vi.fn().mockResolvedValue({
-                content: JSON.stringify({ intent: "discuss", reply: "ok" }),
-                costUsd: 0.01,
-            }),
-        };
-        const fallback = vi.fn().mockResolvedValue({ verdict: "accept", feedback: "via-fallback" });
-        const out = await discordAwaitVerdict(baseArgs({ client, leader, fallback }));
-        expect(fallback).toHaveBeenCalled();
-        expect(out.feedback).toBe("via-fallback");
-    });
-    it("malformed JSON counts as discuss then continues", async () => {
-        const client = makeClient({
-            getChannelMessages: vi
-                .fn()
-                .mockResolvedValueOnce([msg("m1", "something")])
-                .mockResolvedValueOnce([msg("m2", "I accept")])
-                .mockResolvedValue([]),
-        });
-        const leader = {
-            generate: vi
-                .fn()
-                .mockResolvedValueOnce({ content: "not json", costUsd: 0.01 })
-                .mockResolvedValueOnce({ content: JSON.stringify({ intent: "accept", reply: "OK" }), costUsd: 0.01 }),
-        };
-        const out = await discordAwaitVerdict(baseArgs({ client, leader }));
-        expect(out.verdict).toBe("accept");
-    });
-    it("unknown intent ×5 → fallback", async () => {
-        const messages = Array.from({ length: 5 }, (_, i) => msg(`m${i}`, "msg"));
-        const client = makeClient({
-            getChannelMessages: vi.fn().mockResolvedValueOnce(messages).mockResolvedValue([]),
-        });
-        const leader = {
-            generate: vi.fn().mockResolvedValue({
-                content: JSON.stringify({ intent: "maybe", reply: "..." }),
-                costUsd: 0.01,
-            }),
-        };
-        const fallback = vi.fn().mockResolvedValue({ verdict: "reject", feedback: "via-fallback" });
-        const out = await discordAwaitVerdict(baseArgs({ client, leader, fallback }));
-        expect(fallback).toHaveBeenCalled();
-        expect(out.feedback).toBe("via-fallback");
-    });
-    it("leader transient failure ×3 → fallback", async () => {
-        const messages = Array.from({ length: 3 }, (_, i) => msg(`m${i}`, "msg"));
-        const client = makeClient({
-            getChannelMessages: vi.fn().mockResolvedValueOnce(messages).mockResolvedValue([]),
-        });
-        const leader = { generate: vi.fn().mockRejectedValue(new Error("net")) };
-        const fallback = vi.fn().mockResolvedValue({ verdict: "abort", feedback: "via-fallback" });
-        const _out = await discordAwaitVerdict(baseArgs({ client, leader, fallback }));
-        expect(fallback).toHaveBeenCalled();
-    });
-    it("404 on getChannelMessages → fallback", async () => {
-        const err = Object.assign(new Error("404"), { status: 404 });
-        const client = makeClient({ getChannelMessages: vi.fn().mockRejectedValue(err) });
-        const fallback = vi.fn().mockResolvedValue({ verdict: "accept", feedback: "via-fallback" });
-        const _out = await discordAwaitVerdict(baseArgs({ client, fallback }));
-        expect(fallback).toHaveBeenCalled();
-    });
-    it("filters out bot's own messages", async () => {
-        const client = makeClient({
-            getCurrentUserId: vi.fn().mockResolvedValue("bot"),
-            getChannelMessages: vi
-                .fn()
-                .mockResolvedValueOnce([msg("m1", "I am bot", "bot"), msg("m2", "I accept", "user")])
-                .mockResolvedValue([]),
-        });
-        const leader = {
-            generate: vi.fn().mockResolvedValue({
-                content: JSON.stringify({ intent: "accept", reply: "ok" }),
-                costUsd: 0.01,
-            }),
-        };
-        const out = await discordAwaitVerdict(baseArgs({ client, leader }));
-        expect(leader.generate).toHaveBeenCalledOnce();
-        expect(out.verdict).toBe("accept");
-    });
-    it("persists poll cursor in state.md", async () => {
-        const client = makeClient({
-            getChannelMessages: vi
-                .fn()
-                .mockResolvedValueOnce([msg("m99", "I accept")])
-                .mockResolvedValue([]),
-        });
-        const leader = {
-            generate: vi.fn().mockResolvedValue({
-                content: JSON.stringify({ intent: "accept", reply: "ok" }),
-                costUsd: 0.01,
-            }),
-        };
-        await discordAwaitVerdict(baseArgs({ client, leader }));
-        const stateFile = path.join(flowDir, "runs", runId, "state.md");
-        const content = await fs.readFile(stateFile, "utf8");
-        expect(content).toContain("Discord Poll Cursor");
-        expect(content).toContain("m99");
-    });
-    it("cursor advance is AFTER bot reply post (resume safety)", async () => {
-        const order = [];
-        const client = makeClient({
-            getChannelMessages: vi
-                .fn()
-                .mockResolvedValueOnce([msg("m1", "I accept")])
-                .mockResolvedValue([]),
-            postMessage: vi.fn().mockImplementation(async () => {
-                order.push("postReply");
-                return { id: "bot" };
-            }),
-        });
-        const leader = {
-            generate: vi.fn().mockImplementation(async () => {
-                order.push("leaderCall");
-                return { content: JSON.stringify({ intent: "accept", reply: "ok" }), costUsd: 0.01 };
-            }),
-        };
-        await discordAwaitVerdict(baseArgs({ client, leader }));
-        expect(order).toEqual(["leaderCall", "postReply"]);
-    });
-    it("403 on getChannelMessages → fallback", async () => {
-        const err = Object.assign(new Error("403"), { status: 403 });
-        const client = makeClient({ getChannelMessages: vi.fn().mockRejectedValue(err) });
-        const fallback = vi.fn().mockResolvedValue({ verdict: "reject", feedback: "via-fallback" });
-        const out = await discordAwaitVerdict(baseArgs({ client, fallback }));
-        expect(fallback).toHaveBeenCalled();
-        expect(out.verdict).toBe("reject");
-    });
-    it("cursor update replaces existing entry (not appended)", async () => {
-        // Two verdicts on different sprints, cursor for phase-1/sprint-1 gets updated
-        const client = makeClient({
-            getChannelMessages: vi
-                .fn()
-                .mockResolvedValueOnce([msg("m10", "I accept")])
-                .mockResolvedValueOnce([msg("m20", "I accept")])
-                .mockResolvedValue([]),
-        });
-        const leader = {
-            generate: vi.fn().mockResolvedValue({
-                content: JSON.stringify({ intent: "accept", reply: "ok" }),
-                costUsd: 0.01,
-            }),
-        };
-        // First run
-        await discordAwaitVerdict(baseArgs({ client, leader }));
-        // Second run same phase/sprint - cursor entry should be updated (same idx)
-        const client2 = makeClient({
-            getChannelMessages: vi
-                .fn()
-                .mockResolvedValueOnce([msg("m20", "I accept")])
-                .mockResolvedValue([]),
-        });
-        await discordAwaitVerdict(baseArgs({ client: client2, leader }));
-        const stateFile = path.join(flowDir, "runs", runId, "state.md");
-        const content = await fs.readFile(stateFile, "utf8");
-        // Should have exactly one cursor entry, not two
-        const matches = content.match(/"phaseId"/g);
-        expect(matches?.length).toBe(1);
-    });
-    it("budget-exhausted during poll loop aborts with feedback", async () => {
-        let remaining = 10;
-        const client = makeClient({
-            getChannelMessages: vi
-                .fn()
-                .mockResolvedValueOnce([msg("m1", "discuss")])
-                .mockResolvedValue([]),
-        });
-        const leader = {
-            generate: vi.fn().mockImplementation(async () => {
-                remaining = 0; // exhaust budget after first process
-                return { content: JSON.stringify({ intent: "discuss", reply: "ok" }), costUsd: 0.01 };
-            }),
-        };
-        const out = await discordAwaitVerdict(baseArgs({ client, leader, capUsd: 10, remainingUsd: async () => remaining }));
-        expect(out.verdict).toBe("abort");
-        expect(out.feedback).toBe("budget-exhausted");
-    });
-});
-//# sourceMappingURL=verdict-resolver.test.js.map

package/dist/src/cli/__tests__/bw-vault.test.d.ts

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

package/dist/src/cli/__tests__/bw-vault.test.js

@@ -1,87 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { writeBwSecureNote } from "../bw-vault.js";
-function makeRunner(scripted) {
-    const calls = [];
-    let i = 0;
-    const runner = (cmd, args, input) => {
-        calls.push({ cmd, args, input });
-        const next = scripted[i++] ?? { status: 0, stdout: "", stderr: "" };
-        return {
-            pid: 0,
-            output: [],
-            stdout: next.stdout ?? "",
-            stderr: next.stderr ?? "",
-            status: next.status,
-            signal: null,
-        };
-    };
-    return { runner, calls };
-}
-describe("writeBwSecureNote", () => {
-    let origSession;
-    beforeEach(() => {
-        origSession = process.env.BW_SESSION;
-        process.env.BW_SESSION = "fake-session-token";
-    });
-    afterEach(() => {
-        if (origSession === undefined)
-            delete process.env.BW_SESSION;
-        else
-            process.env.BW_SESSION = origSession;
-    });
-    it("creates a new Secure Note when item does not exist", async () => {
-        const { runner, calls } = makeRunner([
-            { status: 0, stdout: "2026.4.0\n" }, // bw --version
-            { status: 0, stdout: '{"status":"unlocked"}' }, // bw status
-            { status: 0, stdout: "[]" }, // bw list items (empty)
-            { status: 0, stdout: "ZW5jb2RlZA==" }, // bw encode
-            { status: 0, stdout: '{"id":"new-uuid"}' }, // bw create item
-            { status: 0, stdout: "Syncing complete." }, // bw sync
-        ]);
-        const res = await writeBwSecureNote("muonroi-cli/tavily", "tvly-test-1234567890", { runner });
-        expect(res).toEqual({ ok: true, action: "created" });
-        expect(calls[3].cmd).toBe("bw");
-        expect(calls[3].args[0]).toBe("encode");
-        expect(calls[3].input).toContain("tvly-test-1234567890");
-        expect(calls[4].args.slice(0, 3)).toEqual(["create", "item", "ZW5jb2RlZA=="]);
-    });
-    it("updates an existing item rather than creating a duplicate", async () => {
-        const { runner, calls } = makeRunner([
-            { status: 0, stdout: "2026.4.0\n" },
-            { status: 0, stdout: '{"status":"unlocked"}' },
-            {
-                status: 0,
-                stdout: JSON.stringify([{ id: "existing-uuid", name: "muonroi-cli/tavily", notes: "old-key", type: 2 }]),
-            },
-            { status: 0, stdout: "ZW5jb2RlZA==" },
-            { status: 0, stdout: '{"id":"existing-uuid"}' }, // bw edit
-            { status: 0, stdout: "Syncing complete." },
-        ]);
-        const res = await writeBwSecureNote("muonroi-cli/tavily", "tvly-new-1234567890", { runner });
-        expect(res).toEqual({ ok: true, action: "updated" });
-        expect(calls[4].args.slice(0, 3)).toEqual(["edit", "item", "existing-uuid"]);
-    });
-    it("returns ok:false when bw is not installed", async () => {
-        const { runner } = makeRunner([{ status: 127, stderr: "command not found" }]);
-        const res = await writeBwSecureNote("muonroi-cli/tavily", "tvly-x", { runner });
-        expect(res.ok).toBe(false);
-        expect(res.error).toMatch(/Bitwarden CLI/);
-    });
-    it("returns ok:false when BW_SESSION is missing", async () => {
-        delete process.env.BW_SESSION;
-        const { runner } = makeRunner([{ status: 0, stdout: "2026.4.0" }]);
-        const res = await writeBwSecureNote("muonroi-cli/tavily", "tvly-x", { runner });
-        expect(res.ok).toBe(false);
-        expect(res.error).toMatch(/BW_SESSION/);
-    });
-    it("returns ok:false when vault is locked", async () => {
-        const { runner } = makeRunner([
-            { status: 0, stdout: "2026.4.0" },
-            { status: 0, stdout: '{"status":"locked"}' },
-        ]);
-        const res = await writeBwSecureNote("muonroi-cli/tavily", "tvly-x", { runner });
-        expect(res.ok).toBe(false);
-        expect(res.error).toMatch(/not unlocked/i);
-    });
-});
-//# sourceMappingURL=bw-vault.test.js.map

package/dist/src/cli/__tests__/keys-bundle.test.d.ts

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